diff --git a/.gitmodules b/.gitmodules
index ab7c8a7c94d..be44e3268e3 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -210,9 +210,6 @@
 [submodule "contrib/fast_float"]
 	path = contrib/fast_float
 	url = https://github.com/fastfloat/fast_float
-[submodule "contrib/libpqxx"]
-	path = contrib/libpqxx
-	url = https://github.com/jtv/libpqxx
 [submodule "contrib/libpq"]
 	path = contrib/libpq
 	url = https://github.com/ClickHouse-Extras/libpq
@@ -231,3 +228,6 @@
 [submodule "contrib/yaml-cpp"]
 	path = contrib/yaml-cpp
 	url = https://github.com/ClickHouse-Extras/yaml-cpp.git
+[submodule "contrib/libpqxx"]
+	path = contrib/libpqxx
+	url = https://github.com/ClickHouse-Extras/libpqxx.git
diff --git a/base/bridge/IBridge.cpp b/base/bridge/IBridge.cpp
index b2ec53158b1..35a9b95c97f 100644
--- a/base/bridge/IBridge.cpp
+++ b/base/bridge/IBridge.cpp
@@ -1,14 +1,22 @@
 #include "IBridge.h"
 
-#include <IO/ReadHelpers.h>
 #include <boost/program_options.hpp>
 #include <Poco/Net/NetException.h>
 #include <Poco/Util/HelpFormatter.h>
-#include <Common/StringUtils/StringUtils.h>
-#include <Formats/registerFormats.h>
+
 #include <common/logger_useful.h>
+#include <common/range.h>
+
+#include <Common/StringUtils/StringUtils.h>
 #include <Common/SensitiveDataMasker.h>
+#include <common/errnoToString.h>
+#include <IO/ReadHelpers.h>
+#include <Formats/registerFormats.h>
 #include <Server/HTTP/HTTPServer.h>
+#include <IO/WriteBufferFromFile.h>
+#include <IO/WriteHelpers.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 
 #if USE_ODBC
 #    include <Poco/Data/ODBC/Connector.h>
@@ -163,6 +171,31 @@ void IBridge::initialize(Application & self)
     max_server_connections = config().getUInt("max-server-connections", 1024);
     keep_alive_timeout = config().getUInt64("keep-alive-timeout", 10);
 
+    struct rlimit limit;
+    const UInt64 gb = 1024 * 1024 * 1024;
+
+    /// Set maximum RSS to 1 GiB.
+    limit.rlim_max = limit.rlim_cur = gb;
+    if (setrlimit(RLIMIT_RSS, &limit))
+        LOG_WARNING(log, "Unable to set maximum RSS to 1GB: {} (current rlim_cur={}, rlim_max={})",
+                    errnoToString(errno), limit.rlim_cur, limit.rlim_max);
+
+    if (!getrlimit(RLIMIT_RSS, &limit))
+        LOG_INFO(log, "RSS limit: cur={}, max={}", limit.rlim_cur, limit.rlim_max);
+
+    try
+    {
+        const auto oom_score = toString(config().getUInt64("bridge_oom_score", 500));
+        WriteBufferFromFile buf("/proc/self/oom_score_adj");
+        buf.write(oom_score.data(), oom_score.size());
+        buf.close();
+        LOG_INFO(log, "OOM score is set to {}", oom_score);
+    }
+    catch (const Exception & e)
+    {
+        LOG_WARNING(log, "Failed to set OOM score, error: {}", e.what());
+    }
+
     initializeTerminationAndSignalProcessing();
 
     ServerApplication::initialize(self); // NOLINT
@@ -214,7 +247,7 @@ int IBridge::main(const std::vector<std::string> & /*args*/)
 
         server.stop();
 
-        for (size_t count : ext::range(1, 6))
+        for (size_t count : collections::range(1, 6))
         {
             if (server.currentConnections() == 0)
                 break;
diff --git a/base/common/DecomposedFloat.h b/base/common/DecomposedFloat.h
index 078ba823c15..21034908fe7 100644
--- a/base/common/DecomposedFloat.h
+++ b/base/common/DecomposedFloat.h
@@ -91,10 +91,12 @@ struct DecomposedFloat
 
 
     /// Compare float with integer of arbitrary width (both signed and unsigned are supported). Assuming two's complement arithmetic.
+    /// This function is generic, big integers (128, 256 bit) are supported as well.
     /// Infinities are compared correctly. NaNs are treat similarly to infinities, so they can be less than all numbers.
     /// (note that we need total order)
+    /// Returns -1, 0 or 1.
     template <typename Int>
-    int compare(Int rhs)
+    int compare(Int rhs) const
     {
         if (rhs == 0)
             return sign();
@@ -137,10 +139,11 @@ struct DecomposedFloat
         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>;
+        using UInt = std::conditional_t<(sizeof(Int) > sizeof(typename Traits::UInt)), make_unsigned_t<Int>, typename Traits::UInt>;
         UInt uint_rhs = rhs < 0 ? -rhs : rhs;
 
         /// Smaller octave: abs(rhs) < abs(float)
+        /// FYI, TIL: octave is also called "binade", https://en.wikipedia.org/wiki/Binade
         if (uint_rhs < (static_cast<UInt>(1) << normalized_exponent()))
             return is_negative() ? -1 : 1;
 
@@ -154,11 +157,11 @@ struct DecomposedFloat
 
         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());
+        UInt a = large_and_always_integer
+            ? static_cast<UInt>(mantissa()) << (normalized_exponent() - Traits::mantissa_bits)
+            : static_cast<UInt>(mantissa()) >> (Traits::mantissa_bits - normalized_exponent());
 
-        typename Traits::UInt b = uint_rhs - (static_cast<UInt>(1) << normalized_exponent());
+        UInt b = uint_rhs - (static_cast<UInt>(1) << normalized_exponent());
 
         if (a < b)
             return is_negative() ? 1 : -1;
@@ -175,37 +178,37 @@ struct DecomposedFloat
 
 
     template <typename Int>
-    bool equals(Int rhs)
+    bool equals(Int rhs) const
     {
         return compare(rhs) == 0;
     }
 
     template <typename Int>
-    bool notEquals(Int rhs)
+    bool notEquals(Int rhs) const
     {
         return compare(rhs) != 0;
     }
 
     template <typename Int>
-    bool less(Int rhs)
+    bool less(Int rhs) const
     {
         return compare(rhs) < 0;
     }
 
     template <typename Int>
-    bool greater(Int rhs)
+    bool greater(Int rhs) const
     {
         return compare(rhs) > 0;
     }
 
     template <typename Int>
-    bool lessOrEquals(Int rhs)
+    bool lessOrEquals(Int rhs) const
     {
         return compare(rhs) <= 0;
     }
 
     template <typename Int>
-    bool greaterOrEquals(Int rhs)
+    bool greaterOrEquals(Int rhs) const
     {
         return compare(rhs) >= 0;
     }
diff --git a/base/common/ReadlineLineReader.cpp b/base/common/ReadlineLineReader.cpp
index 397a7dd7543..f2c2b60f327 100644
--- a/base/common/ReadlineLineReader.cpp
+++ b/base/common/ReadlineLineReader.cpp
@@ -1,6 +1,6 @@
 #include <common/ReadlineLineReader.h>
 #include <common/errnoToString.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <errno.h>
 #include <signal.h>
diff --git a/base/common/SimpleCache.h b/base/common/SimpleCache.h
index e412e921ab8..c3bf019c226 100644
--- a/base/common/SimpleCache.h
+++ b/base/common/SimpleCache.h
@@ -3,7 +3,7 @@
 #include <map>
 #include <tuple>
 #include <mutex>
-#include <ext/function_traits.h>
+#include <common/function_traits.h>
 
 
 /** The simplest cache for a free function.
diff --git a/base/common/arraySize.h b/base/common/arraySize.h
new file mode 100644
index 00000000000..d6245257ad0
--- /dev/null
+++ b/base/common/arraySize.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include <cstdlib>
+
+/** \brief Returns number of elements in an automatic array. */
+template <typename T, std::size_t N>
+constexpr size_t arraySize(const T (&)[N]) noexcept { return N; }
diff --git a/base/common/bit_cast.h b/base/common/bit_cast.h
new file mode 100644
index 00000000000..5b4b0931b62
--- /dev/null
+++ b/base/common/bit_cast.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string.h>
+#include <algorithm>
+#include <type_traits>
+
+
+/** \brief Returns value `from` converted to type `To` while retaining bit representation.
+  *    `To` and `From` must satisfy `CopyConstructible`.
+  */
+template <typename To, typename From>
+std::decay_t<To> bit_cast(const From & from)
+{
+    To res {};
+    memcpy(static_cast<void*>(&res), &from, std::min(sizeof(res), sizeof(from)));
+    return res;
+}
+
+/** \brief Returns value `from` converted to type `To` while retaining bit representation.
+  *    `To` and `From` must satisfy `CopyConstructible`.
+  */
+template <typename To, typename From>
+std::decay_t<To> safe_bit_cast(const From & from)
+{
+    static_assert(sizeof(To) == sizeof(From), "bit cast on types of different width");
+    return bit_cast<To, From>(from);
+}
diff --git a/base/common/chrono_io.h b/base/common/chrono_io.h
new file mode 100644
index 00000000000..4ee8dec6634
--- /dev/null
+++ b/base/common/chrono_io.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+#include <sstream>
+#include <cctz/time_zone.h>
+
+
+inline std::string to_string(const std::time_t & time)
+{
+    return cctz::format("%Y-%m-%d %H:%M:%S", std::chrono::system_clock::from_time_t(time), cctz::local_time_zone());
+}
+
+template <typename Clock, typename Duration = typename Clock::duration>
+std::string to_string(const std::chrono::time_point<Clock, Duration> & tp)
+{
+    // Don't use DateLUT because it shows weird characters for
+    // TimePoint::max(). I wish we could use C++20 format, but it's not
+    // there yet.
+    // return DateLUT::instance().timeToString(std::chrono::system_clock::to_time_t(tp));
+
+    auto in_time_t = std::chrono::system_clock::to_time_t(tp);
+    return to_string(in_time_t);
+}
+
+template <typename Rep, typename Period = std::ratio<1>>
+std::string to_string(const std::chrono::duration<Rep, Period> & duration)
+{
+    auto seconds_as_int = std::chrono::duration_cast<std::chrono::seconds>(duration);
+    if (seconds_as_int == duration)
+        return std::to_string(seconds_as_int.count()) + "s";
+    auto seconds_as_double = std::chrono::duration_cast<std::chrono::duration<double>>(duration);
+    return std::to_string(seconds_as_double.count()) + "s";
+}
+
+template <typename Clock, typename Duration = typename Clock::duration>
+std::ostream & operator<<(std::ostream & o, const std::chrono::time_point<Clock, Duration> & tp)
+{
+    return o << to_string(tp);
+}
+
+template <typename Rep, typename Period = std::ratio<1>>
+std::ostream & operator<<(std::ostream & o, const std::chrono::duration<Rep, Period> & duration)
+{
+    return o << to_string(duration);
+}
diff --git a/base/ext/function_traits.h b/base/common/function_traits.h
similarity index 100%
rename from base/ext/function_traits.h
rename to base/common/function_traits.h
diff --git a/base/common/map.h b/base/common/map.h
new file mode 100644
index 00000000000..043d8363619
--- /dev/null
+++ b/base/common/map.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <type_traits>
+#include <boost/iterator/transform_iterator.hpp>
+
+namespace collections
+{
+
+/// \brief Strip type off top level reference and cv-qualifiers thus allowing storage in containers
+template <typename T>
+using unqualified_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+/** \brief Returns collection of the same container-type as the input collection,
+  *    with each element transformed by the application of `mapper`.
+  */
+template <template <typename...> class Collection, typename... Params, typename Mapper>
+auto map(const Collection<Params...> & collection, Mapper && mapper)
+{
+    using value_type = unqualified_t<decltype(mapper(*std::begin(collection)))>;
+
+    return Collection<value_type>(
+        boost::make_transform_iterator(std::begin(collection), std::forward<Mapper>(mapper)),
+        boost::make_transform_iterator(std::end(collection), std::forward<Mapper>(mapper)));
+}
+
+/** \brief Returns collection of specified container-type,
+  *    with each element transformed by the application of `mapper`.
+  *    Allows conversion between different container-types, e.g. std::vector to std::list
+  */
+template <template <typename...> class ResultCollection, typename Collection, typename Mapper>
+auto map(const Collection & collection, Mapper && mapper)
+{
+    using value_type = unqualified_t<decltype(mapper(*std::begin(collection)))>;
+
+    return ResultCollection<value_type>(
+        boost::make_transform_iterator(std::begin(collection), std::forward<Mapper>(mapper)),
+        boost::make_transform_iterator(std::end(collection), std::forward<Mapper>(mapper)));
+}
+
+/** \brief Returns collection of specified type,
+  *    with each element transformed by the application of `mapper`.
+  *    Allows leveraging implicit conversion between the result of applying `mapper` and R::value_type.
+  */
+template <typename ResultCollection, typename Collection, typename Mapper>
+auto map(const Collection & collection, Mapper && mapper)
+{
+    return ResultCollection(
+        boost::make_transform_iterator(std::begin(collection), std::forward<Mapper>(mapper)),
+        boost::make_transform_iterator(std::end(collection), std::forward<Mapper>(mapper)));
+}
+
+}
diff --git a/base/ext/range.h b/base/common/range.h
similarity index 81%
rename from base/ext/range.h
rename to base/common/range.h
index 266016f5779..aacd7e433a4 100644
--- a/base/ext/range.h
+++ b/base/common/range.h
@@ -4,9 +4,9 @@
 #include <boost/range/adaptor/transformed.hpp>
 #include <type_traits>
 
-
-namespace ext
+namespace collections
 {
+
 namespace internal
 {
     template <typename ResultType, typename CountingType, typename BeginType, typename EndType>
@@ -24,11 +24,11 @@ namespace internal
 /// For loop adaptor which is used to iterate through a half-closed interval [begin, end).
 /// The parameters `begin` and `end` can have any integral or enum types.
 template <typename BeginType,
-          typename EndType,
-          typename = std::enable_if_t<
-              (std::is_integral_v<BeginType> || std::is_enum_v<BeginType>) &&
-              (std::is_integral_v<EndType> || std::is_enum_v<EndType>) &&
-              (!std::is_enum_v<BeginType> || !std::is_enum_v<EndType> || std::is_same_v<BeginType, EndType>), void>>
+        typename EndType,
+        typename = std::enable_if_t<
+            (std::is_integral_v<BeginType> || std::is_enum_v<BeginType>) &&
+            (std::is_integral_v<EndType> || std::is_enum_v<EndType>) &&
+            (!std::is_enum_v<BeginType> || !std::is_enum_v<EndType> || std::is_same_v<BeginType, EndType>), void>>
 inline auto range(BeginType begin, EndType end)
 {
     if constexpr (std::is_integral_v<BeginType> && std::is_integral_v<EndType>)
@@ -51,7 +51,7 @@ inline auto range(BeginType begin, EndType end)
 /// The parameter `end` can have any integral or enum type.
 /// The same as range(0, end).
 template <typename Type,
-          typename = std::enable_if_t<std::is_integral_v<Type> || std::is_enum_v<Type>, void>>
+        typename = std::enable_if_t<std::is_integral_v<Type> || std::is_enum_v<Type>, void>>
 inline auto range(Type end)
 {
     if constexpr (std::is_integral_v<Type>)
@@ -59,4 +59,5 @@ inline auto range(Type end)
     else
         return internal::rangeImpl<Type, std::underlying_type_t<Type>>(0, end);
 }
+
 }
diff --git a/base/ext/scope_guard.h b/base/common/scope_guard.h
similarity index 96%
rename from base/ext/scope_guard.h
rename to base/common/scope_guard.h
index 79bad56f360..96f44a6be66 100644
--- a/base/ext/scope_guard.h
+++ b/base/common/scope_guard.h
@@ -4,9 +4,6 @@
 #include <memory>
 #include <utility>
 
-
-namespace ext
-{
 template <class F>
 class [[nodiscard]] basic_scope_guard
 {
@@ -105,10 +102,9 @@ using scope_guard = basic_scope_guard<std::function<void(void)>>;
 
 template <class F>
 inline basic_scope_guard<F> make_scope_guard(F && function_) { return std::forward<F>(function_); }
-}
 
 #define SCOPE_EXIT_CONCAT(n, ...) \
-const auto scope_exit##n = ext::make_scope_guard([&] { __VA_ARGS__; })
+const auto scope_exit##n = make_scope_guard([&] { __VA_ARGS__; })
 #define SCOPE_EXIT_FWD(n, ...) SCOPE_EXIT_CONCAT(n, __VA_ARGS__)
 #define SCOPE_EXIT(...) SCOPE_EXIT_FWD(__LINE__, __VA_ARGS__)
 
diff --git a/base/ext/scope_guard_safe.h b/base/common/scope_guard_safe.h
similarity index 98%
rename from base/ext/scope_guard_safe.h
rename to base/common/scope_guard_safe.h
index 55140213572..a52b4a14f48 100644
--- a/base/ext/scope_guard_safe.h
+++ b/base/common/scope_guard_safe.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <common/logger_useful.h>
 #include <Common/MemoryTracker.h>
 
diff --git a/base/ext/shared_ptr_helper.h b/base/common/shared_ptr_helper.h
similarity index 97%
rename from base/ext/shared_ptr_helper.h
rename to base/common/shared_ptr_helper.h
index df132382fa6..c1214a20c85 100644
--- a/base/ext/shared_ptr_helper.h
+++ b/base/common/shared_ptr_helper.h
@@ -2,8 +2,6 @@
 
 #include <memory>
 
-namespace ext
-{
 
 /** Allows to make std::shared_ptr from T with protected constructor.
   *
@@ -36,4 +34,3 @@ struct is_shared_ptr<std::shared_ptr<T>>
 
 template <typename T>
 inline constexpr bool is_shared_ptr_v = is_shared_ptr<T>::value;
-}
diff --git a/base/common/wide_integer.h b/base/common/wide_integer.h
index 419b4e4558c..de349633723 100644
--- a/base/common/wide_integer.h
+++ b/base/common/wide_integer.h
@@ -109,10 +109,7 @@ 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;
-
-    template <class T, class = _integral_not_wide_integer_class<T>>
+    template <typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>, T>>
     constexpr operator T() const noexcept;
 
     constexpr operator long double() const noexcept;
diff --git a/base/common/wide_integer_impl.h b/base/common/wide_integer_impl.h
index 725caec6a3e..d2ef8b22d65 100644
--- a/base/common/wide_integer_impl.h
+++ b/base/common/wide_integer_impl.h
@@ -255,13 +255,13 @@ struct integer<Bits, Signed>::_impl
             set_multiplier<double>(self, alpha);
 
         self *= max_int;
-        self += static_cast<uint64_t>(t - alpha * static_cast<T>(max_int)); // += b_i
+        self += static_cast<uint64_t>(t - floor(alpha) * static_cast<T>(max_int)); // += b_i
     }
 
-    constexpr static void wide_integer_from_builtin(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();
+        constexpr int64_t min_int = std::numeric_limits<int64_t>::lowest();
 
         /// There are values in int64 that have more than 53 significant bits (in terms of double
         /// representation). Such values, being promoted to double, are rounded up or down. If they are rounded up,
@@ -271,14 +271,14 @@ struct integer<Bits, Signed>::_impl
         /// The necessary check here is that long double has enough significant (mantissa) bits to store the
         /// int64_t max value precisely.
 
-        //TODO Be compatible with Apple aarch64
+        // TODO Be compatible with Apple aarch64
 #if not (defined(__APPLE__) && defined(__aarch64__))
         static_assert(LDBL_MANT_DIG >= 64,
-            "On your system long double has less than 64 precision bits,"
+            "On your system long double has less than 64 precision bits, "
             "which may result in UB when initializing double from int64_t");
 #endif
 
-        if ((rhs > 0 && rhs < static_cast<long double>(max_int)) || (rhs < 0 && rhs > static_cast<long double>(min_int)))
+        if (rhs > static_cast<long double>(min_int) && rhs < static_cast<long double>(max_int))
         {
             self = static_cast<int64_t>(rhs);
             return;
diff --git a/base/daemon/BaseDaemon.cpp b/base/daemon/BaseDaemon.cpp
index 6aa65942445..ed5c81e89fa 100644
--- a/base/daemon/BaseDaemon.cpp
+++ b/base/daemon/BaseDaemon.cpp
@@ -21,7 +21,7 @@
 #include <fstream>
 #include <sstream>
 #include <memory>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <Poco/Observer.h>
 #include <Poco/AutoPtr.h>
diff --git a/base/ext/bit_cast.h b/base/ext/bit_cast.h
deleted file mode 100644
index d96ddb7590b..00000000000
--- a/base/ext/bit_cast.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-
-#include <string.h>
-#include <algorithm>
-#include <type_traits>
-
-
-namespace ext
-{
-    /** \brief Returns value `from` converted to type `To` while retaining bit representation.
-      *    `To` and `From` must satisfy `CopyConstructible`.
-      */
-    template <typename To, typename From>
-    std::decay_t<To> bit_cast(const From & from)
-    {
-        To res {};
-        memcpy(static_cast<void*>(&res), &from, std::min(sizeof(res), sizeof(from)));
-        return res;
-    }
-
-    /** \brief Returns value `from` converted to type `To` while retaining bit representation.
-      *    `To` and `From` must satisfy `CopyConstructible`.
-      */
-    template <typename To, typename From>
-    std::decay_t<To> safe_bit_cast(const From & from)
-    {
-        static_assert(sizeof(To) == sizeof(From), "bit cast on types of different width");
-        return bit_cast<To, From>(from);
-    }
-}
diff --git a/base/ext/chrono_io.h b/base/ext/chrono_io.h
deleted file mode 100644
index 967b7c5e475..00000000000
--- a/base/ext/chrono_io.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#pragma once
-
-#include <chrono>
-#include <string>
-#include <sstream>
-#include <cctz/time_zone.h>
-
-
-namespace ext
-{
-    inline std::string to_string(const std::time_t & time)
-    {
-        return cctz::format("%Y-%m-%d %H:%M:%S", std::chrono::system_clock::from_time_t(time), cctz::local_time_zone());
-    }
-
-    template <typename Clock, typename Duration = typename Clock::duration>
-    std::string to_string(const std::chrono::time_point<Clock, Duration> & tp)
-    {
-        // Don't use DateLUT because it shows weird characters for
-        // TimePoint::max(). I wish we could use C++20 format, but it's not
-        // there yet.
-        // return DateLUT::instance().timeToString(std::chrono::system_clock::to_time_t(tp));
-
-        auto in_time_t = std::chrono::system_clock::to_time_t(tp);
-        return to_string(in_time_t);
-    }
-
-    template <typename Rep, typename Period = std::ratio<1>>
-    std::string to_string(const std::chrono::duration<Rep, Period> & duration)
-    {
-        auto seconds_as_int = std::chrono::duration_cast<std::chrono::seconds>(duration);
-        if (seconds_as_int == duration)
-            return std::to_string(seconds_as_int.count()) + "s";
-        auto seconds_as_double = std::chrono::duration_cast<std::chrono::duration<double>>(duration);
-        return std::to_string(seconds_as_double.count()) + "s";
-    }
-
-    template <typename Clock, typename Duration = typename Clock::duration>
-    std::ostream & operator<<(std::ostream & o, const std::chrono::time_point<Clock, Duration> & tp)
-    {
-        return o << to_string(tp);
-    }
-
-    template <typename Rep, typename Period = std::ratio<1>>
-    std::ostream & operator<<(std::ostream & o, const std::chrono::duration<Rep, Period> & duration)
-    {
-        return o << to_string(duration);
-    }
-}
diff --git a/base/ext/collection_cast.h b/base/ext/collection_cast.h
deleted file mode 100644
index 95daa5c3b14..00000000000
--- a/base/ext/collection_cast.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include <iterator>
-
-namespace ext
-{
-    /** \brief Returns collection of specified container-type.
-     *    Retains stored value_type, constructs resulting collection using iterator range. */
-    template <template <typename...> class ResultCollection, typename Collection>
-    auto collection_cast(const Collection & collection)
-    {
-        using value_type = typename Collection::value_type;
-
-        return ResultCollection<value_type>(std::begin(collection), std::end(collection));
-    }
-
-    /** \brief Returns collection of specified type.
-     *    Performs implicit conversion of between source and result value_type, if available and required. */
-    template <typename ResultCollection, typename Collection>
-    auto collection_cast(const Collection & collection)
-    {
-        return ResultCollection(std::begin(collection), std::end(collection));
-    }
-}
diff --git a/base/ext/enumerate.h b/base/ext/enumerate.h
deleted file mode 100644
index 9a55d853e35..00000000000
--- a/base/ext/enumerate.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include <ext/size.h>
-#include <type_traits>
-#include <utility>
-#include <iterator>
-
-
-/** \brief Provides a wrapper view around a container, allowing to iterate over it's elements and indices.
-  *    Allow writing code like shown below:
-  *
-  *        std::vector<T> v = getVector();
-  *        for (const std::pair<const std::size_t, T &> index_and_value : ext::enumerate(v))
-  *            std::cout << "element " << index_and_value.first << " is " << index_and_value.second << std::endl;
-  */
-namespace ext
-{
-    template <typename It> struct enumerate_iterator
-    {
-        using traits = typename std::iterator_traits<It>;
-        using iterator_category = typename traits::iterator_category;
-        using value_type = std::pair<const std::size_t, typename traits::value_type>;
-        using difference_type = typename traits::difference_type;
-        using reference = std::pair<const std::size_t, typename traits::reference>;
-
-        std::size_t idx;
-        It it;
-
-        enumerate_iterator(const std::size_t idx_, It it_) : idx{idx_}, it{it_} {}
-
-        auto operator*() const { return reference(idx, *it); }
-
-        bool operator!=(const enumerate_iterator & other) const { return it != other.it; }
-
-        enumerate_iterator & operator++() { return ++idx, ++it, *this; }
-    };
-
-    template <typename Collection> struct enumerate_wrapper
-    {
-        using underlying_iterator = decltype(std::begin(std::declval<Collection &>()));
-        using iterator = enumerate_iterator<underlying_iterator>;
-
-        Collection & collection;
-
-        enumerate_wrapper(Collection & collection_) : collection(collection_) {}
-
-        auto begin() { return iterator(0, std::begin(collection)); }
-        auto end() { return iterator(ext::size(collection), std::end(collection)); }
-    };
-
-    template <typename Collection> auto enumerate(Collection & collection)
-    {
-        return enumerate_wrapper<Collection>{collection};
-    }
-
-    template <typename Collection> auto enumerate(const Collection & collection)
-    {
-        return enumerate_wrapper<const Collection>{collection};
-    }
-}
diff --git a/base/ext/identity.h b/base/ext/identity.h
deleted file mode 100644
index bc7b62be303..00000000000
--- a/base/ext/identity.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include <utility>
-
-namespace ext
-{
-    /// \brief Identity function for use with other algorithms as a pass-through.
-    class identity
-    {
-        /** \brief Function pointer type template for converting identity to a function pointer.
-         *    Presumably useless, provided for completeness. */
-        template <typename T> using function_ptr_t = T &&(*)(T &&);
-
-        /** \brief Implementation of identity as a non-instance member function for taking function pointer. */
-        template <typename T> static T && invoke(T && t) { return std::forward<T>(t); }
-
-    public:
-        /** \brief Returns the value passed as a sole argument using perfect forwarding. */
-        template <typename T> T && operator()(T && t) const { return std::forward<T>(t); }
-
-        /** \brief Allows conversion of identity instance to a function pointer. */
-        template <typename T> operator function_ptr_t<T>() const { return &invoke; };
-    };
-}
diff --git a/base/ext/make_array_n.h b/base/ext/make_array_n.h
deleted file mode 100644
index 070a1dacd5c..00000000000
--- a/base/ext/make_array_n.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include <utility>
-#include <type_traits>
-#include <array>
-
-
-/** \brief Produces std::array of specified size, containing copies of provided object.
-  *    Copy is performed N-1 times, and the last element is being moved.
-  * This helper allows to initialize std::array in place.
-  */
-namespace ext
-{
-    namespace detail
-    {
-
-        template<std::size_t size, typename T, std::size_t... indexes>
-        constexpr auto make_array_n_impl(T && value, std::index_sequence<indexes...>)
-        {
-            /// Comma is used to make N-1 copies of value
-            return std::array<std::decay_t<T>, size>{ (static_cast<void>(indexes), value)..., std::forward<T>(value) };
-        }
-
-    }
-
-    template<typename T>
-    constexpr auto make_array_n(std::integral_constant<std::size_t, 0>, T &&)
-    {
-        return std::array<std::decay_t<T>, 0>{};
-    }
-
-    template<std::size_t size, typename T>
-    constexpr auto make_array_n(std::integral_constant<std::size_t, size>, T && value)
-    {
-        return detail::make_array_n_impl<size>(std::forward<T>(value), std::make_index_sequence<size - 1>{});
-    }
-
-    template<std::size_t size, typename T>
-    constexpr auto make_array_n(T && value)
-    {
-        return make_array_n(std::integral_constant<std::size_t, size>{}, std::forward<T>(value));
-    }
-}
diff --git a/base/ext/map.h b/base/ext/map.h
deleted file mode 100644
index 1066d86037c..00000000000
--- a/base/ext/map.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include <type_traits>
-#include <boost/iterator/transform_iterator.hpp>
-
-
-namespace ext
-{
-    /// \brief Strip type off top level reference and cv-qualifiers thus allowing storage in containers
-    template <typename T>
-    using unqualified_t = std::remove_cv_t<std::remove_reference_t<T>>;
-
-    /** \brief Returns collection of the same container-type as the input collection,
-      *    with each element transformed by the application of `mapper`.
-      */
-    template <template <typename...> class Collection, typename... Params, typename Mapper>
-    auto map(const Collection<Params...> & collection, Mapper && mapper)
-    {
-        using value_type = unqualified_t<decltype(mapper(*std::begin(collection)))>;
-
-        return Collection<value_type>(
-            boost::make_transform_iterator(std::begin(collection), std::forward<Mapper>(mapper)),
-            boost::make_transform_iterator(std::end(collection), std::forward<Mapper>(mapper)));
-    }
-
-    /** \brief Returns collection of specified container-type,
-      *    with each element transformed by the application of `mapper`.
-      *    Allows conversion between different container-types, e.g. std::vector to std::list
-      */
-    template <template <typename...> class ResultCollection, typename Collection, typename Mapper>
-    auto map(const Collection & collection, Mapper && mapper)
-    {
-        using value_type = unqualified_t<decltype(mapper(*std::begin(collection)))>;
-
-        return ResultCollection<value_type>(
-            boost::make_transform_iterator(std::begin(collection), std::forward<Mapper>(mapper)),
-            boost::make_transform_iterator(std::end(collection), std::forward<Mapper>(mapper)));
-    }
-
-    /** \brief Returns collection of specified type,
-      *    with each element transformed by the application of `mapper`.
-      *    Allows leveraging implicit conversion between the result of applying `mapper` and R::value_type.
-      */
-    template <typename ResultCollection, typename Collection, typename Mapper>
-    auto map(const Collection & collection, Mapper && mapper)
-    {
-        return ResultCollection(
-            boost::make_transform_iterator(std::begin(collection), std::forward<Mapper>(mapper)),
-            boost::make_transform_iterator(std::end(collection), std::forward<Mapper>(mapper)));
-    }
-}
diff --git a/base/ext/push_back.h b/base/ext/push_back.h
deleted file mode 100644
index 7201976f548..00000000000
--- a/base/ext/push_back.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include <vector>
-
-namespace ext
-{
-
-/// Moves all arguments starting from the second to the end of the vector.
-/// For example, `push_back(vec, a1, a2, a3)` is a more compact way to write
-/// `vec.push_back(a1); vec.push_back(a2); vec.push_back(a3);`
-/// This function is like boost::range::push_back() but works for noncopyable types too.
-template <typename T>
-void push_back(std::vector<T> &)
-{
-}
-
-template <typename T, typename FirstArg, typename... OtherArgs>
-void push_back(std::vector<T> & vec, FirstArg && first, OtherArgs &&... other)
-{
-    vec.reserve(vec.size() + sizeof...(other) + 1);
-    vec.emplace_back(std::move(first));
-    push_back(vec, std::move(other)...);
-}
-
-}
diff --git a/base/ext/size.h b/base/ext/size.h
deleted file mode 100644
index 3124e39d86f..00000000000
--- a/base/ext/size.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <cstdlib>
-
-
-namespace ext
-{
-    /** \brief Returns number of elements in an automatic array. */
-    template <typename T, std::size_t N>
-    constexpr std::size_t size(const T (&)[N]) noexcept { return N; }
-
-    /** \brief Returns number of in a container providing size() member function. */
-    template <typename T> constexpr auto size(const T & t) { return t.size(); }
-}
diff --git a/base/ext/unlock_guard.h b/base/ext/unlock_guard.h
deleted file mode 100644
index 04d5468293f..00000000000
--- a/base/ext/unlock_guard.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-namespace ext
-{
-
-template <typename T>
-class unlock_guard
-{
-public:
-    unlock_guard(T & mutex_) : mutex(mutex_)
-    {
-        mutex.unlock();
-    }
-
-    ~unlock_guard()
-    {
-        mutex.lock();
-    }
-
-    unlock_guard(const unlock_guard &) = delete;
-    unlock_guard & operator=(const unlock_guard &) = delete;
-
-private:
-    T & mutex;
-};
-
-}
diff --git a/contrib/libpqxx b/contrib/libpqxx
index 58d2a028d16..357608d11b7 160000
--- a/contrib/libpqxx
+++ b/contrib/libpqxx
@@ -1 +1 @@
-Subproject commit 58d2a028d1600225ac3a478d6b3a06ba2f0c01f6
+Subproject commit 357608d11b7a1961c3fb7db2ef9a5dbb2e87da77
diff --git a/contrib/libpqxx-cmake/CMakeLists.txt b/contrib/libpqxx-cmake/CMakeLists.txt
index 4edef7bdd82..ae35538ccf4 100644
--- a/contrib/libpqxx-cmake/CMakeLists.txt
+++ b/contrib/libpqxx-cmake/CMakeLists.txt
@@ -64,7 +64,7 @@ set (HDRS
 add_library(libpqxx ${SRCS} ${HDRS})
 
 target_link_libraries(libpqxx PUBLIC ${LIBPQ_LIBRARY})
-target_include_directories (libpqxx PRIVATE "${LIBRARY_DIR}/include")
+target_include_directories (libpqxx SYSTEM PRIVATE "${LIBRARY_DIR}/include")
 
 # crutch
 set(CM_CONFIG_H_IN "${LIBRARY_DIR}/include/pqxx/config.h.in")
diff --git a/docker/test/fuzzer/run-fuzzer.sh b/docker/test/fuzzer/run-fuzzer.sh
index c5e457726ef..45709e5c501 100755
--- a/docker/test/fuzzer/run-fuzzer.sh
+++ b/docker/test/fuzzer/run-fuzzer.sh
@@ -200,7 +200,7 @@ continue
         # The server has died.
         task_exit_code=210
         echo "failure" > status.txt
-        if ! grep -ao "Received signal.*\|Logical error.*\|Assertion.*failed\|Failed assertion.*\|.*runtime error: .*\|.*is located.*\|SUMMARY: AddressSanitizer:.*\|SUMMARY: MemorySanitizer:.*\|SUMMARY: ThreadSanitizer:.*\|.*_LIBCPP_ASSERT.*" server.log > description.txt
+        if ! grep --text -ao "Received signal.*\|Logical error.*\|Assertion.*failed\|Failed assertion.*\|.*runtime error: .*\|.*is located.*\|SUMMARY: AddressSanitizer:.*\|SUMMARY: MemorySanitizer:.*\|SUMMARY: ThreadSanitizer:.*\|.*_LIBCPP_ASSERT.*" server.log > description.txt
         then
             echo "Lost connection to server. See the logs." > description.txt
         fi
@@ -220,8 +220,8 @@ continue
         # which is confusing.
         task_exit_code=$fuzzer_exit_code
         echo "failure" > status.txt
-        { grep -o "Found error:.*" fuzzer.log \
-            || grep -o "Exception.*" fuzzer.log \
+        { grep --text -o "Found error:.*" fuzzer.log \
+            || grep --text -o "Exception.*" fuzzer.log \
             || echo "Fuzzer failed ($fuzzer_exit_code). See the logs." ; } \
             | tail -1 > description.txt
     fi
diff --git a/docker/test/stateful/run.sh b/docker/test/stateful/run.sh
index 8d865431570..d8ea2153b36 100755
--- a/docker/test/stateful/run.sh
+++ b/docker/test/stateful/run.sh
@@ -112,12 +112,15 @@ timeout "$MAX_RUN_TIME" bash -c run_tests ||:
 
 ./process_functional_tests_result.py || echo -e "failure\tCannot parse results" > /test_output/check_status.tsv
 
+grep -Fa "Fatal" /var/log/clickhouse-server/clickhouse-server.log ||:
 pigz < /var/log/clickhouse-server/clickhouse-server.log > /test_output/clickhouse-server.log.gz ||:
 mv /var/log/clickhouse-server/stderr.log /test_output/ ||:
 if [[ -n "$WITH_COVERAGE" ]] && [[ "$WITH_COVERAGE" -eq 1 ]]; then
     tar -chf /test_output/clickhouse_coverage.tar.gz /profraw ||:
 fi
 if [[ -n "$USE_DATABASE_REPLICATED" ]] && [[ "$USE_DATABASE_REPLICATED" -eq 1 ]]; then
+    grep -Fa "Fatal" /var/log/clickhouse-server/clickhouse-server1.log ||:
+    grep -Fa "Fatal" /var/log/clickhouse-server/clickhouse-server2.log ||:
     pigz < /var/log/clickhouse-server/clickhouse-server1.log > /test_output/clickhouse-server1.log.gz ||:
     pigz < /var/log/clickhouse-server/clickhouse-server2.log > /test_output/clickhouse-server2.log.gz ||:
     mv /var/log/clickhouse-server/stderr1.log /test_output/ ||:
diff --git a/docker/test/stateless/process_functional_tests_result.py b/docker/test/stateless/process_functional_tests_result.py
index 5d183250357..b3c8fa96144 100755
--- a/docker/test/stateless/process_functional_tests_result.py
+++ b/docker/test/stateless/process_functional_tests_result.py
@@ -14,6 +14,8 @@ HUNG_SIGN = "Found hung queries in processlist"
 
 NO_TASK_TIMEOUT_SIGN = "All tests have finished"
 
+RETRIES_SIGN = "Some tests were restarted"
+
 def process_test_log(log_path):
     total = 0
     skipped = 0
@@ -21,6 +23,7 @@ def process_test_log(log_path):
     failed = 0
     success = 0
     hung = False
+    retries = False
     task_timeout = True
     test_results = []
     with open(log_path, 'r') as test_file:
@@ -30,6 +33,8 @@ def process_test_log(log_path):
                 task_timeout = False
             if HUNG_SIGN in line:
                 hung = True
+            if RETRIES_SIGN in line:
+                retries = True
             if any(sign in line for sign in (OK_SIGN, FAIL_SIGN, UNKNOWN_SIGN, SKIPPED_SIGN)):
                 test_name = line.split(' ')[2].split(':')[0]
 
@@ -57,7 +62,7 @@ def process_test_log(log_path):
                 else:
                     success += int(OK_SIGN in line)
                     test_results.append((test_name, "OK", test_time))
-    return total, skipped, unknown, failed, success, hung, task_timeout, test_results
+    return total, skipped, unknown, failed, success, hung, task_timeout, retries, test_results
 
 def process_result(result_path):
     test_results = []
@@ -73,7 +78,7 @@ def process_result(result_path):
         state = "error"
 
     if result_path and os.path.exists(result_path):
-        total, skipped, unknown, failed, success, hung, task_timeout, test_results = process_test_log(result_path)
+        total, skipped, unknown, failed, success, hung, task_timeout, retries, test_results = process_test_log(result_path)
         is_flacky_check = 1 < int(os.environ.get('NUM_TRIES', 1))
         # If no tests were run (success == 0) it indicates an error (e.g. server did not start or crashed immediately)
         # But it's Ok for "flaky checks" - they can contain just one test for check which is marked as skipped.
@@ -83,9 +88,14 @@ def process_result(result_path):
         if hung:
             description = "Some queries hung, "
             state = "failure"
+            test_results.append(("Some queries hung", "FAIL", "0"))
         elif task_timeout:
             description = "Timeout, "
             state = "failure"
+            test_results.append(("Timeout", "FAIL", "0"))
+        elif retries:
+            description = "Some tests restarted, "
+            test_results.append(("Some tests restarted", "SKIPPED", "0"))
         else:
             description = ""
 
diff --git a/docker/test/stateless/run.sh b/docker/test/stateless/run.sh
index 6f7692f5e89..58b1d18a681 100755
--- a/docker/test/stateless/run.sh
+++ b/docker/test/stateless/run.sh
@@ -103,6 +103,7 @@ timeout "$MAX_RUN_TIME" bash -c run_tests ||:
 
 clickhouse-client -q "system flush logs" ||:
 
+grep -Fa "Fatal" /var/log/clickhouse-server/clickhouse-server.log ||:
 pigz < /var/log/clickhouse-server/clickhouse-server.log > /test_output/clickhouse-server.log.gz &
 clickhouse-client -q "select * from system.query_log format TSVWithNamesAndTypes" | pigz > /test_output/query-log.tsv.gz &
 clickhouse-client -q "select * from system.query_thread_log format TSVWithNamesAndTypes" | pigz > /test_output/query-thread-log.tsv.gz &
@@ -140,6 +141,8 @@ tar -chf /test_output/query_log_dump.tar /var/lib/clickhouse/data/system/query_l
 tar -chf /test_output/coordination.tar /var/lib/clickhouse/coordination ||:
 
 if [[ -n "$USE_DATABASE_REPLICATED" ]] && [[ "$USE_DATABASE_REPLICATED" -eq 1 ]]; then
+  grep -Fa "Fatal" /var/log/clickhouse-server/clickhouse-server1.log ||:
+  grep -Fa "Fatal" /var/log/clickhouse-server/clickhouse-server2.log ||:
     pigz < /var/log/clickhouse-server/clickhouse-server1.log > /test_output/clickhouse-server1.log.gz ||:
     pigz < /var/log/clickhouse-server/clickhouse-server2.log > /test_output/clickhouse-server2.log.gz ||:
     mv /var/log/clickhouse-server/stderr1.log /test_output/ ||:
diff --git a/programs/client/Client.cpp b/programs/client/Client.cpp
index 49d3dc3d10b..2a973f9967e 100644
--- a/programs/client/Client.cpp
+++ b/programs/client/Client.cpp
@@ -21,7 +21,7 @@
 #include <unordered_set>
 #include <algorithm>
 #include <optional>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 #include <boost/program_options.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <Poco/String.h>
@@ -549,65 +549,6 @@ private:
 
         /// Initialize DateLUT here to avoid counting time spent here as query execution time.
         const auto local_tz = DateLUT::instance().getTimeZone();
-        if (!context->getSettingsRef().use_client_time_zone)
-        {
-            const auto & time_zone = connection->getServerTimezone(connection_parameters.timeouts);
-            if (!time_zone.empty())
-            {
-                try
-                {
-                    DateLUT::setDefaultTimezone(time_zone);
-                }
-                catch (...)
-                {
-                    std::cerr << "Warning: could not switch to server time zone: " << time_zone
-                              << ", reason: " << getCurrentExceptionMessage(/* with_stacktrace = */ false) << std::endl
-                              << "Proceeding with local time zone." << std::endl
-                              << std::endl;
-                }
-            }
-            else
-            {
-                std::cerr << "Warning: could not determine server time zone. "
-                          << "Proceeding with local time zone." << std::endl
-                          << std::endl;
-            }
-        }
-
-        Strings keys;
-
-        prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name.default", "{display_name} :) ");
-
-        config().keys("prompt_by_server_display_name", keys);
-
-        for (const String & key : keys)
-        {
-            if (key != "default" && server_display_name.find(key) != std::string::npos)
-            {
-                prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name." + key);
-                break;
-            }
-        }
-
-        /// Prompt may contain escape sequences including \e[ or \x1b[ sequences to set terminal color.
-        {
-            String unescaped_prompt_by_server_display_name;
-            ReadBufferFromString in(prompt_by_server_display_name);
-            readEscapedString(unescaped_prompt_by_server_display_name, in);
-            prompt_by_server_display_name = std::move(unescaped_prompt_by_server_display_name);
-        }
-
-        /// Prompt may contain the following substitutions in a form of {name}.
-        std::map<String, String> prompt_substitutions{
-            {"host", connection_parameters.host},
-            {"port", toString(connection_parameters.port)},
-            {"user", connection_parameters.user},
-            {"display_name", server_display_name},
-        };
-
-        /// Quite suboptimal.
-        for (const auto & [key, value] : prompt_substitutions)
-            boost::replace_all(prompt_by_server_display_name, "{" + key + "}", value);
 
         if (is_interactive)
         {
@@ -805,6 +746,66 @@ private:
                           << std::endl;
             }
         }
+
+        if (!context->getSettingsRef().use_client_time_zone)
+        {
+            const auto & time_zone = connection->getServerTimezone(connection_parameters.timeouts);
+            if (!time_zone.empty())
+            {
+                try
+                {
+                    DateLUT::setDefaultTimezone(time_zone);
+                }
+                catch (...)
+                {
+                    std::cerr << "Warning: could not switch to server time zone: " << time_zone
+                              << ", reason: " << getCurrentExceptionMessage(/* with_stacktrace = */ false) << std::endl
+                              << "Proceeding with local time zone." << std::endl
+                              << std::endl;
+                }
+            }
+            else
+            {
+                std::cerr << "Warning: could not determine server time zone. "
+                          << "Proceeding with local time zone." << std::endl
+                          << std::endl;
+            }
+        }
+
+        Strings keys;
+
+        prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name.default", "{display_name} :) ");
+
+        config().keys("prompt_by_server_display_name", keys);
+
+        for (const String & key : keys)
+        {
+            if (key != "default" && server_display_name.find(key) != std::string::npos)
+            {
+                prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name." + key);
+                break;
+            }
+        }
+
+        /// Prompt may contain escape sequences including \e[ or \x1b[ sequences to set terminal color.
+        {
+            String unescaped_prompt_by_server_display_name;
+            ReadBufferFromString in(prompt_by_server_display_name);
+            readEscapedString(unescaped_prompt_by_server_display_name, in);
+            prompt_by_server_display_name = std::move(unescaped_prompt_by_server_display_name);
+        }
+
+        /// Prompt may contain the following substitutions in a form of {name}.
+        std::map<String, String> prompt_substitutions{
+            {"host", connection_parameters.host},
+            {"port", toString(connection_parameters.port)},
+            {"user", connection_parameters.user},
+            {"display_name", server_display_name},
+        };
+
+        /// Quite suboptimal.
+        for (const auto & [key, value] : prompt_substitutions)
+            boost::replace_all(prompt_by_server_display_name, "{" + key + "}", value);
     }
 
 
@@ -1202,7 +1203,9 @@ private:
                 client_exception.reset();
                 server_exception.reset();
                 have_error = false;
-                connection->forceConnected(connection_parameters.timeouts);
+
+                if (!connection->checkConnected())
+                    connect();
             }
 
             // Report error.
@@ -1603,7 +1606,8 @@ private:
             if (with_output && with_output->settings_ast)
                 apply_query_settings(*with_output->settings_ast);
 
-            connection->forceConnected(connection_parameters.timeouts);
+            if (!connection->checkConnected())
+                connect();
 
             ASTPtr input_function;
             if (insert && insert->select)
diff --git a/programs/client/ConnectionParameters.cpp b/programs/client/ConnectionParameters.cpp
index 6faf43759df..fd0b250e66b 100644
--- a/programs/client/ConnectionParameters.cpp
+++ b/programs/client/ConnectionParameters.cpp
@@ -10,7 +10,7 @@
 #include <Common/isLocalAddress.h>
 #include <Common/DNSResolver.h>
 #include <common/setTerminalEcho.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #if !defined(ARCADIA_BUILD)
 #include <readpassphrase.h> // Y_IGNORE
diff --git a/programs/copier/ClusterCopier.cpp b/programs/copier/ClusterCopier.cpp
index 6863c6e7c19..128f8bc1cdd 100644
--- a/programs/copier/ClusterCopier.cpp
+++ b/programs/copier/ClusterCopier.cpp
@@ -1746,7 +1746,7 @@ void ClusterCopier::createShardInternalTables(const ConnectionTimeouts & timeout
     task_shard.table_read_shard = DatabaseAndTableName(working_database_name, read_shard_prefix + task_table.table_id);
     task_shard.main_table_split_shard = DatabaseAndTableName(working_database_name, split_shard_prefix + task_table.table_id);
 
-    for (const auto & piece_number : ext::range(0, task_table.number_of_splits))
+    for (const auto & piece_number : collections::range(0, task_table.number_of_splits))
     {
         task_shard.list_of_split_tables_on_shard[piece_number] =
                 DatabaseAndTableName(working_database_name, split_shard_prefix + task_table.table_id + "_piece_" + toString(piece_number));
@@ -1776,7 +1776,7 @@ void ClusterCopier::createShardInternalTables(const ConnectionTimeouts & timeout
         dropAndCreateLocalTable(create_table_split_piece_ast);
 
         /// Create auxiliary split tables for each piece
-        for (const auto & piece_number : ext::range(0, task_table.number_of_splits))
+        for (const auto & piece_number : collections::range(0, task_table.number_of_splits))
         {
             const auto & storage_piece_split_ast = task_table.auxiliary_engine_split_asts[piece_number];
 
diff --git a/programs/copier/ClusterCopierApp.cpp b/programs/copier/ClusterCopierApp.cpp
index 7a0b81309b0..69f2fd3383c 100644
--- a/programs/copier/ClusterCopierApp.cpp
+++ b/programs/copier/ClusterCopierApp.cpp
@@ -3,7 +3,7 @@
 #include <Common/TerminalSize.h>
 #include <IO/ConnectionTimeoutsContext.h>
 #include <Formats/registerFormats.h>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 #include <unistd.h>
 #include <filesystem>
 
diff --git a/programs/copier/TaskTableAndShard.h b/programs/copier/TaskTableAndShard.h
index 30b057440bb..0e18efd2975 100644
--- a/programs/copier/TaskTableAndShard.h
+++ b/programs/copier/TaskTableAndShard.h
@@ -6,7 +6,7 @@
 
 #include <Core/Defines.h>
 
-#include <ext/map.h>
+#include <common/map.h>
 #include <boost/algorithm/string/join.hpp>
 
 
@@ -305,7 +305,7 @@ inline TaskTable::TaskTable(TaskCluster & parent, const Poco::Util::AbstractConf
         main_engine_split_ast = createASTStorageDistributed(cluster_push_name, table_push.first, table_push.second,
                                                             sharding_key_ast);
 
-        for (const auto piece_number : ext::range(0, number_of_splits))
+        for (const auto piece_number : collections::range(0, number_of_splits))
         {
             auxiliary_engine_split_asts.emplace_back
                     (
diff --git a/programs/install/Install.cpp b/programs/install/Install.cpp
index a7f566a78b8..8013b6cf991 100644
--- a/programs/install/Install.cpp
+++ b/programs/install/Install.cpp
@@ -75,6 +75,9 @@ namespace ErrorCodes
 #define HILITE "\033[1m"
 #define END_HILITE "\033[0m"
 
+static constexpr auto CLICKHOUSE_BRIDGE_USER = "clickhouse-bridge";
+static constexpr auto CLICKHOUSE_BRIDGE_GROUP = "clickhouse-bridge";
+
 using namespace DB;
 namespace po = boost::program_options;
 namespace fs = std::filesystem;
@@ -150,7 +153,6 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
             << argv[0]
             << " install [options]\n";
         std::cout << desc << '\n';
-        return 1;
     }
 
     try
@@ -324,26 +326,34 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
         std::string user = options["user"].as<std::string>();
         std::string group = options["group"].as<std::string>();
 
+        auto create_group = [](const String & group_name)
+        {
+            std::string command = fmt::format("groupadd -r {}", group_name);
+            fmt::print(" {}\n", command);
+            executeScript(command);
+        };
+
         if (!group.empty())
         {
-            {
-                fmt::print("Creating clickhouse group if it does not exist.\n");
-                std::string command = fmt::format("groupadd -r {}", group);
-                fmt::print(" {}\n", command);
-                executeScript(command);
-            }
+            fmt::print("Creating clickhouse group if it does not exist.\n");
+            create_group(group);
         }
         else
             fmt::print("Will not create clickhouse group");
 
+        auto create_user = [](const String & user_name, const String & group_name)
+        {
+            std::string command = group_name.empty()
+                ? fmt::format("useradd -r --shell /bin/false --home-dir /nonexistent --user-group {}", user_name)
+                : fmt::format("useradd -r --shell /bin/false --home-dir /nonexistent -g {} {}", group_name, user_name);
+            fmt::print(" {}\n", command);
+            executeScript(command);
+        };
+
         if (!user.empty())
         {
             fmt::print("Creating clickhouse user if it does not exist.\n");
-            std::string command = group.empty()
-                ? fmt::format("useradd -r --shell /bin/false --home-dir /nonexistent --user-group {}", user)
-                : fmt::format("useradd -r --shell /bin/false --home-dir /nonexistent -g {} {}", group, user);
-            fmt::print(" {}\n", command);
-            executeScript(command);
+            create_user(user, group);
 
             if (group.empty())
                 group = user;
@@ -475,12 +485,15 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
             }
         }
 
-        /// Chmod and chown configs
+        auto change_ownership = [](const String & file_name, const String & user_name, const String & group_name)
         {
-            std::string command = fmt::format("chown --recursive {}:{} '{}'", user, group, config_dir.string());
+            std::string command = fmt::format("chown --recursive {}:{} '{}'", user_name, group_name, file_name);
             fmt::print(" {}\n", command);
             executeScript(command);
-        }
+        };
+
+        /// Chmod and chown configs
+        change_ownership(config_dir.string(), user, group);
 
         /// Symlink "preprocessed_configs" is created by the server, so "write" is needed.
         fs::permissions(config_dir, fs::perms::owner_all, fs::perm_options::replace);
@@ -558,7 +571,19 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
         /// Data directory is not accessible to anyone except clickhouse.
         fs::permissions(data_path, fs::perms::owner_all, fs::perm_options::replace);
 
-        /// Set up password for default user.
+        fs::path odbc_bridge_path = bin_dir / "clickhouse-odbc-bridge";
+        fs::path library_bridge_path = bin_dir / "clickhouse-library-bridge";
+
+        if (fs::exists(odbc_bridge_path) || fs::exists(library_bridge_path))
+        {
+            create_group(CLICKHOUSE_BRIDGE_GROUP);
+            create_user(CLICKHOUSE_BRIDGE_USER, CLICKHOUSE_BRIDGE_GROUP);
+
+            if (fs::exists(odbc_bridge_path))
+                change_ownership(odbc_bridge_path, CLICKHOUSE_BRIDGE_USER, CLICKHOUSE_BRIDGE_GROUP);
+            if (fs::exists(library_bridge_path))
+                change_ownership(library_bridge_path, CLICKHOUSE_BRIDGE_USER, CLICKHOUSE_BRIDGE_GROUP);
+        }
 
         bool stdin_is_a_tty = isatty(STDIN_FILENO);
         bool stdout_is_a_tty = isatty(STDOUT_FILENO);
@@ -573,6 +598,7 @@ int mainEntryClickHouseInstall(int argc, char ** argv)
         /// We can ask password even if stdin is closed/redirected but /dev/tty is available.
         bool can_ask_password = !noninteractive && stdout_is_a_tty;
 
+        /// Set up password for default user.
         if (has_password_for_default_user)
         {
             fmt::print(HILITE "Password for default user is already specified. To remind or reset, see {} and {}." END_HILITE "\n",
@@ -819,15 +845,25 @@ namespace
 
         if (fs::exists(pid_file))
         {
-            ReadBufferFromFile in(pid_file.string());
-            if (tryReadIntText(pid, in))
+            try
             {
-                fmt::print("{} file exists and contains pid = {}.\n", pid_file.string(), pid);
+                ReadBufferFromFile in(pid_file.string());
+                if (tryReadIntText(pid, in))
+                {
+                    fmt::print("{} file exists and contains pid = {}.\n", pid_file.string(), pid);
+                }
+                else
+                {
+                    fmt::print("{} file exists but damaged, ignoring.\n", pid_file.string());
+                    fs::remove(pid_file);
+                }
             }
-            else
+            catch (const Exception & e)
             {
-                fmt::print("{} file exists but damaged, ignoring.\n", pid_file.string());
-                fs::remove(pid_file);
+                if (e.code() != ErrorCodes::FILE_DOESNT_EXIST)
+                    throw;
+
+                /// If file does not exist (TOCTOU) - it's ok.
             }
         }
 
diff --git a/programs/keeper/Keeper.cpp b/programs/keeper/Keeper.cpp
index 8b35ec12850..60695cbfeeb 100644
--- a/programs/keeper/Keeper.cpp
+++ b/programs/keeper/Keeper.cpp
@@ -12,7 +12,7 @@
 #include <common/defines.h>
 #include <common/logger_useful.h>
 #include <common/ErrorHandlers.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Poco/Util/HelpFormatter.h>
 #include <Poco/Version.h>
 #include <Poco/Environment.h>
diff --git a/programs/library-bridge/Handlers.cpp b/programs/library-bridge/Handlers.cpp
index 6a1bfbbccb7..ec82d7d52f4 100644
--- a/programs/library-bridge/Handlers.cpp
+++ b/programs/library-bridge/Handlers.cpp
@@ -51,7 +51,7 @@ namespace
 void LibraryRequestHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
     LOG_TRACE(log, "Request URI: {}", request.getURI());
-    HTMLForm params(request);
+    HTMLForm params(getContext()->getSettingsRef(), request);
 
     if (!params.has("method"))
     {
diff --git a/programs/library-bridge/LibraryUtils.h b/programs/library-bridge/LibraryUtils.h
index 8ced8df1c48..859b7e2633f 100644
--- a/programs/library-bridge/LibraryUtils.h
+++ b/programs/library-bridge/LibraryUtils.h
@@ -2,8 +2,8 @@
 
 #include <Common/StringUtils/StringUtils.h>
 #include <Core/Block.h>
-#include <ext/bit_cast.h>
-#include <ext/range.h>
+#include <common/bit_cast.h>
+#include <common/range.h>
 
 #include "LibraryInterface.h"
 
diff --git a/programs/library-bridge/SharedLibraryHandler.cpp b/programs/library-bridge/SharedLibraryHandler.cpp
index ab8cf2417c2..b31dcdee097 100644
--- a/programs/library-bridge/SharedLibraryHandler.cpp
+++ b/programs/library-bridge/SharedLibraryHandler.cpp
@@ -1,8 +1,9 @@
 #include "SharedLibraryHandler.h"
 
-#include <ext/scope_guard.h>
-#include <IO/ReadHelpers.h>
+#include <common/scope_guard.h>
+#include <common/bit_cast.h>
 #include <common/find_symbols.h>
+#include <IO/ReadHelpers.h>
 
 
 namespace DB
@@ -114,7 +115,7 @@ BlockInputStreamPtr SharedLibraryHandler::loadAll()
 
 BlockInputStreamPtr SharedLibraryHandler::loadIds(const std::vector<uint64_t> & ids)
 {
-    const ClickHouseLibrary::VectorUInt64 ids_data{ext::bit_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
+    const ClickHouseLibrary::VectorUInt64 ids_data{bit_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
 
     auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(attributes_names.size());
     ClickHouseLibrary::CStrings columns_pass{static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), attributes_names.size()};
diff --git a/programs/main.cpp b/programs/main.cpp
index c5df2596422..0e3d71c2c7b 100644
--- a/programs/main.cpp
+++ b/programs/main.cpp
@@ -22,7 +22,7 @@
 #include <Common/IO.h>
 
 #include <common/phdr_cache.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 
 /// Universal executable for various clickhouse applications
diff --git a/programs/obfuscator/Obfuscator.cpp b/programs/obfuscator/Obfuscator.cpp
index f68b255158c..ecefcac1faf 100644
--- a/programs/obfuscator/Obfuscator.cpp
+++ b/programs/obfuscator/Obfuscator.cpp
@@ -27,9 +27,9 @@
 #include <Core/Block.h>
 #include <common/StringRef.h>
 #include <common/DateLUT.h>
+#include <common/bit_cast.h>
 #include <IO/ReadBufferFromFileDescriptor.h>
 #include <IO/WriteBufferFromFileDescriptor.h>
-#include <ext/bit_cast.h>
 #include <memory>
 #include <cmath>
 #include <unistd.h>
@@ -254,9 +254,9 @@ Float transformFloatMantissa(Float x, UInt64 seed)
     using UInt = std::conditional_t<std::is_same_v<Float, Float32>, UInt32, UInt64>;
     constexpr size_t mantissa_num_bits = std::is_same_v<Float, Float32> ? 23 : 52;
 
-    UInt x_uint = ext::bit_cast<UInt>(x);
+    UInt x_uint = bit_cast<UInt>(x);
     x_uint = feistelNetwork(x_uint, mantissa_num_bits, seed);
-    return ext::bit_cast<Float>(x_uint);
+    return bit_cast<Float>(x_uint);
 }
 
 
diff --git a/programs/odbc-bridge/ColumnInfoHandler.cpp b/programs/odbc-bridge/ColumnInfoHandler.cpp
index 58967e78379..8ea1efe843a 100644
--- a/programs/odbc-bridge/ColumnInfoHandler.cpp
+++ b/programs/odbc-bridge/ColumnInfoHandler.cpp
@@ -13,8 +13,8 @@
 #include <Poco/Net/HTTPServerResponse.h>
 #include <Poco/NumberParser.h>
 #include <common/logger_useful.h>
+#include <common/scope_guard.h>
 #include <Common/quoteString.h>
-#include <ext/scope_guard.h>
 #include "getIdentifierQuote.h"
 #include "validateODBCConnectionString.h"
 #include "ODBCConnectionFactory.h"
@@ -69,7 +69,7 @@ namespace
 
 void ODBCColumnsInfoHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
-    HTMLForm params(request, request.getStream());
+    HTMLForm params(getContext()->getSettingsRef(), request, request.getStream());
     LOG_TRACE(log, "Request URI: {}", request.getURI());
 
     auto process_error = [&response, this](const std::string & message)
diff --git a/programs/odbc-bridge/IdentifierQuoteHandler.cpp b/programs/odbc-bridge/IdentifierQuoteHandler.cpp
index c706375a112..1e57ae167c9 100644
--- a/programs/odbc-bridge/IdentifierQuoteHandler.cpp
+++ b/programs/odbc-bridge/IdentifierQuoteHandler.cpp
@@ -11,7 +11,7 @@
 #include <Poco/Net/HTTPServerRequest.h>
 #include <Poco/Net/HTTPServerResponse.h>
 #include <common/logger_useful.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include "getIdentifierQuote.h"
 #include "validateODBCConnectionString.h"
 #include "ODBCConnectionFactory.h"
@@ -21,7 +21,7 @@ namespace DB
 {
 void IdentifierQuoteHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
-    HTMLForm params(request, request.getStream());
+    HTMLForm params(getContext()->getSettingsRef(), request, request.getStream());
     LOG_TRACE(log, "Request URI: {}", request.getURI());
 
     auto process_error = [&response, this](const std::string & message)
diff --git a/programs/odbc-bridge/MainHandler.cpp b/programs/odbc-bridge/MainHandler.cpp
index 65423ac81bf..2f43cbd4ff2 100644
--- a/programs/odbc-bridge/MainHandler.cpp
+++ b/programs/odbc-bridge/MainHandler.cpp
@@ -50,7 +50,7 @@ void ODBCHandler::processError(HTTPServerResponse & response, const std::string
 
 void ODBCHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
-    HTMLForm params(request);
+    HTMLForm params(getContext()->getSettingsRef(), request);
     LOG_TRACE(log, "Request URI: {}", request.getURI());
 
     if (mode == "read")
diff --git a/programs/odbc-bridge/ODBCBlockInputStream.cpp b/programs/odbc-bridge/ODBCBlockInputStream.cpp
index 99af4a2e7c1..b23d09e0481 100644
--- a/programs/odbc-bridge/ODBCBlockInputStream.cpp
+++ b/programs/odbc-bridge/ODBCBlockInputStream.cpp
@@ -9,7 +9,6 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <common/logger_useful.h>
-#include <ext/range.h>
 
 
 namespace DB
diff --git a/programs/odbc-bridge/SchemaAllowedHandler.cpp b/programs/odbc-bridge/SchemaAllowedHandler.cpp
index e6ec49f221d..6ef6f03a137 100644
--- a/programs/odbc-bridge/SchemaAllowedHandler.cpp
+++ b/programs/odbc-bridge/SchemaAllowedHandler.cpp
@@ -29,7 +29,7 @@ namespace
 
 void SchemaAllowedHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
-    HTMLForm params(request, request.getStream());
+    HTMLForm params(getContext()->getSettingsRef(), request, request.getStream());
     LOG_TRACE(log, "Request URI: {}", request.getURI());
 
     auto process_error = [&response, this](const std::string & message)
diff --git a/programs/server/Server.cpp b/programs/server/Server.cpp
index f2bfe9d9ee2..ad2c83da194 100644
--- a/programs/server/Server.cpp
+++ b/programs/server/Server.cpp
@@ -14,7 +14,7 @@
 #include <Poco/Net/NetException.h>
 #include <Poco/Util/HelpFormatter.h>
 #include <Poco/Environment.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <common/defines.h>
 #include <common/logger_useful.h>
 #include <common/phdr_cache.h>
diff --git a/src/Access/AccessFlags.h b/src/Access/AccessFlags.h
index 049140586ea..7e32f423564 100644
--- a/src/Access/AccessFlags.h
+++ b/src/Access/AccessFlags.h
@@ -2,9 +2,8 @@
 
 #include <Access/AccessType.h>
 #include <common/types.h>
+#include <common/range.h>
 #include <Common/Exception.h>
-#include <ext/range.h>
-#include <ext/push_back.h>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <bitset>
diff --git a/src/Access/AllowedClientHosts.cpp b/src/Access/AllowedClientHosts.cpp
index 1bcdd26c383..5ac05bea88d 100644
--- a/src/Access/AllowedClientHosts.cpp
+++ b/src/Access/AllowedClientHosts.cpp
@@ -1,11 +1,11 @@
 #include <Access/AllowedClientHosts.h>
 #include <Common/Exception.h>
 #include <common/SimpleCache.h>
+#include <common/logger_useful.h>
+#include <common/scope_guard.h>
 #include <Functions/likePatternToRegexp.h>
 #include <Poco/Net/SocketAddress.h>
 #include <Poco/RegularExpression.h>
-#include <common/logger_useful.h>
-#include <ext/scope_guard.h>
 #include <boost/algorithm/string/replace.hpp>
 #include <ifaddrs.h>
 #include <Common/DNSResolver.h>
diff --git a/src/Access/ContextAccess.h b/src/Access/ContextAccess.h
index 320c2566769..a4373be4ff0 100644
--- a/src/Access/ContextAccess.h
+++ b/src/Access/ContextAccess.h
@@ -4,8 +4,8 @@
 #include <Access/RowPolicy.h>
 #include <Interpreters/ClientInfo.h>
 #include <Core/UUID.h>
-#include <ext/scope_guard.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/scope_guard.h>
+#include <common/shared_ptr_helper.h>
 #include <boost/container/flat_set.hpp>
 #include <mutex>
 
@@ -214,9 +214,9 @@ private:
     mutable Poco::Logger * trace_log = nullptr;
     mutable UserPtr user;
     mutable String user_name;
-    mutable ext::scope_guard subscription_for_user_change;
+    mutable scope_guard subscription_for_user_change;
     mutable std::shared_ptr<const EnabledRoles> enabled_roles;
-    mutable ext::scope_guard subscription_for_roles_changes;
+    mutable scope_guard subscription_for_roles_changes;
     mutable std::shared_ptr<const EnabledRolesInfo> roles_info;
     mutable std::shared_ptr<const AccessRights> access;
     mutable std::shared_ptr<const AccessRights> access_with_implicit;
diff --git a/src/Access/DiskAccessStorage.cpp b/src/Access/DiskAccessStorage.cpp
index 8c38cd02f9c..2c074e3d0b0 100644
--- a/src/Access/DiskAccessStorage.cpp
+++ b/src/Access/DiskAccessStorage.cpp
@@ -374,7 +374,7 @@ bool DiskAccessStorage::isPathEqual(const String & directory_path_) const
 void DiskAccessStorage::clear()
 {
     entries_by_id.clear();
-    for (auto type : ext::range(EntityType::MAX))
+    for (auto type : collections::range(EntityType::MAX))
         entries_by_name_and_type[static_cast<size_t>(type)].clear();
 }
 
@@ -384,7 +384,7 @@ bool DiskAccessStorage::readLists()
     clear();
 
     bool ok = true;
-    for (auto type : ext::range(EntityType::MAX))
+    for (auto type : collections::range(EntityType::MAX))
     {
         auto & entries_by_name = entries_by_name_and_type[static_cast<size_t>(type)];
         auto file_path = getListFilePath(directory_path, type);
@@ -543,7 +543,7 @@ bool DiskAccessStorage::rebuildLists()
         entries_by_name[entry.name] = &entry;
     }
 
-    for (auto type : ext::range(EntityType::MAX))
+    for (auto type : collections::range(EntityType::MAX))
         types_of_lists_to_write.insert(type);
 
     return true;
@@ -786,7 +786,7 @@ void DiskAccessStorage::prepareNotifications(const UUID & id, const Entry & entr
 }
 
 
-ext::scope_guard DiskAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
+scope_guard DiskAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
 {
     std::lock_guard lock{mutex};
     auto it = entries_by_id.find(id);
@@ -807,7 +807,7 @@ ext::scope_guard DiskAccessStorage::subscribeForChangesImpl(const UUID & id, con
     };
 }
 
-ext::scope_guard DiskAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
+scope_guard DiskAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
 {
     std::lock_guard lock{mutex};
     auto & handlers = handlers_by_type[static_cast<size_t>(type)];
diff --git a/src/Access/DiskAccessStorage.h b/src/Access/DiskAccessStorage.h
index f1df8e87a03..5e3f4a1eafa 100644
--- a/src/Access/DiskAccessStorage.h
+++ b/src/Access/DiskAccessStorage.h
@@ -36,8 +36,8 @@ private:
     UUID insertImpl(const AccessEntityPtr & entity, bool replace_if_exists) override;
     void removeImpl(const UUID & id) override;
     void updateImpl(const UUID & id, const UpdateFunc & update_func) override;
-    ext::scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
-    ext::scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
     bool hasSubscriptionImpl(const UUID & id) const override;
     bool hasSubscriptionImpl(EntityType type) const override;
 
diff --git a/src/Access/EnabledQuota.cpp b/src/Access/EnabledQuota.cpp
index 4a77426004d..4affa4f3ec1 100644
--- a/src/Access/EnabledQuota.cpp
+++ b/src/Access/EnabledQuota.cpp
@@ -2,8 +2,8 @@
 #include <Access/QuotaUsage.h>
 #include <Common/Exception.h>
 #include <Common/quoteString.h>
-#include <ext/chrono_io.h>
-#include <ext/range.h>
+#include <common/chrono_io.h>
+#include <common/range.h>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/range/algorithm/fill.hpp>
 
@@ -28,9 +28,9 @@ struct EnabledQuota::Impl
     {
         const auto & type_info = Quota::ResourceTypeInfo::get(resource_type);
         throw Exception(
-            "Quota for user " + backQuote(user_name) + " for " + ext::to_string(duration) + " has been exceeded: "
+            "Quota for user " + backQuote(user_name) + " for " + to_string(duration) + " has been exceeded: "
                 + type_info.outputWithAmount(used) + "/" + type_info.amountToString(max) + ". "
-                + "Interval will end at " + ext::to_string(end_of_interval) + ". " + "Name of quota template: " + backQuote(quota_name),
+                + "Interval will end at " + to_string(end_of_interval) + ". " + "Name of quota template: " + backQuote(quota_name),
             ErrorCodes::QUOTA_EXPIRED);
     }
 
@@ -137,7 +137,7 @@ struct EnabledQuota::Impl
         const Intervals & intervals,
         std::chrono::system_clock::time_point current_time)
     {
-        for (auto resource_type : ext::range(Quota::MAX_RESOURCE_TYPE))
+        for (auto resource_type : collections::range(Quota::MAX_RESOURCE_TYPE))
             checkExceeded(user_name, intervals, resource_type, current_time);
     }
 };
@@ -145,7 +145,7 @@ struct EnabledQuota::Impl
 
 EnabledQuota::Interval::Interval()
 {
-    for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+    for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
     {
         used[resource_type].store(0);
         max[resource_type] = 0;
@@ -161,7 +161,7 @@ EnabledQuota::Interval & EnabledQuota::Interval::operator =(const Interval & src
     randomize_interval = src.randomize_interval;
     duration = src.duration;
     end_of_interval.store(src.end_of_interval.load());
-    for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+    for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
     {
         max[resource_type] = src.max[resource_type];
         used[resource_type].store(src.used[resource_type].load());
@@ -187,7 +187,7 @@ std::optional<QuotaUsage> EnabledQuota::Intervals::getUsage(std::chrono::system_
         out.randomize_interval = in.randomize_interval;
         bool counters_were_reset = false;
         out.end_of_interval = Impl::getEndOfInterval(in, current_time, counters_were_reset);
-        for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+        for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
         {
             if (in.max[resource_type])
                 out.max[resource_type] = in.max[resource_type];
diff --git a/src/Access/EnabledRoles.cpp b/src/Access/EnabledRoles.cpp
index c847784eb22..282c52a9544 100644
--- a/src/Access/EnabledRoles.cpp
+++ b/src/Access/EnabledRoles.cpp
@@ -20,7 +20,7 @@ std::shared_ptr<const EnabledRolesInfo> EnabledRoles::getRolesInfo() const
 }
 
 
-ext::scope_guard EnabledRoles::subscribeForChanges(const OnChangeHandler & handler) const
+scope_guard EnabledRoles::subscribeForChanges(const OnChangeHandler & handler) const
 {
     std::lock_guard lock{mutex};
     handlers.push_back(handler);
@@ -34,7 +34,7 @@ ext::scope_guard EnabledRoles::subscribeForChanges(const OnChangeHandler & handl
 }
 
 
-void EnabledRoles::setRolesInfo(const std::shared_ptr<const EnabledRolesInfo> & info_, ext::scope_guard & notifications)
+void EnabledRoles::setRolesInfo(const std::shared_ptr<const EnabledRolesInfo> & info_, scope_guard & notifications)
 {
     std::lock_guard lock{mutex};
 
@@ -46,7 +46,7 @@ void EnabledRoles::setRolesInfo(const std::shared_ptr<const EnabledRolesInfo> &
     std::vector<OnChangeHandler> handlers_to_notify;
     boost::range::copy(handlers, std::back_inserter(handlers_to_notify));
 
-    notifications.join(ext::scope_guard([info = info, handlers_to_notify = std::move(handlers_to_notify)]
+    notifications.join(scope_guard([info = info, handlers_to_notify = std::move(handlers_to_notify)]
     {
         for (const auto & handler : handlers_to_notify)
             handler(info);
diff --git a/src/Access/EnabledRoles.h b/src/Access/EnabledRoles.h
index 67528732035..5cb00eb1829 100644
--- a/src/Access/EnabledRoles.h
+++ b/src/Access/EnabledRoles.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Core/UUID.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <boost/container/flat_set.hpp>
 #include <list>
 #include <mutex>
@@ -37,13 +37,13 @@ public:
     using OnChangeHandler = std::function<void(const std::shared_ptr<const EnabledRolesInfo> & info)>;
 
     /// Called when either the specified roles or the roles granted to the specified roles are changed.
-    ext::scope_guard subscribeForChanges(const OnChangeHandler & handler) const;
+    scope_guard subscribeForChanges(const OnChangeHandler & handler) const;
 
 private:
     friend class RoleCache;
     EnabledRoles(const Params & params_);
 
-    void setRolesInfo(const std::shared_ptr<const EnabledRolesInfo> & info_, ext::scope_guard & notifications);
+    void setRolesInfo(const std::shared_ptr<const EnabledRolesInfo> & info_, scope_guard & notifications);
 
     const Params params;
     mutable std::shared_ptr<const EnabledRolesInfo> info;
diff --git a/src/Access/GSSAcceptor.cpp b/src/Access/GSSAcceptor.cpp
index 49b83cc883c..a33e825f510 100644
--- a/src/Access/GSSAcceptor.cpp
+++ b/src/Access/GSSAcceptor.cpp
@@ -1,6 +1,6 @@
 #include <Access/GSSAcceptor.h>
 #include <Common/Exception.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <Poco/StringTokenizer.h>
 
diff --git a/src/Access/IAccessStorage.cpp b/src/Access/IAccessStorage.cpp
index 7b42abb2737..e258935f386 100644
--- a/src/Access/IAccessStorage.cpp
+++ b/src/Access/IAccessStorage.cpp
@@ -377,21 +377,21 @@ std::vector<UUID> IAccessStorage::tryUpdate(const std::vector<UUID> & ids, const
 }
 
 
-ext::scope_guard IAccessStorage::subscribeForChanges(EntityType type, const OnChangedHandler & handler) const
+scope_guard IAccessStorage::subscribeForChanges(EntityType type, const OnChangedHandler & handler) const
 {
     return subscribeForChangesImpl(type, handler);
 }
 
 
-ext::scope_guard IAccessStorage::subscribeForChanges(const UUID & id, const OnChangedHandler & handler) const
+scope_guard IAccessStorage::subscribeForChanges(const UUID & id, const OnChangedHandler & handler) const
 {
     return subscribeForChangesImpl(id, handler);
 }
 
 
-ext::scope_guard IAccessStorage::subscribeForChanges(const std::vector<UUID> & ids, const OnChangedHandler & handler) const
+scope_guard IAccessStorage::subscribeForChanges(const std::vector<UUID> & ids, const OnChangedHandler & handler) const
 {
-    ext::scope_guard subscriptions;
+    scope_guard subscriptions;
     for (const auto & id : ids)
         subscriptions.join(subscribeForChangesImpl(id, handler));
     return subscriptions;
diff --git a/src/Access/IAccessStorage.h b/src/Access/IAccessStorage.h
index cc914664149..f37bc53eeae 100644
--- a/src/Access/IAccessStorage.h
+++ b/src/Access/IAccessStorage.h
@@ -3,7 +3,7 @@
 #include <Access/IAccessEntity.h>
 #include <Core/Types.h>
 #include <Core/UUID.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <functional>
 #include <optional>
 #include <vector>
@@ -130,15 +130,15 @@ public:
 
     /// Subscribes for all changes.
     /// Can return nullptr if cannot subscribe (identifier not found) or if it doesn't make sense (the storage is read-only).
-    ext::scope_guard subscribeForChanges(EntityType type, const OnChangedHandler & handler) const;
+    scope_guard subscribeForChanges(EntityType type, const OnChangedHandler & handler) const;
 
     template <typename EntityClassT>
-    ext::scope_guard subscribeForChanges(OnChangedHandler handler) const { return subscribeForChanges(EntityClassT::TYPE, handler); }
+    scope_guard subscribeForChanges(OnChangedHandler handler) const { return subscribeForChanges(EntityClassT::TYPE, handler); }
 
     /// Subscribes for changes of a specific entry.
     /// Can return nullptr if cannot subscribe (identifier not found) or if it doesn't make sense (the storage is read-only).
-    ext::scope_guard subscribeForChanges(const UUID & id, const OnChangedHandler & handler) const;
-    ext::scope_guard subscribeForChanges(const std::vector<UUID> & ids, const OnChangedHandler & handler) const;
+    scope_guard subscribeForChanges(const UUID & id, const OnChangedHandler & handler) const;
+    scope_guard subscribeForChanges(const std::vector<UUID> & ids, const OnChangedHandler & handler) const;
 
     bool hasSubscription(EntityType type) const;
     bool hasSubscription(const UUID & id) const;
@@ -161,8 +161,8 @@ protected:
     virtual UUID insertImpl(const AccessEntityPtr & entity, bool replace_if_exists) = 0;
     virtual void removeImpl(const UUID & id) = 0;
     virtual void updateImpl(const UUID & id, const UpdateFunc & update_func) = 0;
-    virtual ext::scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const = 0;
-    virtual ext::scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const = 0;
+    virtual scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const = 0;
+    virtual scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const = 0;
     virtual bool hasSubscriptionImpl(const UUID & id) const = 0;
     virtual bool hasSubscriptionImpl(EntityType type) const = 0;
     virtual UUID loginImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators) const;
diff --git a/src/Access/LDAPAccessStorage.cpp b/src/Access/LDAPAccessStorage.cpp
index c1d54e8c9aa..07b9d089198 100644
--- a/src/Access/LDAPAccessStorage.cpp
+++ b/src/Access/LDAPAccessStorage.cpp
@@ -7,7 +7,7 @@
 #include <Access/LDAPClient.h>
 #include <Common/Exception.h>
 #include <common/logger_useful.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Poco/Util/AbstractConfiguration.h>
 #include <Poco/JSON/JSON.h>
 #include <Poco/JSON/Object.h>
@@ -475,14 +475,14 @@ void LDAPAccessStorage::updateImpl(const UUID & id, const UpdateFunc &)
 }
 
 
-ext::scope_guard LDAPAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
+scope_guard LDAPAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
 {
     std::scoped_lock lock(mutex);
     return memory_storage.subscribeForChanges(id, handler);
 }
 
 
-ext::scope_guard LDAPAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
+scope_guard LDAPAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
 {
     std::scoped_lock lock(mutex);
     return memory_storage.subscribeForChanges(type, handler);
diff --git a/src/Access/LDAPAccessStorage.h b/src/Access/LDAPAccessStorage.h
index 33ac9f0a914..3e5b10494ed 100644
--- a/src/Access/LDAPAccessStorage.h
+++ b/src/Access/LDAPAccessStorage.h
@@ -4,7 +4,7 @@
 #include <Access/LDAPClient.h>
 #include <Access/Credentials.h>
 #include <common/types.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <map>
 #include <mutex>
 #include <set>
@@ -51,8 +51,8 @@ private: // IAccessStorage implementations.
     virtual UUID insertImpl(const AccessEntityPtr & entity, bool replace_if_exists) override;
     virtual void removeImpl(const UUID & id) override;
     virtual void updateImpl(const UUID & id, const UpdateFunc & update_func) override;
-    virtual ext::scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
-    virtual ext::scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
+    virtual scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
+    virtual scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
     virtual bool hasSubscriptionImpl(const UUID & id) const override;
     virtual bool hasSubscriptionImpl(EntityType type) const override;
     virtual UUID loginImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators) const override;
@@ -80,7 +80,7 @@ private:
     mutable std::map<String, std::set<String>> roles_per_users; // user name -> role names (...that should be granted to it; may but don't have to include common roles)
     mutable std::map<UUID, String> granted_role_names;          // (currently granted) role id -> its name
     mutable std::map<String, UUID> granted_role_ids;            // (currently granted) role name -> its id
-    ext::scope_guard role_change_subscription;
+    scope_guard role_change_subscription;
     mutable MemoryAccessStorage memory_storage;
 };
 }
diff --git a/src/Access/LDAPClient.cpp b/src/Access/LDAPClient.cpp
index a8f9675774b..c12b0f22ab0 100644
--- a/src/Access/LDAPClient.cpp
+++ b/src/Access/LDAPClient.cpp
@@ -1,6 +1,6 @@
 #include <Access/LDAPClient.h>
 #include <Common/Exception.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <common/logger_useful.h>
 
 #include <Poco/Logger.h>
diff --git a/src/Access/MemoryAccessStorage.cpp b/src/Access/MemoryAccessStorage.cpp
index 58280c8b1d7..e788ca11cf2 100644
--- a/src/Access/MemoryAccessStorage.cpp
+++ b/src/Access/MemoryAccessStorage.cpp
@@ -1,5 +1,5 @@
 #include <Access/MemoryAccessStorage.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <boost/container/flat_set.hpp>
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
@@ -266,7 +266,7 @@ void MemoryAccessStorage::prepareNotifications(const Entry & entry, bool remove,
 }
 
 
-ext::scope_guard MemoryAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
+scope_guard MemoryAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
 {
     std::lock_guard lock{mutex};
     auto & handlers = handlers_by_type[static_cast<size_t>(type)];
@@ -282,7 +282,7 @@ ext::scope_guard MemoryAccessStorage::subscribeForChangesImpl(EntityType type, c
 }
 
 
-ext::scope_guard MemoryAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
+scope_guard MemoryAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
 {
     std::lock_guard lock{mutex};
     auto it = entries_by_id.find(id);
diff --git a/src/Access/MemoryAccessStorage.h b/src/Access/MemoryAccessStorage.h
index 512ccff1d1b..3558fcc6088 100644
--- a/src/Access/MemoryAccessStorage.h
+++ b/src/Access/MemoryAccessStorage.h
@@ -33,8 +33,8 @@ private:
     UUID insertImpl(const AccessEntityPtr & entity, bool replace_if_exists) override;
     void removeImpl(const UUID & id) override;
     void updateImpl(const UUID & id, const UpdateFunc & update_func) override;
-    ext::scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
-    ext::scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
     bool hasSubscriptionImpl(const UUID & id) const override;
     bool hasSubscriptionImpl(EntityType type) const override;
 
diff --git a/src/Access/MultipleAccessStorage.cpp b/src/Access/MultipleAccessStorage.cpp
index 15281d8c471..dbeecc8a2bc 100644
--- a/src/Access/MultipleAccessStorage.cpp
+++ b/src/Access/MultipleAccessStorage.cpp
@@ -1,7 +1,7 @@
 #include <Access/MultipleAccessStorage.h>
 #include <Access/Credentials.h>
 #include <Common/Exception.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/algorithm/copy.hpp>
@@ -265,7 +265,7 @@ void MultipleAccessStorage::updateImpl(const UUID & id, const UpdateFunc & updat
 }
 
 
-ext::scope_guard MultipleAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
+scope_guard MultipleAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
 {
     auto storage = findStorage(id);
     if (!storage)
@@ -286,7 +286,7 @@ bool MultipleAccessStorage::hasSubscriptionImpl(const UUID & id) const
 }
 
 
-ext::scope_guard MultipleAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
+scope_guard MultipleAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
 {
     std::unique_lock lock{mutex};
     auto & handlers = handlers_by_type[static_cast<size_t>(type)];
@@ -321,10 +321,10 @@ void MultipleAccessStorage::updateSubscriptionsToNestedStorages(std::unique_lock
 {
     /// lock is already locked.
 
-    std::vector<std::pair<StoragePtr, ext::scope_guard>> added_subscriptions[static_cast<size_t>(EntityType::MAX)];
-    std::vector<ext::scope_guard> removed_subscriptions;
+    std::vector<std::pair<StoragePtr, scope_guard>> added_subscriptions[static_cast<size_t>(EntityType::MAX)];
+    std::vector<scope_guard> removed_subscriptions;
 
-    for (auto type : ext::range(EntityType::MAX))
+    for (auto type : collections::range(EntityType::MAX))
     {
         auto & handlers = handlers_by_type[static_cast<size_t>(type)];
         auto & subscriptions = subscriptions_to_nested_storages[static_cast<size_t>(type)];
@@ -364,7 +364,7 @@ void MultipleAccessStorage::updateSubscriptionsToNestedStorages(std::unique_lock
     lock.unlock();
     removed_subscriptions.clear();
 
-    for (auto type : ext::range(EntityType::MAX))
+    for (auto type : collections::range(EntityType::MAX))
     {
         if (!added_subscriptions[static_cast<size_t>(type)].empty())
         {
@@ -384,7 +384,7 @@ void MultipleAccessStorage::updateSubscriptionsToNestedStorages(std::unique_lock
     /// Lock the mutex again to store added subscriptions to the nested storages.
     lock.lock();
 
-    for (auto type : ext::range(EntityType::MAX))
+    for (auto type : collections::range(EntityType::MAX))
     {
         if (!added_subscriptions[static_cast<size_t>(type)].empty())
         {
diff --git a/src/Access/MultipleAccessStorage.h b/src/Access/MultipleAccessStorage.h
index 610bf2fadcc..d1c8ec97b36 100644
--- a/src/Access/MultipleAccessStorage.h
+++ b/src/Access/MultipleAccessStorage.h
@@ -44,8 +44,8 @@ protected:
     UUID insertImpl(const AccessEntityPtr & entity, bool replace_if_exists) override;
     void removeImpl(const UUID & id) override;
     void updateImpl(const UUID & id, const UpdateFunc & update_func) override;
-    ext::scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
-    ext::scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
     bool hasSubscriptionImpl(const UUID & id) const override;
     bool hasSubscriptionImpl(EntityType type) const override;
     UUID loginImpl(const Credentials & credentials, const Poco::Net::IPAddress & address, const ExternalAuthenticators & external_authenticators) const override;
@@ -59,7 +59,7 @@ private:
     std::shared_ptr<const Storages> nested_storages;
     mutable LRUCache<UUID, Storage> ids_cache;
     mutable std::list<OnChangedHandler> handlers_by_type[static_cast<size_t>(EntityType::MAX)];
-    mutable std::unordered_map<StoragePtr, ext::scope_guard> subscriptions_to_nested_storages[static_cast<size_t>(EntityType::MAX)];
+    mutable std::unordered_map<StoragePtr, scope_guard> subscriptions_to_nested_storages[static_cast<size_t>(EntityType::MAX)];
     mutable std::mutex mutex;
 };
 
diff --git a/src/Access/Quota.h b/src/Access/Quota.h
index b7970b2583b..5adc6ec95e1 100644
--- a/src/Access/Quota.h
+++ b/src/Access/Quota.h
@@ -2,7 +2,7 @@
 
 #include <Access/IAccessEntity.h>
 #include <Access/RolesOrUsersSet.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/lexical_cast.hpp>
 #include <chrono>
@@ -219,7 +219,7 @@ inline const Quota::KeyTypeInfo & Quota::KeyTypeInfo::get(KeyType type)
         {
             for (const auto & token : tokens)
             {
-                for (auto kt : ext::range(KeyType::MAX))
+                for (auto kt : collections::range(KeyType::MAX))
                 {
                     if (KeyTypeInfo::get(kt).name == token)
                     {
diff --git a/src/Access/QuotaCache.cpp b/src/Access/QuotaCache.cpp
index 0f814bced4e..c20a436e1b9 100644
--- a/src/Access/QuotaCache.cpp
+++ b/src/Access/QuotaCache.cpp
@@ -4,7 +4,7 @@
 #include <Access/AccessControlManager.h>
 #include <Common/Exception.h>
 #include <Common/thread_local_rng.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/range/algorithm/lower_bound.hpp>
@@ -124,7 +124,7 @@ boost::shared_ptr<const EnabledQuota::Intervals> QuotaCache::QuotaInfo::rebuildI
         if (limits.randomize_interval)
             end_of_interval += randomDuration(limits.duration);
         interval.end_of_interval = end_of_interval.time_since_epoch();
-        for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+        for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
         {
             if (limits.max[resource_type])
                 interval.max[resource_type] = *limits.max[resource_type];
@@ -159,7 +159,7 @@ boost::shared_ptr<const EnabledQuota::Intervals> QuotaCache::QuotaInfo::rebuildI
 
             /// Found an interval with the same duration, we need to copy its usage information to `result`.
             const auto & current_interval = *lower_bound;
-            for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+            for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
             {
                 new_interval.used[resource_type].store(current_interval.used[resource_type].load());
                 new_interval.end_of_interval.store(current_interval.end_of_interval.load());
diff --git a/src/Access/QuotaCache.h b/src/Access/QuotaCache.h
index 31d274c4ff6..b5918f86dd4 100644
--- a/src/Access/QuotaCache.h
+++ b/src/Access/QuotaCache.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Access/EnabledQuota.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <memory>
 #include <mutex>
 #include <map>
@@ -60,7 +60,7 @@ private:
     mutable std::mutex mutex;
     std::unordered_map<UUID /* quota id */, QuotaInfo> all_quotas;
     bool all_quotas_read = false;
-    ext::scope_guard subscription;
+    scope_guard subscription;
     std::map<EnabledQuota::Params, std::weak_ptr<EnabledQuota>> enabled_quotas;
 };
 }
diff --git a/src/Access/RoleCache.cpp b/src/Access/RoleCache.cpp
index 8fa3d51f867..d264ec2d953 100644
--- a/src/Access/RoleCache.cpp
+++ b/src/Access/RoleCache.cpp
@@ -66,7 +66,7 @@ std::shared_ptr<const EnabledRoles>
 RoleCache::getEnabledRoles(const std::vector<UUID> & roles, const std::vector<UUID> & roles_with_admin_option)
 {
     /// Declared before `lock` to send notifications after the mutex will be unlocked.
-    ext::scope_guard notifications;
+    scope_guard notifications;
 
     std::lock_guard lock{mutex};
     EnabledRoles::Params params;
@@ -88,7 +88,7 @@ RoleCache::getEnabledRoles(const std::vector<UUID> & roles, const std::vector<UU
 }
 
 
-void RoleCache::collectEnabledRoles(ext::scope_guard & notifications)
+void RoleCache::collectEnabledRoles(scope_guard & notifications)
 {
     /// `mutex` is already locked.
 
@@ -106,7 +106,7 @@ void RoleCache::collectEnabledRoles(ext::scope_guard & notifications)
 }
 
 
-void RoleCache::collectEnabledRoles(EnabledRoles & enabled, ext::scope_guard & notifications)
+void RoleCache::collectEnabledRoles(EnabledRoles & enabled, scope_guard & notifications)
 {
     /// `mutex` is already locked.
 
@@ -146,8 +146,8 @@ RolePtr RoleCache::getRole(const UUID & role_id)
     auto role = manager.tryRead<Role>(role_id);
     if (role)
     {
-        auto cache_value = Poco::SharedPtr<std::pair<RolePtr, ext::scope_guard>>(
-            new std::pair<RolePtr, ext::scope_guard>{role, std::move(subscription)});
+        auto cache_value = Poco::SharedPtr<std::pair<RolePtr, scope_guard>>(
+            new std::pair<RolePtr, scope_guard>{role, std::move(subscription)});
         cache.add(role_id, cache_value);
         return role;
     }
@@ -159,7 +159,7 @@ RolePtr RoleCache::getRole(const UUID & role_id)
 void RoleCache::roleChanged(const UUID & role_id, const RolePtr & changed_role)
 {
     /// Declared before `lock` to send notifications after the mutex will be unlocked.
-    ext::scope_guard notifications;
+    scope_guard notifications;
 
     std::lock_guard lock{mutex};
     auto role_from_cache = cache.get(role_id);
@@ -174,7 +174,7 @@ void RoleCache::roleChanged(const UUID & role_id, const RolePtr & changed_role)
 void RoleCache::roleRemoved(const UUID & role_id)
 {
     /// Declared before `lock` to send notifications after the mutex will be unlocked.
-    ext::scope_guard notifications;
+    scope_guard notifications;
 
     std::lock_guard lock{mutex};
     cache.remove(role_id);
diff --git a/src/Access/RoleCache.h b/src/Access/RoleCache.h
index b3f426debcb..0a1d03c1a80 100644
--- a/src/Access/RoleCache.h
+++ b/src/Access/RoleCache.h
@@ -24,14 +24,14 @@ public:
         const std::vector<UUID> & current_roles_with_admin_option);
 
 private:
-    void collectEnabledRoles(ext::scope_guard & notifications);
-    void collectEnabledRoles(EnabledRoles & enabled, ext::scope_guard & notifications);
+    void collectEnabledRoles(scope_guard & notifications);
+    void collectEnabledRoles(EnabledRoles & enabled, scope_guard & notifications);
     RolePtr getRole(const UUID & role_id);
     void roleChanged(const UUID & role_id, const RolePtr & changed_role);
     void roleRemoved(const UUID & role_id);
 
     const AccessControlManager & manager;
-    Poco::ExpireCache<UUID, std::pair<RolePtr, ext::scope_guard>> cache;
+    Poco::ExpireCache<UUID, std::pair<RolePtr, scope_guard>> cache;
     std::map<EnabledRoles::Params, std::weak_ptr<EnabledRoles>> enabled_roles;
     mutable std::mutex mutex;
 };
diff --git a/src/Access/RowPolicyCache.cpp b/src/Access/RowPolicyCache.cpp
index 243f9c85d70..b4e3c7d16ab 100644
--- a/src/Access/RowPolicyCache.cpp
+++ b/src/Access/RowPolicyCache.cpp
@@ -6,7 +6,7 @@
 #include <Parsers/makeASTForLogicalFunction.h>
 #include <Common/Exception.h>
 #include <Common/quoteString.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <Core/Defines.h>
 
@@ -59,7 +59,7 @@ void RowPolicyCache::PolicyInfo::setPolicy(const RowPolicyPtr & policy_)
     roles = &policy->to_roles;
     database_and_table_name = std::make_shared<std::pair<String, String>>(policy->getDatabase(), policy->getTableName());
 
-    for (auto type : ext::range(0, MAX_CONDITION_TYPE))
+    for (auto type : collections::range(0, MAX_CONDITION_TYPE))
     {
         parsed_conditions[type] = nullptr;
         const String & condition = policy->conditions[type];
@@ -217,7 +217,7 @@ void RowPolicyCache::mixConditionsFor(EnabledRowPolicies & enabled)
         MixedConditionKey key;
         key.database = info.database_and_table_name->first;
         key.table_name = info.database_and_table_name->second;
-        for (auto type : ext::range(0, MAX_CONDITION_TYPE))
+        for (auto type : collections::range(0, MAX_CONDITION_TYPE))
         {
             if (info.parsed_conditions[type])
             {
diff --git a/src/Access/RowPolicyCache.h b/src/Access/RowPolicyCache.h
index f7270c6fce9..6f3964cdadb 100644
--- a/src/Access/RowPolicyCache.h
+++ b/src/Access/RowPolicyCache.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Access/EnabledRowPolicies.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <mutex>
 #include <map>
 #include <unordered_map>
@@ -41,7 +41,7 @@ private:
     const AccessControlManager & access_control_manager;
     std::unordered_map<UUID, PolicyInfo> all_policies;
     bool all_policies_read = false;
-    ext::scope_guard subscription;
+    scope_guard subscription;
     std::map<EnabledRowPolicies::Params, std::weak_ptr<EnabledRowPolicies>> enabled_row_policies;
     std::mutex mutex;
 };
diff --git a/src/Access/SettingsProfilesCache.h b/src/Access/SettingsProfilesCache.h
index ef3cfa51665..fb71d3f4bd0 100644
--- a/src/Access/SettingsProfilesCache.h
+++ b/src/Access/SettingsProfilesCache.h
@@ -3,7 +3,7 @@
 #include <Access/EnabledSettings.h>
 #include <Core/UUID.h>
 #include <common/types.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <map>
 #include <unordered_map>
 
@@ -46,7 +46,7 @@ private:
     std::unordered_map<UUID, SettingsProfilePtr> all_profiles;
     std::unordered_map<String, UUID> profiles_by_name;
     bool all_profiles_read = false;
-    ext::scope_guard subscription;
+    scope_guard subscription;
     std::map<EnabledSettings::Params, std::weak_ptr<EnabledSettings>> enabled_settings;
     std::optional<UUID> default_profile_id;
     std::unordered_map<UUID, std::shared_ptr<const SettingsChanges>> settings_for_profiles;
diff --git a/src/Access/UsersConfigAccessStorage.cpp b/src/Access/UsersConfigAccessStorage.cpp
index 407c3679e9f..5d8725f0cdf 100644
--- a/src/Access/UsersConfigAccessStorage.cpp
+++ b/src/Access/UsersConfigAccessStorage.cpp
@@ -248,7 +248,7 @@ namespace
             limits.duration = duration;
             limits.randomize_interval = config.getBool(interval_config + ".randomize", false);
 
-            for (auto resource_type : ext::range(Quota::MAX_RESOURCE_TYPE))
+            for (auto resource_type : collections::range(Quota::MAX_RESOURCE_TYPE))
             {
                 const auto & type_info = Quota::ResourceTypeInfo::get(resource_type);
                 auto value = config.getString(interval_config + "." + type_info.name, "0");
@@ -598,13 +598,13 @@ void UsersConfigAccessStorage::updateImpl(const UUID & id, const UpdateFunc &)
 }
 
 
-ext::scope_guard UsersConfigAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
+scope_guard UsersConfigAccessStorage::subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const
 {
     return memory_storage.subscribeForChanges(id, handler);
 }
 
 
-ext::scope_guard UsersConfigAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
+scope_guard UsersConfigAccessStorage::subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const
 {
     return memory_storage.subscribeForChanges(type, handler);
 }
diff --git a/src/Access/UsersConfigAccessStorage.h b/src/Access/UsersConfigAccessStorage.h
index f5302f9987b..97164fdb233 100644
--- a/src/Access/UsersConfigAccessStorage.h
+++ b/src/Access/UsersConfigAccessStorage.h
@@ -52,8 +52,8 @@ private:
     UUID insertImpl(const AccessEntityPtr & entity, bool replace_if_exists) override;
     void removeImpl(const UUID & id) override;
     void updateImpl(const UUID & id, const UpdateFunc & update_func) override;
-    ext::scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
-    ext::scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(const UUID & id, const OnChangedHandler & handler) const override;
+    scope_guard subscribeForChangesImpl(EntityType type, const OnChangedHandler & handler) const override;
     bool hasSubscriptionImpl(const UUID & id) const override;
     bool hasSubscriptionImpl(EntityType type) const override;
 
diff --git a/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h b/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h
index a32ea97ec0b..c31be25e950 100644
--- a/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h
+++ b/src/AggregateFunctions/AggregateFunctionCategoricalInformationValue.h
@@ -8,7 +8,7 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -71,7 +71,7 @@ public:
         auto y_col = static_cast<const ColumnUInt8 *>(columns[category_count]);
         bool y = y_col->getData()[row_num];
 
-        for (size_t i : ext::range(0, category_count))
+        for (size_t i : collections::range(0, category_count))
         {
             auto x_col = static_cast<const ColumnUInt8 *>(columns[i]);
             bool x = x_col->getData()[row_num];
@@ -89,7 +89,7 @@ public:
         Arena *
     ) const override
     {
-        for (size_t i : ext::range(0, category_count + 1))
+        for (size_t i : collections::range(0, category_count + 1))
         {
             reinterpret_cast<T *>(place)[i * 2] += reinterpret_cast<const T *>(rhs)[i * 2];
             reinterpret_cast<T *>(place)[i * 2 + 1] += reinterpret_cast<const T *>(rhs)[i * 2 + 1];
@@ -139,7 +139,7 @@ public:
         Float64 rev_no = 1. / sum_no;
         Float64 rev_yes = 1. / sum_yes;
 
-        for (size_t i : ext::range(0, category_count))
+        for (size_t i : collections::range(0, category_count))
         {
             T no = reinterpret_cast<const T *>(place)[i * 2];
             T yes = reinterpret_cast<const T *>(place)[i * 2 + 1];
diff --git a/src/AggregateFunctions/AggregateFunctionIntervalLengthSum.cpp b/src/AggregateFunctions/AggregateFunctionIntervalLengthSum.cpp
index f52756a78b6..eac7e6e9409 100644
--- a/src/AggregateFunctions/AggregateFunctionIntervalLengthSum.cpp
+++ b/src/AggregateFunctions/AggregateFunctionIntervalLengthSum.cpp
@@ -5,7 +5,7 @@
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
 
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
diff --git a/src/AggregateFunctions/AggregateFunctionQuantile.h b/src/AggregateFunctions/AggregateFunctionQuantile.h
index e7e60fe1def..90745c7d749 100644
--- a/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -113,8 +113,8 @@ public:
 
         if constexpr (std::is_same_v<Data, QuantileTiming<Value>>)
         {
-            /// QuantileTiming only supports integers.
-            if (isNaN(value) || value > std::numeric_limits<Value>::max() || value < std::numeric_limits<Value>::min())
+            /// QuantileTiming only supports unsigned integers. Too large values are also meaningless.
+            if (isNaN(value) || value > std::numeric_limits<Int64>::max() || value < 0)
                 return;
         }
 
diff --git a/src/AggregateFunctions/AggregateFunctionRetention.h b/src/AggregateFunctions/AggregateFunctionRetention.h
index 1496c92681a..896160bbe14 100644
--- a/src/AggregateFunctions/AggregateFunctionRetention.h
+++ b/src/AggregateFunctions/AggregateFunctionRetention.h
@@ -9,7 +9,7 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
 #include <Common/ArenaAllocator.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <bitset>
 
 #include <AggregateFunctions/IAggregateFunction.h>
@@ -78,7 +78,7 @@ public:
     AggregateFunctionRetention(const DataTypes & arguments)
         : IAggregateFunctionDataHelper<AggregateFunctionRetentionData, AggregateFunctionRetention>(arguments, {})
     {
-        for (const auto i : ext::range(0, arguments.size()))
+        for (const auto i : collections::range(0, arguments.size()))
         {
             auto cond_arg = arguments[i].get();
             if (!isUInt8(cond_arg))
@@ -100,7 +100,7 @@ public:
 
     void add(AggregateDataPtr __restrict place, const IColumn ** columns, const size_t row_num, Arena *) const override
     {
-        for (const auto i : ext::range(0, events_size))
+        for (const auto i : collections::range(0, events_size))
         {
             auto event = assert_cast<const ColumnVector<UInt8> *>(columns[i])->getData()[row_num];
             if (event)
diff --git a/src/AggregateFunctions/AggregateFunctionSequenceMatch.cpp b/src/AggregateFunctions/AggregateFunctionSequenceMatch.cpp
index b1d80ee2f0f..4e4f89d8846 100644
--- a/src/AggregateFunctions/AggregateFunctionSequenceMatch.cpp
+++ b/src/AggregateFunctions/AggregateFunctionSequenceMatch.cpp
@@ -5,7 +5,7 @@
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
 
-#include <ext/range.h>
+#include <common/range.h>
 
 namespace DB
 {
@@ -43,7 +43,7 @@ AggregateFunctionPtr createAggregateFunctionSequenceBase(
 
     const auto * time_arg = argument_types.front().get();
 
-    for (const auto i : ext::range(1, arg_count))
+    for (const auto i : collections::range(1, arg_count))
     {
         const auto * cond_arg = argument_types[i].get();
         if (!isUInt8(cond_arg))
diff --git a/src/AggregateFunctions/AggregateFunctionSequenceMatch.h b/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
index f0fd1e33dca..efd83f89dfd 100644
--- a/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
+++ b/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
@@ -5,7 +5,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnsNumber.h>
 #include <Common/assert_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <Common/PODArray.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
@@ -155,7 +155,7 @@ public:
         const auto timestamp = assert_cast<const ColumnVector<T> *>(columns[0])->getData()[row_num];
 
         typename Data::Events events;
-        for (const auto i : ext::range(1, arg_count))
+        for (const auto i : collections::range(1, arg_count))
         {
             const auto event = assert_cast<const ColumnUInt8 *>(columns[i])->getData()[row_num];
             events.set(i - 1, event);
diff --git a/src/AggregateFunctions/AggregateFunctionSequenceNextNode.cpp b/src/AggregateFunctions/AggregateFunctionSequenceNextNode.cpp
index 0c87a32a415..965413afb1d 100644
--- a/src/AggregateFunctions/AggregateFunctionSequenceNextNode.cpp
+++ b/src/AggregateFunctions/AggregateFunctionSequenceNextNode.cpp
@@ -8,7 +8,7 @@
 #include <DataTypes/DataTypeNullable.h>
 #include <Interpreters/Context.h>
 #include <Common/CurrentThread.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -98,7 +98,7 @@ createAggregateFunctionSequenceNode(const std::string & name, const DataTypes &
         throw Exception("Illegal type " + cond_arg->getName() + " of third argument of aggregate function "
                 + name + ", must be UInt8", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-    for (const auto i : ext::range(min_required_args, argument_types.size()))
+    for (const auto i : collections::range(min_required_args, argument_types.size()))
     {
         const auto * cond_arg = argument_types[i].get();
         if (!isUInt8(cond_arg))
diff --git a/src/AggregateFunctions/AggregateFunctionUniq.h b/src/AggregateFunctions/AggregateFunctionUniq.h
index efbb9758b03..19c784553f2 100644
--- a/src/AggregateFunctions/AggregateFunctionUniq.h
+++ b/src/AggregateFunctions/AggregateFunctionUniq.h
@@ -3,7 +3,7 @@
 #include <city.h>
 #include <type_traits>
 
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 
 #include <IO/WriteHelpers.h>
 #include <IO/ReadHelpers.h>
@@ -150,7 +150,7 @@ template <typename T> struct AggregateFunctionUniqTraits
     {
         if constexpr (std::is_same_v<T, Float32> || std::is_same_v<T, Float64>)
         {
-            return ext::bit_cast<UInt64>(x);
+            return bit_cast<UInt64>(x);
         }
         else if constexpr (sizeof(T) <= sizeof(UInt64))
         {
diff --git a/src/AggregateFunctions/AggregateFunctionUniqCombined.h b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
index cb623bcb761..7d74041d3d7 100644
--- a/src/AggregateFunctions/AggregateFunctionUniqCombined.h
+++ b/src/AggregateFunctions/AggregateFunctionUniqCombined.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <common/bit_cast.h>
+
 #include <Common/CombinedCardinalityEstimator.h>
 #include <Common/SipHash.h>
 #include <Common/typeid_cast.h>
@@ -13,8 +15,6 @@
 #include <AggregateFunctions/UniqCombinedBiasData.h>
 #include <AggregateFunctions/UniqVariadicHash.h>
 
-#include <ext/bit_cast.h>
-
 #include <Columns/ColumnVector.h>
 #include <Columns/ColumnsNumber.h>
 
@@ -52,7 +52,7 @@ namespace detail
     {
         static Ret hash(Float32 x)
         {
-            UInt64 res = ext::bit_cast<UInt64>(x);
+            UInt64 res = bit_cast<UInt64>(x);
             return static_cast<Ret>(intHash64(res));
         }
     };
@@ -62,7 +62,7 @@ namespace detail
     {
         static Ret hash(Float64 x)
         {
-            UInt64 res = ext::bit_cast<UInt64>(x);
+            UInt64 res = bit_cast<UInt64>(x);
             return static_cast<Ret>(intHash64(res));
         }
     };
diff --git a/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp b/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
index 01ea2636434..4d105d2b8b9 100644
--- a/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
+++ b/src/AggregateFunctions/AggregateFunctionWindowFunnel.cpp
@@ -6,7 +6,7 @@
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
 
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -35,7 +35,7 @@ createAggregateFunctionWindowFunnel(const std::string & name, const DataTypes &
     if (arguments.size() > max_events + 1)
         throw Exception("Too many event arguments for aggregate function " + name, ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-    for (const auto i : ext::range(1, arguments.size()))
+    for (const auto i : collections::range(1, arguments.size()))
     {
         const auto * cond_arg = arguments[i].get();
         if (!isUInt8(cond_arg))
diff --git a/src/AggregateFunctions/QuantileBFloat16Histogram.h b/src/AggregateFunctions/QuantileBFloat16Histogram.h
index 559a87a5591..501cd8dcf2d 100644
--- a/src/AggregateFunctions/QuantileBFloat16Histogram.h
+++ b/src/AggregateFunctions/QuantileBFloat16Histogram.h
@@ -1,10 +1,11 @@
 #pragma once
 
+#include <common/types.h>
+#include <common/bit_cast.h>
+#include <Common/HashTable/HashMap.h>
+
 #include <IO/ReadBuffer.h>
 #include <IO/WriteBuffer.h>
-#include <Common/HashTable/HashMap.h>
-#include <common/types.h>
-#include <ext/bit_cast.h>
 
 
 namespace DB
@@ -102,13 +103,13 @@ private:
     /// Take the most significant 16 bits of the floating point number.
     BFloat16 toBFloat16(const Value & x) const
     {
-        return ext::bit_cast<UInt32>(static_cast<Float32>(x)) >> 16;
+        return bit_cast<UInt32>(static_cast<Float32>(x)) >> 16;
     }
 
     /// Put the bits into most significant 16 bits of the floating point number and fill other bits with zeros.
     Float32 toFloat32(const BFloat16 & x) const
     {
-        return ext::bit_cast<Float32>(x << 16);
+        return bit_cast<Float32>(x << 16);
     }
 
     using Pair = PairNoInit<Float32, Weight>;
diff --git a/src/AggregateFunctions/ReservoirSamplerDeterministic.h b/src/AggregateFunctions/ReservoirSamplerDeterministic.h
index 468a5c7c6a0..2687e0b4a67 100644
--- a/src/AggregateFunctions/ReservoirSamplerDeterministic.h
+++ b/src/AggregateFunctions/ReservoirSamplerDeterministic.h
@@ -59,9 +59,10 @@ template <typename T,
     ReservoirSamplerDeterministicOnEmpty OnEmpty = ReservoirSamplerDeterministicOnEmpty::THROW>
 class ReservoirSamplerDeterministic
 {
-    bool good(const UInt32 hash)
+private:
+    bool good(UInt32 hash) const
     {
-        return !(hash & skip_mask);
+        return (hash & skip_mask) == 0;
     }
 
 public:
@@ -77,15 +78,12 @@ public:
         total_values = 0;
     }
 
-    void insert(const T & v, const UInt64 determinator)
+    void insert(const T & v, UInt64 determinator)
     {
         if (isNaN(v))
             return;
 
-        const UInt32 hash = intHash64(determinator);
-        if (!good(hash))
-            return;
-
+        UInt32 hash = intHash64(determinator);
         insertImpl(v, hash);
         sorted = false;
         ++total_values;
@@ -144,8 +142,7 @@ public:
             setSkipDegree(b.skip_degree);
 
         for (const auto & sample : b.samples)
-            if (good(sample.second))
-                insertImpl(sample.first, sample.second);
+            insertImpl(sample.first, sample.second);
 
         total_values += b.total_values;
     }
@@ -220,10 +217,19 @@ private:
 
     void insertImpl(const T & v, const UInt32 hash)
     {
+        if (!good(hash))
+            return;
+
         /// Make a room for plus one element.
         while (samples.size() >= max_sample_size)
+        {
             setSkipDegree(skip_degree + 1);
 
+            /// Still good?
+            if (!good(hash))
+                return;
+        }
+
         samples.emplace_back(v, hash);
     }
 
diff --git a/src/Bridge/LibraryBridgeHelper.cpp b/src/Bridge/LibraryBridgeHelper.cpp
index 7d378941d25..39ec80534b3 100644
--- a/src/Bridge/LibraryBridgeHelper.cpp
+++ b/src/Bridge/LibraryBridgeHelper.cpp
@@ -11,7 +11,7 @@
 #include <Poco/Util/AbstractConfiguration.h>
 #include <Common/ShellCommand.h>
 #include <common/logger_useful.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <Core/Field.h>
 #include <Common/escapeForFileName.h>
 
diff --git a/src/Bridge/XDBCBridgeHelper.h b/src/Bridge/XDBCBridgeHelper.h
index b170a55e438..8be4c194962 100644
--- a/src/Bridge/XDBCBridgeHelper.h
+++ b/src/Bridge/XDBCBridgeHelper.h
@@ -12,7 +12,7 @@
 #include <Common/ShellCommand.h>
 #include <IO/ConnectionTimeoutsContext.h>
 #include <common/logger_useful.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <Bridge/IBridgeHelper.h>
 
 #if !defined(ARCADIA_BUILD)
diff --git a/src/Client/Connection.h b/src/Client/Connection.h
index 80dbd9ed44e..2ea5a236a13 100644
--- a/src/Client/Connection.h
+++ b/src/Client/Connection.h
@@ -185,6 +185,9 @@ public:
 
     bool isConnected() const { return connected; }
 
+    /// Check if connection is still active with ping request.
+    bool checkConnected() { return connected && ping(); }
+
     TablesStatusResponse getTablesStatus(const ConnectionTimeouts & timeouts,
                                          const TablesStatusRequest & request);
 
diff --git a/src/Columns/ColumnDecimal.cpp b/src/Columns/ColumnDecimal.cpp
index ec08db274b3..da49d0bd412 100644
--- a/src/Columns/ColumnDecimal.cpp
+++ b/src/Columns/ColumnDecimal.cpp
@@ -7,7 +7,7 @@
 
 #include <common/unaligned.h>
 #include <common/sort.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 
 #include <IO/WriteHelpers.h>
diff --git a/src/Columns/ColumnFixedString.cpp b/src/Columns/ColumnFixedString.cpp
index 4d54a46c924..830f8531afc 100644
--- a/src/Columns/ColumnFixedString.cpp
+++ b/src/Columns/ColumnFixedString.cpp
@@ -12,7 +12,7 @@
 #include <Common/memcmpSmall.h>
 #include <Common/memcpySmall.h>
 #include <common/sort.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #if defined(__SSE2__)
 #    include <emmintrin.h>
diff --git a/src/Columns/ColumnLowCardinality.cpp b/src/Columns/ColumnLowCardinality.cpp
index c4d7e75dd2d..5b16c7757e8 100644
--- a/src/Columns/ColumnLowCardinality.cpp
+++ b/src/Columns/ColumnLowCardinality.cpp
@@ -8,7 +8,7 @@
 #include <Common/WeakHash.h>
 #include <Common/assert_cast.h>
 #include <common/sort.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 
 namespace DB
diff --git a/src/Columns/ColumnMap.cpp b/src/Columns/ColumnMap.cpp
index 05c0e0458d8..87c28c44cdb 100644
--- a/src/Columns/ColumnMap.cpp
+++ b/src/Columns/ColumnMap.cpp
@@ -4,8 +4,8 @@
 #include <DataStreams/ColumnGathererStream.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
-#include <ext/map.h>
-#include <ext/range.h>
+#include <common/map.h>
+#include <common/range.h>
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
 #include <Common/WeakHash.h>
diff --git a/src/Columns/ColumnString.cpp b/src/Columns/ColumnString.cpp
index fcd0516d465..d188bbb1132 100644
--- a/src/Columns/ColumnString.cpp
+++ b/src/Columns/ColumnString.cpp
@@ -11,7 +11,7 @@
 #include <Common/memcmpSmall.h>
 #include <common/sort.h>
 #include <common/unaligned.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 
 namespace DB
diff --git a/src/Columns/ColumnTuple.cpp b/src/Columns/ColumnTuple.cpp
index bb59d58b75d..f9b6cf697fd 100644
--- a/src/Columns/ColumnTuple.cpp
+++ b/src/Columns/ColumnTuple.cpp
@@ -10,8 +10,8 @@
 #include <Common/assert_cast.h>
 #include <Common/typeid_cast.h>
 #include <common/sort.h>
-#include <ext/map.h>
-#include <ext/range.h>
+#include <common/map.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -100,14 +100,14 @@ MutableColumnPtr ColumnTuple::cloneResized(size_t new_size) const
 
 Field ColumnTuple::operator[](size_t n) const
 {
-    return ext::map<Tuple>(columns, [n] (const auto & column) { return (*column)[n]; });
+    return collections::map<Tuple>(columns, [n] (const auto & column) { return (*column)[n]; });
 }
 
 void ColumnTuple::get(size_t n, Field & res) const
 {
     const size_t tuple_size = columns.size();
     Tuple tuple(tuple_size);
-    for (const auto i : ext::range(0, tuple_size))
+    for (const auto i : collections::range(0, tuple_size))
         columns[i]->get(n, tuple[i]);
 
     res = tuple;
@@ -467,7 +467,7 @@ void ColumnTuple::getExtremes(Field & min, Field & max) const
     Tuple min_tuple(tuple_size);
     Tuple max_tuple(tuple_size);
 
-    for (const auto i : ext::range(0, tuple_size))
+    for (const auto i : collections::range(0, tuple_size))
         columns[i]->getExtremes(min_tuple[i], max_tuple[i]);
 
     min = min_tuple;
@@ -488,7 +488,7 @@ bool ColumnTuple::structureEquals(const IColumn & rhs) const
         if (tuple_size != rhs_tuple->columns.size())
             return false;
 
-        for (const auto i : ext::range(0, tuple_size))
+        for (const auto i : collections::range(0, tuple_size))
             if (!columns[i]->structureEquals(*rhs_tuple->columns[i]))
                 return false;
 
diff --git a/src/Columns/ColumnUnique.h b/src/Columns/ColumnUnique.h
index 51b45be53fd..d1fa8ecdf93 100644
--- a/src/Columns/ColumnUnique.h
+++ b/src/Columns/ColumnUnique.h
@@ -13,7 +13,7 @@
 
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <common/unaligned.h>
 #include "Columns/ColumnConst.h"
diff --git a/src/Columns/ColumnVector.cpp b/src/Columns/ColumnVector.cpp
index 4e2a8c16586..9dc36b9b018 100644
--- a/src/Columns/ColumnVector.cpp
+++ b/src/Columns/ColumnVector.cpp
@@ -15,8 +15,8 @@
 #include <Common/assert_cast.h>
 #include <common/sort.h>
 #include <common/unaligned.h>
-#include <ext/bit_cast.h>
-#include <ext/scope_guard.h>
+#include <common/bit_cast.h>
+#include <common/scope_guard.h>
 
 #include <cmath>
 #include <cstring>
@@ -303,7 +303,7 @@ template <typename T>
 UInt64 ColumnVector<T>::get64(size_t n [[maybe_unused]]) const
 {
     if constexpr (is_arithmetic_v<T>)
-        return ext::bit_cast<UInt64>(data[n]);
+        return bit_cast<UInt64>(data[n]);
     else
         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot get the value of {} as UInt64", TypeName<T>);
 }
diff --git a/src/Columns/ReverseIndex.h b/src/Columns/ReverseIndex.h
index 35b0029fc7b..1db42fcd6a1 100644
--- a/src/Columns/ReverseIndex.h
+++ b/src/Columns/ReverseIndex.h
@@ -6,7 +6,7 @@
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsNumber.h>
 #include <Common/assert_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <common/unaligned.h>
 
 
@@ -447,7 +447,7 @@ void ReverseIndex<IndexType, ColumnType>::buildIndex()
     IteratorType iterator;
     bool inserted;
 
-    for (auto row : ext::range(num_prefix_rows_to_skip, size))
+    for (auto row : collections::range(num_prefix_rows_to_skip, size))
     {
         UInt64 hash;
         if constexpr (use_saved_hash)
@@ -471,7 +471,7 @@ ColumnUInt64::MutablePtr ReverseIndex<IndexType, ColumnType>::calcHashes() const
     auto size = column->size();
     auto hash = ColumnUInt64::create(size);
 
-    for (auto row : ext::range(0, size))
+    for (auto row : collections::range(0, size))
         hash->getElement(row) = getHash(column->getDataAt(row));
 
     return hash;
diff --git a/src/Common/ArrayCache.h b/src/Common/ArrayCache.h
index 6883d5f8041..b305cc8199d 100644
--- a/src/Common/ArrayCache.h
+++ b/src/Common/ArrayCache.h
@@ -11,7 +11,7 @@
 #include <boost/intrusive/list.hpp>
 #include <boost/intrusive/set.hpp>
 #include <boost/noncopyable.hpp>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <common/getPageSize.h>
 
diff --git a/src/Common/MemoryTracker.h b/src/Common/MemoryTracker.h
index e57fc2e0b75..d4de7a2cafa 100644
--- a/src/Common/MemoryTracker.h
+++ b/src/Common/MemoryTracker.h
@@ -14,7 +14,7 @@
 /// outside of try/catch block of thread functions. ALLOW_ALLOCATIONS_IN_SCOPE cancels effect of
 /// DENY_ALLOCATIONS_IN_SCOPE in the inner scope. In Release builds these macros do nothing.
 #ifdef MEMORY_TRACKER_DEBUG_CHECKS
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 extern thread_local bool _memory_tracker_always_throw_logical_error_on_allocation;
 #define ALLOCATIONS_IN_SCOPE_IMPL_CONCAT(n, val) \
         bool _allocations_flag_prev_val##n = _memory_tracker_always_throw_logical_error_on_allocation; \
diff --git a/src/Common/OpenSSLHelpers.cpp b/src/Common/OpenSSLHelpers.cpp
index d066e8802ad..d8e862b3700 100644
--- a/src/Common/OpenSSLHelpers.cpp
+++ b/src/Common/OpenSSLHelpers.cpp
@@ -4,7 +4,7 @@
 
 #if USE_SSL
 #include "OpenSSLHelpers.h"
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <openssl/err.h>
 #include <openssl/sha.h>
 
diff --git a/src/Common/PoolWithFailoverBase.h b/src/Common/PoolWithFailoverBase.h
index 78d45a93b13..e84e249d179 100644
--- a/src/Common/PoolWithFailoverBase.h
+++ b/src/Common/PoolWithFailoverBase.h
@@ -6,7 +6,7 @@
 #include <random>
 #include <functional>
 #include <common/types.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Common/PoolBase.h>
 #include <Common/ProfileEvents.h>
 #include <Common/NetException.h>
diff --git a/src/Common/RadixSort.h b/src/Common/RadixSort.h
index f490df3e4bb..b14e71a6720 100644
--- a/src/Common/RadixSort.h
+++ b/src/Common/RadixSort.h
@@ -13,7 +13,7 @@
 #include <type_traits>
 #include <memory>
 
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <common/extended_types.h>
 #include <Core/Defines.h>
 
@@ -211,8 +211,8 @@ private:
     static constexpr size_t NUM_PASSES = (KEY_BITS + (Traits::PART_SIZE_BITS - 1)) / Traits::PART_SIZE_BITS;
 
 
-    static KeyBits keyToBits(Key x) { return ext::bit_cast<KeyBits>(x); }
-    static Key bitsToKey(KeyBits x) { return ext::bit_cast<Key>(x); }
+    static KeyBits keyToBits(Key x) { return bit_cast<KeyBits>(x); }
+    static Key bitsToKey(KeyBits x) { return bit_cast<Key>(x); }
 
     static ALWAYS_INLINE KeyBits getPart(size_t N, KeyBits x)
     {
diff --git a/src/Common/StringSearcher.h b/src/Common/StringSearcher.h
index 0d2ee26889f..09011d910ea 100644
--- a/src/Common/StringSearcher.h
+++ b/src/Common/StringSearcher.h
@@ -5,7 +5,7 @@
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/UTF8Helpers.h>
 #include <Core/Defines.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <Poco/Unicode.h>
 #include <stdint.h>
 #include <string.h>
@@ -423,7 +423,7 @@ public:
 
         auto needle_pos = needle;
 
-        for (const auto i : ext::range(0, n))
+        for (const auto i : collections::range(0, n))
         {
             cachel = _mm_srli_si128(cachel, 1);
             cacheu = _mm_srli_si128(cacheu, 1);
@@ -622,7 +622,7 @@ public:
 
         auto needle_pos = needle;
 
-        for (const auto i : ext::range(0, n))
+        for (const auto i : collections::range(0, n))
         {
             cache = _mm_srli_si128(cache, 1);
 
diff --git a/src/Common/ThreadPool.h b/src/Common/ThreadPool.h
index e5f3041004b..1da5d25eef0 100644
--- a/src/Common/ThreadPool.h
+++ b/src/Common/ThreadPool.h
@@ -11,7 +11,7 @@
 
 #include <Poco/Event.h>
 #include <Common/ThreadStatus.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 /** Very simple thread pool similar to boost::threadpool.
   * Advantages:
diff --git a/src/Common/checkStackSize.cpp b/src/Common/checkStackSize.cpp
index 54ffab7f3d0..8278b510282 100644
--- a/src/Common/checkStackSize.cpp
+++ b/src/Common/checkStackSize.cpp
@@ -1,6 +1,6 @@
 #include <Common/checkStackSize.h>
 #include <Common/Exception.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <pthread.h>
 #include <cstdint>
 
diff --git a/src/Common/examples/arena_with_free_lists.cpp b/src/Common/examples/arena_with_free_lists.cpp
index 4c22cd98892..dc830fdb89c 100644
--- a/src/Common/examples/arena_with_free_lists.cpp
+++ b/src/Common/examples/arena_with_free_lists.cpp
@@ -12,11 +12,11 @@
 #include <memory>
 #include <array>
 #include <sys/resource.h>
-#include <ext/bit_cast.h>
-#include <ext/size.h>
-#include <Common/Arena.h>
+#include <common/bit_cast.h>
 
 #include <common/StringRef.h>
+#include <common/arraySize.h>
+#include <Common/Arena.h>
 #include <Core/Field.h>
 #include <Common/Stopwatch.h>
 #include <IO/ReadBufferFromFileDescriptor.h>
@@ -68,7 +68,7 @@ private:
     static auto getMaxFixedBlockSize() { return getSizes().back(); }
 
     Arena pool;
-    const std::unique_ptr<Block * []> free_lists = std::make_unique<Block * []>(ext::size(getSizes()));
+    const std::unique_ptr<Block * []> free_lists = std::make_unique<Block * []>(arraySize(getSizes()));
 
     static size_t findFreeListIndex(const size_t size)
     {
@@ -96,7 +96,7 @@ public:
 
         if (auto & block = free_lists[list_idx])
         {
-            const auto res = ext::bit_cast<char *>(block);
+            const auto res = bit_cast<char *>(block);
             block = block->next;
             return res;
         }
@@ -115,7 +115,7 @@ public:
 
         auto & block = free_lists[list_idx];
         const auto old = block;
-        block = ext::bit_cast<Block *>(ptr);
+        block = bit_cast<Block *>(ptr);
         block->next = old;
     }
 
diff --git a/src/Common/examples/radix_sort.cpp b/src/Common/examples/radix_sort.cpp
index 9288e32e734..0fb3c904466 100644
--- a/src/Common/examples/radix_sort.cpp
+++ b/src/Common/examples/radix_sort.cpp
@@ -1,6 +1,6 @@
 #include <iomanip>
 #include <pcg_random.hpp>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 
 //#if defined(NDEBUG)
 //#undef NDEBUG
@@ -33,8 +33,8 @@ static void NO_INLINE sort3(Key * data, size_t size)
 {
     std::sort(data, data + size, [](Key a, Key b)
     {
-        return RadixSortFloatTransform<uint64_t>::forward(ext::bit_cast<uint64_t>(a))
-            < RadixSortFloatTransform<uint64_t>::forward(ext::bit_cast<uint64_t>(b));
+        return RadixSortFloatTransform<uint64_t>::forward(bit_cast<uint64_t>(a))
+            < RadixSortFloatTransform<uint64_t>::forward(bit_cast<uint64_t>(b));
     });
 }
 
@@ -58,8 +58,8 @@ static void NO_INLINE sort7(Key * data, size_t size, size_t limit)
 {
     std::partial_sort(data, data + limit, data + size, [](Key a, Key b)
     {
-        return RadixSortFloatTransform<uint64_t>::forward(ext::bit_cast<uint64_t>(a))
-            < RadixSortFloatTransform<uint64_t>::forward(ext::bit_cast<uint64_t>(b));
+        return RadixSortFloatTransform<uint64_t>::forward(bit_cast<uint64_t>(a))
+            < RadixSortFloatTransform<uint64_t>::forward(bit_cast<uint64_t>(b));
     });
 }
 
diff --git a/src/Common/formatIPv6.cpp b/src/Common/formatIPv6.cpp
index 5cdfb465399..cffdc425237 100644
--- a/src/Common/formatIPv6.cpp
+++ b/src/Common/formatIPv6.cpp
@@ -2,7 +2,7 @@
 #include <Common/hex.h>
 #include <Common/StringUtils/StringUtils.h>
 
-#include <ext/range.h>
+#include <common/range.h>
 #include <array>
 #include <algorithm>
 
@@ -86,10 +86,10 @@ void formatIPv6(const unsigned char * src, char *& dst, uint8_t zeroed_tail_byte
     /** Preprocess:
         *    Copy the input (bytewise) array into a wordwise array.
         *    Find the longest run of 0x00's in src[] for :: shorthanding. */
-    for (const auto i : ext::range(0, IPV6_BINARY_LENGTH - zeroed_tail_bytes_count))
+    for (const auto i : collections::range(0, IPV6_BINARY_LENGTH - zeroed_tail_bytes_count))
         words[i / 2] |= src[i] << ((1 - (i % 2)) << 3);
 
-    for (const auto i : ext::range(0, words.size()))
+    for (const auto i : collections::range(0, words.size()))
     {
         if (words[i] == 0)
         {
@@ -122,7 +122,7 @@ void formatIPv6(const unsigned char * src, char *& dst, uint8_t zeroed_tail_byte
         best.base = -1;
 
     /// Format the result.
-    for (const int i : ext::range(0, words.size()))
+    for (const int i : collections::range(0, words.size()))
     {
         /// Are we inside the best run of 0x00's?
         if (best.base != -1 && i >= best.base && i < (best.base + best.len))
diff --git a/src/Common/formatIPv6.h b/src/Common/formatIPv6.h
index c16db8490dd..bb8acd6d17a 100644
--- a/src/Common/formatIPv6.h
+++ b/src/Common/formatIPv6.h
@@ -4,7 +4,7 @@
 #include <string.h>
 #include <algorithm>
 #include <utility>
-#include <ext/range.h>
+#include <common/range.h>
 #include <Common/hex.h>
 #include <Common/StringUtils/StringUtils.h>
 
diff --git a/src/Common/typeid_cast.h b/src/Common/typeid_cast.h
index ca145fcc3b8..85534a971f5 100644
--- a/src/Common/typeid_cast.h
+++ b/src/Common/typeid_cast.h
@@ -6,7 +6,7 @@
 #include <memory>
 #include <string>
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Common/Exception.h>
 #include <common/demangle.h>
 
@@ -60,7 +60,7 @@ std::enable_if_t<std::is_pointer_v<To>, To> typeid_cast(From * from)
 
 
 template <typename To, typename From>
-std::enable_if_t<ext::is_shared_ptr_v<To>, To> typeid_cast(const std::shared_ptr<From> & from)
+std::enable_if_t<is_shared_ptr_v<To>, To> typeid_cast(const std::shared_ptr<From> & from)
 {
     try
     {
diff --git a/src/Core/BackgroundSchedulePool.cpp b/src/Core/BackgroundSchedulePool.cpp
index 5f2a115562d..f241eb29dbd 100644
--- a/src/Core/BackgroundSchedulePool.cpp
+++ b/src/Core/BackgroundSchedulePool.cpp
@@ -5,7 +5,7 @@
 #include <Common/CurrentThread.h>
 #include <common/logger_useful.h>
 #include <chrono>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 
 namespace DB
diff --git a/src/Core/BaseSettings.h b/src/Core/BaseSettings.h
index 3b6cc61d1eb..eb12249fe07 100644
--- a/src/Core/BaseSettings.h
+++ b/src/Core/BaseSettings.h
@@ -2,7 +2,7 @@
 
 #include <Core/SettingsFields.h>
 #include <Common/SettingsChanges.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/blank.hpp>
 #include <unordered_map>
 
@@ -303,7 +303,7 @@ template <typename Traits_>
 void BaseSettings<Traits_>::resetToDefault()
 {
     const auto & accessor = Traits::Accessor::instance();
-    for (size_t i : ext::range(accessor.size()))
+    for (size_t i : collections::range(accessor.size()))
     {
         if (accessor.isValueChanged(*this, i))
             accessor.resetValueToDefault(*this, i);
@@ -819,7 +819,7 @@ bool BaseSettings<Traits_>::SettingFieldRef::isCustom() const
             constexpr int IMPORTANT = 1; \
             UNUSED(IMPORTANT); \
             LIST_OF_SETTINGS_MACRO(IMPLEMENT_SETTINGS_TRAITS_) \
-            for (size_t i : ext::range(res.field_infos.size())) \
+            for (size_t i : collections::range(res.field_infos.size())) \
             { \
                 const auto & info = res.field_infos[i]; \
                 res.name_to_index_map.emplace(info.name, i); \
diff --git a/src/Core/MySQL/Authentication.cpp b/src/Core/MySQL/Authentication.cpp
index 0258f9f94af..658c86795b1 100644
--- a/src/Core/MySQL/Authentication.cpp
+++ b/src/Core/MySQL/Authentication.cpp
@@ -8,7 +8,7 @@
 #include <common/logger_useful.h>
 #include <Common/OpenSSLHelpers.h>
 
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 namespace DB
 {
diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index e9379186c0e..3b91e26cd4f 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -104,7 +104,7 @@ class IColumn;
     \
     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, true, "Compile some scalar functions and operators to native code.", 0) \
-    M(UInt64, min_count_to_compile_expression, 0, "The number of identical expressions before they are JIT-compiled", 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, 50000000, "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) \
     M(Bool, distributed_aggregation_memory_efficient, true, "Is the memory-saving mode of distributed aggregation enabled.", 0) \
@@ -234,6 +234,9 @@ class IColumn;
     M(Seconds, http_send_timeout, DEFAULT_HTTP_READ_BUFFER_TIMEOUT, "HTTP send timeout", 0) \
     M(Seconds, http_receive_timeout, DEFAULT_HTTP_READ_BUFFER_TIMEOUT, "HTTP receive timeout", 0) \
     M(UInt64, http_max_uri_size, 1048576, "Maximum URI length of HTTP request", 0) \
+    M(UInt64, http_max_fields, 1000000, "Maximum number of fields in HTTP header", 0) \
+    M(UInt64, http_max_field_name_size, 1048576, "Maximum length of field name in HTTP header", 0) \
+    M(UInt64, http_max_field_value_size, 1048576, "Maximum length of field value in HTTP header", 0) \
     M(Bool, optimize_throw_if_noop, false, "If setting is enabled and OPTIMIZE query didn't actually assign a merge then an explanatory exception is thrown", 0) \
     M(Bool, use_index_for_in_with_subqueries, true, "Try using an index if there is a subquery or a table expression on the right side of the IN operator.", 0) \
     M(Bool, joined_subquery_requires_alias, true, "Force joined subqueries and table functions to have aliases for correct name qualification.", 0) \
diff --git a/src/DataStreams/MongoDBBlockInputStream.cpp b/src/DataStreams/MongoDBBlockInputStream.cpp
index d740448e0cf..31fa17675bc 100644
--- a/src/DataStreams/MongoDBBlockInputStream.cpp
+++ b/src/DataStreams/MongoDBBlockInputStream.cpp
@@ -14,7 +14,7 @@
 #include <IO/ReadHelpers.h>
 #include <Common/assert_cast.h>
 #include <Common/quoteString.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <DataStreams/MongoDBBlockInputStream.h>
 #include <Poco/URI.h>
 #include <Poco/Util/AbstractConfiguration.h>
@@ -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 <ext/enumerate.h>
 
 namespace DB
 {
@@ -314,7 +313,7 @@ Block MongoDBBlockInputStream::readImpl()
     MutableColumns columns(description.sample_block.columns());
     const size_t size = columns.size();
 
-    for (const auto i : ext::range(0, size))
+    for (const auto i : collections::range(0, size))
         columns[i] = description.sample_block.getByPosition(i).column->cloneEmpty();
 
     size_t num_rows = 0;
@@ -326,7 +325,7 @@ Block MongoDBBlockInputStream::readImpl()
         {
             ++num_rows;
 
-            for (const auto idx : ext::range(0, size))
+            for (const auto idx : collections::range(0, size))
             {
                 const auto & name = description.sample_block.getByPosition(idx).name;
 
diff --git a/src/DataStreams/NativeBlockInputStream.cpp b/src/DataStreams/NativeBlockInputStream.cpp
index 2f376f5230d..c76126e950b 100644
--- a/src/DataStreams/NativeBlockInputStream.cpp
+++ b/src/DataStreams/NativeBlockInputStream.cpp
@@ -6,7 +6,7 @@
 
 #include <DataTypes/DataTypeFactory.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <DataStreams/NativeBlockInputStream.h>
 #include <DataTypes/DataTypeLowCardinality.h>
@@ -222,7 +222,7 @@ void NativeBlockInputStream::updateAvgValueSizeHints(const Block & block)
 
     avg_value_size_hints.resize_fill(block.columns(), 0);
 
-    for (auto idx : ext::range(0, block.columns()))
+    for (auto idx : collections::range(0, block.columns()))
     {
         auto & avg_value_size_hint = avg_value_size_hints[idx];
         IDataType::updateAvgValueSizeHint(*block.getByPosition(idx).column, avg_value_size_hint);
diff --git a/src/DataStreams/PostgreSQLBlockInputStream.cpp b/src/DataStreams/PostgreSQLBlockInputStream.cpp
index 9ef0a45acc0..a41280847a5 100644
--- a/src/DataStreams/PostgreSQLBlockInputStream.cpp
+++ b/src/DataStreams/PostgreSQLBlockInputStream.cpp
@@ -15,7 +15,7 @@
 #include <IO/WriteHelpers.h>
 #include <IO/ReadBufferFromString.h>
 #include <Common/assert_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <common/logger_useful.h>
 
 
@@ -37,7 +37,7 @@ PostgreSQLBlockInputStream::PostgreSQLBlockInputStream(
     , connection_holder(std::move(connection_holder_))
 {
     description.init(sample_block);
-    for (const auto idx : ext::range(0, description.sample_block.columns()))
+    for (const auto idx : collections::range(0, description.sample_block.columns()))
         if (description.types[idx].first == ValueType::vtArray)
             prepareArrayInfo(idx, description.sample_block.getByPosition(idx).type);
     /// pqxx::stream_from uses COPY command, will get error if ';' is present
@@ -70,7 +70,7 @@ Block PostgreSQLBlockInputStream::readImpl()
         if (!row)
             break;
 
-        for (const auto idx : ext::range(0, row->size()))
+        for (const auto idx : collections::range(0, row->size()))
         {
             const auto & sample = description.sample_block.getByPosition(idx);
 
diff --git a/src/DataTypes/DataTypeMap.cpp b/src/DataTypes/DataTypeMap.cpp
index b09a5e9e590..3f2d9987018 100644
--- a/src/DataTypes/DataTypeMap.cpp
+++ b/src/DataTypes/DataTypeMap.cpp
@@ -1,3 +1,4 @@
+#include <common/map.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Columns/ColumnMap.h>
 #include <Columns/ColumnArray.h>
@@ -19,9 +20,6 @@
 #include <IO/ReadBufferFromString.h>
 #include <IO/Operators.h>
 
-#include <ext/map.h>
-#include <ext/enumerate.h>
-
 
 namespace DB
 {
diff --git a/src/DataTypes/DataTypeTuple.cpp b/src/DataTypes/DataTypeTuple.cpp
index 9ebc061d6f9..ed00582fd29 100644
--- a/src/DataTypes/DataTypeTuple.cpp
+++ b/src/DataTypes/DataTypeTuple.cpp
@@ -1,3 +1,5 @@
+#include <common/map.h>
+#include <common/range.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Columns/ColumnTuple.h>
 #include <Core/Field.h>
@@ -18,10 +20,6 @@
 #include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
 
-#include <ext/map.h>
-#include <ext/enumerate.h>
-#include <ext/range.h>
-
 
 namespace DB
 {
@@ -127,7 +125,7 @@ static void addElementSafe(const DataTypes & elems, IColumn & column, F && impl)
         // Check that all columns now have the same size.
         size_t new_size = column.size();
 
-        for (auto i : ext::range(0, ext::size(elems)))
+        for (auto i : collections::range(0, elems.size()))
         {
             const auto & element_column = extractElementColumn(column, i);
             if (element_column.size() != new_size)
@@ -141,7 +139,7 @@ static void addElementSafe(const DataTypes & elems, IColumn & column, F && impl)
     }
     catch (...)
     {
-        for (const auto & i : ext::range(0, ext::size(elems)))
+        for (const auto & i : collections::range(0, elems.size()))
         {
             auto & element_column = extractElementColumn(column, i);
 
@@ -164,14 +162,14 @@ MutableColumnPtr DataTypeTuple::createColumn() const
 
 Field DataTypeTuple::getDefault() const
 {
-    return Tuple(ext::map<Tuple>(elems, [] (const DataTypePtr & elem) { return elem->getDefault(); }));
+    return Tuple(collections::map<Tuple>(elems, [] (const DataTypePtr & elem) { return elem->getDefault(); }));
 }
 
 void DataTypeTuple::insertDefaultInto(IColumn & column) const
 {
     addElementSafe(elems, column, [&]
     {
-        for (const auto & i : ext::range(0, ext::size(elems)))
+        for (const auto & i : collections::range(0, elems.size()))
             elems[i]->insertDefaultInto(extractElementColumn(column, i));
     });
 }
diff --git a/src/DataTypes/FieldToDataType.cpp b/src/DataTypes/FieldToDataType.cpp
index a8d439612f5..c1a8cacd5c2 100644
--- a/src/DataTypes/FieldToDataType.cpp
+++ b/src/DataTypes/FieldToDataType.cpp
@@ -11,7 +11,6 @@
 #include <DataTypes/getLeastSupertype.h>
 #include <DataTypes/DataTypeFactory.h>
 #include <Common/Exception.h>
-#include <ext/size.h>
 
 
 namespace DB
@@ -121,7 +120,7 @@ DataTypePtr FieldToDataType::operator() (const Tuple & tuple) const
         throw Exception("Cannot infer type of an empty tuple", ErrorCodes::EMPTY_DATA_PASSED);
 
     DataTypes element_types;
-    element_types.reserve(ext::size(tuple));
+    element_types.reserve(tuple.size());
 
     for (const auto & element : tuple)
         element_types.push_back(applyVisitor(FieldToDataType(), element));
diff --git a/src/DataTypes/Serializations/SerializationMap.cpp b/src/DataTypes/Serializations/SerializationMap.cpp
index 26b473c9d0a..84e6fd3b897 100644
--- a/src/DataTypes/Serializations/SerializationMap.cpp
+++ b/src/DataTypes/Serializations/SerializationMap.cpp
@@ -1,3 +1,5 @@
+#include <common/map.h>
+
 #include <DataTypes/Serializations/SerializationMap.h>
 #include <DataTypes/Serializations/SerializationArray.h>
 #include <DataTypes/Serializations/SerializationTuple.h>
@@ -16,9 +18,6 @@
 #include <IO/ReadBufferFromString.h>
 #include <IO/Operators.h>
 
-#include <ext/map.h>
-#include <ext/enumerate.h>
-
 
 namespace DB
 {
diff --git a/src/DataTypes/Serializations/SerializationTuple.cpp b/src/DataTypes/Serializations/SerializationTuple.cpp
index bdeea80477e..6ce3761ff98 100644
--- a/src/DataTypes/Serializations/SerializationTuple.cpp
+++ b/src/DataTypes/Serializations/SerializationTuple.cpp
@@ -1,3 +1,5 @@
+#include <common/map.h>
+#include <common/range.h>
 #include <DataTypes/Serializations/SerializationTuple.h>
 #include <Core/Field.h>
 #include <Columns/ColumnTuple.h>
@@ -7,10 +9,6 @@
 #include <IO/WriteBufferFromString.h>
 #include <IO/Operators.h>
 
-#include <ext/map.h>
-#include <ext/enumerate.h>
-#include <ext/range.h>
-
 
 namespace DB
 {
@@ -36,8 +34,11 @@ static inline const IColumn & extractElementColumn(const IColumn & column, size_
 void SerializationTuple::serializeBinary(const Field & field, WriteBuffer & ostr) const
 {
     const auto & tuple = get<const Tuple &>(field);
-    for (const auto idx_elem : ext::enumerate(elems))
-        idx_elem.second->serializeBinary(tuple[idx_elem.first], ostr);
+    for (size_t element_index = 0; element_index < elems.size(); ++element_index)
+    {
+        const auto & serialization = elems[element_index];
+        serialization->serializeBinary(tuple[element_index], ostr);
+    }
 }
 
 void SerializationTuple::deserializeBinary(Field & field, ReadBuffer & istr) const
@@ -45,7 +46,7 @@ void SerializationTuple::deserializeBinary(Field & field, ReadBuffer & istr) con
     const size_t size = elems.size();
 
     Tuple tuple(size);
-    for (const auto i : ext::range(0, size))
+    for (const auto i : collections::range(0, size))
         elems[i]->deserializeBinary(tuple[i], istr);
 
     field = tuple;
@@ -53,8 +54,11 @@ void SerializationTuple::deserializeBinary(Field & field, ReadBuffer & istr) con
 
 void SerializationTuple::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    for (const auto idx_elem : ext::enumerate(elems))
-        idx_elem.second->serializeBinary(extractElementColumn(column, idx_elem.first), row_num, ostr);
+    for (size_t element_index = 0; element_index < elems.size(); ++element_index)
+    {
+        const auto & serialization = elems[element_index];
+        serialization->serializeBinary(extractElementColumn(column, element_index), row_num, ostr);
+    }
 }
 
 
@@ -70,7 +74,7 @@ static void addElementSafe(size_t num_elems, IColumn & column, F && impl)
 
         // Check that all columns now have the same size.
         size_t new_size = column.size();
-        for (auto i : ext::range(1, num_elems))
+        for (auto i : collections::range(1, num_elems))
         {
             const auto & element_column = extractElementColumn(column, i);
             if (element_column.size() != new_size)
@@ -84,7 +88,7 @@ static void addElementSafe(size_t num_elems, IColumn & column, F && impl)
     }
     catch (...)
     {
-        for (const auto & i : ext::range(0, num_elems))
+        for (const auto & i : collections::range(0, num_elems))
         {
             auto & element_column = extractElementColumn(column, i);
             if (element_column.size() > old_size)
@@ -99,7 +103,7 @@ void SerializationTuple::deserializeBinary(IColumn & column, ReadBuffer & istr)
 {
     addElementSafe(elems.size(), column, [&]
     {
-        for (const auto & i : ext::range(0, ext::size(elems)))
+        for (const auto & i : collections::range(0, elems.size()))
             elems[i]->deserializeBinary(extractElementColumn(column, i), istr);
     });
 }
@@ -107,7 +111,7 @@ void SerializationTuple::deserializeBinary(IColumn & column, ReadBuffer & istr)
 void SerializationTuple::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
     writeChar('(', ostr);
-    for (const auto i : ext::range(0, ext::size(elems)))
+    for (const auto i : collections::range(0, elems.size()))
     {
         if (i != 0)
             writeChar(',', ostr);
@@ -123,7 +127,7 @@ void SerializationTuple::deserializeText(IColumn & column, ReadBuffer & istr, co
 
     addElementSafe(elems.size(), column, [&]
     {
-        for (const auto i : ext::range(0, size))
+        for (const auto i : collections::range(0, size))
         {
             skipWhitespaceIfAny(istr);
             if (i != 0)
@@ -152,7 +156,7 @@ void SerializationTuple::serializeTextJSON(const IColumn & column, size_t row_nu
         && have_explicit_names)
     {
         writeChar('{', ostr);
-        for (const auto i : ext::range(0, ext::size(elems)))
+        for (const auto i : collections::range(0, elems.size()))
         {
             if (i != 0)
             {
@@ -167,7 +171,7 @@ void SerializationTuple::serializeTextJSON(const IColumn & column, size_t row_nu
     else
     {
         writeChar('[', ostr);
-        for (const auto i : ext::range(0, ext::size(elems)))
+        for (const auto i : collections::range(0, elems.size()))
         {
             if (i != 0)
                 writeChar(',', ostr);
@@ -189,7 +193,7 @@ void SerializationTuple::deserializeTextJSON(IColumn & column, ReadBuffer & istr
         addElementSafe(elems.size(), column, [&]
         {
             // Require all elements but in arbitrary order.
-            for (auto i : ext::range(0, ext::size(elems)))
+            for (auto i : collections::range(0, elems.size()))
             {
                 if (i > 0)
                 {
@@ -220,7 +224,7 @@ void SerializationTuple::deserializeTextJSON(IColumn & column, ReadBuffer & istr
 
         addElementSafe(elems.size(), column, [&]
         {
-            for (const auto i : ext::range(0, size))
+            for (const auto i : collections::range(0, size))
             {
                 skipWhitespaceIfAny(istr);
                 if (i != 0)
@@ -240,7 +244,7 @@ void SerializationTuple::deserializeTextJSON(IColumn & column, ReadBuffer & istr
 void SerializationTuple::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
     writeCString("<tuple>", ostr);
-    for (const auto i : ext::range(0, ext::size(elems)))
+    for (const auto i : collections::range(0, elems.size()))
     {
         writeCString("<elem>", ostr);
         elems[i]->serializeTextXML(extractElementColumn(column, i), row_num, ostr, settings);
@@ -251,7 +255,7 @@ void SerializationTuple::serializeTextXML(const IColumn & column, size_t row_num
 
 void SerializationTuple::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const
 {
-    for (const auto i : ext::range(0, ext::size(elems)))
+    for (const auto i : collections::range(0, elems.size()))
     {
         if (i != 0)
             writeChar(',', ostr);
@@ -264,7 +268,7 @@ void SerializationTuple::deserializeTextCSV(IColumn & column, ReadBuffer & istr,
     addElementSafe(elems.size(), column, [&]
     {
         const size_t size = elems.size();
-        for (const auto i : ext::range(0, size))
+        for (const auto i : collections::range(0, size))
         {
             if (i != 0)
             {
@@ -372,7 +376,7 @@ void SerializationTuple::serializeBinaryBulkWithMultipleStreams(
 {
     auto * tuple_state = checkAndGetTupleSerializeState(state);
 
-    for (const auto i : ext::range(0, ext::size(elems)))
+    for (const auto i : collections::range(0, elems.size()))
     {
         const auto & element_col = extractElementColumn(column, i);
         elems[i]->serializeBinaryBulkWithMultipleStreams(element_col, offset, limit, settings, tuple_state->states[i]);
@@ -392,7 +396,7 @@ void SerializationTuple::deserializeBinaryBulkWithMultipleStreams(
     auto & column_tuple = assert_cast<ColumnTuple &>(*mutable_column);
 
     settings.avg_value_size_hint = 0;
-    for (const auto i : ext::range(0, ext::size(elems)))
+    for (const auto i : collections::range(0, elems.size()))
         elems[i]->deserializeBinaryBulkWithMultipleStreams(column_tuple.getColumnPtr(i), limit, settings, tuple_state->states[i], cache);
 }
 
diff --git a/src/Databases/DatabaseLazy.cpp b/src/Databases/DatabaseLazy.cpp
index 22afaa971a1..28f9372a61e 100644
--- a/src/Databases/DatabaseLazy.cpp
+++ b/src/Databases/DatabaseLazy.cpp
@@ -10,7 +10,7 @@
 #include <Storages/IStorage.h>
 
 #include <common/logger_useful.h>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 #include <iomanip>
 #include <filesystem>
 
diff --git a/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp b/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp
index e5783be4624..a8577ddbd03 100644
--- a/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp
+++ b/src/Databases/MySQL/MaterializeMySQLSyncThread.cpp
@@ -22,7 +22,7 @@
 #    include <Common/quoteString.h>
 #    include <Common/setThreadName.h>
 #    include <common/sleep.h>
-#    include <ext/bit_cast.h>
+#    include <common/bit_cast.h>
 
 namespace DB
 {
diff --git a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
index 2eb10bf273f..a310315dcc8 100644
--- a/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
+++ b/src/Databases/PostgreSQL/fetchPostgreSQLTableStructure.cpp
@@ -116,7 +116,7 @@ std::shared_ptr<NamesAndTypesList> fetchPostgreSQLTableStructure(
     try
     {
         pqxx::read_transaction tx(connection_holder->get());
-        pqxx::stream_from stream(tx, pqxx::from_query, std::string_view(query));
+        auto stream{pqxx::stream_from::query(tx, query)};
 
         std::tuple<std::string, std::string, std::string, uint16_t> row;
         while (stream >> row)
diff --git a/src/Dictionaries/CacheDictionary.cpp b/src/Dictionaries/CacheDictionary.cpp
index 9bb8b34e74e..8a8a64fab36 100644
--- a/src/Dictionaries/CacheDictionary.cpp
+++ b/src/Dictionaries/CacheDictionary.cpp
@@ -1,11 +1,7 @@
 #include "CacheDictionary.h"
 
 #include <memory>
-
-#include <ext/range.h>
-#include <ext/size.h>
-#include <ext/map.h>
-#include <ext/chrono_io.h>
+#include <common/chrono_io.h>
 
 #include <Core/Defines.h>
 #include <Common/CurrentMetrics.h>
@@ -654,7 +650,7 @@ void CacheDictionary<dictionary_key_type>::update(CacheDictionaryUpdateUnitPtr<d
 
             tryLogException(last_exception, log,
                             "Could not update cache dictionary '" + getDictionaryID().getNameForLogs() +
-                            "', next update is scheduled at " + ext::to_string(backoff_end_time.load()));
+                            "', next update is scheduled at " + to_string(backoff_end_time.load()));
             try
             {
                 std::rethrow_exception(last_exception);
@@ -683,7 +679,7 @@ void CacheDictionary<dictionary_key_type>::update(CacheDictionaryUpdateUnitPtr<d
         throw DB::Exception(ErrorCodes::CACHE_DICTIONARY_UPDATE_FAIL,
             "Query contains keys that are not present in cache or expired. Could not update cache dictionary {} now, because nearest update is scheduled at {}. Try again later.",
             getDictionaryID().getNameForLogs(),
-            ext::to_string(backoff_end_time.load()));
+            to_string(backoff_end_time.load()));
     }
 }
 
diff --git a/src/Dictionaries/DictionaryBlockInputStream.cpp b/src/Dictionaries/DictionaryBlockInputStream.cpp
index 433ff211831..c902a87cfe3 100644
--- a/src/Dictionaries/DictionaryBlockInputStream.cpp
+++ b/src/Dictionaries/DictionaryBlockInputStream.cpp
@@ -129,9 +129,8 @@ Block DictionaryBlockInputStream::fillBlock(
 
     auto dictionary_key_type = dictionary->getKeyType();
 
-    for (const auto idx : ext::range(0, structure.attributes.size()))
+    for (const auto & attribute : structure.attributes)
     {
-        const DictionaryAttribute & attribute = structure.attributes[idx];
         if (names.find(attribute.name) != names.end())
         {
             ColumnPtr column;
@@ -182,9 +181,9 @@ void DictionaryBlockInputStream::fillKeyColumns(
     for (const DictionaryAttribute & attribute : *dictionary_structure.key)
         columns.emplace_back(attribute.type->createColumn());
 
-    for (auto idx : ext::range(start, size))
+    for (size_t index = start; index < size; ++index)
     {
-        const auto & key = keys[idx];
+        const auto & key = keys[index];
         const auto *ptr = key.data;
         for (auto & column : columns)
             ptr = column->deserializeAndInsertFromArena(ptr);
diff --git a/src/Dictionaries/DictionaryBlockInputStream.h b/src/Dictionaries/DictionaryBlockInputStream.h
index 5197df411fa..de1acd294f7 100644
--- a/src/Dictionaries/DictionaryBlockInputStream.h
+++ b/src/Dictionaries/DictionaryBlockInputStream.h
@@ -9,7 +9,6 @@
 #include <DataStreams/IBlockInputStream.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <common/logger_useful.h>
-#include <ext/range.h>
 #include "DictionaryBlockInputStreamBase.h"
 #include "DictionaryStructure.h"
 #include "IDictionary.h"
diff --git a/src/Dictionaries/DictionaryStructure.cpp b/src/Dictionaries/DictionaryStructure.cpp
index c280a2b94de..9f46addd912 100644
--- a/src/Dictionaries/DictionaryStructure.cpp
+++ b/src/Dictionaries/DictionaryStructure.cpp
@@ -12,7 +12,6 @@
 #include <numeric>
 #include <unordered_map>
 #include <unordered_set>
-#include <ext/range.h>
 
 
 namespace DB
@@ -206,7 +205,7 @@ void DictionaryStructure::validateKeyTypes(const DataTypes & key_types) const
     if (key_types.size() != key->size())
         throw Exception(ErrorCodes::TYPE_MISMATCH, "Key structure does not match, expected {}", getKeyDescription());
 
-    for (const auto i : ext::range(0, key_types.size()))
+    for (size_t i = 0; i < key_types.size(); ++i)
     {
         const auto & expected_type = (*key)[i].type;
         const auto & actual_type = key_types[i];
diff --git a/src/Dictionaries/DirectDictionary.h b/src/Dictionaries/DirectDictionary.h
index 1cc73622592..a4e8d5f82e6 100644
--- a/src/Dictionaries/DirectDictionary.h
+++ b/src/Dictionaries/DirectDictionary.h
@@ -7,8 +7,6 @@
 #include <Columns/ColumnString.h>
 #include <Common/Arena.h>
 #include <Core/Block.h>
-#include <ext/range.h>
-#include <ext/size.h>
 #include <Common/HashTable/HashMap.h>
 #include "DictionaryStructure.h"
 #include "IDictionary.h"
diff --git a/src/Dictionaries/ExecutableDictionarySource.cpp b/src/Dictionaries/ExecutableDictionarySource.cpp
index 1a7281ea810..5247c8038cd 100644
--- a/src/Dictionaries/ExecutableDictionarySource.cpp
+++ b/src/Dictionaries/ExecutableDictionarySource.cpp
@@ -1,7 +1,7 @@
 #include "ExecutableDictionarySource.h"
 
 #include <functional>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <DataStreams/IBlockOutputStream.h>
 #include <DataStreams/OwningBlockInputStream.h>
 #include <Interpreters/Context.h>
diff --git a/src/Dictionaries/ExecutablePoolDictionarySource.cpp b/src/Dictionaries/ExecutablePoolDictionarySource.cpp
index 205c2419156..fe6b19b8253 100644
--- a/src/Dictionaries/ExecutablePoolDictionarySource.cpp
+++ b/src/Dictionaries/ExecutablePoolDictionarySource.cpp
@@ -1,7 +1,7 @@
 #include "ExecutablePoolDictionarySource.h"
 
 #include <functional>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <DataStreams/IBlockOutputStream.h>
 #include <Interpreters/Context.h>
 #include <IO/WriteHelpers.h>
diff --git a/src/Dictionaries/ExternalQueryBuilder.cpp b/src/Dictionaries/ExternalQueryBuilder.cpp
index 0c1dced2cdd..e0920535e33 100644
--- a/src/Dictionaries/ExternalQueryBuilder.cpp
+++ b/src/Dictionaries/ExternalQueryBuilder.cpp
@@ -3,7 +3,6 @@
 #include <IO/WriteBufferFromString.h>
 #include <IO/WriteHelpers.h>
 #include <boost/range/join.hpp>
-#include <ext/range.h>
 #include "DictionaryStructure.h"
 #include "writeParenthesisedString.h"
 
@@ -346,7 +345,7 @@ void ExternalQueryBuilder::composeKeyCondition(const Columns & key_columns, cons
                                                size_t beg, size_t end) const
 {
     auto first = true;
-    for (const auto i : ext::range(beg, end))
+    for (size_t i = beg; i < end; ++i)
     {
         if (!first)
             writeString(" AND ", out);
@@ -391,7 +390,7 @@ void ExternalQueryBuilder::composeKeyTupleDefinition(WriteBuffer & out, size_t b
     writeChar('(', out);
 
     auto first = true;
-    for (const auto i : ext::range(beg, end))
+    for (size_t i = beg; i < end; ++i)
     {
         if (!first)
             writeString(", ", out);
@@ -409,7 +408,7 @@ void ExternalQueryBuilder::composeKeyTuple(const Columns & key_columns, const si
     writeString("(", out);
 
     auto first = true;
-    for (const auto i : ext::range(beg, end))
+    for (size_t i = beg; i < end; ++i)
     {
         if (!first)
             writeString(", ", out);
diff --git a/src/Dictionaries/FlatDictionary.h b/src/Dictionaries/FlatDictionary.h
index 053eda72b37..ccd3bf9d9eb 100644
--- a/src/Dictionaries/FlatDictionary.h
+++ b/src/Dictionaries/FlatDictionary.h
@@ -5,9 +5,6 @@
 #include <vector>
 #include <optional>
 
-#include <ext/range.h>
-#include <ext/size.h>
-
 #include <Common/HashTable/HashSet.h>
 #include <Common/Arena.h>
 #include <DataTypes/IDataType.h>
diff --git a/src/Dictionaries/HashedDictionary.h b/src/Dictionaries/HashedDictionary.h
index 7213eb616c8..842e49aa8f0 100644
--- a/src/Dictionaries/HashedDictionary.h
+++ b/src/Dictionaries/HashedDictionary.h
@@ -6,7 +6,6 @@
 #include <optional>
 
 #include <sparsehash/sparse_hash_map>
-#include <ext/range.h>
 
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/HashSet.h>
diff --git a/src/Dictionaries/IPAddressDictionary.cpp b/src/Dictionaries/IPAddressDictionary.cpp
index 26ceb11c33c..a36aeb59f01 100644
--- a/src/Dictionaries/IPAddressDictionary.cpp
+++ b/src/Dictionaries/IPAddressDictionary.cpp
@@ -11,8 +11,8 @@
 #include <Poco/ByteOrder.h>
 #include <Common/formatIPv6.h>
 #include <common/itoa.h>
-#include <ext/map.h>
-#include <ext/range.h>
+#include <common/map.h>
+#include <common/range.h>
 #include <Dictionaries/DictionaryBlockInputStream.h>
 #include <Dictionaries/DictionaryFactory.h>
 #include <Functions/FunctionHelpers.h>
@@ -292,7 +292,7 @@ ColumnUInt8::Ptr IPAddressDictionary::hasKeys(const Columns & key_columns, const
     if (first_column->isNumeric())
     {
         uint8_t addrv6_buf[IPV6_BINARY_LENGTH];
-        for (const auto i : ext::range(0, rows))
+        for (const auto i : collections::range(0, rows))
         {
             auto addrv4 = UInt32(first_column->get64(i));
             auto found = tryLookupIPv4(addrv4, addrv6_buf);
@@ -302,7 +302,7 @@ ColumnUInt8::Ptr IPAddressDictionary::hasKeys(const Columns & key_columns, const
     }
     else
     {
-        for (const auto i : ext::range(0, rows))
+        for (const auto i : collections::range(0, rows))
         {
             auto addr = first_column->getDataAt(i);
             if (unlikely(addr.size != IPV6_BINARY_LENGTH))
@@ -365,13 +365,13 @@ void IPAddressDictionary::loadData()
         element_count += rows;
 
         const ColumnPtr key_column_ptr = block.safeGetByPosition(0).column;
-        const auto attribute_column_ptrs = ext::map<Columns>(
-            ext::range(0, dict_struct.attributes.size()),
+        const auto attribute_column_ptrs = collections::map<Columns>(
+            collections::range(0, dict_struct.attributes.size()),
             [&](const size_t attribute_idx) { return block.safeGetByPosition(attribute_idx + 1).column; });
 
-        for (const auto row : ext::range(0, rows))
+        for (const auto row : collections::range(0, rows))
         {
-            for (const auto attribute_idx : ext::range(0, dict_struct.attributes.size()))
+            for (const auto attribute_idx : collections::range(0, dict_struct.attributes.size()))
             {
                 const auto & attribute_column = *attribute_column_ptrs[attribute_idx];
                 auto & attribute = attributes[attribute_idx];
@@ -476,7 +476,7 @@ void IPAddressDictionary::loadData()
 
     parent_subnet.resize(ip_records.size());
     std::stack<size_t> subnets_stack;
-    for (const auto i : ext::range(0, ip_records.size()))
+    for (const auto i : collections::range(0, ip_records.size()))
     {
         parent_subnet[i] = i;
         while (!subnets_stack.empty())
@@ -627,12 +627,12 @@ void IPAddressDictionary::getItemsByTwoKeyColumnsImpl(
             return addr < target.addr;
         };
 
-        for (const auto i : ext::range(0, rows))
+        for (const auto i : collections::range(0, rows))
         {
             UInt32 addr = key_ip_column_ptr->getElement(i);
             UInt8 mask = key_mask_column.getElement(i);
 
-            auto range = ext::range(0, row_idx.size());
+            auto range = collections::range(0, row_idx.size());
             auto found_it = std::lower_bound(range.begin(), range.end(), IPv4Subnet{addr, mask}, comp_v4);
 
             if (likely(found_it != range.end() &&
@@ -662,14 +662,14 @@ void IPAddressDictionary::getItemsByTwoKeyColumnsImpl(
         return cmpres < 0;
     };
 
-    for (const auto i : ext::range(0, rows))
+    for (const auto i : collections::range(0, rows))
     {
         auto addr = key_ip_column_ptr->getDataAt(i);
         UInt8 mask = key_mask_column.getElement(i);
 
         IPv6Subnet target{reinterpret_cast<const uint8_t *>(addr.data), mask};
 
-        auto range = ext::range(0, row_idx.size());
+        auto range = collections::range(0, row_idx.size());
         auto found_it = std::lower_bound(range.begin(), range.end(), target, comp_v6);
 
         if (likely(found_it != range.end() &&
@@ -707,7 +707,7 @@ void IPAddressDictionary::getItemsImpl(
     if (first_column->isNumeric())
     {
         uint8_t addrv6_buf[IPV6_BINARY_LENGTH];
-        for (const auto i : ext::range(0, rows))
+        for (const auto i : collections::range(0, rows))
         {
             // addrv4 has native endianness
             auto addrv4 = UInt32(first_column->get64(i));
@@ -723,7 +723,7 @@ void IPAddressDictionary::getItemsImpl(
     }
     else
     {
-        for (const auto i : ext::range(0, rows))
+        for (const auto i : collections::range(0, rows))
         {
             auto addr = first_column->getDataAt(i);
             if (addr.size != IPV6_BINARY_LENGTH)
@@ -789,7 +789,7 @@ Columns IPAddressDictionary::getKeyColumns() const
     {
         auto key_ip_column = ColumnVector<UInt32>::create();
         auto key_mask_column = ColumnVector<UInt8>::create();
-        for (size_t row : ext::range(0, row_idx.size()))
+        for (size_t row : collections::range(0, row_idx.size()))
         {
             key_ip_column->insertValue((*ipv4_col)[row]);
             key_mask_column->insertValue(mask_column[row]);
@@ -802,7 +802,7 @@ Columns IPAddressDictionary::getKeyColumns() const
     auto key_ip_column = ColumnFixedString::create(IPV6_BINARY_LENGTH);
     auto key_mask_column = ColumnVector<UInt8>::create();
 
-    for (size_t row : ext::range(0, row_idx.size()))
+    for (size_t row : collections::range(0, row_idx.size()))
     {
         const char * data = reinterpret_cast<const char *>(getIPv6FromOffset(*ipv6_col, row));
         key_ip_column->insertData(data, IPV6_BINARY_LENGTH);
@@ -820,7 +820,7 @@ static auto keyViewGetter()
         const auto & key_ip_column = assert_cast<const KeyColumnType &>(*columns.front());
         const auto & key_mask_column = assert_cast<const ColumnVector<UInt8> &>(*columns.back());
         char buffer[48];
-        for (size_t row : ext::range(0, key_ip_column.size()))
+        for (size_t row : collections::range(0, key_ip_column.size()))
         {
             UInt8 mask = key_mask_column.getElement(row);
             size_t str_len;
@@ -912,7 +912,7 @@ IPAddressDictionary::RowIdxConstIter IPAddressDictionary::lookupIP(IPValueType t
             return memcmp16(value, getIPv6FromOffset(*ipv4or6_col, idx)) < 0;
     };
 
-    auto range = ext::range(0, row_idx.size());
+    auto range = collections::range(0, row_idx.size());
     auto found_it = std::upper_bound(range.begin(), range.end(), target, comp);
 
     if (found_it == range.begin())
diff --git a/src/Dictionaries/IPAddressDictionary.h b/src/Dictionaries/IPAddressDictionary.h
index 075742da11a..f44291cec6a 100644
--- a/src/Dictionaries/IPAddressDictionary.h
+++ b/src/Dictionaries/IPAddressDictionary.h
@@ -12,7 +12,6 @@
 #include <Poco/Net/IPAddress.h>
 #include <common/StringRef.h>
 #include <common/logger_useful.h>
-#include <ext/range.h>
 #include "DictionaryStructure.h"
 #include "IDictionary.h"
 #include "IDictionarySource.h"
diff --git a/src/Dictionaries/MongoDBDictionarySource.cpp b/src/Dictionaries/MongoDBDictionarySource.cpp
index 2a809f52817..4a5207dc5d8 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 <ext/enumerate.h>
 #include <DataStreams/MongoDBBlockInputStream.h>
 
 
@@ -182,9 +181,12 @@ BlockInputStreamPtr MongoDBDictionarySource::loadKeys(const Columns & key_column
     {
         auto & key = keys_array->addNewDocument(DB::toString(row_idx));
 
-        for (const auto attr : ext::enumerate(*dict_struct.key))
+        const auto & key_attributes = *dict_struct.key;
+        for (size_t attribute_index = 0; attribute_index < key_attributes.size(); ++attribute_index)
         {
-            switch (attr.second.underlying_type)
+            const auto & key_attribute = key_attributes[attribute_index];
+
+            switch (key_attribute.underlying_type)
             {
                 case AttributeUnderlyingType::UInt8:
                 case AttributeUnderlyingType::UInt16:
@@ -195,27 +197,27 @@ BlockInputStreamPtr MongoDBDictionarySource::loadKeys(const Columns & key_column
                 case AttributeUnderlyingType::Int32:
                 case AttributeUnderlyingType::Int64:
                 {
-                    key.add(attr.second.name, Int32(key_columns[attr.first]->get64(row_idx)));
+                    key.add(key_attribute.name, Int32(key_columns[attribute_index]->get64(row_idx)));
                     break;
                 }
                 case AttributeUnderlyingType::Float32:
                 case AttributeUnderlyingType::Float64:
                 {
-                    key.add(attr.second.name, key_columns[attr.first]->getFloat64(row_idx));
+                    key.add(key_attribute.name, key_columns[attribute_index]->getFloat64(row_idx));
                     break;
                 }
                 case AttributeUnderlyingType::String:
                 {
-                    String loaded_str(get<String>((*key_columns[attr.first])[row_idx]));
+                    String loaded_str(get<String>((*key_columns[attribute_index])[row_idx]));
                     /// Convert string to ObjectID
-                    if (attr.second.is_object_id)
+                    if (key_attribute.is_object_id)
                     {
                         Poco::MongoDB::ObjectId::Ptr loaded_id(new Poco::MongoDB::ObjectId(loaded_str));
-                        key.add(attr.second.name, loaded_id);
+                        key.add(key_attribute.name, loaded_id);
                     }
                     else
                     {
-                        key.add(attr.second.name, loaded_str);
+                        key.add(key_attribute.name, loaded_str);
                     }
                     break;
                 }
diff --git a/src/Dictionaries/PolygonDictionary.cpp b/src/Dictionaries/PolygonDictionary.cpp
index 17e7605d136..73810d4b057 100644
--- a/src/Dictionaries/PolygonDictionary.cpp
+++ b/src/Dictionaries/PolygonDictionary.cpp
@@ -233,7 +233,7 @@ std::vector<IPolygonDictionary::Point> IPolygonDictionary::extractPoints(const C
     std::vector<Point> result;
     result.reserve(rows);
 
-    for (const auto row : ext::range(0, rows))
+    for (size_t row = 0; row < rows; ++row)
     {
         auto x = column_x->getElement(row);
         auto y = column_y->getElement(row);
diff --git a/src/Dictionaries/RangeDictionaryBlockInputStream.h b/src/Dictionaries/RangeDictionaryBlockInputStream.h
index 499eea7152f..bef28e71d57 100644
--- a/src/Dictionaries/RangeDictionaryBlockInputStream.h
+++ b/src/Dictionaries/RangeDictionaryBlockInputStream.h
@@ -5,7 +5,7 @@
 #include <DataStreams/IBlockInputStream.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypesNumber.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include "DictionaryBlockInputStreamBase.h"
 #include "DictionaryStructure.h"
 #include "IDictionary.h"
@@ -84,7 +84,7 @@ Block RangeDictionaryBlockInputStream<RangeType>::getBlock(size_t start, size_t
     block_start_dates.reserve(length);
     block_end_dates.reserve(length);
 
-    for (auto idx : ext::range(start, start + length))
+    for (auto idx : collections::range(start, start + length))
     {
         block_ids.push_back(ids[idx]);
         block_start_dates.push_back(start_dates[idx]);
@@ -153,7 +153,7 @@ Block RangeDictionaryBlockInputStream<RangeType>::fillBlock(
         columns.emplace_back(range_max_column, structure.range_max->type, range_max_column_name);
     }
 
-    for (const auto idx : ext::range(0, structure.attributes.size()))
+    for (const auto idx : collections::range(0, structure.attributes.size()))
     {
         const DictionaryAttribute & attribute = structure.attributes[idx];
         if (column_names.find(attribute.name) != column_names.end())
diff --git a/src/Dictionaries/RangeHashedDictionary.cpp b/src/Dictionaries/RangeHashedDictionary.cpp
index e2775ce1ec0..eadfc03ef33 100644
--- a/src/Dictionaries/RangeHashedDictionary.cpp
+++ b/src/Dictionaries/RangeHashedDictionary.cpp
@@ -2,7 +2,7 @@
 #include <Columns/ColumnNullable.h>
 #include <Functions/FunctionHelpers.h>
 #include <Common/TypeList.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include "DictionaryFactory.h"
 #include "RangeDictionaryBlockInputStream.h"
 #include <Interpreters/castColumn.h>
@@ -254,7 +254,7 @@ ColumnUInt8::Ptr RangeHashedDictionary::hasKeysImpl(
 
     keys_found = 0;
 
-    for (const auto row : ext::range(0, ids.size()))
+    for (const auto row : collections::range(0, ids.size()))
     {
         const auto it = attr.find(ids[row]);
 
@@ -313,12 +313,12 @@ void RangeHashedDictionary::loadData()
 
         element_count += id_column.size();
 
-        for (const auto attribute_idx : ext::range(0, attributes.size()))
+        for (const auto attribute_idx : collections::range(0, attributes.size()))
         {
             const auto & attribute_column = *block.safeGetByPosition(attribute_idx + 3).column;
             auto & attribute = attributes[attribute_idx];
 
-            for (const auto row_idx : ext::range(0, id_column.size()))
+            for (const auto row_idx : collections::range(0, id_column.size()))
             {
                 RangeStorageType lower_bound;
                 RangeStorageType upper_bound;
@@ -416,7 +416,7 @@ void RangeHashedDictionary::getItemsImpl(
 
     size_t keys_found = 0;
 
-    for (const auto row : ext::range(0, ids.size()))
+    for (const auto row : collections::range(0, ids.size()))
     {
         const auto it = attr.find(ids[row]);
         if (it)
diff --git a/src/Dictionaries/RedisBlockInputStream.cpp b/src/Dictionaries/RedisBlockInputStream.cpp
index bb8ef92eeea..bf02de9b9b5 100644
--- a/src/Dictionaries/RedisBlockInputStream.cpp
+++ b/src/Dictionaries/RedisBlockInputStream.cpp
@@ -13,7 +13,6 @@
 #include <Columns/ColumnsNumber.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
-#include <ext/range.h>
 
 #include "DictionaryStructure.h"
 
@@ -131,7 +130,7 @@ namespace DB
         const size_t size = description.sample_block.columns();
         MutableColumns columns(size);
 
-        for (const auto i : ext::range(0, size))
+        for (size_t i = 0; i < size; ++i)
             columns[i] = description.sample_block.getByPosition(i).column->cloneEmpty();
 
         const auto insert_value_by_idx = [this, &columns](size_t idx, const auto & value)
diff --git a/src/Formats/MySQLBlockInputStream.cpp b/src/Formats/MySQLBlockInputStream.cpp
index b12b4f755ed..3ea86c82fa3 100644
--- a/src/Formats/MySQLBlockInputStream.cpp
+++ b/src/Formats/MySQLBlockInputStream.cpp
@@ -16,7 +16,7 @@
 #include <IO/WriteHelpers.h>
 #include <IO/Operators.h>
 #include <Common/assert_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <common/logger_useful.h>
 #include "MySQLBlockInputStream.h"
 
@@ -216,7 +216,7 @@ Block MySQLBlockInputStream::readImpl()
     }
 
     MutableColumns columns(description.sample_block.columns());
-    for (const auto i : ext::range(0, columns.size()))
+    for (const auto i : collections::range(0, columns.size()))
         columns[i] = description.sample_block.getByPosition(i).column->cloneEmpty();
 
     size_t num_rows = 0;
@@ -276,7 +276,7 @@ void MySQLBlockInputStream::initPositionMappingFromQueryResultStructure()
             throw Exception{"mysqlxx::UseQueryResult contains " + toString(connection->result.getNumFields()) + " columns while "
                 + toString(description.sample_block.columns()) + " expected", ErrorCodes::NUMBER_OF_COLUMNS_DOESNT_MATCH};
 
-        for (const auto idx : ext::range(0, connection->result.getNumFields()))
+        for (const auto idx : collections::range(0, connection->result.getNumFields()))
             position_mapping[idx] = idx;
     }
     else
@@ -286,7 +286,7 @@ void MySQLBlockInputStream::initPositionMappingFromQueryResultStructure()
 
         size_t fields_size = connection->result.getNumFields();
 
-        for (const size_t & idx : ext::range(0, fields_size))
+        for (const size_t & idx : collections::range(0, fields_size))
         {
             const auto & field_name = connection->result.getFieldName(idx);
             if (description.sample_block.has(field_name))
diff --git a/src/Formats/ProtobufSerializer.cpp b/src/Formats/ProtobufSerializer.cpp
index 962df507f82..ac1d5f048e3 100644
--- a/src/Formats/ProtobufSerializer.cpp
+++ b/src/Formats/ProtobufSerializer.cpp
@@ -32,7 +32,7 @@
 #   include <IO/ReadHelpers.h>
 #   include <IO/WriteBufferFromString.h>
 #   include <IO/WriteHelpers.h>
-#   include <ext/range.h>
+#   include <common/range.h>
 #   include <google/protobuf/descriptor.h>
 #   include <google/protobuf/descriptor.pb.h>
 #   include <boost/algorithm/string.hpp>
@@ -40,7 +40,7 @@
 #   include <boost/container/flat_set.hpp>
 #   include <boost/numeric/conversion/cast.hpp>
 #   include <boost/range/algorithm.hpp>
-
+#   include <boost/range/algorithm_ext/erase.hpp>
 #   include <common/logger_useful.h>
 
 namespace DB
@@ -1007,7 +1007,7 @@ namespace
             auto iless = [](const std::string_view & s1, const std::string_view & s2) { return ColumnNameWithProtobufFieldNameComparator::less(s1, s2); };
             boost::container::flat_map<std::string_view, int, decltype(iless)> string_to_protobuf_enum_value_map;
             typename decltype(string_to_protobuf_enum_value_map)::sequence_type string_to_protobuf_enum_value_seq;
-            for (int i : ext::range(enum_descriptor.value_count()))
+            for (int i : collections::range(enum_descriptor.value_count()))
                 string_to_protobuf_enum_value_seq.emplace_back(enum_descriptor.value(i)->name(), enum_descriptor.value(i)->number());
             string_to_protobuf_enum_value_map.adopt_sequence(std::move(string_to_protobuf_enum_value_seq));
 
@@ -1895,7 +1895,7 @@ namespace
         {
             const auto & column_array = assert_cast<const ColumnArray &>(*column);
             const auto & offsets = column_array.getOffsets();
-            for (size_t i : ext::range(offsets[row_num - 1], offsets[row_num]))
+            for (size_t i : collections::range(offsets[row_num - 1], offsets[row_num]))
                 element_serializer->writeRow(i);
         }
 
@@ -1967,7 +1967,7 @@ namespace
             assert(num_columns == 1);
             column = columns[0];
             const auto & column_tuple = assert_cast<const ColumnTuple &>(*column);
-            for (size_t i : ext::range(tuple_size))
+            for (size_t i : collections::range(tuple_size))
             {
                 auto element_column = column_tuple.getColumnPtr(i);
                 element_serializers[i]->setColumns(&element_column, 1);
@@ -1984,7 +1984,7 @@ namespace
 
         void writeRow(size_t row_num) override
         {
-            for (size_t i : ext::range(tuple_size))
+            for (size_t i : collections::range(tuple_size))
                 element_serializers[i]->writeRow(row_num);
         }
 
@@ -2020,12 +2020,12 @@ namespace
 
             try
             {
-                for (size_t i : ext::range(tuple_size))
+                for (size_t i : collections::range(tuple_size))
                     element_serializers[i]->insertDefaults(row_num);
             }
             catch (...)
             {
-                for (size_t i : ext::range(tuple_size))
+                for (size_t i : collections::range(tuple_size))
                 {
                     auto element_column = column_tuple.getColumnPtr(i)->assumeMutable();
                     if (element_column->size() > old_size)
@@ -2051,8 +2051,7 @@ namespace
     public:
         struct FieldDesc
         {
-            size_t column_index;
-            size_t num_columns;
+            std::vector<size_t> column_indices;
             const FieldDescriptor * field_descriptor;
             std::unique_ptr<ProtobufSerializer> field_serializer;
         };
@@ -2070,12 +2069,12 @@ namespace
         {
             field_infos.reserve(field_descs_.size());
             for (auto & desc : field_descs_)
-                field_infos.emplace_back(desc.column_index, desc.num_columns, *desc.field_descriptor, std::move(desc.field_serializer));
+                field_infos.emplace_back(std::move(desc.column_indices), *desc.field_descriptor, std::move(desc.field_serializer));
 
             std::sort(field_infos.begin(), field_infos.end(),
                       [](const FieldInfo & lhs, const FieldInfo & rhs) { return lhs.field_tag < rhs.field_tag; });
 
-            for (size_t i : ext::range(field_infos.size()))
+            for (size_t i : collections::range(field_infos.size()))
                 field_index_by_field_tag.emplace(field_infos[i].field_tag, i);
         }
 
@@ -2083,22 +2082,28 @@ namespace
         {
             columns.assign(columns_, columns_ + num_columns_);
 
+            std::vector<ColumnPtr> field_columns;
             for (const FieldInfo & info : field_infos)
-                info.field_serializer->setColumns(columns.data() + info.column_index, info.num_columns);
+            {
+                field_columns.clear();
+                for (size_t column_index : info.column_indices)
+                {
+                    field_columns.emplace_back(columns_[column_index]);
+                }
+                info.field_serializer->setColumns(field_columns.data(), field_columns.size());
+            }
 
             if (reader)
             {
-                missing_column_indices.clear();
-                missing_column_indices.reserve(num_columns_);
-                size_t current_idx = 0;
+                missing_column_indices.resize(num_columns_);
+                for (size_t column_index : collections::range(num_columns_))
+                    missing_column_indices[column_index] = column_index;
                 for (const FieldInfo & info : field_infos)
                 {
-                    while (current_idx < info.column_index)
-                        missing_column_indices.push_back(current_idx++);
-                    current_idx = info.column_index + info.num_columns;
+                    for (size_t column_index : info.column_indices)
+                        missing_column_indices[column_index] = static_cast<size_t>(-1);
                 }
-                while (current_idx < num_columns_)
-                    missing_column_indices.push_back(current_idx++);
+                boost::range::remove_erase(missing_column_indices, static_cast<size_t>(-1));
             }
         }
 
@@ -2106,7 +2111,7 @@ namespace
         {
             Columns cols;
             cols.reserve(num_columns_);
-            for (size_t i : ext::range(num_columns_))
+            for (size_t i : collections::range(num_columns_))
                 cols.push_back(columns_[i]->getPtr());
             setColumns(cols.data(), cols.size());
         }
@@ -2231,20 +2236,17 @@ namespace
         struct FieldInfo
         {
             FieldInfo(
-                size_t column_index_,
-                size_t num_columns_,
+                std::vector<size_t> column_indices_,
                 const FieldDescriptor & field_descriptor_,
                 std::unique_ptr<ProtobufSerializer> field_serializer_)
-                : column_index(column_index_)
-                , num_columns(num_columns_)
+                : column_indices(std::move(column_indices_))
                 , field_descriptor(&field_descriptor_)
                 , field_tag(field_descriptor_.number())
                 , should_pack_repeated(shouldPackRepeated(field_descriptor_))
                 , field_serializer(std::move(field_serializer_))
             {
             }
-            size_t column_index;
-            size_t num_columns;
+            std::vector<size_t> column_indices;
             const FieldDescriptor * field_descriptor;
             int field_tag;
             bool should_pack_repeated;
@@ -2283,7 +2285,7 @@ namespace
             assert(tuple_size);
             Columns element_columns;
             element_columns.reserve(tuple_size);
-            for (size_t i : ext::range(tuple_size))
+            for (size_t i : collections::range(tuple_size))
                 element_columns.emplace_back(column_tuple.getColumnPtr(i));
             nested_message_serializer->setColumns(element_columns.data(), element_columns.size());
         }
@@ -2323,7 +2325,7 @@ namespace
             offset_columns.clear();
             offset_columns.reserve(num_columns);
 
-            for (size_t i : ext::range(num_columns))
+            for (size_t i : collections::range(num_columns))
             {
                 const auto & column_array = assert_cast<const ColumnArray &>(*columns[i]);
                 data_columns.emplace_back(column_array.getDataPtr());
@@ -2340,7 +2342,7 @@ namespace
         {
             Columns cols;
             cols.reserve(num_columns);
-            for (size_t i : ext::range(num_columns))
+            for (size_t i : collections::range(num_columns))
                 cols.push_back(columns[i]->getPtr());
             setColumns(cols.data(), cols.size());
         }
@@ -2350,13 +2352,13 @@ namespace
             const auto & offset_column0 = assert_cast<const ColumnArray::ColumnOffsets &>(*offset_columns[0]);
             size_t start_offset = offset_column0.getElement(row_num - 1);
             size_t end_offset = offset_column0.getElement(row_num);
-            for (size_t i : ext::range(1, offset_columns.size()))
+            for (size_t i : collections::range(1, offset_columns.size()))
             {
                 const auto & offset_column = assert_cast<const ColumnArray::ColumnOffsets &>(*offset_columns[i]);
                 if (offset_column.getElement(row_num) != end_offset)
                     throw Exception("Components of FlattenedNested have different sizes", ErrorCodes::PROTOBUF_BAD_CAST);
             }
-            for (size_t i : ext::range(start_offset, end_offset))
+            for (size_t i : collections::range(start_offset, end_offset))
                 nested_message_serializer->writeRow(i);
         }
 
@@ -2466,7 +2468,7 @@ namespace
 
             missing_column_indices.clear();
             missing_column_indices.reserve(column_names.size() - used_column_indices.size());
-            boost::range::set_difference(ext::range(column_names.size()), used_column_indices,
+            boost::range::set_difference(collections::range(column_names.size()), used_column_indices,
                                          std::back_inserter(missing_column_indices));
 
             return serializer;
@@ -2478,7 +2480,7 @@ namespace
         {
             Strings field_names;
             field_names.reserve(message_descriptor.field_count());
-            for (int i : ext::range(message_descriptor.field_count()))
+            for (int i : collections::range(message_descriptor.field_count()))
                 field_names.emplace_back(message_descriptor.field(i)->name());
             return field_names;
         }
@@ -2545,7 +2547,7 @@ namespace
 
             /// Find all fields which have the same name as column's name (case-insensitively); i.e. we're checking
             /// field_name == column_name.
-            for (int i : ext::range(message_descriptor.field_count()))
+            for (int i : collections::range(message_descriptor.field_count()))
             {
                 const auto & field_descriptor = *message_descriptor.field(i);
                 if (columnNameEqualsToFieldName(column_name, field_descriptor))
@@ -2560,7 +2562,7 @@ namespace
 
             /// Find all fields which name is used as prefix in column's name; i.e. we're checking
             /// column_name == field_name + '.' + nested_message_field_name
-            for (int i : ext::range(message_descriptor.field_count()))
+            for (int i : collections::range(message_descriptor.field_count()))
             {
                 const auto & field_descriptor = *message_descriptor.field(i);
                 std::string_view suffix;
@@ -2581,6 +2583,38 @@ namespace
             return !out_field_descriptors_with_suffixes.empty();
         }
 
+        /// Removes TypeIndex::Array from the specified vector of data types,
+        /// and also removes corresponding elements from two other vectors.
+        template <typename T1, typename T2>
+        static void removeNonArrayElements(DataTypes & data_types, std::vector<T1> & elements1, std::vector<T2> & elements2)
+        {
+            size_t initial_size = data_types.size();
+            assert(initial_size == elements1.size() && initial_size == elements2.size());
+            data_types.reserve(initial_size * 2);
+            elements1.reserve(initial_size * 2);
+            elements2.reserve(initial_size * 2);
+            for (size_t i : collections::range(initial_size))
+            {
+                if (data_types[i]->getTypeId() == TypeIndex::Array)
+                {
+                    data_types.push_back(std::move(data_types[i]));
+                    elements1.push_back(std::move(elements1[i]));
+                    elements2.push_back(std::move(elements2[i]));
+                }
+            }
+            data_types.erase(data_types.begin(), data_types.begin() + initial_size);
+            elements1.erase(elements1.begin(), elements1.begin() + initial_size);
+            elements2.erase(elements2.begin(), elements2.begin() + initial_size);
+        }
+
+        /// Treats specified column indices as indices in another vector of column indices.
+        /// Useful for handling of nested messages.
+        static void transformColumnIndices(std::vector<size_t> & column_indices, const std::vector<size_t> & outer_indices)
+        {
+            for (size_t & idx : column_indices)
+                idx = outer_indices[idx];
+        }
+
         /// Builds a serializer for a protobuf message (root or nested).
         template <typename StringOrStringViewT>
         std::unique_ptr<ProtobufSerializerMessage> buildMessageSerializerImpl(
@@ -2598,9 +2632,8 @@ namespace
             used_column_indices.clear();
             used_column_indices.reserve(num_columns);
 
-            auto add_field_serializer = [&](size_t column_index_,
-                                            const std::string_view & column_name_,
-                                            size_t num_columns_,
+            auto add_field_serializer = [&](const std::string_view & column_name_,
+                                            std::vector<size_t> column_indices_,
                                             const FieldDescriptor & field_descriptor_,
                                             std::unique_ptr<ProtobufSerializer> field_serializer_)
             {
@@ -2608,24 +2641,30 @@ namespace
                 if (it != field_descriptors_in_use.end())
                 {
                     throw Exception(
-                        "Multiple columns (" + backQuote(StringRef{field_descriptors_in_use[&field_descriptor_]}) + ", "
+                        "Multiple columns (" + backQuote(StringRef{it->second}) + ", "
                             + backQuote(StringRef{column_name_}) + ") cannot be serialized to a single protobuf field "
                             + quoteString(field_descriptor_.full_name()),
                         ErrorCodes::MULTIPLE_COLUMNS_SERIALIZED_TO_SAME_PROTOBUF_FIELD);
                 }
 
-                field_descs.push_back({column_index_, num_columns_, &field_descriptor_, std::move(field_serializer_)});
+                for (size_t column_index : column_indices_)
+                {
+                    /// Keep `used_column_indices` sorted.
+                    used_column_indices.insert(boost::range::upper_bound(used_column_indices, column_index), column_index);
+                }
+                field_descs.push_back({std::move(column_indices_), &field_descriptor_, std::move(field_serializer_)});
                 field_descriptors_in_use.emplace(&field_descriptor_, column_name_);
             };
 
             std::vector<std::pair<const FieldDescriptor *, std::string_view>> field_descriptors_with_suffixes;
 
             /// We're going through all the passed columns.
-            size_t column_idx = 0;
-            size_t next_column_idx = 1;
-            for (; column_idx != num_columns; column_idx = next_column_idx++)
+            for (size_t column_idx : collections::range(num_columns))
             {
-                auto column_name = column_names[column_idx];
+                if (boost::range::binary_search(used_column_indices, column_idx))
+                    continue;
+
+                const auto & column_name = column_names[column_idx];
                 const auto & data_type = data_types[column_idx];
 
                 if (!findFieldsByColumnName(column_name, message_descriptor, field_descriptors_with_suffixes))
@@ -2639,8 +2678,7 @@ namespace
 
                     if (field_serializer)
                     {
-                        add_field_serializer(column_idx, column_name, 1, field_descriptor, std::move(field_serializer));
-                        used_column_indices.push_back(column_idx);
+                        add_field_serializer(column_name, {column_idx}, field_descriptor, std::move(field_serializer));
                         continue;
                     }
                 }
@@ -2650,42 +2688,53 @@ namespace
                     if (!suffix.empty())
                     {
                         /// Complex case: one or more columns are serialized as a nested message.
-                        std::vector<std::string_view> names_relative_to_nested_message;
-                        names_relative_to_nested_message.reserve(num_columns - column_idx);
-                        names_relative_to_nested_message.emplace_back(suffix);
+                        std::vector<size_t> nested_column_indices;
+                        std::vector<std::string_view> nested_column_names;
+                        nested_column_indices.reserve(num_columns - used_column_indices.size());
+                        nested_column_names.reserve(num_columns - used_column_indices.size());
+                        nested_column_indices.push_back(column_idx);
+                        nested_column_names.push_back(suffix);
 
-                        for (size_t j : ext::range(column_idx + 1, num_columns))
+                        for (size_t j : collections::range(column_idx + 1, num_columns))
                         {
-                            std::string_view next_suffix;
-                            if (!columnNameStartsWithFieldName(column_names[j], *field_descriptor, next_suffix))
-                                break;
-                            names_relative_to_nested_message.emplace_back(next_suffix);
+                            if (boost::range::binary_search(used_column_indices, j))
+                                continue;
+                            std::string_view other_suffix;
+                            if (!columnNameStartsWithFieldName(column_names[j], *field_descriptor, other_suffix))
+                                continue;
+                            nested_column_indices.push_back(j);
+                            nested_column_names.push_back(other_suffix);
                         }
 
-                        /// Now we have up to `names_relative_to_nested_message.size()` sequential columns
+                        DataTypes nested_data_types;
+                        nested_data_types.reserve(nested_column_indices.size());
+                        for (size_t j : nested_column_indices)
+                            nested_data_types.push_back(data_types[j]);
+
+                        /// Now we have up to `nested_message_column_names.size()` columns
                         /// which can be serialized as a nested message.
 
-                        /// Calculate how many of those sequential columns are arrays.
-                        size_t num_arrays = 0;
-                        for (size_t j : ext::range(column_idx, column_idx + names_relative_to_nested_message.size()))
+                        /// We will try to serialize those columns as one nested message,
+                        /// then, if failed, as an array of nested messages (on condition if those columns are array).
+                        bool has_fallback_to_array_of_nested_messages = false;
+                        if (field_descriptor->is_repeated())
                         {
-                            if (data_types[j]->getTypeId() != TypeIndex::Array)
-                                break;
-                            ++num_arrays;
+                            bool has_arrays
+                                = boost::range::find_if(
+                                      nested_data_types, [](const DataTypePtr & dt) { return (dt->getTypeId() == TypeIndex::Array); })
+                                != nested_data_types.end();
+                            if (has_arrays)
+                                has_fallback_to_array_of_nested_messages = true;
                         }
 
-                        /// We will try to serialize the sequential columns as one nested message,
-                        /// then, if failed, as an array of nested messages (on condition those columns are array).
-                        bool has_fallback_to_array_of_nested_messages = num_arrays && field_descriptor->is_repeated();
-
-                        /// Try to serialize the sequential columns as one nested message.
+                        /// Try to serialize those columns as one nested message.
                         try
                         {
                             std::vector<size_t> used_column_indices_in_nested;
                             auto nested_message_serializer = buildMessageSerializerImpl(
-                                names_relative_to_nested_message.size(),
-                                names_relative_to_nested_message.data(),
-                                &data_types[column_idx],
+                                nested_column_names.size(),
+                                nested_column_names.data(),
+                                nested_data_types.data(),
                                 used_column_indices_in_nested,
                                 *field_descriptor->message_type(),
                                 false,
@@ -2693,11 +2742,12 @@ namespace
 
                             if (nested_message_serializer)
                             {
-                                for (size_t & idx_in_nested : used_column_indices_in_nested)
-                                    used_column_indices.push_back(idx_in_nested + column_idx);
-
-                                next_column_idx = used_column_indices.back() + 1;
-                                add_field_serializer(column_idx, column_name, next_column_idx - column_idx, *field_descriptor, std::move(nested_message_serializer));
+                                transformColumnIndices(used_column_indices_in_nested, nested_column_indices);
+                                add_field_serializer(
+                                    column_name,
+                                    std::move(used_column_indices_in_nested),
+                                    *field_descriptor,
+                                    std::move(nested_message_serializer));
                                 break;
                             }
                         }
@@ -2709,17 +2759,16 @@ namespace
 
                         if (has_fallback_to_array_of_nested_messages)
                         {
-                            /// Try to serialize the sequential columns as an array of nested messages.
-                            DataTypes array_nested_data_types;
-                            array_nested_data_types.reserve(num_arrays);
-                            for (size_t j : ext::range(column_idx, column_idx + num_arrays))
-                                array_nested_data_types.emplace_back(assert_cast<const DataTypeArray &>(*data_types[j]).getNestedType());
+                            /// Try to serialize those columns as an array of nested messages.
+                            removeNonArrayElements(nested_data_types, nested_column_names, nested_column_indices);
+                            for (DataTypePtr & dt : nested_data_types)
+                                dt = assert_cast<const DataTypeArray &>(*dt).getNestedType();
 
                             std::vector<size_t> used_column_indices_in_nested;
                             auto nested_message_serializer = buildMessageSerializerImpl(
-                                array_nested_data_types.size(),
-                                names_relative_to_nested_message.data(),
-                                array_nested_data_types.data(),
+                                nested_column_names.size(),
+                                nested_column_names.data(),
+                                nested_data_types.data(),
                                 used_column_indices_in_nested,
                                 *field_descriptor->message_type(),
                                 false,
@@ -2728,12 +2777,8 @@ namespace
                             if (nested_message_serializer)
                             {
                                 auto field_serializer = std::make_unique<ProtobufSerializerFlattenedNestedAsArrayOfNestedMessages>(std::move(nested_message_serializer));
-
-                                for (size_t & idx_in_nested : used_column_indices_in_nested)
-                                    used_column_indices.push_back(idx_in_nested + column_idx);
-
-                                next_column_idx = used_column_indices.back() + 1;
-                                add_field_serializer(column_idx, column_name, next_column_idx - column_idx, *field_descriptor, std::move(field_serializer));
+                                transformColumnIndices(used_column_indices_in_nested, nested_column_indices);
+                                add_field_serializer(column_name, std::move(used_column_indices_in_nested), *field_descriptor, std::move(field_serializer));
                                 break;
                             }
                         }
@@ -2745,7 +2790,7 @@ namespace
             if ((message_descriptor.file()->syntax() == google::protobuf::FileDescriptor::SYNTAX_PROTO2)
                     && reader_or_writer.writer)
             {
-                for (int i : ext::range(message_descriptor.field_count()))
+                for (int i : collections::range(message_descriptor.field_count()))
                 {
                     const auto & field_descriptor = *message_descriptor.field(i);
                     if (field_descriptor.is_required() && !field_descriptors_in_use.count(&field_descriptor))
diff --git a/src/Functions/FunctionBinaryArithmetic.h b/src/Functions/FunctionBinaryArithmetic.h
index 06d945eb3ce..fc36541a078 100644
--- a/src/Functions/FunctionBinaryArithmetic.h
+++ b/src/Functions/FunctionBinaryArithmetic.h
@@ -33,7 +33,7 @@
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
 #include <Common/FieldVisitorsAccurateComparison.h>
-#include <ext/map.h>
+#include <common/map.h>
 
 #if !defined(ARCADIA_BUILD)
 #    include <Common/config.h>
@@ -1556,13 +1556,13 @@ public:
             return std::make_unique<FunctionToFunctionBaseAdaptor>(
                 FunctionBinaryArithmeticWithConstants<Op, Name, valid_on_default_arguments, valid_on_float_arguments>::create(
                     arguments[0], arguments[1], return_type, context),
-                ext::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
+                collections::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
                 return_type);
         }
 
         return std::make_unique<FunctionToFunctionBaseAdaptor>(
             FunctionBinaryArithmetic<Op, Name, valid_on_default_arguments, valid_on_float_arguments>::create(context),
-            ext::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
+            collections::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
             return_type);
     }
 
diff --git a/src/Functions/FunctionBitTestMany.h b/src/Functions/FunctionBitTestMany.h
index 567be37cda8..c2797ee69b4 100644
--- a/src/Functions/FunctionBitTestMany.h
+++ b/src/Functions/FunctionBitTestMany.h
@@ -5,7 +5,7 @@
 #include <Functions/IFunction.h>
 #include <Functions/FunctionHelpers.h>
 #include <IO/WriteHelpers.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -43,7 +43,7 @@ public:
             throw Exception{"Illegal type " + first_arg->getName() + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
 
-        for (const auto i : ext::range(1, arguments.size()))
+        for (const auto i : collections::range(1, arguments.size()))
         {
             const auto & pos_arg = arguments[i];
 
@@ -90,14 +90,14 @@ private:
 
             if (is_const)
             {
-                for (const auto i : ext::range(0, size))
+                for (const auto i : collections::range(0, size))
                     out[i] = Impl::apply(val[i], const_mask);
             }
             else
             {
                 const auto mask = createMask<T>(size, arguments);
 
-                for (const auto i : ext::range(0, size))
+                for (const auto i : collections::range(0, size))
                     out[i] = Impl::apply(val[i], mask[i]);
             }
 
@@ -121,7 +121,7 @@ private:
 
                 auto & out = out_col->getData();
 
-                for (const auto i : ext::range(0, size))
+                for (const auto i : collections::range(0, size))
                     out[i] = Impl::apply(val, mask[i]);
 
                 return out_col;
@@ -137,7 +137,7 @@ private:
         out_is_const = true;
         ValueType mask = 0;
 
-        for (const auto i : ext::range(1, arguments.size()))
+        for (const auto i : collections::range(1, arguments.size()))
         {
             if (auto pos_col_const = checkAndGetColumnConst<ColumnVector<ValueType>>(arguments[i].column.get()))
             {
@@ -160,7 +160,7 @@ private:
     {
         PaddedPODArray<ValueType> mask(size, ValueType{});
 
-        for (const auto i : ext::range(1, arguments.size()))
+        for (const auto i : collections::range(1, arguments.size()))
         {
             const auto * pos_col = arguments[i].column.get();
 
@@ -181,7 +181,7 @@ private:
         {
             const auto & pos = pos_col->getData();
 
-            for (const auto i : ext::range(0, mask.size()))
+            for (const auto i : collections::range(0, mask.size()))
                 if (pos[i] < 8 * sizeof(ValueType))
                     mask[i] = mask[i] | (ValueType(1) << pos[i]);
 
@@ -192,7 +192,7 @@ private:
             const auto & pos = pos_col_const->template getValue<PosType>();
             const auto new_mask = pos < 8 * sizeof(ValueType) ? ValueType(1) << pos : 0;
 
-            for (const auto i : ext::range(0, mask.size()))
+            for (const auto i : collections::range(0, mask.size()))
                 mask[i] = mask[i] | new_mask;
 
             return true;
diff --git a/src/Functions/FunctionNumericPredicate.h b/src/Functions/FunctionNumericPredicate.h
index d5fa9f03aba..c539907ddc8 100644
--- a/src/Functions/FunctionNumericPredicate.h
+++ b/src/Functions/FunctionNumericPredicate.h
@@ -5,7 +5,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnsNumber.h>
 #include <Interpreters/Context_fwd.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -80,7 +80,7 @@ public:
             const auto & in_data = in->getData();
             auto & out_data = out->getData();
 
-            for (const auto i : ext::range(0, size))
+            for (const auto i : collections::range(0, size))
                 out_data[i] = Impl::execute(in_data[i]);
 
             return out;
diff --git a/src/Functions/FunctionsCoding.h b/src/Functions/FunctionsCoding.h
index b45eca565d7..ae827668139 100644
--- a/src/Functions/FunctionsCoding.h
+++ b/src/Functions/FunctionsCoding.h
@@ -26,7 +26,7 @@
 #include <Common/typeid_cast.h>
 
 #include <arpa/inet.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <type_traits>
 #include <array>
 
diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h
index a2202b9d8a4..ad538a05a5e 100644
--- a/src/Functions/FunctionsConversion.h
+++ b/src/Functions/FunctionsConversion.h
@@ -1,8 +1,5 @@
 #pragma once
 
-#include <ext/enumerate.h>
-#include <ext/collection_cast.h>
-#include <ext/range.h>
 #include <type_traits>
 
 #include <IO/WriteBufferFromVector.h>
@@ -2569,8 +2566,12 @@ private:
         element_wrappers.reserve(from_element_types.size());
 
         /// Create conversion wrapper for each element in tuple
-        for (const auto idx_type : ext::enumerate(from_element_types))
-            element_wrappers.push_back(prepareUnpackDictionaries(idx_type.second, to_element_types[idx_type.first]));
+        for (size_t i = 0; i < from_element_types.size(); ++i)
+        {
+            const DataTypePtr & from_element_type = from_element_types[i];
+            const DataTypePtr & to_element_type = to_element_types[i];
+            element_wrappers.push_back(prepareUnpackDictionaries(from_element_type, to_element_type));
+        }
 
         return element_wrappers;
     }
@@ -2816,7 +2817,7 @@ private:
 
                 if (nullable_col)
                 {
-                    for (const auto i : ext::range(0, size))
+                    for (size_t i = 0; i < size; ++i)
                     {
                         if (!nullable_col->isNullAt(i))
                             out_data[i] = result_type.getValue(col->getDataAt(i));
@@ -2826,7 +2827,7 @@ private:
                 }
                 else
                 {
-                    for (const auto i : ext::range(0, size))
+                    for (size_t i = 0; i < size; ++i)
                         out_data[i] = result_type.getValue(col->getDataAt(i));
                 }
 
diff --git a/src/Functions/FunctionsExternalDictionaries.h b/src/Functions/FunctionsExternalDictionaries.h
index 3087d2312f3..381401be2c5 100644
--- a/src/Functions/FunctionsExternalDictionaries.h
+++ b/src/Functions/FunctionsExternalDictionaries.h
@@ -29,7 +29,7 @@
 
 #include <Functions/IFunction.h>
 #include <Functions/FunctionHelpers.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <type_traits>
 
diff --git a/src/Functions/FunctionsExternalModels.cpp b/src/Functions/FunctionsExternalModels.cpp
index da46f7fcb38..e3b0e852731 100644
--- a/src/Functions/FunctionsExternalModels.cpp
+++ b/src/Functions/FunctionsExternalModels.cpp
@@ -5,7 +5,7 @@
 #include <Interpreters/Context.h>
 #include <Interpreters/ExternalModelsLoader.h>
 #include <Columns/ColumnString.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <string>
 #include <memory>
 #include <DataTypes/DataTypeNullable.h>
@@ -83,7 +83,7 @@ ColumnPtr FunctionModelEvaluate::executeImpl(const ColumnsWithTypeAndName & argu
     ColumnPtr null_map;
 
     column_ptrs.reserve(arguments.size());
-    for (auto arg : ext::range(1, arguments.size()))
+    for (auto arg : collections::range(1, arguments.size()))
     {
         const auto & column = arguments[arg].column;
         column_ptrs.push_back(column.get());
diff --git a/src/Functions/FunctionsHashing.h b/src/Functions/FunctionsHashing.h
index 690991759a3..6b1a582bcf7 100644
--- a/src/Functions/FunctionsHashing.h
+++ b/src/Functions/FunctionsHashing.h
@@ -43,8 +43,8 @@
 #include <Functions/FunctionHelpers.h>
 #include <Functions/TargetSpecific.h>
 #include <Functions/PerformanceAdaptors.h>
-#include <ext/range.h>
-#include <ext/bit_cast.h>
+#include <common/range.h>
+#include <common/bit_cast.h>
 
 
 namespace DB
@@ -754,9 +754,9 @@ private:
                 if constexpr (Impl::use_int_hash_for_pods)
                 {
                     if constexpr (std::is_same_v<ToType, UInt64>)
-                        h = IntHash64Impl::apply(ext::bit_cast<UInt64>(vec_from[i]));
+                        h = IntHash64Impl::apply(bit_cast<UInt64>(vec_from[i]));
                     else
-                        h = IntHash32Impl::apply(ext::bit_cast<UInt32>(vec_from[i]));
+                        h = IntHash32Impl::apply(bit_cast<UInt32>(vec_from[i]));
                 }
                 else
                 {
@@ -774,9 +774,9 @@ private:
             auto value = col_from_const->template getValue<FromType>();
             ToType hash;
             if constexpr (std::is_same_v<ToType, UInt64>)
-                hash = IntHash64Impl::apply(ext::bit_cast<UInt64>(value));
+                hash = IntHash64Impl::apply(bit_cast<UInt64>(value));
             else
-                hash = IntHash32Impl::apply(ext::bit_cast<UInt32>(value));
+                hash = IntHash32Impl::apply(bit_cast<UInt32>(value));
 
             size_t size = vec_to.size();
             if constexpr (first)
diff --git a/src/Functions/FunctionsJSON.cpp b/src/Functions/FunctionsJSON.cpp
index 7516600ac85..b220a59f8eb 100644
--- a/src/Functions/FunctionsJSON.cpp
+++ b/src/Functions/FunctionsJSON.cpp
@@ -14,7 +14,7 @@ std::vector<FunctionJSONHelpers::Move> FunctionJSONHelpers::prepareMoves(const c
 {
     std::vector<Move> moves;
     moves.reserve(num_index_arguments);
-    for (const auto i : ext::range(first_index_argument, first_index_argument + num_index_arguments))
+    for (const auto i : collections::range(first_index_argument, first_index_argument + num_index_arguments))
     {
         const auto & column = columns[i];
         if (!isString(column.type) && !isInteger(column.type))
@@ -44,7 +44,7 @@ std::vector<FunctionJSONHelpers::Move> FunctionJSONHelpers::prepareMoves(const c
 size_t FunctionJSONHelpers::calculateMaxSize(const ColumnString::Offsets & offsets)
 {
     size_t max_size = 0;
-    for (const auto i : ext::range(0, offsets.size()))
+    for (const auto i : collections::range(0, offsets.size()))
     {
         size_t size = offsets[i] - offsets[i - 1];
         if (max_size < size)
diff --git a/src/Functions/FunctionsJSON.h b/src/Functions/FunctionsJSON.h
index 2b49d01de2c..b6bdf1be013 100644
--- a/src/Functions/FunctionsJSON.h
+++ b/src/Functions/FunctionsJSON.h
@@ -24,7 +24,7 @@
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <Interpreters/Context.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <type_traits>
 #include <boost/tti/has_member_function.hpp>
 
@@ -108,7 +108,7 @@ public:
                 document_ok = parser.parse(json, document);
             }
 
-            for (const auto i : ext::range(0, input_rows_count))
+            for (const auto i : collections::range(0, input_rows_count))
             {
                 if (!col_json_const)
                 {
diff --git a/src/Functions/FunctionsRound.h b/src/Functions/FunctionsRound.h
index f56b92d6db5..29e86b23c10 100644
--- a/src/Functions/FunctionsRound.h
+++ b/src/Functions/FunctionsRound.h
@@ -16,7 +16,7 @@
 #include <cmath>
 #include <type_traits>
 #include <array>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <algorithm>
 
 #ifdef __SSE4_1__
diff --git a/src/Functions/GatherUtils/Algorithms.h b/src/Functions/GatherUtils/Algorithms.h
index 2df2e988ec5..fbd658ca7be 100644
--- a/src/Functions/GatherUtils/Algorithms.h
+++ b/src/Functions/GatherUtils/Algorithms.h
@@ -5,7 +5,7 @@
 #include "Sources.h"
 #include "Sinks.h"
 #include <Core/AccurateComparison.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include "GatherUtils.h"
 
 
@@ -213,7 +213,7 @@ void concat(const std::vector<std::unique_ptr<IArraySource>> & array_sources, Si
     };
 
     size_t size_to_reserve = 0;
-    for (auto i : ext::range(0, sources_num))
+    for (auto i : collections::range(0, sources_num))
     {
         auto & source = array_sources[i];
         is_const[i] = source->isConst();
@@ -233,7 +233,7 @@ void concat(const std::vector<std::unique_ptr<IArraySource>> & array_sources, Si
 
     while (!sink.isEnd())
     {
-        for (auto i : ext::range(0, sources_num))
+        for (auto i : collections::range(0, sources_num))
         {
             auto & source = array_sources[i];
             if (is_const[i])
@@ -663,7 +663,7 @@ void NO_INLINE arrayAllAny(FirstSource && first, SecondSource && second, ColumnU
 {
     auto size = result.size();
     auto & data = result.getData();
-    for (auto row : ext::range(0, size))
+    for (auto row : collections::range(0, size))
     {
         data[row] = static_cast<UInt8>(sliceHas<search_type>(first.getWhole(), second.getWhole()));
         first.next();
diff --git a/src/Functions/LeastGreatestGeneric.h b/src/Functions/LeastGreatestGeneric.h
index 51564ad7cdc..68cfda7d116 100644
--- a/src/Functions/LeastGreatestGeneric.h
+++ b/src/Functions/LeastGreatestGeneric.h
@@ -6,7 +6,7 @@
 #include <Columns/ColumnsNumber.h>
 #include <Functions/IFunction.h>
 #include <Functions/FunctionFactory.h>
-#include <ext/map.h>
+#include <common/map.h>
 
 
 namespace DB
diff --git a/src/Functions/PolygonUtils.h b/src/Functions/PolygonUtils.h
index 4226e3ae0b0..3367b52cc36 100644
--- a/src/Functions/PolygonUtils.h
+++ b/src/Functions/PolygonUtils.h
@@ -7,7 +7,7 @@
 #include <Columns/ColumnVector.h>
 #include <Common/typeid_cast.h>
 #include <Common/SipHash.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 /// Warning in boost::geometry during template strategy substitution.
 #pragma GCC diagnostic push
@@ -413,7 +413,7 @@ bool PointInPolygonWithGrid<CoordinateType>::isConvex(const PointInPolygonWithGr
     Point first = get_vector(outer[0], outer[1]);
     Point prev = first;
 
-    for (auto i : ext::range(1, outer.size() - 1))
+    for (auto i : collections::range(1, outer.size() - 1))
     {
         Point cur = get_vector(outer[i], outer[i + 1]);
         if (vec_product(prev, cur) < 0)
@@ -434,7 +434,7 @@ PointInPolygonWithGrid<CoordinateType>::findHalfPlanes(
     std::vector<HalfPlane> half_planes;
     const auto & outer = intersection.outer();
 
-    for (auto i : ext::range(0, outer.size() - 1))
+    for (auto i : collections::range(0, outer.size() - 1))
     {
         /// Want to detect is intersection edge was formed from box edge or from polygon edge.
         /// If section (x1, y1), (x2, y2) is on box edge, then either x1 = x2 = one of box_x or y1 = y2 = one of box_y
@@ -572,7 +572,7 @@ ColumnPtr pointInPolygon(const ColumnVector<T> & x, const ColumnVector<U> & y, P
     const auto & x_data = x.getData();
     const auto & y_data = y.getData();
 
-    for (auto i : ext::range(0, size))
+    for (auto i : collections::range(0, size))
         data[i] = static_cast<UInt8>(impl.contains(x_data[i], y_data[i]));
 
     return result;
diff --git a/src/Functions/appendTrailingCharIfAbsent.cpp b/src/Functions/appendTrailingCharIfAbsent.cpp
index 266b2a44f4a..64687b8c166 100644
--- a/src/Functions/appendTrailingCharIfAbsent.cpp
+++ b/src/Functions/appendTrailingCharIfAbsent.cpp
@@ -4,7 +4,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunction.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -85,7 +85,7 @@ private:
             ColumnString::Offset src_offset{};
             ColumnString::Offset dst_offset{};
 
-            for (const auto i : ext::range(0, size))
+            for (const auto i : collections::range(0, size))
             {
                 const auto src_length = src_offsets[i] - src_offset;
                 memcpySmallAllowReadWriteOverflow15(&dst_data[dst_offset], &src_data[src_offset], src_length);
diff --git a/src/Functions/array/arrayConcat.cpp b/src/Functions/array/arrayConcat.cpp
index 57a783a3244..0a689714eb4 100644
--- a/src/Functions/array/arrayConcat.cpp
+++ b/src/Functions/array/arrayConcat.cpp
@@ -7,7 +7,7 @@
 #include <Columns/ColumnArray.h>
 #include <Columns/ColumnConst.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -38,7 +38,7 @@ public:
         if (arguments.empty())
             throw Exception{"Function " + getName() + " requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
-        for (auto i : ext::range(0, arguments.size()))
+        for (auto i : collections::range(0, arguments.size()))
         {
             const auto * array_type = typeid_cast<const DataTypeArray *>(arguments[i].get());
             if (!array_type)
diff --git a/src/Functions/array/arrayIntersect.cpp b/src/Functions/array/arrayIntersect.cpp
index 5a6dac0a8a1..6627e18b3c4 100644
--- a/src/Functions/array/arrayIntersect.cpp
+++ b/src/Functions/array/arrayIntersect.cpp
@@ -21,7 +21,7 @@
 #include <Common/assert_cast.h>
 #include <Core/TypeListNumber.h>
 #include <Interpreters/castColumn.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -133,7 +133,7 @@ DataTypePtr FunctionArrayIntersect::getReturnTypeImpl(const DataTypes & argument
     if (arguments.empty())
         throw Exception{"Function " + getName() + " requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
-    for (auto i : ext::range(0, arguments.size()))
+    for (auto i : collections::range(0, arguments.size()))
     {
         const auto * array_type = typeid_cast<const DataTypeArray *>(arguments[i].get());
         if (!array_type)
@@ -195,7 +195,7 @@ ColumnPtr FunctionArrayIntersect::castRemoveNullable(const ColumnPtr & column, c
 
         const auto & types = tuple_type->getElements();
 
-        for (auto i : ext::range(0, columns_number))
+        for (auto i : collections::range(0, columns_number))
         {
             columns[i] = castRemoveNullable(column_tuple->getColumnPtr(i), types[i]);
         }
@@ -300,7 +300,7 @@ FunctionArrayIntersect::UnpackedArrays FunctionArrayIntersect::prepareArrays(
 
     bool all_const = true;
 
-    for (auto i : ext::range(0, columns_number))
+    for (auto i : collections::range(0, columns_number))
     {
         auto & arg = arrays.args[i];
         const auto * argument_column = columns[i].column.get();
@@ -359,7 +359,7 @@ FunctionArrayIntersect::UnpackedArrays FunctionArrayIntersect::prepareArrays(
     }
     else
     {
-        for (auto i : ext::range(0, columns_number))
+        for (auto i : collections::range(0, columns_number))
         {
             if (arrays.args[i].is_const)
                 continue;
@@ -493,13 +493,13 @@ ColumnPtr FunctionArrayIntersect::execute(const UnpackedArrays & arrays, Mutable
     Map map;
     std::vector<size_t> prev_off(args, 0);
     size_t result_offset = 0;
-    for (auto row : ext::range(0, rows))
+    for (auto row : collections::range(0, rows))
     {
         map.clear();
 
         bool all_has_nullable = all_nullable;
 
-        for (auto arg_num : ext::range(0, args))
+        for (auto arg_num : collections::range(0, args))
         {
             const auto & arg = arrays.args[arg_num];
             bool current_has_nullable = false;
@@ -511,7 +511,7 @@ ColumnPtr FunctionArrayIntersect::execute(const UnpackedArrays & arrays, Mutable
             else
                 off = (*arg.offsets)[row];
 
-            for (auto i : ext::range(prev_off[arg_num], off))
+            for (auto i : collections::range(prev_off[arg_num], off))
             {
                 if (arg.null_map && (*arg.null_map)[i])
                     current_has_nullable = true;
diff --git a/src/Functions/array/arrayReduce.cpp b/src/Functions/array/arrayReduce.cpp
index 606dd94012a..9a4b5aafdb9 100644
--- a/src/Functions/array/arrayReduce.cpp
+++ b/src/Functions/array/arrayReduce.cpp
@@ -11,7 +11,7 @@
 #include <AggregateFunctions/parseAggregateFunctionParameters.h>
 #include <Common/Arena.h>
 
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 
 namespace DB
diff --git a/src/Functions/array/arrayReduceInRanges.cpp b/src/Functions/array/arrayReduceInRanges.cpp
index 230bcf9f0ba..9a2e8e1ca95 100644
--- a/src/Functions/array/arrayReduceInRanges.cpp
+++ b/src/Functions/array/arrayReduceInRanges.cpp
@@ -13,7 +13,7 @@
 #include <AggregateFunctions/parseAggregateFunctionParameters.h>
 #include <Common/Arena.h>
 
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 
 namespace DB
diff --git a/src/Functions/array/hasAllAny.h b/src/Functions/array/hasAllAny.h
index 04c6558f066..40eba0207ab 100644
--- a/src/Functions/array/hasAllAny.h
+++ b/src/Functions/array/hasAllAny.h
@@ -1,4 +1,8 @@
 #pragma once
+
+#include <common/range.h>
+#include <common/map.h>
+
 #include <Functions/IFunction.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/GatherUtils/GatherUtils.h>
@@ -12,8 +16,6 @@
 #include <Columns/ColumnConst.h>
 #include <Interpreters/castColumn.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
-#include <ext/map.h>
 
 
 namespace DB
@@ -39,7 +41,7 @@ public:
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
-        for (auto i : ext::range(0, arguments.size()))
+        for (auto i : collections::range(0, arguments.size()))
         {
             auto array_type = typeid_cast<const DataTypeArray *>(arguments[i].get());
             if (!array_type)
@@ -54,7 +56,7 @@ public:
     {
         size_t num_args = arguments.size();
 
-        DataTypePtr common_type = getLeastSupertype(ext::map(arguments, [](auto & arg) { return arg.type; }));
+        DataTypePtr common_type = getLeastSupertype(collections::map(arguments, [](auto & arg) { return arg.type; }));
 
         Columns preprocessed_columns(num_args);
         for (size_t i = 0; i < num_args; ++i)
diff --git a/src/Functions/bitCount.cpp b/src/Functions/bitCount.cpp
index 0b7af6eca7f..2890b1a8253 100644
--- a/src/Functions/bitCount.cpp
+++ b/src/Functions/bitCount.cpp
@@ -1,4 +1,4 @@
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionUnaryArithmetic.h>
 
@@ -29,7 +29,7 @@ struct BitCountImpl
         if constexpr (std::is_same_v<A, Int8>)
             return __builtin_popcount(static_cast<UInt8>(a));
         else
-            return __builtin_popcountll(ext::bit_cast<uint64_t>(a));
+            return __builtin_popcountll(bit_cast<uint64_t>(a));
     }
 
 #if USE_EMBEDDED_COMPILER
diff --git a/src/Functions/concat.cpp b/src/Functions/concat.cpp
index c1b9f8e7967..195107cb221 100644
--- a/src/Functions/concat.cpp
+++ b/src/Functions/concat.cpp
@@ -9,8 +9,8 @@
 #include <Functions/GatherUtils/Sources.h>
 #include <Functions/IFunction.h>
 #include <IO/WriteHelpers.h>
-#include <ext/map.h>
-#include <ext/range.h>
+#include <common/map.h>
+#include <common/range.h>
 
 #include "formatString.h"
 
@@ -60,7 +60,7 @@ public:
                     + ", should be at most " + std::to_string(FormatImpl::argument_threshold),
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        for (const auto arg_idx : ext::range(0, arguments.size()))
+        for (const auto arg_idx : collections::range(0, arguments.size()))
         {
             const auto * arg = arguments[arg_idx].get();
             if (!isStringOrFixedString(arg))
@@ -207,7 +207,7 @@ public:
         }
         else
             return std::make_unique<FunctionToFunctionBaseAdaptor>(
-                FunctionConcat::create(context), ext::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }), return_type);
+                FunctionConcat::create(context), collections::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }), return_type);
     }
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
diff --git a/src/Functions/convertCharset.cpp b/src/Functions/convertCharset.cpp
index b204875b4ff..7e351af6cce 100644
--- a/src/Functions/convertCharset.cpp
+++ b/src/Functions/convertCharset.cpp
@@ -12,7 +12,7 @@
 #    include <IO/WriteHelpers.h>
 #    include <Common/ObjectPool.h>
 #    include <Common/typeid_cast.h>
-#    include <ext/range.h>
+#    include <common/range.h>
 
 #    include <memory>
 #    include <string>
@@ -173,7 +173,7 @@ public:
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
-        for (size_t i : ext::range(0, 3))
+        for (size_t i : collections::range(0, 3))
             if (!isString(arguments[i]))
                 throw Exception("Illegal type " + arguments[i]->getName() + " of argument of function " + getName()
                     + ", must be String", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
diff --git a/src/Functions/formatDateTime.cpp b/src/Functions/formatDateTime.cpp
index b8d5fe7d281..dc075dea7d0 100644
--- a/src/Functions/formatDateTime.cpp
+++ b/src/Functions/formatDateTime.cpp
@@ -477,8 +477,6 @@ public:
             {
                 for (auto & instruction : instructions)
                 {
-                    // since right now LUT does not support Int64-values and not format instructions for subsecond parts,
-                    // treat DatTime64 values just as DateTime values by ignoring fractional and casting to UInt32.
                     const auto c = DecimalUtils::split(vec[i], scale);
                     instruction.perform(pos, static_cast<Int64>(c.whole), time_zone);
                 }
diff --git a/src/Functions/formatRow.cpp b/src/Functions/formatRow.cpp
index 2d7739a02d6..f45986ea08e 100644
--- a/src/Functions/formatRow.cpp
+++ b/src/Functions/formatRow.cpp
@@ -9,7 +9,7 @@
 #include <IO/WriteBufferFromVector.h>
 #include <IO/WriteHelpers.h>
 #include <Processors/Formats/IOutputFormat.h>
-#include <ext/map.h>
+#include <common/map.h>
 
 
 namespace DB
@@ -102,7 +102,7 @@ public:
         if (const auto * name_col = checkAndGetColumnConst<ColumnString>(arguments.at(0).column.get()))
             return std::make_unique<FunctionToFunctionBaseAdaptor>(
                 std::make_shared<FunctionFormatRow<no_newline>>(name_col->getValue<String>(), context),
-                ext::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
+                collections::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
                 return_type);
         else
             throw Exception("First argument to " + getName() + " must be a format name", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
diff --git a/src/Functions/formatString.cpp b/src/Functions/formatString.cpp
index 4a3b04aaa05..71da598060f 100644
--- a/src/Functions/formatString.cpp
+++ b/src/Functions/formatString.cpp
@@ -5,7 +5,7 @@
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunction.h>
 #include <IO/WriteHelpers.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <memory>
 #include <string>
@@ -55,7 +55,7 @@ public:
                     + ", should be at most " + std::to_string(FormatImpl::argument_threshold),
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        for (const auto arg_idx : ext::range(0, arguments.size()))
+        for (const auto arg_idx : collections::range(0, arguments.size()))
         {
             const auto * arg = arguments[arg_idx].get();
             if (!isStringOrFixedString(arg))
diff --git a/src/Functions/geoToH3.cpp b/src/Functions/geoToH3.cpp
index 6030cbeea65..7edb3faf62d 100644
--- a/src/Functions/geoToH3.cpp
+++ b/src/Functions/geoToH3.cpp
@@ -11,7 +11,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <h3api.h>
 
@@ -73,7 +73,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const double lon = col_lon->getFloat64(row);
             const double lat = col_lat->getFloat64(row);
diff --git a/src/Functions/greatCircleDistance.cpp b/src/Functions/greatCircleDistance.cpp
index 756b76859ae..bc02033cfc9 100644
--- a/src/Functions/greatCircleDistance.cpp
+++ b/src/Functions/greatCircleDistance.cpp
@@ -8,7 +8,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/TargetSpecific.h>
 #include <Functions/PerformanceAdaptors.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <cmath>
 
 
@@ -249,7 +249,7 @@ private:
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
-        for (const auto arg_idx : ext::range(0, arguments.size()))
+        for (const auto arg_idx : collections::range(0, arguments.size()))
         {
             const auto * arg = arguments[arg_idx].get();
             if (!isNumber(WhichDataType(arg)))
diff --git a/src/Functions/h3EdgeAngle.cpp b/src/Functions/h3EdgeAngle.cpp
index ad8d1ee441f..0fdafff9eed 100644
--- a/src/Functions/h3EdgeAngle.cpp
+++ b/src/Functions/h3EdgeAngle.cpp
@@ -10,7 +10,7 @@
 #include <Functions/IFunction.h>
 #include <IO/WriteHelpers.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <constants.h>
 #include <h3api.h>
@@ -58,7 +58,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const int resolution = col_hindex->getUInt(row);
             if (resolution > MAX_H3_RES)
diff --git a/src/Functions/h3EdgeLengthM.cpp b/src/Functions/h3EdgeLengthM.cpp
index 85d307e1da3..5ec57510e54 100644
--- a/src/Functions/h3EdgeLengthM.cpp
+++ b/src/Functions/h3EdgeLengthM.cpp
@@ -10,7 +10,7 @@
 #include <Functions/IFunction.h>
 #include <IO/WriteHelpers.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <constants.h>
 #include <h3api.h>
@@ -63,7 +63,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 resolution = col_hindex->getUInt(row);
             if (resolution > MAX_H3_RES)
diff --git a/src/Functions/h3GetBaseCell.cpp b/src/Functions/h3GetBaseCell.cpp
index fcad82098e6..7f3843ed792 100644
--- a/src/Functions/h3GetBaseCell.cpp
+++ b/src/Functions/h3GetBaseCell.cpp
@@ -9,7 +9,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <h3api.h>
 
@@ -55,7 +55,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 hindex = col_hindex->getUInt(row);
 
diff --git a/src/Functions/h3GetResolution.cpp b/src/Functions/h3GetResolution.cpp
index d1bfd899150..074e07e4277 100644
--- a/src/Functions/h3GetResolution.cpp
+++ b/src/Functions/h3GetResolution.cpp
@@ -9,7 +9,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <h3api.h>
 
@@ -55,7 +55,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 hindex = col_hindex->getUInt(row);
 
diff --git a/src/Functions/h3HexAreaM2.cpp b/src/Functions/h3HexAreaM2.cpp
index e44bf660333..e630fb7bd70 100644
--- a/src/Functions/h3HexAreaM2.cpp
+++ b/src/Functions/h3HexAreaM2.cpp
@@ -10,7 +10,7 @@
 #include <Functions/IFunction.h>
 #include <IO/WriteHelpers.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <constants.h>
 #include <h3api.h>
@@ -58,7 +58,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 resolution = col_hindex->getUInt(row);
             if (resolution > MAX_H3_RES)
diff --git a/src/Functions/h3IndexesAreNeighbors.cpp b/src/Functions/h3IndexesAreNeighbors.cpp
index 56c69ed0a8b..3c03d3d1adb 100644
--- a/src/Functions/h3IndexesAreNeighbors.cpp
+++ b/src/Functions/h3IndexesAreNeighbors.cpp
@@ -9,7 +9,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <h3api.h>
 
@@ -62,7 +62,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 hindex_origin = col_hindex_origin->getUInt(row);
             const UInt64 hindex_dest = col_hindex_dest->getUInt(row);
diff --git a/src/Functions/h3IsValid.cpp b/src/Functions/h3IsValid.cpp
index 1e4840b3537..d7f5a2c0771 100644
--- a/src/Functions/h3IsValid.cpp
+++ b/src/Functions/h3IsValid.cpp
@@ -9,7 +9,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <h3api.h>
 
@@ -55,7 +55,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 hindex = col_hindex->getUInt(row);
 
diff --git a/src/Functions/h3ToChildren.cpp b/src/Functions/h3ToChildren.cpp
index 9730aefe3d4..d472c298432 100644
--- a/src/Functions/h3ToChildren.cpp
+++ b/src/Functions/h3ToChildren.cpp
@@ -12,7 +12,7 @@
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
 #include <IO/WriteHelpers.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <constants.h>
 #include <h3api.h>
@@ -75,7 +75,7 @@ public:
 
         std::vector<H3Index> hindex_vec;
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 parent_hindex = col_hindex->getUInt(row);
             const UInt8 child_resolution = col_resolution->getUInt(row);
diff --git a/src/Functions/h3ToParent.cpp b/src/Functions/h3ToParent.cpp
index 4baf9527301..6719d9f3456 100644
--- a/src/Functions/h3ToParent.cpp
+++ b/src/Functions/h3ToParent.cpp
@@ -10,7 +10,7 @@
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
 #include <IO/WriteHelpers.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <constants.h>
 #include <h3api.h>
@@ -65,7 +65,7 @@ public:
         auto & dst_data = dst->getData();
         dst_data.resize(input_rows_count);
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const UInt64 hindex = col_hindex->getUInt(row);
             const UInt8 resolution = col_resolution->getUInt(row);
diff --git a/src/Functions/h3kRing.cpp b/src/Functions/h3kRing.cpp
index 40e73f9dea2..b54ed48ef3f 100644
--- a/src/Functions/h3kRing.cpp
+++ b/src/Functions/h3kRing.cpp
@@ -13,7 +13,7 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/IFunction.h>
 #include <Common/typeid_cast.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 #include <h3api.h>
 
@@ -72,7 +72,7 @@ public:
 
         std::vector<H3Index> hindex_vec;
 
-        for (const auto row : ext::range(0, input_rows_count))
+        for (const auto row : collections::range(0, input_rows_count))
         {
             const H3Index origin_hindex = col_hindex->getUInt(row);
             const int k = col_k->getInt(row);
diff --git a/src/Functions/if.cpp b/src/Functions/if.cpp
index ec3447ffb81..8b930a73dfb 100644
--- a/src/Functions/if.cpp
+++ b/src/Functions/if.cpp
@@ -153,21 +153,6 @@ struct NumIfImpl<Decimal<A>, Decimal<B>, Decimal<R>>
     }
 };
 
-template <typename A, typename B>
-struct NumIfImpl<A, B, NumberTraits::Error>
-{
-private:
-    [[noreturn]] static void throwError()
-    {
-        throw Exception("Incompatible types of arguments corresponding to two conditional branches", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-    }
-public:
-    template <typename... Args> static ColumnPtr vectorVector(Args &&...) { throwError(); }
-    template <typename... Args> static ColumnPtr vectorConstant(Args &&...) { throwError(); }
-    template <typename... Args> static ColumnPtr constantVector(Args &&...) { throwError(); }
-    template <typename... Args> static ColumnPtr constantConstant(Args &&...) { throwError(); }
-};
-
 
 class FunctionIf : public FunctionIfBase
 {
@@ -193,52 +178,66 @@ private:
 
     template <typename T0, typename T1, typename ColVecT0, typename ColVecT1>
     ColumnPtr executeRightType(
-            const ColumnUInt8 * cond_col,
-            const ColumnsWithTypeAndName & arguments,
-            const ColVecT0 * col_left) const
+        [[maybe_unused]] const ColumnUInt8 * cond_col,
+        [[maybe_unused]] const ColumnsWithTypeAndName & arguments,
+        [[maybe_unused]] const ColVecT0 * col_left) const
     {
         using ResultType = typename NumberTraits::ResultOfIf<T0, T1>::Type;
 
-        const IColumn * col_right_untyped = arguments[2].column.get();
-        UInt32 scale = decimalScale<T0, T1>(arguments);
-
-        if (const auto * col_right_vec = checkAndGetColumn<ColVecT1>(col_right_untyped))
+        if constexpr (std::is_same_v<ResultType, NumberTraits::Error>)
         {
-            return NumIfImpl<T0, T1, ResultType>::vectorVector(
-                cond_col->getData(), col_left->getData(), col_right_vec->getData(), scale);
+            return nullptr;
         }
-        else if (const auto * col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_untyped))
+        else
         {
-            return NumIfImpl<T0, T1, ResultType>::vectorConstant(
-                cond_col->getData(), col_left->getData(), col_right_const->template getValue<T1>(), scale);
-        }
+            const IColumn * col_right_untyped = arguments[2].column.get();
+            UInt32 scale = decimalScale<T0, T1>(arguments);
 
-        return nullptr;
+            if (const auto * col_right_vec = checkAndGetColumn<ColVecT1>(col_right_untyped))
+            {
+                return NumIfImpl<T0, T1, ResultType>::vectorVector(
+                    cond_col->getData(), col_left->getData(), col_right_vec->getData(), scale);
+            }
+            else if (const auto * col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_untyped))
+            {
+                return NumIfImpl<T0, T1, ResultType>::vectorConstant(
+                    cond_col->getData(), col_left->getData(), col_right_const->template getValue<T1>(), scale);
+            }
+
+            return nullptr;
+        }
     }
 
     template <typename T0, typename T1, typename ColVecT0, typename ColVecT1>
     ColumnPtr executeConstRightType(
-            const ColumnUInt8 * cond_col,
-            const ColumnsWithTypeAndName & arguments,
-            const ColumnConst * col_left) const
+        [[maybe_unused]] const ColumnUInt8 * cond_col,
+        [[maybe_unused]] const ColumnsWithTypeAndName & arguments,
+        [[maybe_unused]] const ColumnConst * col_left) const
     {
         using ResultType = typename NumberTraits::ResultOfIf<T0, T1>::Type;
 
-        const IColumn * col_right_untyped = arguments[2].column.get();
-        UInt32 scale = decimalScale<T0, T1>(arguments);
-
-        if (const auto * col_right_vec = checkAndGetColumn<ColVecT1>(col_right_untyped))
+        if constexpr (std::is_same_v<ResultType, NumberTraits::Error>)
         {
-            return NumIfImpl<T0, T1, ResultType>::constantVector(
-                cond_col->getData(), col_left->template getValue<T0>(), col_right_vec->getData(), scale);
+            return nullptr;
         }
-        else if (const auto * col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_untyped))
+        else
         {
-            return NumIfImpl<T0, T1, ResultType>::constantConstant(
-                cond_col->getData(), col_left->template getValue<T0>(), col_right_const->template getValue<T1>(), scale);
-        }
+            const IColumn * col_right_untyped = arguments[2].column.get();
+            UInt32 scale = decimalScale<T0, T1>(arguments);
 
-        return nullptr;
+            if (const auto * col_right_vec = checkAndGetColumn<ColVecT1>(col_right_untyped))
+            {
+                return NumIfImpl<T0, T1, ResultType>::constantVector(
+                    cond_col->getData(), col_left->template getValue<T0>(), col_right_vec->getData(), scale);
+            }
+            else if (const auto * col_right_const = checkAndGetColumnConst<ColVecT1>(col_right_untyped))
+            {
+                return NumIfImpl<T0, T1, ResultType>::constantConstant(
+                    cond_col->getData(), col_left->template getValue<T0>(), col_right_const->template getValue<T1>(), scale);
+            }
+
+            return nullptr;
+        }
     }
 
     template <typename T0, typename T1, typename ColVecT0, typename ColVecT1>
@@ -249,12 +248,14 @@ private:
         [[maybe_unused]] const ColumnArray * col_left_array,
         [[maybe_unused]] size_t input_rows_count) const
     {
-        if constexpr (std::is_same_v<NumberTraits::Error, typename NumberTraits::ResultOfIf<T0, T1>::Type>)
+        using ResultType = typename NumberTraits::ResultOfIf<T0, T1>::Type;
+
+        if constexpr (std::is_same_v<ResultType, NumberTraits::Error>)
+        {
             return nullptr;
+        }
         else
         {
-            using ResultType = typename NumberTraits::ResultOfIf<T0, T1>::Type;
-
             const IColumn * col_right_untyped = arguments[2].column.get();
 
             if (const auto * col_right_array = checkAndGetColumn<ColumnArray>(col_right_untyped))
@@ -291,9 +292,9 @@ private:
 
                 return res;
             }
-        }
 
-        return nullptr;
+            return nullptr;
+        }
     }
 
     template <typename T0, typename T1, typename ColVecT0, typename ColVecT1>
@@ -304,12 +305,14 @@ private:
         [[maybe_unused]] const ColumnConst * col_left_const_array,
         [[maybe_unused]] size_t input_rows_count) const
     {
-        if constexpr (std::is_same_v<NumberTraits::Error, typename NumberTraits::ResultOfIf<T0, T1>::Type>)
+        using ResultType = typename NumberTraits::ResultOfIf<T0, T1>::Type;
+
+        if constexpr (std::is_same_v<ResultType, NumberTraits::Error>)
+        {
             return nullptr;
+        }
         else
         {
-            using ResultType = typename NumberTraits::ResultOfIf<T0, T1>::Type;
-
             const IColumn * col_right_untyped = arguments[2].column.get();
 
             if (const auto * col_right_array = checkAndGetColumn<ColumnArray>(col_right_untyped))
@@ -347,37 +350,34 @@ private:
 
                 return res;
             }
-        }
 
-        return nullptr;
+            return nullptr;
+        }
     }
 
     template <typename T0, typename T1>
-    ColumnPtr executeTyped(const ColumnUInt8 * cond_col, const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
+    ColumnPtr executeTyped(
+        const ColumnUInt8 * cond_col, const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const
     {
         using ColVecT0 = std::conditional_t<IsDecimalNumber<T0>, ColumnDecimal<T0>, ColumnVector<T0>>;
         using ColVecT1 = std::conditional_t<IsDecimalNumber<T1>, ColumnDecimal<T1>, ColumnVector<T1>>;
 
         const IColumn * col_left_untyped = arguments[1].column.get();
 
-        bool left_ok = false;
         ColumnPtr right_column = nullptr;
 
         if (const auto * col_left = checkAndGetColumn<ColVecT0>(col_left_untyped))
         {
-            left_ok = true;
             right_column = executeRightType<T0, T1, ColVecT0, ColVecT1>(cond_col, arguments, col_left);
         }
         else if (const auto * col_const_left = checkAndGetColumnConst<ColVecT0>(col_left_untyped))
         {
-            left_ok = true;
             right_column = executeConstRightType<T0, T1, ColVecT0, ColVecT1>(cond_col, arguments, col_const_left);
         }
         else if (const auto * col_arr_left = checkAndGetColumn<ColumnArray>(col_left_untyped))
         {
             if (auto col_arr_left_elems = checkAndGetColumn<ColVecT0>(&col_arr_left->getData()))
             {
-                left_ok = true;
                 right_column = executeRightTypeArray<T0, T1, ColVecT0, ColVecT1>(
                     cond_col, arguments, result_type, col_arr_left, input_rows_count);
             }
@@ -386,20 +386,11 @@ private:
         {
             if (checkColumn<ColVecT0>(&assert_cast<const ColumnArray &>(col_const_arr_left->getDataColumn()).getData()))
             {
-                left_ok = true;
                 right_column = executeConstRightTypeArray<T0, T1, ColVecT0, ColVecT1>(
                     cond_col, arguments, result_type, col_const_arr_left, input_rows_count);
             }
         }
 
-        if (!left_ok)
-            return nullptr;
-
-        const ColumnWithTypeAndName & right_column_typed = arguments[2];
-        if (!right_column)
-            throw Exception("Illegal column " + right_column_typed.column->getName() + " of third argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN);
-
         return right_column;
     }
 
@@ -643,7 +634,8 @@ private:
         return result_column;
     }
 
-    ColumnPtr executeForConstAndNullableCondition(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t /*input_rows_count*/) const
+    ColumnPtr executeForConstAndNullableCondition(
+        const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t /*input_rows_count*/) const
     {
         const ColumnWithTypeAndName & arg_cond = arguments[0];
         bool cond_is_null = arg_cond.column->onlyNull();
@@ -973,7 +965,8 @@ public:
             using T0 = typename Types::LeftType;
             using T1 = typename Types::RightType;
 
-            return (res = executeTyped<T0, T1>(cond_col, arguments, result_type, input_rows_count)) != nullptr;
+            res = executeTyped<T0, T1>(cond_col, arguments, result_type, input_rows_count);
+            return res != nullptr;
         };
 
         TypeIndex left_id = arg_then.type->getTypeId();
diff --git a/src/Functions/in.cpp b/src/Functions/in.cpp
index 827e0212396..7cd9f64004d 100644
--- a/src/Functions/in.cpp
+++ b/src/Functions/in.cpp
@@ -3,10 +3,12 @@
 #include <Functions/FunctionHelpers.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeLowCardinality.h>
 #include <Columns/ColumnConst.h>
 #include <Columns/ColumnsNumber.h>
 #include <Columns/ColumnTuple.h>
 #include <Columns/ColumnSet.h>
+#include <Columns/ColumnLowCardinality.h>
 #include <Interpreters/Set.h>
 
 
@@ -67,6 +69,12 @@ public:
         return 2;
     }
 
+    /// Do not use default implementation for LowCardinality.
+    /// For now, Set may be const or non const column, depending on how it was created.
+    /// But we will return UInt8 for any case.
+    /// TODO: we could use special implementation later.
+    bool useDefaultImplementationForLowCardinalityColumns() const override { return false; }
+
     DataTypePtr getReturnTypeImpl(const DataTypes & /*arguments*/) const override
     {
         return std::make_shared<DataTypeUInt8>();
@@ -122,7 +130,29 @@ public:
         else
             columns_of_key_columns.insert(left_arg);
 
-        return set->execute(columns_of_key_columns, negative);
+        /// Replace single LowCardinality column to it's dictionary if possible.
+        ColumnPtr lc_indexes = nullptr;
+        if (columns_of_key_columns.columns() == 1)
+        {
+            auto & arg = columns_of_key_columns.safeGetByPosition(0);
+            const auto * col = arg.column.get();
+            if (const auto * const_col = typeid_cast<const ColumnConst *>(col))
+                col = &const_col->getDataColumn();
+
+            if (const auto * lc = typeid_cast<const ColumnLowCardinality *>(col))
+            {
+                lc_indexes = lc->getIndexesPtr();
+                arg.column = lc->getDictionary().getNestedColumn();
+                arg.type = removeLowCardinality(arg.type);
+            }
+        }
+
+        auto res = set->execute(columns_of_key_columns, negative);
+
+        if (lc_indexes)
+            return res->index(*lc_indexes, 0);
+
+        return res;
     }
 };
 
diff --git a/src/Functions/initializeAggregation.cpp b/src/Functions/initializeAggregation.cpp
index 45a23255d50..b9b3d219551 100644
--- a/src/Functions/initializeAggregation.cpp
+++ b/src/Functions/initializeAggregation.cpp
@@ -9,7 +9,7 @@
 #include <AggregateFunctions/parseAggregateFunctionParameters.h>
 #include <Common/Arena.h>
 
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 
 namespace DB
diff --git a/src/Functions/isFinite.cpp b/src/Functions/isFinite.cpp
index 72cdc4d3a4f..85e84e55b3b 100644
--- a/src/Functions/isFinite.cpp
+++ b/src/Functions/isFinite.cpp
@@ -1,6 +1,6 @@
 #include <Functions/FunctionNumericPredicate.h>
 #include <Functions/FunctionFactory.h>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <type_traits>
 
 
@@ -20,11 +20,11 @@ struct IsFiniteImpl
     static bool execute(const T t)
     {
         if constexpr (std::is_same_v<T, float>)
-            return (ext::bit_cast<uint32_t>(t)
+            return (bit_cast<uint32_t>(t)
                  & 0b01111111100000000000000000000000)
                 != 0b01111111100000000000000000000000;
         else if constexpr (std::is_same_v<T, double>)
-            return (ext::bit_cast<uint64_t>(t)
+            return (bit_cast<uint64_t>(t)
                  & 0b0111111111110000000000000000000000000000000000000000000000000000)
                 != 0b0111111111110000000000000000000000000000000000000000000000000000;
         else
diff --git a/src/Functions/isInfinite.cpp b/src/Functions/isInfinite.cpp
index 12abb8eab6a..b509d5e0765 100644
--- a/src/Functions/isInfinite.cpp
+++ b/src/Functions/isInfinite.cpp
@@ -1,6 +1,6 @@
 #include <Functions/FunctionNumericPredicate.h>
 #include <Functions/FunctionFactory.h>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <type_traits>
 
 
@@ -16,11 +16,11 @@ struct IsInfiniteImpl
     static bool execute(const T t)
     {
         if constexpr (std::is_same_v<T, float>)
-            return (ext::bit_cast<uint32_t>(t)
+            return (bit_cast<uint32_t>(t)
                  & 0b01111111111111111111111111111111)
                 == 0b01111111100000000000000000000000;
         else if constexpr (std::is_same_v<T, double>)
-            return (ext::bit_cast<uint64_t>(t)
+            return (bit_cast<uint64_t>(t)
                  & 0b0111111111111111111111111111111111111111111111111111111111111111)
                 == 0b0111111111110000000000000000000000000000000000000000000000000000;
         else
diff --git a/src/Functions/pointInEllipses.cpp b/src/Functions/pointInEllipses.cpp
index f7bfc24559c..ac0f47d2264 100644
--- a/src/Functions/pointInEllipses.cpp
+++ b/src/Functions/pointInEllipses.cpp
@@ -6,7 +6,7 @@
 #include <Functions/IFunction.h>
 #include <Functions/FunctionHelpers.h>
 #include <Functions/FunctionFactory.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -73,7 +73,7 @@ private:
                 "Number of arguments of function " + getName() + " is too large.", ErrorCodes::TOO_MANY_ARGUMENTS_FOR_FUNCTION);
         }
 
-        for (const auto arg_idx : ext::range(0, arguments.size()))
+        for (const auto arg_idx : collections::range(0, arguments.size()))
         {
             const auto * arg = arguments[arg_idx].get();
             if (!WhichDataType(arg).isFloat64())
@@ -95,10 +95,10 @@ private:
         size_t ellipses_count = (arguments.size() - 2) / 4;
         std::vector<Ellipse> ellipses(ellipses_count);
 
-        for (const auto ellipse_idx : ext::range(0, ellipses_count))
+        for (const auto ellipse_idx : collections::range(0, ellipses_count))
         {
             Float64 ellipse_data[4];
-            for (const auto idx : ext::range(0, 4))
+            for (const auto idx : collections::range(0, 4))
             {
                 int arg_idx = 2 + 4 * ellipse_idx + idx;
                 const auto * column = arguments[arg_idx].column.get();
@@ -117,7 +117,7 @@ private:
         }
 
         int const_cnt = 0;
-        for (const auto idx : ext::range(0, 2))
+        for (const auto idx : collections::range(0, 2))
         {
             const auto * column = arguments[idx].column.get();
             if (typeid_cast<const ColumnConst *> (column))
@@ -143,7 +143,7 @@ private:
                 dst_data.resize(size);
 
                 size_t start_index = 0;
-                for (const auto row : ext::range(0, size))
+                for (const auto row : collections::range(0, size))
                 {
                     dst_data[row] = isPointInEllipses(col_vec_x->getData()[row], col_vec_y->getData()[row], ellipses.data(), ellipses_count, start_index);
                 }
diff --git a/src/Functions/pointInPolygon.cpp b/src/Functions/pointInPolygon.cpp
index 842a5010190..3848721c051 100644
--- a/src/Functions/pointInPolygon.cpp
+++ b/src/Functions/pointInPolygon.cpp
@@ -108,7 +108,7 @@ public:
             if (elements.size() != 2)
                 throw Exception(getMessagePrefix(i) + " must have exactly two elements", ErrorCodes::BAD_ARGUMENTS);
 
-            for (auto j : ext::range(0, elements.size()))
+            for (auto j : collections::range(0, elements.size()))
             {
                 if (!isNativeNumber(elements[j]))
                 {
@@ -506,7 +506,7 @@ private:
             if (size == 0)
                 throw Exception(getMessagePrefix(i) + " shouldn't be empty.", ErrorCodes::ILLEGAL_COLUMN);
 
-            for (auto j : ext::range(0, size))
+            for (auto j : collections::range(0, size))
             {
                 CoordinateType x_coord = column_x->getFloat64(j);
                 CoordinateType y_coord = column_y->getFloat64(j);
diff --git a/src/Functions/reverse.cpp b/src/Functions/reverse.cpp
index f9701af75da..2b3692f6f22 100644
--- a/src/Functions/reverse.cpp
+++ b/src/Functions/reverse.cpp
@@ -4,7 +4,7 @@
 #include <Columns/ColumnArray.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionHelpers.h>
-#include <ext/map.h>
+#include <common/map.h>
 
 
 namespace DB
@@ -131,7 +131,7 @@ public:
         else
             return std::make_unique<FunctionToFunctionBaseAdaptor>(
                 FunctionReverse::create(context),
-                ext::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
+                collections::map<DataTypes>(arguments, [](const auto & elem) { return elem.type; }),
                 return_type);
     }
 
diff --git a/src/Functions/roundToExp2.cpp b/src/Functions/roundToExp2.cpp
index 2abe94b2b26..8f467aa9281 100644
--- a/src/Functions/roundToExp2.cpp
+++ b/src/Functions/roundToExp2.cpp
@@ -1,5 +1,5 @@
 #include <type_traits>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionUnaryArithmetic.h>
 
@@ -31,14 +31,14 @@ template <typename T>
 inline std::enable_if_t<std::is_same_v<T, Float32>, T>
 roundDownToPowerOfTwo(T x)
 {
-    return ext::bit_cast<T>(ext::bit_cast<UInt32>(x) & ~((1ULL << 23) - 1));
+    return bit_cast<T>(bit_cast<UInt32>(x) & ~((1ULL << 23) - 1));
 }
 
 template <typename T>
 inline std::enable_if_t<std::is_same_v<T, Float64>, T>
 roundDownToPowerOfTwo(T x)
 {
-    return ext::bit_cast<T>(ext::bit_cast<UInt64>(x) & ~((1ULL << 52) - 1));
+    return bit_cast<T>(bit_cast<UInt64>(x) & ~((1ULL << 52) - 1));
 }
 
 template <typename T>
diff --git a/src/Functions/runningAccumulate.cpp b/src/Functions/runningAccumulate.cpp
index 1eab573b046..796c501e86f 100644
--- a/src/Functions/runningAccumulate.cpp
+++ b/src/Functions/runningAccumulate.cpp
@@ -5,7 +5,7 @@
 #include <DataTypes/DataTypeAggregateFunction.h>
 #include <Common/AlignedBuffer.h>
 #include <Common/Arena.h>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 
 namespace DB
diff --git a/src/Functions/transform.cpp b/src/Functions/transform.cpp
index b886a3794f5..e93d6d089b6 100644
--- a/src/Functions/transform.cpp
+++ b/src/Functions/transform.cpp
@@ -1,5 +1,5 @@
 #include <mutex>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 
 #include <Common/FieldVisitorConvertToNumber.h>
 #include <DataTypes/DataTypeArray.h>
@@ -493,7 +493,7 @@ private:
         dst.resize(size);
         for (size_t i = 0; i < size; ++i)
         {
-            const auto * it = table.find(ext::bit_cast<UInt64>(src[i]));
+            const auto * it = table.find(bit_cast<UInt64>(src[i]));
             if (it)
                 memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));    /// little endian.
             else
@@ -509,7 +509,7 @@ private:
         dst.resize(size);
         for (size_t i = 0; i < size; ++i)
         {
-            const auto * it = table.find(ext::bit_cast<UInt64>(src[i]));
+            const auto * it = table.find(bit_cast<UInt64>(src[i]));
             if (it)
                 memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));    /// little endian.
             else
@@ -525,7 +525,7 @@ private:
         dst.resize(size);
         for (size_t i = 0; i < size; ++i)
         {
-            const auto * it = table.find(ext::bit_cast<UInt64>(src[i]));
+            const auto * it = table.find(bit_cast<UInt64>(src[i]));
             if (it)
                 memcpy(&dst[i], &it->getMapped(), sizeof(dst[i]));
             else
@@ -543,7 +543,7 @@ private:
         ColumnString::Offset current_dst_offset = 0;
         for (size_t i = 0; i < size; ++i)
         {
-            const auto * it = table.find(ext::bit_cast<UInt64>(src[i]));
+            const auto * it = table.find(bit_cast<UInt64>(src[i]));
             StringRef ref = it ? it->getMapped() : dst_default;
             dst_data.resize(current_dst_offset + ref.size);
             memcpy(&dst_data[current_dst_offset], ref.data, ref.size);
diff --git a/src/Functions/trap.cpp b/src/Functions/trap.cpp
index f946a7fabfb..d499885ae31 100644
--- a/src/Functions/trap.cpp
+++ b/src/Functions/trap.cpp
@@ -7,7 +7,7 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnString.h>
 #include <Interpreters/Context.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <thread>
 #include <memory>
diff --git a/src/Interpreters/BloomFilterHash.h b/src/Interpreters/BloomFilterHash.h
index b88ca36ad84..ae9aa9d193b 100644
--- a/src/Interpreters/BloomFilterHash.h
+++ b/src/Interpreters/BloomFilterHash.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <common/bit_cast.h>
+#include <Common/HashTable/Hash.h>
 #include <Columns/IColumn.h>
 #include <Columns/ColumnArray.h>
 #include <Columns/ColumnConst.h>
@@ -13,8 +15,6 @@
 #include <DataTypes/DataTypeFixedString.h>
 #include <DataTypes/DataTypeLowCardinality.h>
 #include <DataTypes/DataTypesNumber.h>
-#include <ext/bit_cast.h>
-#include <Common/HashTable/Hash.h>
 #include <Interpreters/BloomFilter.h>
 
 namespace DB
diff --git a/src/Interpreters/Cluster.cpp b/src/Interpreters/Cluster.cpp
index 2d746493988..42d4b9d05a1 100644
--- a/src/Interpreters/Cluster.cpp
+++ b/src/Interpreters/Cluster.cpp
@@ -11,7 +11,7 @@
 #include <IO/ReadHelpers.h>
 #include <Poco/Util/AbstractConfiguration.h>
 #include <Poco/Util/Application.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm_ext/erase.hpp>
 
 namespace DB
@@ -599,7 +599,7 @@ Cluster::Cluster(Cluster::ReplicasAsShardsTag, const Cluster & from, const Setti
 
     UInt32 shard_num = 0;
     std::set<std::pair<String, int>> unique_hosts;
-    for (size_t shard_index : ext::range(0, from.shards_info.size()))
+    for (size_t shard_index : collections::range(0, from.shards_info.size()))
     {
         const auto & replicas = from.addresses_with_failover[shard_index];
         for (const auto & address : replicas)
diff --git a/src/Interpreters/Context.cpp b/src/Interpreters/Context.cpp
index 1fe1e32a2e1..dcddeef2811 100644
--- a/src/Interpreters/Context.cpp
+++ b/src/Interpreters/Context.cpp
@@ -344,9 +344,9 @@ struct ContextSharedPart
     mutable std::optional<ExternalDictionariesLoader> external_dictionaries_loader;
     mutable std::optional<ExternalModelsLoader> external_models_loader;
     ConfigurationPtr external_models_config;
-    ext::scope_guard models_repository_guard;
+    scope_guard models_repository_guard;
 
-    ext::scope_guard dictionaries_xmls;
+    scope_guard dictionaries_xmls;
 
     String default_profile_name;                            /// Default profile name used for default values.
     String system_profile_name;                             /// Profile used by system processes
diff --git a/src/Interpreters/DDLWorker.cpp b/src/Interpreters/DDLWorker.cpp
index 1c023f757f8..c6e58e7b5b2 100644
--- a/src/Interpreters/DDLWorker.cpp
+++ b/src/Interpreters/DDLWorker.cpp
@@ -29,7 +29,7 @@
 #include <common/logger_useful.h>
 #include <random>
 #include <pcg_random.hpp>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 namespace fs = std::filesystem;
 
@@ -1137,7 +1137,9 @@ void DDLWorker::runMainThread()
             scheduleTasks(reinitialized);
 
             LOG_DEBUG(log, "Waiting for queue updates");
-            queue_updated_event->wait();
+            /// FIXME It may hang for unknown reason. Timeout is just a hotfix.
+            constexpr int queue_wait_timeout_ms = 10000;
+            queue_updated_event->tryWait(queue_wait_timeout_ms);
         }
         catch (const Coordination::Exception & e)
         {
diff --git a/src/Interpreters/ExternalLoader.cpp b/src/Interpreters/ExternalLoader.cpp
index 70d6e9a277d..eb7824a1124 100644
--- a/src/Interpreters/ExternalLoader.cpp
+++ b/src/Interpreters/ExternalLoader.cpp
@@ -9,8 +9,8 @@
 #include <Common/randomSeed.h>
 #include <Common/setThreadName.h>
 #include <Common/StatusInfo.h>
-#include <ext/chrono_io.h>
-#include <ext/scope_guard_safe.h>
+#include <common/chrono_io.h>
+#include <common/scope_guard_safe.h>
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <unordered_set>
@@ -685,7 +685,7 @@ public:
                         if (!should_update_flag)
                         {
                             info.next_update_time = calculateNextUpdateTime(info.object, info.error_count);
-                            LOG_TRACE(log, "Object '{}' not modified, will not reload. Next update at {}", info.name, ext::to_string(info.next_update_time));
+                            LOG_TRACE(log, "Object '{}' not modified, will not reload. Next update at {}", info.name, to_string(info.next_update_time));
                             continue;
                         }
 
@@ -1090,7 +1090,7 @@ private:
             {
                 if (next_update_time == TimePoint::max())
                     return String();
-                return ", next update is scheduled at " + ext::to_string(next_update_time);
+                return ", next update is scheduled at " + to_string(next_update_time);
             };
             if (previous_version)
                 tryLogException(new_exception, log, "Could not update " + type_name + " '" + name + "'"
@@ -1110,7 +1110,7 @@ private:
             info->last_successful_update_time = current_time;
         info->state_id = info->loading_id;
         info->next_update_time = next_update_time;
-        LOG_TRACE(log, "Next update time for '{}' was set to {}", info->name, ext::to_string(next_update_time));
+        LOG_TRACE(log, "Next update time for '{}' was set to {}", info->name, to_string(next_update_time));
     }
 
     /// Removes the references to the loading thread from the maps.
@@ -1159,18 +1159,18 @@ private:
                 std::uniform_int_distribution<UInt64> distribution{lifetime.min_sec, lifetime.max_sec};
                 auto result = std::chrono::system_clock::now() + std::chrono::seconds{distribution(rnd_engine)};
                 LOG_TRACE(log, "Supposed update time for '{}' is {} (loaded, lifetime [{}, {}], no errors)",
-                    loaded_object->getLoadableName(), ext::to_string(result), lifetime.min_sec, lifetime.max_sec);
+                    loaded_object->getLoadableName(), to_string(result), lifetime.min_sec, lifetime.max_sec);
                 return result;
             }
 
             auto result = std::chrono::system_clock::now() + std::chrono::seconds(calculateDurationWithBackoff(rnd_engine, error_count));
-            LOG_TRACE(log, "Supposed update time for '{}' is {} (backoff, {} errors)", loaded_object->getLoadableName(), ext::to_string(result), error_count);
+            LOG_TRACE(log, "Supposed update time for '{}' is {} (backoff, {} errors)", loaded_object->getLoadableName(), to_string(result), error_count);
             return result;
         }
         else
         {
             auto result = std::chrono::system_clock::now() + std::chrono::seconds(calculateDurationWithBackoff(rnd_engine, error_count));
-            LOG_TRACE(log, "Supposed update time for unspecified object is {} (backoff, {} errors.", ext::to_string(result), error_count);
+            LOG_TRACE(log, "Supposed update time for unspecified object is {} (backoff, {} errors.", to_string(result), error_count);
             return result;
         }
     }
@@ -1272,7 +1272,7 @@ ExternalLoader::ExternalLoader(const String & type_name_, Poco::Logger * log_)
 
 ExternalLoader::~ExternalLoader() = default;
 
-ext::scope_guard ExternalLoader::addConfigRepository(std::unique_ptr<IExternalLoaderConfigRepository> repository) const
+scope_guard ExternalLoader::addConfigRepository(std::unique_ptr<IExternalLoaderConfigRepository> repository) const
 {
     auto * ptr = repository.get();
     String name = ptr->getName();
diff --git a/src/Interpreters/ExternalLoader.h b/src/Interpreters/ExternalLoader.h
index d1a39af962f..2ea79d3aade 100644
--- a/src/Interpreters/ExternalLoader.h
+++ b/src/Interpreters/ExternalLoader.h
@@ -7,7 +7,7 @@
 #include <Interpreters/IExternalLoadable.h>
 #include <Interpreters/IExternalLoaderConfigRepository.h>
 #include <common/logger_useful.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Common/ExternalLoaderStatus.h>
 
 
@@ -87,7 +87,7 @@ public:
     virtual ~ExternalLoader();
 
     /// Adds a repository which will be used to read configurations from.
-    ext::scope_guard addConfigRepository(std::unique_ptr<IExternalLoaderConfigRepository> config_repository) const;
+    scope_guard addConfigRepository(std::unique_ptr<IExternalLoaderConfigRepository> config_repository) const;
 
     void setConfigSettings(const ExternalLoaderConfigSettings & settings_);
 
diff --git a/src/Interpreters/InterpreterCreateQuotaQuery.cpp b/src/Interpreters/InterpreterCreateQuotaQuery.cpp
index 223215624b3..c6983c65cef 100644
--- a/src/Interpreters/InterpreterCreateQuotaQuery.cpp
+++ b/src/Interpreters/InterpreterCreateQuotaQuery.cpp
@@ -5,7 +5,7 @@
 #include <Interpreters/executeDDLQueryOnCluster.h>
 #include <Access/AccessControlManager.h>
 #include <Access/AccessFlags.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm/find_if.hpp>
 #include <boost/range/algorithm/upper_bound.hpp>
 #include <boost/range/algorithm/sort.hpp>
@@ -58,7 +58,7 @@ namespace
 
             auto & quota_limits = *it;
             quota_limits.randomize_interval = query_limits.randomize_interval;
-            for (auto resource_type : ext::range(Quota::MAX_RESOURCE_TYPE))
+            for (auto resource_type : collections::range(Quota::MAX_RESOURCE_TYPE))
                 quota_limits.max[resource_type] = query_limits.max[resource_type];
         }
 
diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp
index 34158183bb2..9e598f4934e 100644
--- a/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/src/Interpreters/InterpreterSelectQuery.cpp
@@ -82,8 +82,8 @@
 #include <Common/FieldVisitorToString.h>
 #include <Common/typeid_cast.h>
 #include <Common/checkStackSize.h>
-#include <ext/map.h>
-#include <ext/scope_guard_safe.h>
+#include <common/map.h>
+#include <common/scope_guard_safe.h>
 #include <memory>
 
 
@@ -1682,7 +1682,7 @@ void InterpreterSelectQuery::addPrewhereAliasActions()
             }
 
             required_columns_after_prewhere_set
-                = ext::map<NameSet>(required_columns_after_prewhere, [](const auto & it) { return it.name; });
+                = collections::map<NameSet>(required_columns_after_prewhere, [](const auto & it) { return it.name; });
         }
 
         auto syntax_result
diff --git a/src/Interpreters/InterpreterShowAccessQuery.cpp b/src/Interpreters/InterpreterShowAccessQuery.cpp
index d2e21b71ae5..a82ba0411b4 100644
--- a/src/Interpreters/InterpreterShowAccessQuery.cpp
+++ b/src/Interpreters/InterpreterShowAccessQuery.cpp
@@ -9,7 +9,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <Access/AccessFlags.h>
 #include <Access/AccessControlManager.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm/sort.hpp>
 #include <boost/range/algorithm_ext/push_back.hpp>
 
@@ -53,7 +53,7 @@ std::vector<AccessEntityPtr> InterpreterShowAccessQuery::getEntities() const
     getContext()->checkAccess(AccessType::SHOW_ACCESS);
 
     std::vector<AccessEntityPtr> entities;
-    for (auto type : ext::range(EntityType::MAX))
+    for (auto type : collections::range(EntityType::MAX))
     {
         auto ids = access_control.findAll(type);
         for (const auto & id : ids)
diff --git a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
index 33e29d2b7bd..fbe4855f0af 100644
--- a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
+++ b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
@@ -24,7 +24,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Core/Defines.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm/sort.hpp>
 
 
@@ -151,7 +151,7 @@ namespace
             ASTCreateQuotaQuery::Limits create_query_limits;
             create_query_limits.duration = limits.duration;
             create_query_limits.randomize_interval = limits.randomize_interval;
-            for (auto resource_type : ext::range(Quota::MAX_RESOURCE_TYPE))
+            for (auto resource_type : collections::range(Quota::MAX_RESOURCE_TYPE))
                 create_query_limits.max[resource_type] = limits.max[resource_type];
             query->all_limits.push_back(create_query_limits);
         }
@@ -181,7 +181,7 @@ namespace
         if (policy.isRestrictive())
             query->is_restrictive = policy.isRestrictive();
 
-        for (auto type : ext::range(RowPolicy::MAX_CONDITION_TYPE))
+        for (auto type : collections::range(RowPolicy::MAX_CONDITION_TYPE))
         {
             const auto & condition = policy.conditions[static_cast<size_t>(type)];
             if (!condition.empty())
diff --git a/src/Interpreters/Set.cpp b/src/Interpreters/Set.cpp
index 97ebdf11918..66ba1f9ac9c 100644
--- a/src/Interpreters/Set.cpp
+++ b/src/Interpreters/Set.cpp
@@ -26,7 +26,7 @@
 
 #include <Storages/MergeTree/KeyCondition.h>
 
-#include <ext/range.h>
+#include <common/range.h>
 #include <DataTypes/DataTypeLowCardinality.h>
 
 namespace DB
@@ -539,7 +539,7 @@ BoolMask MergeTreeSetIndex::checkInRange(const std::vector<Range> & key_ranges,
      * if and only if either bound coincides with an element or at least one element
      * is between the lower bounds
      */
-    auto indices = ext::range(0, size());
+    auto indices = collections::range(0, size());
     auto left_lower = std::lower_bound(indices.begin(), indices.end(), left_point, less);
     auto right_lower = std::lower_bound(indices.begin(), indices.end(), right_point, less);
 
diff --git a/src/Interpreters/SystemLog.h b/src/Interpreters/SystemLog.h
index 074586efe3d..9e57e308dbe 100644
--- a/src/Interpreters/SystemLog.h
+++ b/src/Interpreters/SystemLog.h
@@ -8,7 +8,7 @@
 #include <condition_variable>
 #include <boost/noncopyable.hpp>
 #include <common/logger_useful.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <common/types.h>
 #include <Core/Defines.h>
 #include <Storages/IStorage.h>
diff --git a/src/Interpreters/executeDDLQueryOnCluster.cpp b/src/Interpreters/executeDDLQueryOnCluster.cpp
index 99ece6bb14c..8a6abf7714f 100644
--- a/src/Interpreters/executeDDLQueryOnCluster.cpp
+++ b/src/Interpreters/executeDDLQueryOnCluster.cpp
@@ -15,6 +15,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataStreams/NullBlockOutputStream.h>
+#include <DataStreams/NullAndDoCopyBlockInputStream.h>
 #include <DataStreams/copyData.h>
 #include <filesystem>
 
@@ -175,17 +176,15 @@ BlockIO getDistributedDDLStatus(const String & node_path, const DDLLogEntry & en
     if (context->getSettingsRef().distributed_ddl_task_timeout == 0)
         return io;
 
-    auto stream = std::make_shared<DDLQueryStatusInputStream>(node_path, entry, context, hosts_to_wait);
+    BlockInputStreamPtr stream = std::make_shared<DDLQueryStatusInputStream>(node_path, entry, context, hosts_to_wait);
     if (context->getSettingsRef().distributed_ddl_output_mode == DistributedDDLOutputMode::NONE)
     {
         /// Wait for query to finish, but ignore output
-        NullBlockOutputStream output{Block{}};
-        copyData(*stream, output);
-    }
-    else
-    {
-        io.in = std::move(stream);
+        auto null_output = std::make_shared<NullBlockOutputStream>(stream->getHeader());
+        stream = std::make_shared<NullAndDoCopyBlockInputStream>(std::move(stream), std::move(null_output));
     }
+
+    io.in = std::move(stream);
     return io;
 }
 
diff --git a/src/Parsers/ASTColumnsTransformers.cpp b/src/Parsers/ASTColumnsTransformers.cpp
index 024c9c3b767..359efbd03aa 100644
--- a/src/Parsers/ASTColumnsTransformers.cpp
+++ b/src/Parsers/ASTColumnsTransformers.cpp
@@ -165,7 +165,7 @@ void ASTColumnsReplaceTransformer::Replacement::formatImpl(
     const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const
 {
     expr->formatImpl(settings, state, frame);
-    settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS " << (settings.hilite ? hilite_none : "") << name;
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS " << (settings.hilite ? hilite_none : "") << backQuoteIfNeed(name);
 }
 
 void ASTColumnsReplaceTransformer::formatImpl(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const
diff --git a/src/Parsers/ASTCreateQuotaQuery.cpp b/src/Parsers/ASTCreateQuotaQuery.cpp
index 18f72d61319..d967498e573 100644
--- a/src/Parsers/ASTCreateQuotaQuery.cpp
+++ b/src/Parsers/ASTCreateQuotaQuery.cpp
@@ -2,7 +2,7 @@
 #include <Parsers/ASTRolesOrUsersSet.h>
 #include <Common/quoteString.h>
 #include <Common/IntervalKind.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <IO/Operators.h>
 
 
@@ -93,7 +93,7 @@ namespace
         else
         {
             bool limit_found = false;
-            for (auto resource_type : ext::range(Quota::MAX_RESOURCE_TYPE))
+            for (auto resource_type : collections::range(Quota::MAX_RESOURCE_TYPE))
             {
                 if (limits.max[resource_type])
                     limit_found = true;
@@ -102,7 +102,7 @@ namespace
             {
                 settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " MAX" << (settings.hilite ? IAST::hilite_none : "");
                 bool need_comma = false;
-                for (auto resource_type : ext::range(Quota::MAX_RESOURCE_TYPE))
+                for (auto resource_type : collections::range(Quota::MAX_RESOURCE_TYPE))
                 {
                     if (limits.max[resource_type])
                     {
diff --git a/src/Parsers/ASTCreateRowPolicyQuery.cpp b/src/Parsers/ASTCreateRowPolicyQuery.cpp
index 3b4c2484acf..2f3d96dbf69 100644
--- a/src/Parsers/ASTCreateRowPolicyQuery.cpp
+++ b/src/Parsers/ASTCreateRowPolicyQuery.cpp
@@ -3,7 +3,7 @@
 #include <Parsers/ASTRolesOrUsersSet.h>
 #include <Parsers/formatAST.h>
 #include <Common/quoteString.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm/transform.hpp>
 #include <IO/Operators.h>
 
diff --git a/src/Parsers/ParserCreateQuotaQuery.cpp b/src/Parsers/ParserCreateQuotaQuery.cpp
index c2e1514c7f6..084c9f32690 100644
--- a/src/Parsers/ParserCreateQuotaQuery.cpp
+++ b/src/Parsers/ParserCreateQuotaQuery.cpp
@@ -10,7 +10,7 @@
 #include <Parsers/ASTRolesOrUsersSet.h>
 #include <Parsers/ExpressionListParsers.h>
 #include <Common/FieldVisitorConvertToNumber.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/algorithm/string/predicate.hpp>
 
 
@@ -63,7 +63,7 @@ namespace
             boost::to_lower(name);
             boost::replace_all(name, " ", "_");
 
-            for (auto kt : ext::range(Quota::KeyType::MAX))
+            for (auto kt : collections::range(Quota::KeyType::MAX))
             {
                 if (KeyTypeInfo::get(kt).name == name)
                 {
@@ -73,7 +73,7 @@ namespace
             }
 
             String all_types_str;
-            for (auto kt : ext::range(Quota::KeyType::MAX))
+            for (auto kt : collections::range(Quota::KeyType::MAX))
                 all_types_str += String(all_types_str.empty() ? "" : ", ") + "'" + KeyTypeInfo::get(kt).name + "'";
             String msg = "Quota cannot be keyed by '" + name + "'. Expected one of the following identifiers: " + all_types_str;
             throw Exception(msg, ErrorCodes::SYNTAX_ERROR);
@@ -85,7 +85,7 @@ namespace
     {
         return IParserBase::wrapParseImpl(pos, [&]
         {
-            for (auto rt : ext::range(Quota::MAX_RESOURCE_TYPE))
+            for (auto rt : collections::range(Quota::MAX_RESOURCE_TYPE))
             {
                 if (ParserKeyword{ResourceTypeInfo::get(rt).keyword.c_str()}.ignore(pos, expected))
                 {
@@ -99,7 +99,7 @@ namespace
                 return false;
 
             String name = getIdentifierName(ast);
-            for (auto rt : ext::range(Quota::MAX_RESOURCE_TYPE))
+            for (auto rt : collections::range(Quota::MAX_RESOURCE_TYPE))
             {
                 if (ResourceTypeInfo::get(rt).name == name)
                 {
diff --git a/src/Parsers/ParserCreateRowPolicyQuery.cpp b/src/Parsers/ParserCreateRowPolicyQuery.cpp
index 534f781a273..37c2aed7830 100644
--- a/src/Parsers/ParserCreateRowPolicyQuery.cpp
+++ b/src/Parsers/ParserCreateRowPolicyQuery.cpp
@@ -10,7 +10,7 @@
 #include <Parsers/ExpressionListParsers.h>
 #include <Parsers/ExpressionElementParsers.h>
 #include <Parsers/ASTLiteral.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm_ext/push_back.hpp>
 
 
@@ -78,7 +78,7 @@ namespace
 
     void addAllCommands(boost::container::flat_set<std::string_view> & commands)
     {
-        for (auto condition_type : ext::range(MAX_CONDITION_TYPE))
+        for (auto condition_type : collections::range(MAX_CONDITION_TYPE))
         {
             const std::string_view & command = ConditionTypeInfo::get(condition_type).command;
             commands.emplace(command);
@@ -99,7 +99,7 @@ namespace
                 return true;
             }
 
-            for (auto condition_type : ext::range(MAX_CONDITION_TYPE))
+            for (auto condition_type : collections::range(MAX_CONDITION_TYPE))
             {
                 const std::string_view & command = ConditionTypeInfo::get(condition_type).command;
                 if (ParserKeyword{command.data()}.ignore(pos, expected))
@@ -156,7 +156,7 @@ namespace
             if (!check && !alter)
                 check = filter;
 
-            for (auto condition_type : ext::range(MAX_CONDITION_TYPE))
+            for (auto condition_type : collections::range(MAX_CONDITION_TYPE))
             {
                 const auto & type_info = ConditionTypeInfo::get(condition_type);
                 if (commands.count(type_info.command))
diff --git a/src/Parsers/ParserCreateUserQuery.cpp b/src/Parsers/ParserCreateUserQuery.cpp
index 84bf60d56d3..1d132582580 100644
--- a/src/Parsers/ParserCreateUserQuery.cpp
+++ b/src/Parsers/ParserCreateUserQuery.cpp
@@ -12,7 +12,7 @@
 #include <Parsers/ParserRolesOrUsersSet.h>
 #include <Parsers/ASTSettingsProfileElement.h>
 #include <Parsers/ParserSettingsProfileElement.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/range/algorithm_ext/push_back.hpp>
 
@@ -54,7 +54,7 @@ namespace
 
             if (ParserKeyword{"WITH"}.ignore(pos, expected))
             {
-                for (auto check_type : ext::range(Authentication::MAX_TYPE))
+                for (auto check_type : collections::range(Authentication::MAX_TYPE))
                 {
                     if (ParserKeyword{Authentication::TypeInfo::get(check_type).raw_name}.ignore(pos, expected))
                     {
diff --git a/src/Parsers/ParserDropAccessEntityQuery.cpp b/src/Parsers/ParserDropAccessEntityQuery.cpp
index b1f3ce5f93d..d59b68ba5ad 100644
--- a/src/Parsers/ParserDropAccessEntityQuery.cpp
+++ b/src/Parsers/ParserDropAccessEntityQuery.cpp
@@ -5,7 +5,7 @@
 #include <Parsers/ASTRowPolicyName.h>
 #include <Parsers/parseIdentifierOrStringLiteral.h>
 #include <Parsers/parseUserName.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -18,7 +18,7 @@ namespace
 
     bool parseEntityType(IParserBase::Pos & pos, Expected & expected, EntityType & type)
     {
-        for (auto i : ext::range(EntityType::MAX))
+        for (auto i : collections::range(EntityType::MAX))
         {
             const auto & type_info = EntityTypeInfo::get(i);
             if (ParserKeyword{type_info.name.c_str()}.ignore(pos, expected)
diff --git a/src/Parsers/ParserShowAccessEntitiesQuery.cpp b/src/Parsers/ParserShowAccessEntitiesQuery.cpp
index f070641cbd2..4e934327a14 100644
--- a/src/Parsers/ParserShowAccessEntitiesQuery.cpp
+++ b/src/Parsers/ParserShowAccessEntitiesQuery.cpp
@@ -3,7 +3,7 @@
 #include <Parsers/CommonParsers.h>
 #include <Parsers/parseDatabaseAndTableName.h>
 #include <Parsers/parseIdentifierOrStringLiteral.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -15,7 +15,7 @@ namespace
 
     bool parseEntityType(IParserBase::Pos & pos, Expected & expected, EntityType & type)
     {
-        for (auto i : ext::range(EntityType::MAX))
+        for (auto i : collections::range(EntityType::MAX))
         {
             const auto & type_info = EntityTypeInfo::get(i);
             if (ParserKeyword{type_info.plural_name.c_str()}.ignore(pos, expected)
diff --git a/src/Parsers/ParserShowCreateAccessEntityQuery.cpp b/src/Parsers/ParserShowCreateAccessEntityQuery.cpp
index 55d00572e48..05b6b333d6a 100644
--- a/src/Parsers/ParserShowCreateAccessEntityQuery.cpp
+++ b/src/Parsers/ParserShowCreateAccessEntityQuery.cpp
@@ -6,7 +6,7 @@
 #include <Parsers/ASTRowPolicyName.h>
 #include <Parsers/parseUserName.h>
 #include <Parsers/parseDatabaseAndTableName.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <assert.h>
 
 
@@ -25,7 +25,7 @@ namespace
 
     bool parseEntityType(IParserBase::Pos & pos, Expected & expected, EntityType & type, bool & plural)
     {
-        for (auto i : ext::range(EntityType::MAX))
+        for (auto i : collections::range(EntityType::MAX))
         {
             const auto & type_info = EntityTypeInfo::get(i);
             if (ParserKeyword{type_info.name.c_str()}.ignore(pos, expected)
@@ -37,7 +37,7 @@ namespace
             }
         }
 
-        for (auto i : ext::range(EntityType::MAX))
+        for (auto i : collections::range(EntityType::MAX))
         {
             const auto & type_info = EntityTypeInfo::get(i);
             if (ParserKeyword{type_info.plural_name.c_str()}.ignore(pos, expected)
diff --git a/src/Processors/Executors/PipelineExecutor.cpp b/src/Processors/Executors/PipelineExecutor.cpp
index b1751dfd030..ac6a2176979 100644
--- a/src/Processors/Executors/PipelineExecutor.cpp
+++ b/src/Processors/Executors/PipelineExecutor.cpp
@@ -9,7 +9,7 @@
 #include <Processors/ISource.h>
 #include <Interpreters/ProcessList.h>
 #include <Interpreters/OpenTelemetrySpanLog.h>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 #ifndef NDEBUG
     #include <Common/Stopwatch.h>
diff --git a/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp b/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp
index 9f1999bc4a3..ca5f4cc290f 100644
--- a/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp
+++ b/src/Processors/Executors/PullingAsyncPipelineExecutor.cpp
@@ -5,7 +5,7 @@
 #include <Processors/QueryPipeline.h>
 
 #include <Common/setThreadName.h>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 namespace DB
 {
diff --git a/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp b/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp
index 7152c9d9916..2971dbe8b5a 100644
--- a/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ParallelParsingInputFormat.cpp
@@ -2,7 +2,7 @@
 #include <IO/ReadHelpers.h>
 #include <Common/CurrentThread.h>
 #include <Common/setThreadName.h>
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 namespace DB
 {
diff --git a/src/Processors/Formats/Impl/ProtobufRowInputFormat.cpp b/src/Processors/Formats/Impl/ProtobufRowInputFormat.cpp
index 22a758b80f6..978dcb268b4 100644
--- a/src/Processors/Formats/Impl/ProtobufRowInputFormat.cpp
+++ b/src/Processors/Formats/Impl/ProtobufRowInputFormat.cpp
@@ -8,7 +8,7 @@
 #   include <Formats/ProtobufSchemas.h>
 #   include <Formats/ProtobufSerializer.h>
 #   include <Interpreters/Context.h>
-#   include <ext/range.h>
+#   include <common/range.h>
 
 
 namespace DB
diff --git a/src/Processors/Merges/Algorithms/FinishAggregatingInOrderAlgorithm.cpp b/src/Processors/Merges/Algorithms/FinishAggregatingInOrderAlgorithm.cpp
index 3eb94ba78b7..eaffe394ee4 100644
--- a/src/Processors/Merges/Algorithms/FinishAggregatingInOrderAlgorithm.cpp
+++ b/src/Processors/Merges/Algorithms/FinishAggregatingInOrderAlgorithm.cpp
@@ -2,7 +2,7 @@
 #include <Processors/Transforms/AggregatingTransform.h>
 #include <Core/SortCursor.h>
 
-#include <ext/range.h>
+#include <common/range.h>
 
 namespace DB
 {
@@ -93,7 +93,7 @@ IMergingAlgorithm::Status FinishAggregatingInOrderAlgorithm::merge()
         if (!states[i].isValid() || i == *best_input)
             continue;
 
-        auto indices = ext::range(states[i].current_row, states[i].num_rows);
+        auto indices = collections::range(states[i].current_row, states[i].num_rows);
         auto it = std::upper_bound(indices.begin(), indices.end(), best_state.num_rows - 1,
             [&](size_t lhs_pos, size_t rhs_pos)
             {
diff --git a/src/Processors/Transforms/AggregatingInOrderTransform.cpp b/src/Processors/Transforms/AggregatingInOrderTransform.cpp
index c19d6bd00b5..243b20edb1f 100644
--- a/src/Processors/Transforms/AggregatingInOrderTransform.cpp
+++ b/src/Processors/Transforms/AggregatingInOrderTransform.cpp
@@ -1,7 +1,7 @@
 #include <Processors/Transforms/AggregatingInOrderTransform.h>
 #include <DataTypes/DataTypeLowCardinality.h>
 #include <Core/SortCursor.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 namespace DB
 {
@@ -99,7 +99,7 @@ void AggregatingInOrderTransform::consume(Chunk chunk)
     while (key_end != rows)
     {
         /// Find the first position of new (not current) key in current chunk
-        auto indices = ext::range(key_begin, rows);
+        auto indices = collections::range(key_begin, rows);
         auto it = std::upper_bound(indices.begin(), indices.end(), cur_block_size - 1,
             [&](size_t lhs_row, size_t rhs_row)
             {
diff --git a/src/Server/GRPCServer.cpp b/src/Server/GRPCServer.cpp
index 2d6de423c5b..82e5ed4d0db 100644
--- a/src/Server/GRPCServer.cpp
+++ b/src/Server/GRPCServer.cpp
@@ -25,7 +25,7 @@
 #include <Poco/FileStream.h>
 #include <Poco/StreamCopier.h>
 #include <Poco/Util/LayeredConfiguration.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <grpc++/security/server_credentials.h>
 #include <grpc++/server.h>
 #include <grpc++/server_builder.h>
@@ -908,7 +908,7 @@ namespace
                 else
                 {
                     NamesAndTypesList columns;
-                    for (size_t column_idx : ext::range(external_table.columns_size()))
+                    for (size_t column_idx : collections::range(external_table.columns_size()))
                     {
                         const auto & name_and_type = external_table.columns(column_idx);
                         NameAndTypePair column;
@@ -1524,7 +1524,7 @@ private:
     {
         std::lock_guard lock{mutex};
         responders_for_new_calls.resize(CALL_MAX);
-        for (CallType call_type : ext::range(CALL_MAX))
+        for (CallType call_type : collections::range(CALL_MAX))
             makeResponderForNewCall(call_type);
     }
 
diff --git a/src/Server/HTTP/HTMLForm.cpp b/src/Server/HTTP/HTMLForm.cpp
index 9e0f74dcc33..86e08f3c8e7 100644
--- a/src/Server/HTTP/HTMLForm.cpp
+++ b/src/Server/HTTP/HTMLForm.cpp
@@ -1,5 +1,6 @@
 #include <Server/HTTP/HTMLForm.h>
 
+#include <Core/Settings.h>
 #include <IO/EmptyReadBuffer.h>
 #include <IO/ReadBufferFromString.h>
 #include <Server/HTTP/ReadHeaders.h>
@@ -35,38 +36,41 @@ const std::string HTMLForm::ENCODING_MULTIPART = "multipart/form-data";
 const int HTMLForm::UNKNOWN_CONTENT_LENGTH = -1;
 
 
-HTMLForm::HTMLForm() : field_limit(DFL_FIELD_LIMIT), value_length_limit(DFL_MAX_VALUE_LENGTH), encoding(ENCODING_URL)
+HTMLForm::HTMLForm(const Settings & settings)
+    : max_fields_number(settings.http_max_fields)
+    , max_field_name_size(settings.http_max_field_name_size)
+    , max_field_value_size(settings.http_max_field_value_size)
+    , encoding(ENCODING_URL)
 {
 }
 
 
-HTMLForm::HTMLForm(const std::string & encoding_)
-    : field_limit(DFL_FIELD_LIMIT), value_length_limit(DFL_MAX_VALUE_LENGTH), encoding(encoding_)
+HTMLForm::HTMLForm(const Settings & settings, const std::string & encoding_) : HTMLForm(settings)
 {
+    encoding = encoding_;
 }
 
 
-HTMLForm::HTMLForm(const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody, PartHandler & handler)
-    : field_limit(DFL_FIELD_LIMIT), value_length_limit(DFL_MAX_VALUE_LENGTH)
+HTMLForm::HTMLForm(const Settings & settings, const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody, PartHandler & handler)
+    : HTMLForm(settings)
 {
     load(request, requestBody, handler);
 }
 
 
-HTMLForm::HTMLForm(const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody)
-    : field_limit(DFL_FIELD_LIMIT), value_length_limit(DFL_MAX_VALUE_LENGTH)
+HTMLForm::HTMLForm(const Settings & settings, const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody) : HTMLForm(settings)
 {
     load(request, requestBody);
 }
 
 
-HTMLForm::HTMLForm(const Poco::Net::HTTPRequest & request) : HTMLForm(Poco::URI(request.getURI()))
+HTMLForm::HTMLForm(const Settings & settings, const Poco::Net::HTTPRequest & request) : HTMLForm(settings, Poco::URI(request.getURI()))
 {
 }
 
-HTMLForm::HTMLForm(const Poco::URI & uri) : field_limit(DFL_FIELD_LIMIT), value_length_limit(DFL_MAX_VALUE_LENGTH)
+HTMLForm::HTMLForm(const Settings & settings, const Poco::URI & uri) : HTMLForm(settings)
 {
-    ReadBufferFromString istr(uri.getRawQuery()); // STYLE_CHECK_ALLOW_STD_STRING_STREAM
+    ReadBufferFromString istr(uri.getRawQuery());  // STYLE_CHECK_ALLOW_STD_STRING_STREAM
     readQuery(istr);
 }
 
@@ -123,7 +127,7 @@ void HTMLForm::readQuery(ReadBuffer & in)
 
     while (true)
     {
-        if (field_limit > 0 && fields == field_limit)
+        if (max_fields_number > 0 && fields == max_fields_number)
             throw Poco::Net::HTMLFormException("Too many form fields");
 
         std::string name;
@@ -133,7 +137,7 @@ void HTMLForm::readQuery(ReadBuffer & in)
         {
             if (ch == '+')
                 ch = ' ';
-            if (name.size() < MAX_NAME_LENGTH)
+            if (name.size() < max_field_name_size)
                 name += ch;
             else
                 throw Poco::Net::HTMLFormException("Field name too long");
@@ -145,7 +149,7 @@ void HTMLForm::readQuery(ReadBuffer & in)
             {
                 if (ch == '+')
                     ch = ' ';
-                if (value.size() < value_length_limit)
+                if (value.size() < max_field_value_size)
                     value += ch;
                 else
                     throw Poco::Net::HTMLFormException("Field value too long");
@@ -185,11 +189,11 @@ void HTMLForm::readMultipart(ReadBuffer & in_, PartHandler & handler)
     /// Read each part until next boundary (or last boundary)
     while (!in.eof())
     {
-        if (field_limit && fields > field_limit)
+        if (max_fields_number && fields > max_fields_number)
             throw Poco::Net::HTMLFormException("Too many form fields");
 
         Poco::Net::MessageHeader header;
-        readHeaders(header, in);
+        readHeaders(header, in, max_fields_number, max_field_name_size, max_field_value_size);
         skipToNextLineOrEOF(in);
 
         NameValueCollection params;
@@ -209,7 +213,7 @@ void HTMLForm::readMultipart(ReadBuffer & in_, PartHandler & handler)
 
             while (in.read(ch))
             {
-                if (value.size() > value_length_limit)
+                if (value.size() > max_field_value_size)
                     throw Poco::Net::HTMLFormException("Field value too long");
                 value += ch;
             }
diff --git a/src/Server/HTTP/HTMLForm.h b/src/Server/HTTP/HTMLForm.h
index ca6bb9048f1..16889b41d80 100644
--- a/src/Server/HTTP/HTMLForm.h
+++ b/src/Server/HTTP/HTMLForm.h
@@ -12,6 +12,8 @@
 namespace DB
 {
 
+struct Settings;
+
 class HTMLForm : public Poco::Net::NameValueCollection, private boost::noncopyable
 {
 public:
@@ -19,31 +21,31 @@ public:
 
     enum Options
     {
-        OPT_USE_CONTENT_LENGTH = 0x01 // don't use Chunked Transfer-Encoding for multipart requests.
+        OPT_USE_CONTENT_LENGTH = 0x01,  /// don't use Chunked Transfer-Encoding for multipart requests.
     };
 
     /// Creates an empty HTMLForm and sets the
     /// encoding to "application/x-www-form-urlencoded".
-    HTMLForm();
+    explicit HTMLForm(const Settings & settings);
 
     /// Creates an empty HTMLForm that uses the given encoding.
     /// Encoding must be either "application/x-www-form-urlencoded" (which is the default) or "multipart/form-data".
-    explicit HTMLForm(const std::string & encoding);
+    explicit HTMLForm(const Settings & settings, const std::string & encoding);
 
     /// Creates a HTMLForm from the given HTTP request.
     /// Uploaded files are passed to the given PartHandler.
-    HTMLForm(const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody, PartHandler & handler);
+    HTMLForm(const Settings & settings, const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody, PartHandler & handler);
 
     /// Creates a HTMLForm from the given HTTP request.
     /// Uploaded files are silently discarded.
-    HTMLForm(const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody);
+    HTMLForm(const Settings & settings, const Poco::Net::HTTPRequest & request, ReadBuffer & requestBody);
 
     /// Creates a HTMLForm from the given HTTP request.
     /// The request must be a GET request and the form data must be in the query string (URL encoded).
     /// For POST requests, you must use one of the constructors taking an additional input stream for the request body.
-    explicit HTMLForm(const Poco::Net::HTTPRequest & request);
+    explicit HTMLForm(const Settings & settings, const Poco::Net::HTTPRequest & request);
 
-    explicit HTMLForm(const Poco::URI & uri);
+    explicit HTMLForm(const Settings & settings, const Poco::URI & uri);
 
     template <typename T>
     T getParsed(const std::string & key, T default_value)
@@ -76,13 +78,6 @@ private:
     /// This buffer provides data line by line to check for boundary line in a convenient way.
     class MultipartReadBuffer;
 
-    enum Limits
-    {
-        DFL_FIELD_LIMIT = 100,
-        MAX_NAME_LENGTH = 1024,
-        DFL_MAX_VALUE_LENGTH = 256 * 1024
-    };
-
     struct Part
     {
         std::string name;
@@ -91,8 +86,8 @@ private:
 
     using PartVec = std::vector<Part>;
 
-    size_t field_limit;
-    size_t value_length_limit;
+    const size_t max_fields_number, max_field_name_size, max_field_value_size;
+
     std::string encoding;
     std::string boundary;
     PartVec parts;
diff --git a/src/Server/HTTP/HTTPServerRequest.cpp b/src/Server/HTTP/HTTPServerRequest.cpp
index 69dc8d4dbda..788c13557f3 100644
--- a/src/Server/HTTP/HTTPServerRequest.cpp
+++ b/src/Server/HTTP/HTTPServerRequest.cpp
@@ -17,6 +17,9 @@ namespace DB
 {
 HTTPServerRequest::HTTPServerRequest(ContextPtr context, HTTPServerResponse & response, Poco::Net::HTTPServerSession & session)
     : max_uri_size(context->getSettingsRef().http_max_uri_size)
+    , max_fields_number(context->getSettingsRef().http_max_fields)
+    , max_field_name_size(context->getSettingsRef().http_max_field_name_size)
+    , max_field_value_size(context->getSettingsRef().http_max_field_value_size)
 {
     response.attachRequest(this);
 
@@ -110,7 +113,7 @@ void HTTPServerRequest::readRequest(ReadBuffer & in)
 
     skipToNextLineOrEOF(in);
 
-    readHeaders(*this, in);
+    readHeaders(*this, in, max_fields_number, max_field_name_size, max_field_value_size);
 
     skipToNextLineOrEOF(in);
 
diff --git a/src/Server/HTTP/HTTPServerRequest.h b/src/Server/HTTP/HTTPServerRequest.h
index a560f907cf0..9e33e78a424 100644
--- a/src/Server/HTTP/HTTPServerRequest.h
+++ b/src/Server/HTTP/HTTPServerRequest.h
@@ -40,14 +40,14 @@ private:
     /// Limits for basic sanity checks when reading a header
     enum Limits
     {
-        MAX_NAME_LENGTH = 256,
-        MAX_VALUE_LENGTH = 8192,
         MAX_METHOD_LENGTH = 32,
         MAX_VERSION_LENGTH = 8,
-        MAX_FIELDS_NUMBER = 100,
     };
 
     const size_t max_uri_size;
+    const size_t max_fields_number;
+    const size_t max_field_name_size;
+    const size_t max_field_value_size;
 
     std::unique_ptr<ReadBuffer> stream;
     Poco::Net::SocketImpl * socket;
diff --git a/src/Server/HTTP/ReadHeaders.h b/src/Server/HTTP/ReadHeaders.h
index e94cddcf489..1b0e627f779 100644
--- a/src/Server/HTTP/ReadHeaders.h
+++ b/src/Server/HTTP/ReadHeaders.h
@@ -8,10 +8,6 @@ namespace DB
 class ReadBuffer;
 
 void readHeaders(
-    Poco::Net::MessageHeader & headers,
-    ReadBuffer & in,
-    size_t max_fields_number = 100,
-    size_t max_name_length = 256,
-    size_t max_value_length = 8192);
+    Poco::Net::MessageHeader & headers, ReadBuffer & in, size_t max_fields_number, size_t max_name_length, size_t max_value_length);
 
 }
diff --git a/src/Server/HTTPHandler.cpp b/src/Server/HTTPHandler.cpp
index 6eab6cdda5e..ad38cfb341a 100644
--- a/src/Server/HTTPHandler.cpp
+++ b/src/Server/HTTPHandler.cpp
@@ -31,7 +31,7 @@
 #include <Common/setThreadName.h>
 #include <Common/typeid_cast.h>
 #include <common/getFQDNOrHostName.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #if !defined(ARCADIA_BUILD)
 #    include <Common/config.h>
@@ -895,7 +895,7 @@ void HTTPHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse
         if (request.getVersion() == HTTPServerRequest::HTTP_1_1)
             response.setChunkedTransferEncoding(true);
 
-        HTMLForm params(request);
+        HTMLForm params(request_context->getSettingsRef(), request);
         with_stacktrace = params.getParsed<bool>("stacktrace", false);
 
         /// FIXME: maybe this check is already unnecessary.
diff --git a/src/Server/InterserverIOHTTPHandler.cpp b/src/Server/InterserverIOHTTPHandler.cpp
index 64af8860b23..d76361e856e 100644
--- a/src/Server/InterserverIOHTTPHandler.cpp
+++ b/src/Server/InterserverIOHTTPHandler.cpp
@@ -50,7 +50,7 @@ std::pair<String, bool> InterserverIOHTTPHandler::checkAuthentication(HTTPServer
 
 void InterserverIOHTTPHandler::processQuery(HTTPServerRequest & request, HTTPServerResponse & response, Output & used_output)
 {
-    HTMLForm params(request);
+    HTMLForm params(server.context()->getSettingsRef(), request);
 
     LOG_TRACE(log, "Request URI: {}", request.getURI());
 
diff --git a/src/Server/InterserverIOHTTPHandler.h b/src/Server/InterserverIOHTTPHandler.h
index c0d776115e1..da5b286b9e5 100644
--- a/src/Server/InterserverIOHTTPHandler.h
+++ b/src/Server/InterserverIOHTTPHandler.h
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <Interpreters/InterserverCredentials.h>
 #include <Server/HTTP/HTTPRequestHandler.h>
 #include <Common/CurrentMetrics.h>
-#include <Interpreters/InterserverCredentials.h>
 
 #include <Poco/Logger.h>
 
diff --git a/src/Server/MySQLHandler.cpp b/src/Server/MySQLHandler.cpp
index ef6fc3ee728..497c0574fae 100644
--- a/src/Server/MySQLHandler.cpp
+++ b/src/Server/MySQLHandler.cpp
@@ -1,7 +1,7 @@
 #include "MySQLHandler.h"
 
 #include <limits>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Columns/ColumnVector.h>
 #include <Common/NetException.h>
 #include <Common/OpenSSLHelpers.h>
diff --git a/src/Server/MySQLHandlerFactory.cpp b/src/Server/MySQLHandlerFactory.cpp
index 18e05f88402..46db9c8c328 100644
--- a/src/Server/MySQLHandlerFactory.cpp
+++ b/src/Server/MySQLHandlerFactory.cpp
@@ -3,7 +3,7 @@
 #include <Poco/Net/TCPServerConnectionFactory.h>
 #include <Poco/Util/Application.h>
 #include <common/logger_useful.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Server/MySQLHandler.h>
 
 #if USE_SSL
diff --git a/src/Server/ReplicasStatusHandler.cpp b/src/Server/ReplicasStatusHandler.cpp
index 86295cc5170..b7dc8c14858 100644
--- a/src/Server/ReplicasStatusHandler.cpp
+++ b/src/Server/ReplicasStatusHandler.cpp
@@ -18,23 +18,20 @@
 namespace DB
 {
 
-
-ReplicasStatusHandler::ReplicasStatusHandler(IServer & server)
-    : context(server.context())
+ReplicasStatusHandler::ReplicasStatusHandler(IServer & server) : WithContext(server.context())
 {
 }
 
-
 void ReplicasStatusHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse & response)
 {
     try
     {
-        HTMLForm params(request);
+        HTMLForm params(getContext()->getSettingsRef(), request);
 
         /// Even if lag is small, output detailed information about the lag.
         bool verbose = params.get("verbose", "") == "1";
 
-        const MergeTreeSettings & settings = context->getReplicatedMergeTreeSettings();
+        const MergeTreeSettings & settings = getContext()->getReplicatedMergeTreeSettings();
 
         bool ok = true;
         WriteBufferFromOwnString message;
@@ -48,7 +45,7 @@ void ReplicasStatusHandler::handleRequest(HTTPServerRequest & request, HTTPServe
             if (!db.second->canContainMergeTreeTables())
                 continue;
 
-            for (auto iterator = db.second->getTablesIterator(context); iterator->isValid(); iterator->next())
+            for (auto iterator = db.second->getTablesIterator(getContext()); iterator->isValid(); iterator->next())
             {
                 const auto & table = iterator->table();
                 if (!table)
@@ -73,7 +70,7 @@ void ReplicasStatusHandler::handleRequest(HTTPServerRequest & request, HTTPServe
             }
         }
 
-        const auto & config = context->getConfigRef();
+        const auto & config = getContext()->getConfigRef();
         setResponseDefaultHeaders(response, config.getUInt("keep_alive_timeout", 10));
 
         if (!ok)
diff --git a/src/Server/ReplicasStatusHandler.h b/src/Server/ReplicasStatusHandler.h
index eda0b15ed6f..1a5388aa2ab 100644
--- a/src/Server/ReplicasStatusHandler.h
+++ b/src/Server/ReplicasStatusHandler.h
@@ -9,11 +9,8 @@ class Context;
 class IServer;
 
 /// Replies "Ok.\n" if all replicas on this server don't lag too much. Otherwise output lag information.
-class ReplicasStatusHandler : public HTTPRequestHandler
+class ReplicasStatusHandler : public HTTPRequestHandler, WithContext
 {
-private:
-    ContextPtr context;
-
 public:
     explicit ReplicasStatusHandler(IServer & server_);
 
diff --git a/src/Server/TCPHandler.cpp b/src/Server/TCPHandler.cpp
index d44b17d42ff..108b7b8070a 100644
--- a/src/Server/TCPHandler.cpp
+++ b/src/Server/TCPHandler.cpp
@@ -1,5 +1,5 @@
 #include <iomanip>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Poco/Net/NetException.h>
 #include <Poco/Util/LayeredConfiguration.h>
 #include <Common/CurrentThread.h>
diff --git a/src/Storages/Distributed/DistributedBlockOutputStream.cpp b/src/Storages/Distributed/DistributedBlockOutputStream.cpp
index ba91b5b576d..9b13198812b 100644
--- a/src/Storages/Distributed/DistributedBlockOutputStream.cpp
+++ b/src/Storages/Distributed/DistributedBlockOutputStream.cpp
@@ -30,8 +30,8 @@
 #include <Common/CurrentThread.h>
 #include <Common/createHardLink.h>
 #include <common/logger_useful.h>
-#include <ext/range.h>
-#include <ext/scope_guard.h>
+#include <common/range.h>
+#include <common/scope_guard.h>
 
 #include <future>
 #include <condition_variable>
@@ -216,7 +216,7 @@ void DistributedBlockOutputStream::initWritingJobs(const Block & first_block, si
     local_jobs_count = 0;
     per_shard_jobs.resize(shards_info.size());
 
-    for (size_t shard_index : ext::range(start, end))
+    for (size_t shard_index : collections::range(start, end))
     {
         const auto & shard_info = shards_info[shard_index];
         auto & shard_jobs = per_shard_jobs[shard_index];
@@ -226,7 +226,7 @@ void DistributedBlockOutputStream::initWritingJobs(const Block & first_block, si
         {
             const auto & replicas = addresses_with_failovers[shard_index];
 
-            for (size_t replica_index : ext::range(0, replicas.size()))
+            for (size_t replica_index : collections::range(0, replicas.size()))
             {
                 if (!replicas[replica_index].is_local || !settings.prefer_localhost_replica)
                 {
@@ -445,7 +445,7 @@ void DistributedBlockOutputStream::writeSync(const Block & block)
         auto current_selector = createSelector(block);
 
         /// Prepare row numbers for each shard
-        for (size_t shard_index : ext::range(0, num_shards))
+        for (size_t shard_index : collections::range(0, num_shards))
             per_shard_jobs[shard_index].shard_current_block_permutation.resize(0);
 
         for (size_t i = 0; i < block.rows(); ++i)
@@ -456,7 +456,7 @@ void DistributedBlockOutputStream::writeSync(const Block & block)
     {
         /// Run jobs in parallel for each block and wait them
         finished_jobs_count = 0;
-        for (size_t shard_index : ext::range(0, shards_info.size()))
+        for (size_t shard_index : collections::range(0, shards_info.size()))
             for (JobReplica & job : per_shard_jobs[shard_index].replicas_jobs)
                 pool->scheduleOrThrowOnError(runWritingJob(job, block, num_shards));
     }
diff --git a/src/Storages/HDFS/StorageHDFS.h b/src/Storages/HDFS/StorageHDFS.h
index 0afd89fe568..397e147e7cd 100644
--- a/src/Storages/HDFS/StorageHDFS.h
+++ b/src/Storages/HDFS/StorageHDFS.h
@@ -9,7 +9,7 @@
 #include <Storages/IStorage.h>
 #include <Poco/URI.h>
 #include <common/logger_useful.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 namespace DB
 {
@@ -17,9 +17,9 @@ namespace DB
  * This class represents table engine for external hdfs files.
  * Read method is supported for now.
  */
-class StorageHDFS final : public ext::shared_ptr_helper<StorageHDFS>, public IStorage, WithContext
+class StorageHDFS final : public shared_ptr_helper<StorageHDFS>, public IStorage, WithContext
 {
-    friend struct ext::shared_ptr_helper<StorageHDFS>;
+    friend struct shared_ptr_helper<StorageHDFS>;
 public:
     String getName() const override { return "HDFS"; }
 
diff --git a/src/Storages/Kafka/StorageKafka.h b/src/Storages/Kafka/StorageKafka.h
index b09b2ecd39e..805fa9d510c 100644
--- a/src/Storages/Kafka/StorageKafka.h
+++ b/src/Storages/Kafka/StorageKafka.h
@@ -7,7 +7,7 @@
 #include <Common/SettingsChanges.h>
 
 #include <Poco/Semaphore.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <mutex>
 #include <list>
@@ -28,9 +28,9 @@ struct StorageKafkaInterceptors;
 /** Implements a Kafka queue table engine that can be used as a persistent queue / buffer,
   * or as a basic building block for creating pipelines with a continuous insertion / ETL.
   */
-class StorageKafka final : public ext::shared_ptr_helper<StorageKafka>, public IStorage, WithContext
+class StorageKafka final : public shared_ptr_helper<StorageKafka>, public IStorage, WithContext
 {
-    friend struct ext::shared_ptr_helper<StorageKafka>;
+    friend struct shared_ptr_helper<StorageKafka>;
     friend struct StorageKafkaInterceptors;
 
 public:
diff --git a/src/Storages/LiveView/StorageLiveView.h b/src/Storages/LiveView/StorageLiveView.h
index e787b7bf939..23a9c84cb9e 100644
--- a/src/Storages/LiveView/StorageLiveView.h
+++ b/src/Storages/LiveView/StorageLiveView.h
@@ -11,7 +11,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License. */
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 #include <Core/BackgroundSchedulePool.h>
 
@@ -49,9 +49,9 @@ class Pipe;
 using Pipes = std::vector<Pipe>;
 
 
-class StorageLiveView final : public ext::shared_ptr_helper<StorageLiveView>, public IStorage, WithContext
+class StorageLiveView final : public shared_ptr_helper<StorageLiveView>, public IStorage, WithContext
 {
-friend struct ext::shared_ptr_helper<StorageLiveView>;
+friend struct shared_ptr_helper<StorageLiveView>;
 friend class LiveViewBlockInputStream;
 friend class LiveViewEventsBlockInputStream;
 friend class LiveViewBlockOutputStream;
diff --git a/src/Storages/MergeTree/DataPartsExchange.cpp b/src/Storages/MergeTree/DataPartsExchange.cpp
index 47f446a0b8b..ff6101fce07 100644
--- a/src/Storages/MergeTree/DataPartsExchange.cpp
+++ b/src/Storages/MergeTree/DataPartsExchange.cpp
@@ -13,7 +13,7 @@
 #include <Common/CurrentMetrics.h>
 #include <Common/NetException.h>
 #include <IO/createReadBufferFromFileBase.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 #include <Poco/Net/HTTPRequest.h>
 
 
diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index f21250a8cea..b0bf0c8e672 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -55,7 +55,7 @@
 #include <boost/range/adaptor/filtered.hpp>
 #include <boost/algorithm/string/join.hpp>
 
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 
 #include <algorithm>
 #include <iomanip>
@@ -1116,6 +1116,16 @@ void MergeTreeData::clearOldTemporaryDirectories(ssize_t custom_directories_life
                         disk->removeRecursive(it->path());
                     }
                 }
+                /// see getModificationTime()
+                catch (const ErrnoException & e)
+                {
+                    if (e.getErrno() == ENOENT)
+                    {
+                        /// If the file is already deleted, do nothing.
+                    }
+                    else
+                        throw;
+                }
                 catch (const fs::filesystem_error & e)
                 {
                     if (e.code() == std::errc::no_such_file_or_directory)
diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
index 929fb814ab8..ae3b533918d 100644
--- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
@@ -1,5 +1,5 @@
 #include <boost/rational.hpp>   /// For calculations related to sampling coefficients.
-#include <ext/scope_guard_safe.h>
+#include <common/scope_guard_safe.h>
 #include <optional>
 #include <unordered_set>
 
diff --git a/src/Storages/MergeTree/MergeTreeIndexAggregatorBloomFilter.cpp b/src/Storages/MergeTree/MergeTreeIndexAggregatorBloomFilter.cpp
index e9176426e83..90178ec38b9 100644
--- a/src/Storages/MergeTree/MergeTreeIndexAggregatorBloomFilter.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexAggregatorBloomFilter.cpp
@@ -1,6 +1,6 @@
 #include <Storages/MergeTree/MergeTreeIndexAggregatorBloomFilter.h>
 
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnsNumber.h>
 #include <Columns/ColumnFixedString.h>
diff --git a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
index 79581fb3ab4..83c29c40c3f 100644
--- a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
@@ -3,7 +3,7 @@
 #include <Interpreters/TreeRewriter.h>
 #include <Interpreters/ExpressionAnalyzer.h>
 #include <common/types.h>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <Parsers/ASTLiteral.h>
 #include <IO/ReadHelpers.h>
 #include <IO/WriteHelpers.h>
diff --git a/src/Storages/MergeTree/MergeTreeIndexGranuleBloomFilter.cpp b/src/Storages/MergeTree/MergeTreeIndexGranuleBloomFilter.cpp
index 83f8884e03a..b513437fbe1 100644
--- a/src/Storages/MergeTree/MergeTreeIndexGranuleBloomFilter.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexGranuleBloomFilter.cpp
@@ -5,7 +5,7 @@
 #include <Columns/ColumnFixedString.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <Common/HashTable/Hash.h>
-#include <ext/bit_cast.h>
+#include <common/bit_cast.h>
 #include <Interpreters/BloomFilterHash.h>
 #include <IO/WriteHelpers.h>
 
diff --git a/src/Storages/MergeTree/MergeTreeRangeReader.cpp b/src/Storages/MergeTree/MergeTreeRangeReader.cpp
index bef67f0ade2..27682b81c94 100644
--- a/src/Storages/MergeTree/MergeTreeRangeReader.cpp
+++ b/src/Storages/MergeTree/MergeTreeRangeReader.cpp
@@ -1,7 +1,7 @@
 #include <Storages/MergeTree/IMergeTreeReader.h>
 #include <Columns/FilterDescription.h>
 #include <Columns/ColumnsCommon.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <DataTypes/DataTypeNothing.h>
 
 #ifdef __SSE2__
@@ -117,7 +117,7 @@ size_t MergeTreeRangeReader::DelayedStream::finalize(Columns & columns)
     /// We need to skip some rows before reading
     if (current_offset && !continue_reading)
     {
-        for (size_t mark_num : ext::range(current_mark, index_granularity->getMarksCount()))
+        for (size_t mark_num : collections::range(current_mark, index_granularity->getMarksCount()))
         {
             size_t mark_index_granularity = index_granularity->getMarkRows(mark_num);
             if (current_offset >= mark_index_granularity)
@@ -355,7 +355,7 @@ void MergeTreeRangeReader::ReadResult::optimize(bool can_read_incomplete_granule
     /// Just a guess. If only a few rows may be skipped, it's better not to skip at all.
     else if (2 * total_zero_rows_in_tails > filter->size())
     {
-        for (auto i : ext::range(0, rows_per_granule.size()))
+        for (auto i : collections::range(0, rows_per_granule.size()))
         {
             rows_per_granule_original.push_back(rows_per_granule[i]);
             rows_per_granule[i] -= zero_tails[i];
@@ -419,7 +419,7 @@ void MergeTreeRangeReader::ReadResult::collapseZeroTails(const IColumn::Filter &
     const auto * filter_data = filter_vec.data();
     auto * new_filter_data = new_filter_vec.data();
 
-    for (auto i : ext::range(0, rows_per_granule.size()))
+    for (auto i : collections::range(0, rows_per_granule.size()))
     {
         memcpySmallAllowReadWriteOverflow15(new_filter_data, filter_data, rows_per_granule[i]);
         filter_data += rows_per_granule_original[i];
@@ -809,7 +809,7 @@ Columns MergeTreeRangeReader::continueReadingChain(ReadResult & result, size_t &
     size_t next_range_to_start = 0;
 
     auto size = rows_per_granule.size();
-    for (auto i : ext::range(0, size))
+    for (auto i : collections::range(0, size))
     {
         if (next_range_to_start < started_ranges.size()
             && i == started_ranges[next_range_to_start].num_granules_read_before_start)
diff --git a/src/Storages/MergeTree/MergeTreeReadPool.cpp b/src/Storages/MergeTree/MergeTreeReadPool.cpp
index d9a250e3f7a..e8ea56b6531 100644
--- a/src/Storages/MergeTree/MergeTreeReadPool.cpp
+++ b/src/Storages/MergeTree/MergeTreeReadPool.cpp
@@ -1,7 +1,7 @@
 #include <Storages/MergeTree/MergeTreeReadPool.h>
 #include <Storages/MergeTree/MergeTreeBaseSelectProcessor.h>
 #include <Common/formatReadable.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace ProfileEvents
@@ -217,7 +217,7 @@ std::vector<size_t> MergeTreeReadPool::fillPerPartInfo(
     std::vector<size_t> per_part_sum_marks;
     Block sample_block = metadata_snapshot->getSampleBlock();
 
-    for (const auto i : ext::range(0, parts.size()))
+    for (const auto i : collections::range(0, parts.size()))
     {
         const auto & part = parts[i];
 
diff --git a/src/Storages/MergeTree/MergeTreeReaderStream.cpp b/src/Storages/MergeTree/MergeTreeReaderStream.cpp
index 774c5bcf3d8..23e62c29c51 100644
--- a/src/Storages/MergeTree/MergeTreeReaderStream.cpp
+++ b/src/Storages/MergeTree/MergeTreeReaderStream.cpp
@@ -43,7 +43,7 @@ MergeTreeReaderStream::MergeTreeReaderStream(
         /// If the end of range is inside the block, we will need to read it too.
         if (right_mark < marks_count && marks_loader.getMark(right_mark).offset_in_decompressed_block > 0)
         {
-            auto indices = ext::range(right_mark, marks_count);
+            auto indices = collections::range(right_mark, marks_count);
             auto it = std::upper_bound(indices.begin(), indices.end(), right_mark, [this](size_t i, size_t j)
             {
                 return marks_loader.getMark(i).offset_in_compressed_file < marks_loader.getMark(j).offset_in_compressed_file;
diff --git a/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp b/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
index 2b27a51ba5e..2da20073427 100644
--- a/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
+++ b/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
@@ -12,7 +12,7 @@
 #include <Interpreters/misc.h>
 #include <Common/typeid_cast.h>
 #include <DataTypes/NestedUtils.h>
-#include <ext/map.h>
+#include <common/map.h>
 
 
 namespace DB
@@ -34,7 +34,7 @@ MergeTreeWhereOptimizer::MergeTreeWhereOptimizer(
     const StorageMetadataPtr & metadata_snapshot,
     const Names & queried_columns_,
     Poco::Logger * log_)
-    : table_columns{ext::map<std::unordered_set>(
+    : table_columns{collections::map<std::unordered_set>(
         metadata_snapshot->getColumns().getAllPhysical(), [](const NameAndTypePair & col) { return col.name; })}
     , queried_columns{queried_columns_}
     , sorting_key_names{NameSet(
diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
index 573d40951f7..1c9921aad1d 100644
--- a/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
+++ b/src/Storages/MergeTree/ReplicatedMergeTreeRestartingThread.cpp
@@ -356,7 +356,12 @@ void ReplicatedMergeTreeRestartingThread::partialShutdown()
     storage.part_check_thread.stop();
 
     /// Stop queue processing
-    storage.background_executor.finish();
+    {
+        auto fetch_lock = storage.fetcher.blocker.cancel();
+        auto merge_lock = storage.merger_mutator.merges_blocker.cancel();
+        auto move_lock = storage.parts_mover.moves_blocker.cancel();
+        storage.background_executor.finish();
+    }
 
     LOG_TRACE(log, "Threads finished");
 }
diff --git a/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h b/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h
index 13d835d13a0..5d82716af11 100644
--- a/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h
+++ b/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h
@@ -9,15 +9,15 @@
 #include <Storages/MergeTree/IMergeTreeDataPart.h>
 #include <Storages/MergeTree/MergeTreeDataSelectExecutor.h>
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
 {
 /// A Storage that allows reading from a single MergeTree data part.
-class StorageFromBasePartsOfProjection final : public ext::shared_ptr_helper<StorageFromBasePartsOfProjection>, public IStorage
+class StorageFromBasePartsOfProjection final : public shared_ptr_helper<StorageFromBasePartsOfProjection>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageFromBasePartsOfProjection>;
+    friend struct shared_ptr_helper<StorageFromBasePartsOfProjection>;
 
 public:
     String getName() const override { return "FromBasePartsOfProjection"; }
diff --git a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h
index dff864bc58c..9cc2787697d 100644
--- a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h
+++ b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h
@@ -9,16 +9,16 @@
 #include <Processors/QueryPipeline.h>
 #include <Core/Defines.h>
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
 {
 
 /// A Storage that allows reading from a single MergeTree data part.
-class StorageFromMergeTreeDataPart final : public ext::shared_ptr_helper<StorageFromMergeTreeDataPart>, public IStorage
+class StorageFromMergeTreeDataPart final : public shared_ptr_helper<StorageFromMergeTreeDataPart>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageFromMergeTreeDataPart>;
+    friend struct shared_ptr_helper<StorageFromMergeTreeDataPart>;
 public:
     String getName() const override { return "FromMergeTreeDataPart"; }
 
diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
index 60f0ce313f8..369f4e9eca9 100644
--- a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
+++ b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp
@@ -279,7 +279,7 @@ void StorageRabbitMQ::initRabbitMQ()
     initExchange(rabbit_channel);
     bindExchange(rabbit_channel);
 
-    for (const auto i : ext::range(0, num_queues))
+    for (const auto i : collections::range(0, num_queues))
         bindQueue(i + 1, rabbit_channel);
 
     LOG_TRACE(log, "RabbitMQ setup completed");
diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.h b/src/Storages/RabbitMQ/StorageRabbitMQ.h
index 129e231e46a..1935dcaee0e 100644
--- a/src/Storages/RabbitMQ/StorageRabbitMQ.h
+++ b/src/Storages/RabbitMQ/StorageRabbitMQ.h
@@ -3,7 +3,7 @@
 #include <Core/BackgroundSchedulePool.h>
 #include <Storages/IStorage.h>
 #include <Poco/Semaphore.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <mutex>
 #include <atomic>
 #include <Storages/RabbitMQ/Buffer_fwd.h>
@@ -21,9 +21,9 @@ namespace DB
 
 using ChannelPtr = std::shared_ptr<AMQP::TcpChannel>;
 
-class StorageRabbitMQ final: public ext::shared_ptr_helper<StorageRabbitMQ>, public IStorage, WithContext
+class StorageRabbitMQ final: public shared_ptr_helper<StorageRabbitMQ>, public IStorage, WithContext
 {
-    friend struct ext::shared_ptr_helper<StorageRabbitMQ>;
+    friend struct shared_ptr_helper<StorageRabbitMQ>;
 
 public:
     std::string getName() const override { return "RabbitMQ"; }
diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.h b/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
index 64255392c35..aa81bc4d35f 100644
--- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
+++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <memory>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 
 
@@ -16,9 +16,9 @@ namespace DB
 
 class Context;
 
-class StorageEmbeddedRocksDB final : public ext::shared_ptr_helper<StorageEmbeddedRocksDB>, public IStorage
+class StorageEmbeddedRocksDB final : public shared_ptr_helper<StorageEmbeddedRocksDB>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageEmbeddedRocksDB>;
+    friend struct shared_ptr_helper<StorageEmbeddedRocksDB>;
     friend class EmbeddedRocksDBSource;
     friend class EmbeddedRocksDBBlockOutputStream;
     friend class EmbeddedRocksDBBlockInputStream;
diff --git a/src/Storages/StorageBuffer.cpp b/src/Storages/StorageBuffer.cpp
index 6aeb17a5727..55dc2d12c9d 100644
--- a/src/Storages/StorageBuffer.cpp
+++ b/src/Storages/StorageBuffer.cpp
@@ -21,7 +21,7 @@
 #include <Common/ProfileEvents.h>
 #include <common/logger_useful.h>
 #include <common/getThreadId.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <Processors/QueryPlan/ExpressionStep.h>
 #include <Processors/Transforms/FilterTransform.h>
 #include <Processors/Transforms/ExpressionTransform.h>
@@ -920,7 +920,7 @@ void StorageBuffer::writeBlockToDestination(const Block & block, StoragePtr tabl
     Block structure_of_destination_table = allow_materialized ? destination_metadata_snapshot->getSampleBlock()
                                                               : destination_metadata_snapshot->getSampleBlockNonMaterialized();
     Block block_to_write;
-    for (size_t i : ext::range(0, structure_of_destination_table.columns()))
+    for (size_t i : collections::range(0, structure_of_destination_table.columns()))
     {
         auto dst_col = structure_of_destination_table.getByPosition(i);
         if (block.has(dst_col.name))
diff --git a/src/Storages/StorageBuffer.h b/src/Storages/StorageBuffer.h
index d9cb22ef446..b4fcdf6cbc9 100644
--- a/src/Storages/StorageBuffer.h
+++ b/src/Storages/StorageBuffer.h
@@ -4,7 +4,7 @@
 #include <Core/NamesAndTypes.h>
 #include <DataStreams/IBlockOutputStream.h>
 #include <Storages/IStorage.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Poco/Event.h>
 
@@ -42,9 +42,9 @@ namespace DB
   * When you destroy a Buffer table, all remaining data is flushed to the subordinate table.
   * The data in the buffer is not replicated, not logged to disk, not indexed. With a rough restart of the server, the data is lost.
   */
-class StorageBuffer final : public ext::shared_ptr_helper<StorageBuffer>, public IStorage, WithContext
+class StorageBuffer final : public shared_ptr_helper<StorageBuffer>, public IStorage, WithContext
 {
-friend struct ext::shared_ptr_helper<StorageBuffer>;
+friend struct shared_ptr_helper<StorageBuffer>;
 friend class BufferSource;
 friend class BufferBlockOutputStream;
 
diff --git a/src/Storages/StorageDictionary.h b/src/Storages/StorageDictionary.h
index 9c92cd90d36..e2ba2964b1d 100644
--- a/src/Storages/StorageDictionary.h
+++ b/src/Storages/StorageDictionary.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <atomic>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Storages/IStorage.h>
 #include <Interpreters/IExternalLoaderConfigRepository.h>
@@ -12,9 +12,9 @@ namespace DB
 struct DictionaryStructure;
 class TableFunctionDictionary;
 
-class StorageDictionary final : public ext::shared_ptr_helper<StorageDictionary>, public IStorage, public WithContext
+class StorageDictionary final : public shared_ptr_helper<StorageDictionary>, public IStorage, public WithContext
 {
-    friend struct ext::shared_ptr_helper<StorageDictionary>;
+    friend struct shared_ptr_helper<StorageDictionary>;
     friend class TableFunctionDictionary;
 public:
     std::string getName() const override { return "Dictionary"; }
@@ -74,7 +74,7 @@ private:
     LoadablesConfigurationPtr configuration;
 
     std::atomic<bool> remove_repository_callback_executed = false;
-    ext::scope_guard remove_repository_callback;
+    scope_guard remove_repository_callback;
 
     void removeDictionaryConfigurationFromRepository();
 
diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp
index 4a70e31ff8d..c7703c481c3 100644
--- a/src/Storages/StorageDistributed.cpp
+++ b/src/Storages/StorageDistributed.cpp
@@ -709,7 +709,7 @@ QueryPipelinePtr StorageDistributed::distributedWrite(const ASTInsertQuery & que
     std::vector<std::unique_ptr<QueryPipeline>> pipelines;
 
     String new_query_str = queryToString(new_query);
-    for (size_t shard_index : ext::range(0, shards_info.size()))
+    for (size_t shard_index : collections::range(0, shards_info.size()))
     {
         const auto & shard_info = shards_info[shard_index];
         if (shard_info.isLocal())
diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h
index 9849ce7625c..c734b0f777e 100644
--- a/src/Storages/StorageDistributed.h
+++ b/src/Storages/StorageDistributed.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Storages/IStorage.h>
 #include <Storages/Distributed/DirectoryMonitor.h>
@@ -36,9 +36,9 @@ using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
   * You can pass one address, not several.
   * In this case, the table can be considered remote, rather than distributed.
   */
-class StorageDistributed final : public ext::shared_ptr_helper<StorageDistributed>, public IStorage, WithContext
+class StorageDistributed final : public shared_ptr_helper<StorageDistributed>, public IStorage, WithContext
 {
-    friend struct ext::shared_ptr_helper<StorageDistributed>;
+    friend struct shared_ptr_helper<StorageDistributed>;
     friend class DistributedBlockOutputStream;
     friend class StorageDistributedDirectoryMonitor;
     friend class StorageSystemDistributionQueue;
diff --git a/src/Storages/StorageExternalDistributed.h b/src/Storages/StorageExternalDistributed.h
index 00ec868b460..c85276c09dd 100644
--- a/src/Storages/StorageExternalDistributed.h
+++ b/src/Storages/StorageExternalDistributed.h
@@ -4,7 +4,7 @@
 #include "config_core.h"
 #endif
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 
 
@@ -16,9 +16,9 @@ namespace DB
 /// A query to external database is passed to one replica on each shard, the result is united.
 /// Replicas on each shard have the same priority, traversed replicas are moved to the end of the queue.
 /// TODO: try `load_balancing` setting for replicas priorities same way as for table function `remote`
-class StorageExternalDistributed final : public ext::shared_ptr_helper<StorageExternalDistributed>, public DB::IStorage
+class StorageExternalDistributed final : public shared_ptr_helper<StorageExternalDistributed>, public DB::IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageExternalDistributed>;
+    friend struct shared_ptr_helper<StorageExternalDistributed>;
 
 public:
     enum class ExternalStorageEngine
diff --git a/src/Storages/StorageFile.h b/src/Storages/StorageFile.h
index 91758931ed1..1626ce15b3a 100644
--- a/src/Storages/StorageFile.h
+++ b/src/Storages/StorageFile.h
@@ -5,7 +5,7 @@
 
 #include <atomic>
 #include <shared_mutex>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
@@ -14,9 +14,9 @@ namespace DB
 class StorageFileBlockInputStream;
 class StorageFileBlockOutputStream;
 
-class StorageFile final : public ext::shared_ptr_helper<StorageFile>, public IStorage
+class StorageFile final : public shared_ptr_helper<StorageFile>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageFile>;
+    friend struct shared_ptr_helper<StorageFile>;
 public:
     std::string getName() const override { return "File"; }
 
diff --git a/src/Storages/StorageGenerateRandom.h b/src/Storages/StorageGenerateRandom.h
index 4a4015ebc0d..61fd68cb80c 100644
--- a/src/Storages/StorageGenerateRandom.h
+++ b/src/Storages/StorageGenerateRandom.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <optional>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 
 
@@ -9,9 +9,9 @@ namespace DB
 {
 /* Generates random data for given schema.
  */
-class StorageGenerateRandom final : public ext::shared_ptr_helper<StorageGenerateRandom>, public IStorage
+class StorageGenerateRandom final : public shared_ptr_helper<StorageGenerateRandom>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageGenerateRandom>;
+    friend struct shared_ptr_helper<StorageGenerateRandom>;
 public:
     std::string getName() const override { return "GenerateRandom"; }
 
diff --git a/src/Storages/StorageInput.h b/src/Storages/StorageInput.h
index 106c22db385..4b04907bea2 100644
--- a/src/Storages/StorageInput.h
+++ b/src/Storages/StorageInput.h
@@ -1,16 +1,16 @@
 #pragma once
 
 #include <Storages/IStorage.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 namespace DB
 {
 /** Internal temporary storage for table function input(...)
   */
 
-class StorageInput final : public ext::shared_ptr_helper<StorageInput>, public IStorage
+class StorageInput final : public shared_ptr_helper<StorageInput>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageInput>;
+    friend struct shared_ptr_helper<StorageInput>;
 public:
     String getName() const override { return "Input"; }
 
diff --git a/src/Storages/StorageJoin.h b/src/Storages/StorageJoin.h
index 78d8b9768e9..cf28e9d4dd0 100644
--- a/src/Storages/StorageJoin.h
+++ b/src/Storages/StorageJoin.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Storages/StorageSet.h>
 #include <Storages/JoinSettings.h>
@@ -21,9 +21,9 @@ using HashJoinPtr = std::shared_ptr<HashJoin>;
   *
   * When using, JOIN must be of the appropriate type (ANY|ALL LEFT|INNER ...).
   */
-class StorageJoin final : public ext::shared_ptr_helper<StorageJoin>, public StorageSetOrJoinBase
+class StorageJoin final : public shared_ptr_helper<StorageJoin>, public StorageSetOrJoinBase
 {
-    friend struct ext::shared_ptr_helper<StorageJoin>;
+    friend struct shared_ptr_helper<StorageJoin>;
 public:
     String getName() const override { return "Join"; }
 
diff --git a/src/Storages/StorageLog.h b/src/Storages/StorageLog.h
index 20103f51479..6fea00edefd 100644
--- a/src/Storages/StorageLog.h
+++ b/src/Storages/StorageLog.h
@@ -2,7 +2,7 @@
 
 #include <map>
 #include <shared_mutex>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Disks/IDisk.h>
 #include <Storages/IStorage.h>
@@ -16,11 +16,11 @@ namespace DB
 /** Implements simple table engine without support of indices.
   * The data is stored in a compressed form.
   */
-class StorageLog final : public ext::shared_ptr_helper<StorageLog>, public IStorage
+class StorageLog final : public shared_ptr_helper<StorageLog>, public IStorage
 {
     friend class LogSource;
     friend class LogBlockOutputStream;
-    friend struct ext::shared_ptr_helper<StorageLog>;
+    friend struct shared_ptr_helper<StorageLog>;
 
 public:
     String getName() const override { return "Log"; }
diff --git a/src/Storages/StorageMaterializeMySQL.h b/src/Storages/StorageMaterializeMySQL.h
index 8a4b88cbbb4..45221ed5b76 100644
--- a/src/Storages/StorageMaterializeMySQL.h
+++ b/src/Storages/StorageMaterializeMySQL.h
@@ -16,9 +16,9 @@ namespace ErrorCodes
     extern const int NOT_IMPLEMENTED;
 }
 
-class StorageMaterializeMySQL final : public ext::shared_ptr_helper<StorageMaterializeMySQL>, public StorageProxy
+class StorageMaterializeMySQL final : public shared_ptr_helper<StorageMaterializeMySQL>, public StorageProxy
 {
-    friend struct ext::shared_ptr_helper<StorageMaterializeMySQL>;
+    friend struct shared_ptr_helper<StorageMaterializeMySQL>;
 public:
     String getName() const override { return "MaterializeMySQL"; }
 
diff --git a/src/Storages/StorageMaterializedView.h b/src/Storages/StorageMaterializedView.h
index 8e2b8bdc9f5..0f5bf724c2f 100644
--- a/src/Storages/StorageMaterializedView.h
+++ b/src/Storages/StorageMaterializedView.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Parsers/IAST_fwd.h>
 #include <Parsers/ASTSelectWithUnionQuery.h>
@@ -12,9 +12,9 @@
 namespace DB
 {
 
-class StorageMaterializedView final : public ext::shared_ptr_helper<StorageMaterializedView>, public IStorage, WithMutableContext
+class StorageMaterializedView final : public shared_ptr_helper<StorageMaterializedView>, public IStorage, WithMutableContext
 {
-    friend struct ext::shared_ptr_helper<StorageMaterializedView>;
+    friend struct shared_ptr_helper<StorageMaterializedView>;
 public:
     std::string getName() const override { return "MaterializedView"; }
     bool isView() const override { return true; }
diff --git a/src/Storages/StorageMemory.h b/src/Storages/StorageMemory.h
index e623f29e2e6..47f9a942b82 100644
--- a/src/Storages/StorageMemory.h
+++ b/src/Storages/StorageMemory.h
@@ -4,7 +4,7 @@
 #include <optional>
 #include <mutex>
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Core/NamesAndTypes.h>
 #include <Storages/IStorage.h>
@@ -20,10 +20,10 @@ namespace DB
   * It does not support keys.
   * Data is stored as a set of blocks and is not stored anywhere else.
   */
-class StorageMemory final : public ext::shared_ptr_helper<StorageMemory>, public IStorage
+class StorageMemory final : public shared_ptr_helper<StorageMemory>, public IStorage
 {
 friend class MemoryBlockOutputStream;
-friend struct ext::shared_ptr_helper<StorageMemory>;
+friend struct shared_ptr_helper<StorageMemory>;
 
 public:
     String getName() const override { return "Memory"; }
diff --git a/src/Storages/StorageMerge.cpp b/src/Storages/StorageMerge.cpp
index 15d520c13aa..46132020ab6 100644
--- a/src/Storages/StorageMerge.cpp
+++ b/src/Storages/StorageMerge.cpp
@@ -20,7 +20,7 @@
 #include <Common/typeid_cast.h>
 #include <Common/checkStackSize.h>
 #include <Databases/IDatabase.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <algorithm>
 #include <Parsers/queryToString.h>
 #include <Processors/Transforms/MaterializingTransform.h>
@@ -571,7 +571,7 @@ void StorageMerge::convertingSourceStream(
     if (!where_expression)
         return;
 
-    for (size_t column_index : ext::range(0, header.columns()))
+    for (size_t column_index : collections::range(0, header.columns()))
     {
         ColumnWithTypeAndName header_column = header.getByPosition(column_index);
         ColumnWithTypeAndName before_column = before_block_header.getByName(header_column.name);
diff --git a/src/Storages/StorageMerge.h b/src/Storages/StorageMerge.h
index b9d44bfa27e..2339716519c 100644
--- a/src/Storages/StorageMerge.h
+++ b/src/Storages/StorageMerge.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Common/OptimizedRegularExpression.h>
 #include <Storages/IStorage.h>
@@ -12,9 +12,9 @@ namespace DB
 /** A table that represents the union of an arbitrary number of other tables.
   * All tables must have the same structure.
   */
-class StorageMerge final : public ext::shared_ptr_helper<StorageMerge>, public IStorage, WithContext
+class StorageMerge final : public shared_ptr_helper<StorageMerge>, public IStorage, WithContext
 {
-    friend struct ext::shared_ptr_helper<StorageMerge>;
+    friend struct shared_ptr_helper<StorageMerge>;
 public:
     std::string getName() const override { return "Merge"; }
 
diff --git a/src/Storages/StorageMergeTree.h b/src/Storages/StorageMergeTree.h
index 72fbb37bdd9..45ea68e8a6f 100644
--- a/src/Storages/StorageMergeTree.h
+++ b/src/Storages/StorageMergeTree.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Core/Names.h>
 #include <Storages/AlterCommands.h>
@@ -24,9 +24,9 @@ namespace DB
 
 /** See the description of the data structure in MergeTreeData.
   */
-class StorageMergeTree final : public ext::shared_ptr_helper<StorageMergeTree>, public MergeTreeData
+class StorageMergeTree final : public shared_ptr_helper<StorageMergeTree>, public MergeTreeData
 {
-    friend struct ext::shared_ptr_helper<StorageMergeTree>;
+    friend struct shared_ptr_helper<StorageMergeTree>;
 public:
     void startup() override;
     void shutdown() override;
diff --git a/src/Storages/StorageMongoDB.h b/src/Storages/StorageMongoDB.h
index e5f60f59c1a..6caf6978f1c 100644
--- a/src/Storages/StorageMongoDB.h
+++ b/src/Storages/StorageMongoDB.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Storages/IStorage.h>
 
@@ -14,9 +14,9 @@ namespace DB
  * Read only.
  */
 
-class StorageMongoDB final : public ext::shared_ptr_helper<StorageMongoDB>, public IStorage
+class StorageMongoDB final : public shared_ptr_helper<StorageMongoDB>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageMongoDB>;
+    friend struct shared_ptr_helper<StorageMongoDB>;
 public:
     StorageMongoDB(
         const StorageID & table_id_,
diff --git a/src/Storages/StorageMySQL.h b/src/Storages/StorageMySQL.h
index 5eb9ed14524..2bcc7af5f2b 100644
--- a/src/Storages/StorageMySQL.h
+++ b/src/Storages/StorageMySQL.h
@@ -6,7 +6,7 @@
 
 #if USE_MYSQL
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Storages/IStorage.h>
 #include <Storages/MySQL/MySQLSettings.h>
@@ -20,9 +20,9 @@ namespace DB
   * Use ENGINE = mysql(host_port, database_name, table_name, user_name, password)
   * Read only.
   */
-class StorageMySQL final : public ext::shared_ptr_helper<StorageMySQL>, public IStorage, WithContext
+class StorageMySQL final : public shared_ptr_helper<StorageMySQL>, public IStorage, WithContext
 {
-    friend struct ext::shared_ptr_helper<StorageMySQL>;
+    friend struct shared_ptr_helper<StorageMySQL>;
 public:
     StorageMySQL(
         const StorageID & table_id_,
diff --git a/src/Storages/StorageNull.h b/src/Storages/StorageNull.h
index 85fae2cc470..c20937b2359 100644
--- a/src/Storages/StorageNull.h
+++ b/src/Storages/StorageNull.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Core/NamesAndTypes.h>
 #include <Storages/IStorage.h>
@@ -15,9 +15,9 @@ namespace DB
 /** When writing, does nothing.
   * When reading, returns nothing.
   */
-class StorageNull final : public ext::shared_ptr_helper<StorageNull>, public IStorage
+class StorageNull final : public shared_ptr_helper<StorageNull>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageNull>;
+    friend struct shared_ptr_helper<StorageNull>;
 public:
     std::string getName() const override { return "Null"; }
 
diff --git a/src/Storages/StoragePostgreSQL.cpp b/src/Storages/StoragePostgreSQL.cpp
index 1d863a43b29..9f59ddb12c9 100644
--- a/src/Storages/StoragePostgreSQL.cpp
+++ b/src/Storages/StoragePostgreSQL.cpp
@@ -100,40 +100,35 @@ public:
     explicit PostgreSQLBlockOutputStream(
         const StorageMetadataPtr & metadata_snapshot_,
         postgres::ConnectionHolderPtr connection_holder_,
-        const std::string & remote_table_name_)
+        const String & remote_table_name_,
+        const String & remote_table_schema_)
         : metadata_snapshot(metadata_snapshot_)
         , connection_holder(std::move(connection_holder_))
         , remote_table_name(remote_table_name_)
+        , remote_table_schema(remote_table_schema_)
     {
     }
 
     Block getHeader() const override { return metadata_snapshot->getSampleBlock(); }
 
-
-    void writePrefix() override
-    {
-        work = std::make_unique<pqxx::work>(connection_holder->get());
-    }
-
-
     void write(const Block & block) override
     {
-        if (!work)
-            return;
+        if (!inserter)
+            inserter = std::make_unique<StreamTo>(connection_holder->get(),
+                                                  remote_table_schema.empty() ? pqxx::table_path({remote_table_name})
+                                                                              : pqxx::table_path({remote_table_schema, remote_table_name}),
+                                                  block.getNames());
 
         const auto columns = block.getColumns();
         const size_t num_rows = block.rows(), num_cols = block.columns();
         const auto data_types = block.getDataTypes();
 
-        if (!stream_inserter)
-            stream_inserter = std::make_unique<pqxx::stream_to>(*work, remote_table_name, block.getNames());
-
         /// std::optional lets libpqxx to know if value is NULL
         std::vector<std::optional<std::string>> row(num_cols);
 
-        for (const auto i : ext::range(0, num_rows))
+        for (const auto i : collections::range(0, num_rows))
         {
-            for (const auto j : ext::range(0, num_cols))
+            for (const auto j : collections::range(0, num_cols))
             {
                 if (columns[j]->isNullAt(i))
                 {
@@ -156,21 +151,16 @@ public:
                 }
             }
 
-            stream_inserter->write_values(row);
+            inserter->stream.write_values(row);
         }
     }
 
-
     void writeSuffix() override
     {
-        if (stream_inserter)
-        {
-            stream_inserter->complete();
-            work->commit();
-        }
+        if (inserter)
+            inserter->complete();
     }
 
-
     /// Cannot just use serializeAsText for array data type even though it converts perfectly
     /// any dimension number array into text format, because it incloses in '[]' and for postgres it must be '{}'.
     /// Check if array[...] syntax from PostgreSQL will be applicable.
@@ -207,7 +197,6 @@ public:
         writeChar('}', ostr);
     }
 
-
     /// Conversion is done via column casting because with writeText(Array..) got incorrect conversion
     /// of Date and DateTime data types and it added extra quotes for values inside array.
     static std::string clickhouseToPostgresArray(const Array & array_field, const DataTypePtr & data_type)
@@ -223,7 +212,6 @@ public:
         return '{' + std::string(ostr.str().begin() + 1, ostr.str().end() - 1) + '}';
     }
 
-
     static MutableColumnPtr createNested(DataTypePtr nested)
     {
         bool is_nullable = false;
@@ -275,21 +263,38 @@ public:
         return nested_column;
     }
 
-
 private:
+    struct StreamTo
+    {
+        pqxx::work tx;
+        Names columns;
+        pqxx::stream_to stream;
+
+        StreamTo(pqxx::connection & connection, pqxx::table_path table_, Names columns_)
+            : tx(connection)
+            , columns(std::move(columns_))
+            , stream(pqxx::stream_to::raw_table(tx, connection.quote_table(table_), connection.quote_columns(columns)))
+        {
+        }
+
+        void complete()
+        {
+            stream.complete();
+            tx.commit();
+        }
+    };
+
     StorageMetadataPtr metadata_snapshot;
     postgres::ConnectionHolderPtr connection_holder;
-    std::string remote_table_name;
-
-    std::unique_ptr<pqxx::work> work;
-    std::unique_ptr<pqxx::stream_to> stream_inserter;
+    const String remote_table_name, remote_table_schema;
+    std::unique_ptr<StreamTo> inserter;
 };
 
 
 BlockOutputStreamPtr StoragePostgreSQL::write(
         const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr /* context */)
 {
-    return std::make_shared<PostgreSQLBlockOutputStream>(metadata_snapshot, pool->get(), remote_table_name);
+    return std::make_shared<PostgreSQLBlockOutputStream>(metadata_snapshot, pool->get(), remote_table_name, remote_table_schema);
 }
 
 
diff --git a/src/Storages/StoragePostgreSQL.h b/src/Storages/StoragePostgreSQL.h
index 76e10bebf67..d1f86dd50ef 100644
--- a/src/Storages/StoragePostgreSQL.h
+++ b/src/Storages/StoragePostgreSQL.h
@@ -5,7 +5,7 @@
 #endif
 
 #if USE_LIBPQXX
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Interpreters/Context.h>
 #include <Storages/IStorage.h>
 #include <DataStreams/IBlockOutputStream.h>
@@ -16,9 +16,9 @@ namespace DB
 {
 
 
-class StoragePostgreSQL final : public ext::shared_ptr_helper<StoragePostgreSQL>, public IStorage
+class StoragePostgreSQL final : public shared_ptr_helper<StoragePostgreSQL>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StoragePostgreSQL>;
+    friend struct shared_ptr_helper<StoragePostgreSQL>;
 public:
     StoragePostgreSQL(
         const StorageID & table_id_,
diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp
index e49e8aa7bb1..c11f1580a2e 100644
--- a/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/src/Storages/StorageReplicatedMergeTree.cpp
@@ -59,9 +59,9 @@
 
 #include <Poco/DirectoryIterator.h>
 
-#include <ext/range.h>
-#include <ext/scope_guard.h>
-#include <ext/scope_guard_safe.h>
+#include <common/range.h>
+#include <common/scope_guard.h>
+#include <common/scope_guard_safe.h>
 
 #include <ctime>
 #include <thread>
diff --git a/src/Storages/StorageReplicatedMergeTree.h b/src/Storages/StorageReplicatedMergeTree.h
index 2ae19387ee8..505eb4e87c4 100644
--- a/src/Storages/StorageReplicatedMergeTree.h
+++ b/src/Storages/StorageReplicatedMergeTree.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <atomic>
 #include <pcg_random.hpp>
 #include <Storages/IStorage.h>
@@ -80,9 +80,9 @@ namespace DB
   * as the time will take the time of creation the appropriate part on any of the replicas.
   */
 
-class StorageReplicatedMergeTree final : public ext::shared_ptr_helper<StorageReplicatedMergeTree>, public MergeTreeData
+class StorageReplicatedMergeTree final : public shared_ptr_helper<StorageReplicatedMergeTree>, public MergeTreeData
 {
-    friend struct ext::shared_ptr_helper<StorageReplicatedMergeTree>;
+    friend struct shared_ptr_helper<StorageReplicatedMergeTree>;
 public:
     void startup() override;
     void shutdown() override;
diff --git a/src/Storages/StorageS3.h b/src/Storages/StorageS3.h
index 6498e7f0a05..73becc2aa57 100644
--- a/src/Storages/StorageS3.h
+++ b/src/Storages/StorageS3.h
@@ -14,7 +14,7 @@
 #include <Processors/Sources/SourceWithProgress.h>
 #include <Poco/URI.h>
 #include <common/logger_useful.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <IO/S3Common.h>
 #include <IO/CompressionMethod.h>
 #include <Interpreters/Context.h>
@@ -94,7 +94,7 @@ private:
  * It sends HTTP GET to server when select is called and
  * HTTP PUT when insert is called.
  */
-class StorageS3 : public ext::shared_ptr_helper<StorageS3>, public IStorage, WithContext
+class StorageS3 : public shared_ptr_helper<StorageS3>, public IStorage, WithContext
 {
 public:
     StorageS3(
diff --git a/src/Storages/StorageS3Cluster.h b/src/Storages/StorageS3Cluster.h
index a2d7c63e7b6..8da1ed120ae 100644
--- a/src/Storages/StorageS3Cluster.h
+++ b/src/Storages/StorageS3Cluster.h
@@ -6,15 +6,16 @@
 
 #if USE_AWS_S3
 
+#include <memory>
+#include <optional>
+
+#include <common/shared_ptr_helper.h>
+
 #include "Client/Connection.h"
 #include <Interpreters/Cluster.h>
 #include <IO/S3Common.h>
 #include <Storages/StorageS3.h>
 
-#include <memory>
-#include <optional>
-#include "ext/shared_ptr_helper.h"
-
 namespace DB
 {
 
@@ -27,9 +28,9 @@ struct ClientAuthentificationBuilder
     UInt64 max_connections;
 };
 
-class StorageS3Cluster : public ext::shared_ptr_helper<StorageS3Cluster>, public IStorage
+class StorageS3Cluster : public shared_ptr_helper<StorageS3Cluster>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageS3Cluster>;
+    friend struct shared_ptr_helper<StorageS3Cluster>;
 public:
     std::string getName() const override { return "S3Cluster"; }
 
diff --git a/src/Storages/StorageSet.h b/src/Storages/StorageSet.h
index 5dd497527a9..90b4a00d915 100644
--- a/src/Storages/StorageSet.h
+++ b/src/Storages/StorageSet.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Interpreters/Context.h>
 #include <Storages/IStorage.h>
@@ -63,9 +63,9 @@ private:
   *  and also written to a file-backup, for recovery after a restart.
   * Reading from the table is not possible directly - it is possible to specify only the right part of the IN statement.
   */
-class StorageSet final : public ext::shared_ptr_helper<StorageSet>, public StorageSetOrJoinBase
+class StorageSet final : public shared_ptr_helper<StorageSet>, public StorageSetOrJoinBase
 {
-friend struct ext::shared_ptr_helper<StorageSet>;
+friend struct shared_ptr_helper<StorageSet>;
 
 public:
     String getName() const override { return "Set"; }
diff --git a/src/Storages/StorageStripeLog.h b/src/Storages/StorageStripeLog.h
index 21dbbd4bae8..0749273043f 100644
--- a/src/Storages/StorageStripeLog.h
+++ b/src/Storages/StorageStripeLog.h
@@ -3,7 +3,7 @@
 #include <map>
 #include <shared_mutex>
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Core/Defines.h>
 #include <Storages/IStorage.h>
@@ -16,11 +16,11 @@ namespace DB
 /** Implements a table engine that is suitable for small chunks of the log.
   * In doing so, stores all the columns in a single Native file, with a nearby index.
   */
-class StorageStripeLog final : public ext::shared_ptr_helper<StorageStripeLog>, public IStorage
+class StorageStripeLog final : public shared_ptr_helper<StorageStripeLog>, public IStorage
 {
     friend class StripeLogSource;
     friend class StripeLogBlockOutputStream;
-    friend struct ext::shared_ptr_helper<StorageStripeLog>;
+    friend struct shared_ptr_helper<StorageStripeLog>;
 
 public:
     String getName() const override { return "StripeLog"; }
diff --git a/src/Storages/StorageTinyLog.h b/src/Storages/StorageTinyLog.h
index 72cf1ce7e2e..71763a6403e 100644
--- a/src/Storages/StorageTinyLog.h
+++ b/src/Storages/StorageTinyLog.h
@@ -2,7 +2,7 @@
 
 #include <map>
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 #include <Core/Defines.h>
 #include <Storages/IStorage.h>
@@ -15,11 +15,11 @@ namespace DB
 /** Implements a table engine that is suitable for small chunks of the log.
   * It differs from StorageLog in the absence of mark files.
   */
-class StorageTinyLog final : public ext::shared_ptr_helper<StorageTinyLog>, public IStorage
+class StorageTinyLog final : public shared_ptr_helper<StorageTinyLog>, public IStorage
 {
     friend class TinyLogSource;
     friend class TinyLogBlockOutputStream;
-    friend struct ext::shared_ptr_helper<StorageTinyLog>;
+    friend struct shared_ptr_helper<StorageTinyLog>;
 
 public:
     String getName() const override { return "TinyLog"; }
diff --git a/src/Storages/StorageURL.h b/src/Storages/StorageURL.h
index e1aa1735936..78306292044 100644
--- a/src/Storages/StorageURL.h
+++ b/src/Storages/StorageURL.h
@@ -2,7 +2,7 @@
 
 #include <Storages/IStorage.h>
 #include <Poco/URI.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <DataStreams/IBlockOutputStream.h>
 #include <Formats/FormatSettings.h>
 #include <IO/CompressionMethod.h>
@@ -104,9 +104,9 @@ private:
     BlockOutputStreamPtr writer;
 };
 
-class StorageURL : public ext::shared_ptr_helper<StorageURL>, public IStorageURLBase
+class StorageURL : public shared_ptr_helper<StorageURL>, public IStorageURLBase
 {
-    friend struct ext::shared_ptr_helper<StorageURL>;
+    friend struct shared_ptr_helper<StorageURL>;
 public:
     StorageURL(
         const Poco::URI & uri_,
diff --git a/src/Storages/StorageValues.h b/src/Storages/StorageValues.h
index 6ae33ed70f1..4d6d168441c 100644
--- a/src/Storages/StorageValues.h
+++ b/src/Storages/StorageValues.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 
 
@@ -9,9 +9,9 @@ namespace DB
 /* One block storage used for values table function
  * It's structure is similar to IStorageSystemOneBlock
  */
-class StorageValues final : public ext::shared_ptr_helper<StorageValues>, public IStorage
+class StorageValues final : public shared_ptr_helper<StorageValues>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageValues>;
+    friend struct shared_ptr_helper<StorageValues>;
 public:
     std::string getName() const override { return "Values"; }
 
diff --git a/src/Storages/StorageView.h b/src/Storages/StorageView.h
index b5b8ae2dd8e..35e2c21265a 100644
--- a/src/Storages/StorageView.h
+++ b/src/Storages/StorageView.h
@@ -4,15 +4,15 @@
 #include <Parsers/IAST_fwd.h>
 #include <Storages/IStorage.h>
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
 {
 
-class StorageView final : public ext::shared_ptr_helper<StorageView>, public IStorage
+class StorageView final : public shared_ptr_helper<StorageView>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageView>;
+    friend struct shared_ptr_helper<StorageView>;
 public:
     std::string getName() const override { return "View"; }
     bool isView() const override { return true; }
diff --git a/src/Storages/System/IStorageSystemOneBlock.h b/src/Storages/System/IStorageSystemOneBlock.h
index fdc966130ad..0fe9ca94972 100644
--- a/src/Storages/System/IStorageSystemOneBlock.h
+++ b/src/Storages/System/IStorageSystemOneBlock.h
@@ -2,7 +2,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <Storages/ColumnsDescription.h>
 #include <Storages/IStorage.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Processors/Sources/SourceFromSingleChunk.h>
 #include <Processors/Pipe.h>
 
diff --git a/src/Storages/System/StorageSystemAggregateFunctionCombinators.h b/src/Storages/System/StorageSystemAggregateFunctionCombinators.h
index a978bfbface..0528dc76ff5 100644
--- a/src/Storages/System/StorageSystemAggregateFunctionCombinators.h
+++ b/src/Storages/System/StorageSystemAggregateFunctionCombinators.h
@@ -3,14 +3,14 @@
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 namespace DB
 {
-class StorageSystemAggregateFunctionCombinators final : public ext::shared_ptr_helper<StorageSystemAggregateFunctionCombinators>,
+class StorageSystemAggregateFunctionCombinators final : public shared_ptr_helper<StorageSystemAggregateFunctionCombinators>,
                                                   public IStorageSystemOneBlock<StorageSystemAggregateFunctionCombinators>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemAggregateFunctionCombinators>;
+    friend struct shared_ptr_helper<StorageSystemAggregateFunctionCombinators>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemAsynchronousMetrics.h b/src/Storages/System/StorageSystemAsynchronousMetrics.h
index eee029bbe51..d28ddc545d9 100644
--- a/src/Storages/System/StorageSystemAsynchronousMetrics.h
+++ b/src/Storages/System/StorageSystemAsynchronousMetrics.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 namespace DB
@@ -12,10 +12,10 @@ class Context;
 
 /** Implements system table asynchronous_metrics, which allows to get values of periodically (asynchronously) updated metrics.
   */
-class StorageSystemAsynchronousMetrics final : public ext::shared_ptr_helper<StorageSystemAsynchronousMetrics>,
+class StorageSystemAsynchronousMetrics final : public shared_ptr_helper<StorageSystemAsynchronousMetrics>,
     public IStorageSystemOneBlock<StorageSystemAsynchronousMetrics>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemAsynchronousMetrics>;
+    friend struct shared_ptr_helper<StorageSystemAsynchronousMetrics>;
 public:
     std::string getName() const override { return "SystemAsynchronousMetrics"; }
 
diff --git a/src/Storages/System/StorageSystemBuildOptions.h b/src/Storages/System/StorageSystemBuildOptions.h
index 8a22a3dcb45..e0792b64ef6 100644
--- a/src/Storages/System/StorageSystemBuildOptions.h
+++ b/src/Storages/System/StorageSystemBuildOptions.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** System table "build_options" with many params used for clickhouse building
   */
-class StorageSystemBuildOptions final : public ext::shared_ptr_helper<StorageSystemBuildOptions>, public IStorageSystemOneBlock<StorageSystemBuildOptions>
+class StorageSystemBuildOptions final : public shared_ptr_helper<StorageSystemBuildOptions>, public IStorageSystemOneBlock<StorageSystemBuildOptions>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemBuildOptions>;
+    friend struct shared_ptr_helper<StorageSystemBuildOptions>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemClusters.h b/src/Storages/System/StorageSystemClusters.h
index 81aefaff1c4..c2eb6a5e02d 100644
--- a/src/Storages/System/StorageSystemClusters.h
+++ b/src/Storages/System/StorageSystemClusters.h
@@ -2,7 +2,7 @@
 
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypesNumber.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -16,9 +16,9 @@ class Cluster;
   *  that allows to obtain information about available clusters
   *  (which may be specified in Distributed tables).
   */
-class StorageSystemClusters final : public ext::shared_ptr_helper<StorageSystemClusters>, public IStorageSystemOneBlock<StorageSystemClusters>
+class StorageSystemClusters final : public shared_ptr_helper<StorageSystemClusters>, public IStorageSystemOneBlock<StorageSystemClusters>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemClusters>;
+    friend struct shared_ptr_helper<StorageSystemClusters>;
 public:
     std::string getName() const override { return "SystemClusters"; }
 
diff --git a/src/Storages/System/StorageSystemCollations.h b/src/Storages/System/StorageSystemCollations.h
index 454fd968511..51e0e456586 100644
--- a/src/Storages/System/StorageSystemCollations.h
+++ b/src/Storages/System/StorageSystemCollations.h
@@ -1,14 +1,14 @@
 #pragma once
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 namespace DB
 {
 
-class StorageSystemCollations final : public ext::shared_ptr_helper<StorageSystemCollations>,
+class StorageSystemCollations final : public shared_ptr_helper<StorageSystemCollations>,
                                 public IStorageSystemOneBlock<StorageSystemCollations>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemCollations>;
+    friend struct shared_ptr_helper<StorageSystemCollations>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemColumns.h b/src/Storages/System/StorageSystemColumns.h
index 5cd8c5b38fd..015b8627c4b 100644
--- a/src/Storages/System/StorageSystemColumns.h
+++ b/src/Storages/System/StorageSystemColumns.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -11,9 +11,9 @@ class Context;
 
 /** Implements system table 'columns', that allows to get information about columns for every table.
   */
-class StorageSystemColumns final : public ext::shared_ptr_helper<StorageSystemColumns>, public IStorage
+class StorageSystemColumns final : public shared_ptr_helper<StorageSystemColumns>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemColumns>;
+    friend struct shared_ptr_helper<StorageSystemColumns>;
 public:
     std::string getName() const override { return "SystemColumns"; }
 
diff --git a/src/Storages/System/StorageSystemContributors.h b/src/Storages/System/StorageSystemContributors.h
index c4a50263c5b..d25fa7aa933 100644
--- a/src/Storages/System/StorageSystemContributors.h
+++ b/src/Storages/System/StorageSystemContributors.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
@@ -11,10 +11,10 @@ class Context;
 
 /** System table "contributors" with list of clickhouse contributors
   */
-class StorageSystemContributors final : public ext::shared_ptr_helper<StorageSystemContributors>,
+class StorageSystemContributors final : public shared_ptr_helper<StorageSystemContributors>,
                                   public IStorageSystemOneBlock<StorageSystemContributors>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemContributors>;
+    friend struct shared_ptr_helper<StorageSystemContributors>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemCurrentRoles.h b/src/Storages/System/StorageSystemCurrentRoles.h
index 77ab95547fa..d3e21290290 100644
--- a/src/Storages/System/StorageSystemCurrentRoles.h
+++ b/src/Storages/System/StorageSystemCurrentRoles.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `current_roles` system table, which allows you to get information about current roles.
-class StorageSystemCurrentRoles final : public ext::shared_ptr_helper<StorageSystemCurrentRoles>, public IStorageSystemOneBlock<StorageSystemCurrentRoles>
+class StorageSystemCurrentRoles final : public shared_ptr_helper<StorageSystemCurrentRoles>, public IStorageSystemOneBlock<StorageSystemCurrentRoles>
 {
 public:
     std::string getName() const override { return "SystemCurrentRoles"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemCurrentRoles>;
+    friend struct shared_ptr_helper<StorageSystemCurrentRoles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemDDLWorkerQueue.h b/src/Storages/System/StorageSystemDDLWorkerQueue.h
index d1afa2d546a..891ba4db509 100644
--- a/src/Storages/System/StorageSystemDDLWorkerQueue.h
+++ b/src/Storages/System/StorageSystemDDLWorkerQueue.h
@@ -5,7 +5,7 @@
 
 #include <Interpreters/DDLWorker.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
@@ -15,10 +15,10 @@ class Context;
 
 /** System table "distributed_ddl_queue" with list of queries that are currently in the DDL worker queue.
   */
-class StorageSystemDDLWorkerQueue final : public ext::shared_ptr_helper<StorageSystemDDLWorkerQueue>,
+class StorageSystemDDLWorkerQueue final : public shared_ptr_helper<StorageSystemDDLWorkerQueue>,
                                           public IStorageSystemOneBlock<StorageSystemDDLWorkerQueue>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemDDLWorkerQueue>;
+    friend struct shared_ptr_helper<StorageSystemDDLWorkerQueue>;
     Poco::Util::LayeredConfiguration & config = Poco::Util::Application::instance().config();
 
 protected:
diff --git a/src/Storages/System/StorageSystemDataTypeFamilies.h b/src/Storages/System/StorageSystemDataTypeFamilies.h
index 4de2ed99252..0cc347467c2 100644
--- a/src/Storages/System/StorageSystemDataTypeFamilies.h
+++ b/src/Storages/System/StorageSystemDataTypeFamilies.h
@@ -1,15 +1,15 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 namespace DB
 {
 
-class StorageSystemDataTypeFamilies final : public ext::shared_ptr_helper<StorageSystemDataTypeFamilies>,
+class StorageSystemDataTypeFamilies final : public shared_ptr_helper<StorageSystemDataTypeFamilies>,
                                       public IStorageSystemOneBlock<StorageSystemDataTypeFamilies>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemDataTypeFamilies>;
+    friend struct shared_ptr_helper<StorageSystemDataTypeFamilies>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemDatabases.h b/src/Storages/System/StorageSystemDatabases.h
index 33f91fee837..3d0ff9da6cd 100644
--- a/src/Storages/System/StorageSystemDatabases.h
+++ b/src/Storages/System/StorageSystemDatabases.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements `databases` system table, which allows you to get information about all databases.
   */
-class StorageSystemDatabases final : public ext::shared_ptr_helper<StorageSystemDatabases>, public IStorageSystemOneBlock<StorageSystemDatabases>
+class StorageSystemDatabases final : public shared_ptr_helper<StorageSystemDatabases>, public IStorageSystemOneBlock<StorageSystemDatabases>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemDatabases>;
+    friend struct shared_ptr_helper<StorageSystemDatabases>;
 public:
     std::string getName() const override
     {
diff --git a/src/Storages/System/StorageSystemDetachedParts.cpp b/src/Storages/System/StorageSystemDetachedParts.cpp
index 56644620f97..1a9418485e5 100644
--- a/src/Storages/System/StorageSystemDetachedParts.cpp
+++ b/src/Storages/System/StorageSystemDetachedParts.cpp
@@ -3,7 +3,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeNullable.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 #include <Storages/System/StorageSystemPartsBase.h>
 #include <Processors/Sources/SourceFromSingleChunk.h>
diff --git a/src/Storages/System/StorageSystemDetachedParts.h b/src/Storages/System/StorageSystemDetachedParts.h
index 18a6f5576d6..9350e758d93 100644
--- a/src/Storages/System/StorageSystemDetachedParts.h
+++ b/src/Storages/System/StorageSystemDetachedParts.h
@@ -12,10 +12,10 @@ namespace DB
   * column and column aliases which we don't need.
   */
 class StorageSystemDetachedParts final :
-        public ext::shared_ptr_helper<StorageSystemDetachedParts>,
+        public shared_ptr_helper<StorageSystemDetachedParts>,
         public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemDetachedParts>;
+    friend struct shared_ptr_helper<StorageSystemDetachedParts>;
 public:
     std::string getName() const override { return "SystemDetachedParts"; }
 
diff --git a/src/Storages/System/StorageSystemDictionaries.cpp b/src/Storages/System/StorageSystemDictionaries.cpp
index eb313f93a25..5a4e54a9e7f 100644
--- a/src/Storages/System/StorageSystemDictionaries.cpp
+++ b/src/Storages/System/StorageSystemDictionaries.cpp
@@ -15,7 +15,7 @@
 #include <Columns/ColumnString.h>
 #include <Core/Names.h>
 
-#include <ext/map.h>
+#include <common/map.h>
 #include <mutex>
 
 namespace DB
@@ -99,15 +99,15 @@ void StorageSystemDictionaries::fillData(MutableColumns & res_columns, ContextPt
         else
             res_columns[i++]->insertDefault();
 
-        res_columns[i++]->insert(ext::map<Array>(dictionary_structure.getKeysNames(), [] (auto & name) { return name; }));
+        res_columns[i++]->insert(collections::map<Array>(dictionary_structure.getKeysNames(), [] (auto & name) { return name; }));
 
         if (dictionary_structure.id)
             res_columns[i++]->insert(Array({"UInt64"}));
         else
-            res_columns[i++]->insert(ext::map<Array>(*dictionary_structure.key, [] (auto & attr) { return attr.type->getName(); }));
+            res_columns[i++]->insert(collections::map<Array>(*dictionary_structure.key, [] (auto & attr) { return attr.type->getName(); }));
 
-        res_columns[i++]->insert(ext::map<Array>(dictionary_structure.attributes, [] (auto & attr) { return attr.name; }));
-        res_columns[i++]->insert(ext::map<Array>(dictionary_structure.attributes, [] (auto & attr) { return attr.type->getName(); }));
+        res_columns[i++]->insert(collections::map<Array>(dictionary_structure.attributes, [] (auto & attr) { return attr.name; }));
+        res_columns[i++]->insert(collections::map<Array>(dictionary_structure.attributes, [] (auto & attr) { return attr.type->getName(); }));
 
         if (dict_ptr)
         {
diff --git a/src/Storages/System/StorageSystemDictionaries.h b/src/Storages/System/StorageSystemDictionaries.h
index aa65a946127..b144445a3b4 100644
--- a/src/Storages/System/StorageSystemDictionaries.h
+++ b/src/Storages/System/StorageSystemDictionaries.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -10,9 +10,9 @@ namespace DB
 class Context;
 
 
-class StorageSystemDictionaries final : public ext::shared_ptr_helper<StorageSystemDictionaries>, public IStorageSystemOneBlock<StorageSystemDictionaries>
+class StorageSystemDictionaries final : public shared_ptr_helper<StorageSystemDictionaries>, public IStorageSystemOneBlock<StorageSystemDictionaries>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemDictionaries>;
+    friend struct shared_ptr_helper<StorageSystemDictionaries>;
 public:
     std::string getName() const override { return "SystemDictionaries"; }
 
diff --git a/src/Storages/System/StorageSystemDisks.h b/src/Storages/System/StorageSystemDisks.h
index fa0f6fe4b8a..1274903ff00 100644
--- a/src/Storages/System/StorageSystemDisks.h
+++ b/src/Storages/System/StorageSystemDisks.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Formats/FormatSettings.h>
 #include <Storages/IStorage.h>
 #include <Storages/MergeTree/MergeTreeData.h>
@@ -14,9 +14,9 @@ class Context;
 
 /** Implements the system table `disks`, which allows you to get information about all disks.
 */
-class StorageSystemDisks final : public ext::shared_ptr_helper<StorageSystemDisks>, public IStorage
+class StorageSystemDisks final : public shared_ptr_helper<StorageSystemDisks>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemDisks>;
+    friend struct shared_ptr_helper<StorageSystemDisks>;
 public:
     std::string getName() const override { return "SystemDisks"; }
 
diff --git a/src/Storages/System/StorageSystemDistributionQueue.h b/src/Storages/System/StorageSystemDistributionQueue.h
index 9314418d242..cb2812a5aab 100644
--- a/src/Storages/System/StorageSystemDistributionQueue.h
+++ b/src/Storages/System/StorageSystemDistributionQueue.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements the `distribution_queue` system table, which allows you to view the INSERT queues for the Distributed tables.
   */
-class StorageSystemDistributionQueue final : public ext::shared_ptr_helper<StorageSystemDistributionQueue>, public IStorageSystemOneBlock<StorageSystemDistributionQueue>
+class StorageSystemDistributionQueue final : public shared_ptr_helper<StorageSystemDistributionQueue>, public IStorageSystemOneBlock<StorageSystemDistributionQueue>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemDistributionQueue>;
+    friend struct shared_ptr_helper<StorageSystemDistributionQueue>;
 public:
     std::string getName() const override { return "SystemDistributionQueue"; }
 
diff --git a/src/Storages/System/StorageSystemEnabledRoles.h b/src/Storages/System/StorageSystemEnabledRoles.h
index 13b0533b790..2c385d40c85 100644
--- a/src/Storages/System/StorageSystemEnabledRoles.h
+++ b/src/Storages/System/StorageSystemEnabledRoles.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `enabled_roles` system table, which allows you to get information about enabled roles.
-class StorageSystemEnabledRoles final : public ext::shared_ptr_helper<StorageSystemEnabledRoles>, public IStorageSystemOneBlock<StorageSystemEnabledRoles>
+class StorageSystemEnabledRoles final : public shared_ptr_helper<StorageSystemEnabledRoles>, public IStorageSystemOneBlock<StorageSystemEnabledRoles>
 {
 public:
     std::string getName() const override { return "SystemEnabledRoles"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemEnabledRoles>;
+    friend struct shared_ptr_helper<StorageSystemEnabledRoles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemErrors.h b/src/Storages/System/StorageSystemErrors.h
index ff3af11d251..114a138e907 100644
--- a/src/Storages/System/StorageSystemErrors.h
+++ b/src/Storages/System/StorageSystemErrors.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -14,9 +14,9 @@ class Context;
  * Implements the `errors` system table, which shows the error code and the number of times it happens
  * (i.e. Exception with this code had been thrown).
  */
-class StorageSystemErrors final : public ext::shared_ptr_helper<StorageSystemErrors>, public IStorageSystemOneBlock<StorageSystemErrors>
+class StorageSystemErrors final : public shared_ptr_helper<StorageSystemErrors>, public IStorageSystemOneBlock<StorageSystemErrors>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemErrors>;
+    friend struct shared_ptr_helper<StorageSystemErrors>;
 public:
     std::string getName() const override { return "SystemErrors"; }
 
diff --git a/src/Storages/System/StorageSystemEvents.h b/src/Storages/System/StorageSystemEvents.h
index 6071cb7b2b3..b94833d09e2 100644
--- a/src/Storages/System/StorageSystemEvents.h
+++ b/src/Storages/System/StorageSystemEvents.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 namespace DB
@@ -11,9 +11,9 @@ class Context;
 
 /** Implements `events` system table, which allows you to obtain information for profiling.
   */
-class StorageSystemEvents final : public ext::shared_ptr_helper<StorageSystemEvents>, public IStorageSystemOneBlock<StorageSystemEvents>
+class StorageSystemEvents final : public shared_ptr_helper<StorageSystemEvents>, public IStorageSystemOneBlock<StorageSystemEvents>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemEvents>;
+    friend struct shared_ptr_helper<StorageSystemEvents>;
 public:
     std::string getName() const override { return "SystemEvents"; }
 
diff --git a/src/Storages/System/StorageSystemFormats.h b/src/Storages/System/StorageSystemFormats.h
index ed65cd2af88..0db47496107 100644
--- a/src/Storages/System/StorageSystemFormats.h
+++ b/src/Storages/System/StorageSystemFormats.h
@@ -1,13 +1,13 @@
 #pragma once
 
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 namespace DB
 {
-class StorageSystemFormats final : public ext::shared_ptr_helper<StorageSystemFormats>, public IStorageSystemOneBlock<StorageSystemFormats>
+class StorageSystemFormats final : public shared_ptr_helper<StorageSystemFormats>, public IStorageSystemOneBlock<StorageSystemFormats>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemFormats>;
+    friend struct shared_ptr_helper<StorageSystemFormats>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemFunctions.h b/src/Storages/System/StorageSystemFunctions.h
index 62942721995..9781d5a7f12 100644
--- a/src/Storages/System/StorageSystemFunctions.h
+++ b/src/Storages/System/StorageSystemFunctions.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -13,9 +13,9 @@ class Context;
 /** Implements `functions`system table, which allows you to get a list
   * all normal and aggregate functions.
   */
-class StorageSystemFunctions final : public ext::shared_ptr_helper<StorageSystemFunctions>, public IStorageSystemOneBlock<StorageSystemFunctions>
+class StorageSystemFunctions final : public shared_ptr_helper<StorageSystemFunctions>, public IStorageSystemOneBlock<StorageSystemFunctions>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemFunctions>;
+    friend struct shared_ptr_helper<StorageSystemFunctions>;
 public:
     std::string getName() const override { return "SystemFunctions"; }
 
diff --git a/src/Storages/System/StorageSystemGrants.h b/src/Storages/System/StorageSystemGrants.h
index 8c8a0f9f7bf..b511b4b77cf 100644
--- a/src/Storages/System/StorageSystemGrants.h
+++ b/src/Storages/System/StorageSystemGrants.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `grants` system table, which allows you to get information about grants.
-class StorageSystemGrants final : public ext::shared_ptr_helper<StorageSystemGrants>, public IStorageSystemOneBlock<StorageSystemGrants>
+class StorageSystemGrants final : public shared_ptr_helper<StorageSystemGrants>, public IStorageSystemOneBlock<StorageSystemGrants>
 {
 public:
     std::string getName() const override { return "SystemGrants"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemGrants>;
+    friend struct shared_ptr_helper<StorageSystemGrants>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemGraphite.h b/src/Storages/System/StorageSystemGraphite.h
index 256ad50e472..80325b0e2cb 100644
--- a/src/Storages/System/StorageSystemGraphite.h
+++ b/src/Storages/System/StorageSystemGraphite.h
@@ -5,15 +5,15 @@
 #include <DataTypes/DataTypesNumber.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 #include <Storages/MergeTree/MergeTreeData.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 namespace DB
 {
 
 /// Provides information about Graphite configuration.
-class StorageSystemGraphite final : public ext::shared_ptr_helper<StorageSystemGraphite>, public IStorageSystemOneBlock<StorageSystemGraphite>
+class StorageSystemGraphite final : public shared_ptr_helper<StorageSystemGraphite>, public IStorageSystemOneBlock<StorageSystemGraphite>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemGraphite>;
+    friend struct shared_ptr_helper<StorageSystemGraphite>;
 public:
     std::string getName() const override { return "SystemGraphite"; }
 
diff --git a/src/Storages/System/StorageSystemLicenses.h b/src/Storages/System/StorageSystemLicenses.h
index 43bb1c20c22..1dd30fd7cff 100644
--- a/src/Storages/System/StorageSystemLicenses.h
+++ b/src/Storages/System/StorageSystemLicenses.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
@@ -12,10 +12,10 @@ class Context;
 /** System table "licenses" with list of licenses of 3rd party libraries
   */
 class StorageSystemLicenses final :
-    public ext::shared_ptr_helper<StorageSystemLicenses>,
+    public shared_ptr_helper<StorageSystemLicenses>,
     public IStorageSystemOneBlock<StorageSystemLicenses>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemLicenses>;
+    friend struct shared_ptr_helper<StorageSystemLicenses>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemMacros.h b/src/Storages/System/StorageSystemMacros.h
index 298aa488265..fec0995b827 100644
--- a/src/Storages/System/StorageSystemMacros.h
+++ b/src/Storages/System/StorageSystemMacros.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <DataTypes/DataTypeString.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -13,9 +13,9 @@ class Context;
 
 /** Information about macros for introspection.
   */
-class StorageSystemMacros final : public ext::shared_ptr_helper<StorageSystemMacros>, public IStorageSystemOneBlock<StorageSystemMacros>
+class StorageSystemMacros final : public shared_ptr_helper<StorageSystemMacros>, public IStorageSystemOneBlock<StorageSystemMacros>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemMacros>;
+    friend struct shared_ptr_helper<StorageSystemMacros>;
 public:
     std::string getName() const override { return "SystemMacros"; }
 
diff --git a/src/Storages/System/StorageSystemMergeTreeSettings.h b/src/Storages/System/StorageSystemMergeTreeSettings.h
index b02b191fb69..64aec4634b2 100644
--- a/src/Storages/System/StorageSystemMergeTreeSettings.h
+++ b/src/Storages/System/StorageSystemMergeTreeSettings.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/MergeTree/MergeTreeSettings.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
@@ -15,10 +15,10 @@ class Context;
   *  which allows to get information about the current MergeTree settings.
   */
 template <bool replicated>
-class SystemMergeTreeSettings final : public ext::shared_ptr_helper<SystemMergeTreeSettings<replicated>>,
+class SystemMergeTreeSettings final : public shared_ptr_helper<SystemMergeTreeSettings<replicated>>,
                                       public IStorageSystemOneBlock<SystemMergeTreeSettings<replicated>>
 {
-    friend struct ext::shared_ptr_helper<SystemMergeTreeSettings<replicated>>;
+    friend struct shared_ptr_helper<SystemMergeTreeSettings<replicated>>;
 
 public:
     std::string getName() const override { return replicated ? "SystemReplicatedMergeTreeSettings" : "SystemMergeTreeSettings"; }
diff --git a/src/Storages/System/StorageSystemMerges.h b/src/Storages/System/StorageSystemMerges.h
index 5898bf62825..f88925cda67 100644
--- a/src/Storages/System/StorageSystemMerges.h
+++ b/src/Storages/System/StorageSystemMerges.h
@@ -3,7 +3,7 @@
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeArray.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -13,9 +13,9 @@ namespace DB
 class Context;
 
 
-class StorageSystemMerges final : public ext::shared_ptr_helper<StorageSystemMerges>, public IStorageSystemOneBlock<StorageSystemMerges>
+class StorageSystemMerges final : public shared_ptr_helper<StorageSystemMerges>, public IStorageSystemOneBlock<StorageSystemMerges>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemMerges>;
+    friend struct shared_ptr_helper<StorageSystemMerges>;
 public:
     std::string getName() const override { return "SystemMerges"; }
 
diff --git a/src/Storages/System/StorageSystemMetrics.h b/src/Storages/System/StorageSystemMetrics.h
index af5d32ec46b..b1a8cb52231 100644
--- a/src/Storages/System/StorageSystemMetrics.h
+++ b/src/Storages/System/StorageSystemMetrics.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements `metrics` system table, which provides information about the operation of the server.
   */
-class StorageSystemMetrics final : public ext::shared_ptr_helper<StorageSystemMetrics>, public IStorageSystemOneBlock<StorageSystemMetrics>
+class StorageSystemMetrics final : public shared_ptr_helper<StorageSystemMetrics>, public IStorageSystemOneBlock<StorageSystemMetrics>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemMetrics>;
+    friend struct shared_ptr_helper<StorageSystemMetrics>;
 public:
     std::string getName() const override { return "SystemMetrics"; }
 
diff --git a/src/Storages/System/StorageSystemModels.h b/src/Storages/System/StorageSystemModels.h
index 832a9d550db..3ec279f7f44 100644
--- a/src/Storages/System/StorageSystemModels.h
+++ b/src/Storages/System/StorageSystemModels.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -10,9 +10,9 @@ namespace DB
 class Context;
 
 
-class StorageSystemModels final : public ext::shared_ptr_helper<StorageSystemModels>, public IStorageSystemOneBlock<StorageSystemModels>
+class StorageSystemModels final : public shared_ptr_helper<StorageSystemModels>, public IStorageSystemOneBlock<StorageSystemModels>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemModels>;
+    friend struct shared_ptr_helper<StorageSystemModels>;
 public:
     std::string getName() const override { return "SystemModels"; }
 
diff --git a/src/Storages/System/StorageSystemMutations.h b/src/Storages/System/StorageSystemMutations.h
index 1f41ff6051b..350998c9d9e 100644
--- a/src/Storages/System/StorageSystemMutations.h
+++ b/src/Storages/System/StorageSystemMutations.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /// Implements the `mutations` system table, which provides information about the status of mutations
 /// in the MergeTree tables.
-class StorageSystemMutations final : public ext::shared_ptr_helper<StorageSystemMutations>, public IStorageSystemOneBlock<StorageSystemMutations>
+class StorageSystemMutations final : public shared_ptr_helper<StorageSystemMutations>, public IStorageSystemOneBlock<StorageSystemMutations>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemMutations>;
+    friend struct shared_ptr_helper<StorageSystemMutations>;
 public:
     String getName() const override { return "SystemMutations"; }
 
diff --git a/src/Storages/System/StorageSystemNumbers.h b/src/Storages/System/StorageSystemNumbers.h
index 708ace7a4cd..960c354fda2 100644
--- a/src/Storages/System/StorageSystemNumbers.h
+++ b/src/Storages/System/StorageSystemNumbers.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <optional>
 #include <Storages/IStorage.h>
 
@@ -23,9 +23,9 @@ class Context;
   *  In multithreaded case, if even_distributed is False, implementation with atomic is used,
   *     and result is always in [0 ... limit - 1] range.
   */
-class StorageSystemNumbers final : public ext::shared_ptr_helper<StorageSystemNumbers>, public IStorage
+class StorageSystemNumbers final : public shared_ptr_helper<StorageSystemNumbers>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemNumbers>;
+    friend struct shared_ptr_helper<StorageSystemNumbers>;
 public:
     std::string getName() const override { return "SystemNumbers"; }
 
diff --git a/src/Storages/System/StorageSystemOne.h b/src/Storages/System/StorageSystemOne.h
index a14d5e15726..71a29847919 100644
--- a/src/Storages/System/StorageSystemOne.h
+++ b/src/Storages/System/StorageSystemOne.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 
 
@@ -15,9 +15,9 @@ class Context;
   * Used when the table is not specified in the query.
   * Analog of the DUAL table in Oracle and MySQL.
   */
-class StorageSystemOne final : public ext::shared_ptr_helper<StorageSystemOne>, public IStorage
+class StorageSystemOne final : public shared_ptr_helper<StorageSystemOne>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemOne>;
+    friend struct shared_ptr_helper<StorageSystemOne>;
 public:
     std::string getName() const override { return "SystemOne"; }
 
diff --git a/src/Storages/System/StorageSystemPartMovesBetweenShards.h b/src/Storages/System/StorageSystemPartMovesBetweenShards.h
index 892f816d48e..64344a7a8a1 100644
--- a/src/Storages/System/StorageSystemPartMovesBetweenShards.h
+++ b/src/Storages/System/StorageSystemPartMovesBetweenShards.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -10,9 +10,9 @@ namespace DB
 class Context;
 
 
-class StorageSystemPartMovesBetweenShards final : public ext::shared_ptr_helper<StorageSystemPartMovesBetweenShards>, public IStorageSystemOneBlock<StorageSystemPartMovesBetweenShards>
+class StorageSystemPartMovesBetweenShards final : public shared_ptr_helper<StorageSystemPartMovesBetweenShards>, public IStorageSystemOneBlock<StorageSystemPartMovesBetweenShards>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemPartMovesBetweenShards>;
+    friend struct shared_ptr_helper<StorageSystemPartMovesBetweenShards>;
 public:
     std::string getName() const override { return "SystemShardMoves"; }
 
diff --git a/src/Storages/System/StorageSystemParts.h b/src/Storages/System/StorageSystemParts.h
index d67e62049cd..df436f8f972 100644
--- a/src/Storages/System/StorageSystemParts.h
+++ b/src/Storages/System/StorageSystemParts.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/StorageSystemPartsBase.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements system table 'parts' which allows to get information about data parts for tables of MergeTree family.
   */
-class StorageSystemParts final : public ext::shared_ptr_helper<StorageSystemParts>, public StorageSystemPartsBase
+class StorageSystemParts final : public shared_ptr_helper<StorageSystemParts>, public StorageSystemPartsBase
 {
-    friend struct ext::shared_ptr_helper<StorageSystemParts>;
+    friend struct shared_ptr_helper<StorageSystemParts>;
 public:
     std::string getName() const override { return "SystemParts"; }
 
diff --git a/src/Storages/System/StorageSystemPartsBase.h b/src/Storages/System/StorageSystemPartsBase.h
index 45057616dad..86f62e37fad 100644
--- a/src/Storages/System/StorageSystemPartsBase.h
+++ b/src/Storages/System/StorageSystemPartsBase.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Formats/FormatSettings.h>
 #include <Storages/IStorage.h>
 #include <Storages/MergeTree/MergeTreeData.h>
diff --git a/src/Storages/System/StorageSystemPartsColumns.h b/src/Storages/System/StorageSystemPartsColumns.h
index ec12a608cd1..842b3834561 100644
--- a/src/Storages/System/StorageSystemPartsColumns.h
+++ b/src/Storages/System/StorageSystemPartsColumns.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/StorageSystemPartsBase.h>
 
 
@@ -14,9 +14,9 @@ class Context;
  * columns in data parts for tables of MergeTree family.
  */
 class StorageSystemPartsColumns final
-        : public ext::shared_ptr_helper<StorageSystemPartsColumns>, public StorageSystemPartsBase
+        : public shared_ptr_helper<StorageSystemPartsColumns>, public StorageSystemPartsBase
 {
-    friend struct ext::shared_ptr_helper<StorageSystemPartsColumns>;
+    friend struct shared_ptr_helper<StorageSystemPartsColumns>;
 public:
     std::string getName() const override { return "SystemPartsColumns"; }
 
diff --git a/src/Storages/System/StorageSystemPrivileges.h b/src/Storages/System/StorageSystemPrivileges.h
index 618e1c91597..a10e768e041 100644
--- a/src/Storages/System/StorageSystemPrivileges.h
+++ b/src/Storages/System/StorageSystemPrivileges.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,7 +9,7 @@ namespace DB
 class Context;
 
 /// Implements `privileges` system table, which allows you to get information about access types.
-class StorageSystemPrivileges final : public ext::shared_ptr_helper<StorageSystemPrivileges>, public IStorageSystemOneBlock<StorageSystemPrivileges>
+class StorageSystemPrivileges final : public shared_ptr_helper<StorageSystemPrivileges>, public IStorageSystemOneBlock<StorageSystemPrivileges>
 {
 public:
     std::string getName() const override { return "SystemPrivileges"; }
@@ -17,7 +17,7 @@ public:
     static const std::vector<std::pair<String, Int8>> & getAccessTypeEnumValues();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemPrivileges>;
+    friend struct shared_ptr_helper<StorageSystemPrivileges>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemProcesses.h b/src/Storages/System/StorageSystemProcesses.h
index 4f876348a4b..e63e3cc3e9d 100644
--- a/src/Storages/System/StorageSystemProcesses.h
+++ b/src/Storages/System/StorageSystemProcesses.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements `processes` system table, which allows you to get information about the queries that are currently executing.
   */
-class StorageSystemProcesses final : public ext::shared_ptr_helper<StorageSystemProcesses>, public IStorageSystemOneBlock<StorageSystemProcesses>
+class StorageSystemProcesses final : public shared_ptr_helper<StorageSystemProcesses>, public IStorageSystemOneBlock<StorageSystemProcesses>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemProcesses>;
+    friend struct shared_ptr_helper<StorageSystemProcesses>;
 public:
     std::string getName() const override { return "SystemProcesses"; }
 
diff --git a/src/Storages/System/StorageSystemProjectionParts.h b/src/Storages/System/StorageSystemProjectionParts.h
index 11a7b034b6e..a4197769b0d 100644
--- a/src/Storages/System/StorageSystemProjectionParts.h
+++ b/src/Storages/System/StorageSystemProjectionParts.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/StorageSystemPartsBase.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements system table 'projection_parts' which allows to get information about projection parts for tables of MergeTree family.
   */
-class StorageSystemProjectionParts final : public ext::shared_ptr_helper<StorageSystemProjectionParts>, public StorageSystemPartsBase
+class StorageSystemProjectionParts final : public shared_ptr_helper<StorageSystemProjectionParts>, public StorageSystemPartsBase
 {
-    friend struct ext::shared_ptr_helper<StorageSystemProjectionParts>;
+    friend struct shared_ptr_helper<StorageSystemProjectionParts>;
 public:
     std::string getName() const override { return "SystemProjectionParts"; }
 
diff --git a/src/Storages/System/StorageSystemProjectionPartsColumns.h b/src/Storages/System/StorageSystemProjectionPartsColumns.h
index 16a32823db8..64ef1e2c286 100644
--- a/src/Storages/System/StorageSystemProjectionPartsColumns.h
+++ b/src/Storages/System/StorageSystemProjectionPartsColumns.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/StorageSystemPartsBase.h>
 
 
@@ -14,9 +14,9 @@ class Context;
  * columns in projection parts for tables of MergeTree family.
  */
 class StorageSystemProjectionPartsColumns final
-        : public ext::shared_ptr_helper<StorageSystemProjectionPartsColumns>, public StorageSystemPartsBase
+        : public shared_ptr_helper<StorageSystemProjectionPartsColumns>, public StorageSystemPartsBase
 {
-    friend struct ext::shared_ptr_helper<StorageSystemProjectionPartsColumns>;
+    friend struct shared_ptr_helper<StorageSystemProjectionPartsColumns>;
 public:
     std::string getName() const override { return "SystemProjectionPartsColumns"; }
 
diff --git a/src/Storages/System/StorageSystemQuotaLimits.cpp b/src/Storages/System/StorageSystemQuotaLimits.cpp
index 63a419e213c..82fdecfdf5b 100644
--- a/src/Storages/System/StorageSystemQuotaLimits.cpp
+++ b/src/Storages/System/StorageSystemQuotaLimits.cpp
@@ -9,7 +9,7 @@
 #include <Access/AccessControlManager.h>
 #include <Access/Quota.h>
 #include <Access/AccessFlags.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm_ext/push_back.hpp>
 
 
@@ -53,7 +53,7 @@ NamesAndTypesList StorageSystemQuotaLimits::getNamesAndTypes()
         {"is_randomized_interval", std::make_shared<DataTypeUInt8>()},
     };
 
-    for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+    for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
     {
         const auto & type_info = ResourceTypeInfo::get(resource_type);
         String column_name = "max_" + type_info.name;
@@ -82,7 +82,7 @@ void StorageSystemQuotaLimits::fillData(MutableColumns & res_columns, ContextPtr
 
     IColumn * column_max[MAX_RESOURCE_TYPE];
     NullMap * column_max_null_map[MAX_RESOURCE_TYPE];
-    for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+    for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
     {
         column_max[resource_type] = &assert_cast<ColumnNullable &>(*res_columns[column_index]).getNestedColumn();
         column_max_null_map[resource_type] = &assert_cast<ColumnNullable &>(*res_columns[column_index++]).getNullMapData();
@@ -94,7 +94,7 @@ void StorageSystemQuotaLimits::fillData(MutableColumns & res_columns, ContextPtr
         column_duration.push_back(limits.duration.count());
         column_is_randomized_interval.push_back(limits.randomize_interval);
 
-        for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+        for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
         {
             const auto & type_info = ResourceTypeInfo::get(resource_type);
             addValue(*column_max[resource_type], *column_max_null_map[resource_type], limits.max[resource_type], type_info);
diff --git a/src/Storages/System/StorageSystemQuotaLimits.h b/src/Storages/System/StorageSystemQuotaLimits.h
index 8f496734e0f..7f089fd3945 100644
--- a/src/Storages/System/StorageSystemQuotaLimits.h
+++ b/src/Storages/System/StorageSystemQuotaLimits.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `quota_limits` system table, which allows you to get information about the limits set for quotas.
-class StorageSystemQuotaLimits final : public ext::shared_ptr_helper<StorageSystemQuotaLimits>, public IStorageSystemOneBlock<StorageSystemQuotaLimits>
+class StorageSystemQuotaLimits final : public shared_ptr_helper<StorageSystemQuotaLimits>, public IStorageSystemOneBlock<StorageSystemQuotaLimits>
 {
 public:
     std::string getName() const override { return "SystemQuotaLimits"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemQuotaLimits>;
+    friend struct shared_ptr_helper<StorageSystemQuotaLimits>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemQuotaUsage.cpp b/src/Storages/System/StorageSystemQuotaUsage.cpp
index a25a130bf6c..835936036ed 100644
--- a/src/Storages/System/StorageSystemQuotaUsage.cpp
+++ b/src/Storages/System/StorageSystemQuotaUsage.cpp
@@ -10,7 +10,7 @@
 #include <Access/AccessControlManager.h>
 #include <Access/QuotaUsage.h>
 #include <Access/AccessFlags.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -64,7 +64,7 @@ NamesAndTypesList StorageSystemQuotaUsage::getNamesAndTypesImpl(bool add_column_
     names_and_types.push_back({"end_time", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeDateTime>())});
     names_and_types.push_back({"duration", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt32>())});
 
-    for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+    for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
     {
         const auto & type_info = ResourceTypeInfo::get(resource_type);
         String column_name = type_info.name;
@@ -117,7 +117,7 @@ void StorageSystemQuotaUsage::fillDataImpl(
     NullMap * column_usage_null_map[MAX_RESOURCE_TYPE];
     IColumn * column_max[MAX_RESOURCE_TYPE];
     NullMap * column_max_null_map[MAX_RESOURCE_TYPE];
-    for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+    for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
     {
         column_usage[resource_type] = &assert_cast<ColumnNullable &>(*res_columns[column_index]).getNestedColumn();
         column_usage_null_map[resource_type] = &assert_cast<ColumnNullable &>(*res_columns[column_index++]).getNullMapData();
@@ -148,7 +148,7 @@ void StorageSystemQuotaUsage::fillDataImpl(
             column_end_time_null_map.push_back(true);
             column_duration.insertDefault();
             column_duration_null_map.push_back(true);
-            for (auto resource_type : ext::range(MAX_RESOURCE_TYPE))
+            for (auto resource_type : collections::range(MAX_RESOURCE_TYPE))
             {
                 column_usage[resource_type]->insertDefault();
                 column_usage_null_map[resource_type]->push_back(true);
@@ -168,7 +168,7 @@ void StorageSystemQuotaUsage::fillDataImpl(
         column_end_time_null_map.push_back(false);
         column_duration_null_map.push_back(false);
 
-        for (auto resource_type : ext::range(Quota::MAX_RESOURCE_TYPE))
+        for (auto resource_type : collections::range(Quota::MAX_RESOURCE_TYPE))
         {
             const auto & type_info = ResourceTypeInfo::get(resource_type);
             addValue(*column_max[resource_type], *column_max_null_map[resource_type], interval->max[resource_type], type_info);
diff --git a/src/Storages/System/StorageSystemQuotaUsage.h b/src/Storages/System/StorageSystemQuotaUsage.h
index 806c3eb3f4a..e3c076a0b4c 100644
--- a/src/Storages/System/StorageSystemQuotaUsage.h
+++ b/src/Storages/System/StorageSystemQuotaUsage.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -13,7 +13,7 @@ struct QuotaUsage;
 /** Implements the `quota_usage` system table, which allows you to get information about
   * how the current user uses the quota.
   */
-class StorageSystemQuotaUsage final : public ext::shared_ptr_helper<StorageSystemQuotaUsage>, public IStorageSystemOneBlock<StorageSystemQuotaUsage>
+class StorageSystemQuotaUsage final : public shared_ptr_helper<StorageSystemQuotaUsage>, public IStorageSystemOneBlock<StorageSystemQuotaUsage>
 {
 public:
     std::string getName() const override { return "SystemQuotaUsage"; }
@@ -23,7 +23,7 @@ public:
     static void fillDataImpl(MutableColumns & res_columns, ContextPtr context, bool add_column_is_current, const std::vector<QuotaUsage> & quotas_usage);
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemQuotaUsage>;
+    friend struct shared_ptr_helper<StorageSystemQuotaUsage>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemQuotas.cpp b/src/Storages/System/StorageSystemQuotas.cpp
index 5e1ce220bec..dcde4b70179 100644
--- a/src/Storages/System/StorageSystemQuotas.cpp
+++ b/src/Storages/System/StorageSystemQuotas.cpp
@@ -12,7 +12,7 @@
 #include <Access/AccessControlManager.h>
 #include <Access/Quota.h>
 #include <Access/AccessFlags.h>
-#include <ext/range.h>
+#include <common/range.h>
 
 
 namespace DB
@@ -25,7 +25,7 @@ namespace
     DataTypeEnum8::Values getKeyTypeEnumValues()
     {
         DataTypeEnum8::Values enum_values;
-        for (auto key_type : ext::range(KeyType::MAX))
+        for (auto key_type : collections::range(KeyType::MAX))
         {
             const auto & type_info = KeyTypeInfo::get(key_type);
             if ((key_type != KeyType::NONE) && type_info.base_types.empty())
diff --git a/src/Storages/System/StorageSystemQuotas.h b/src/Storages/System/StorageSystemQuotas.h
index fb74ea9b05f..3eac1aaa784 100644
--- a/src/Storages/System/StorageSystemQuotas.h
+++ b/src/Storages/System/StorageSystemQuotas.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -10,14 +10,14 @@ class Context;
 
 /** Implements the `quotas` system tables, which allows you to get information about quotas.
   */
-class StorageSystemQuotas final : public ext::shared_ptr_helper<StorageSystemQuotas>, public IStorageSystemOneBlock<StorageSystemQuotas>
+class StorageSystemQuotas final : public shared_ptr_helper<StorageSystemQuotas>, public IStorageSystemOneBlock<StorageSystemQuotas>
 {
 public:
     std::string getName() const override { return "SystemQuotas"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemQuotas>;
+    friend struct shared_ptr_helper<StorageSystemQuotas>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemQuotasUsage.h b/src/Storages/System/StorageSystemQuotasUsage.h
index 1f29ea9b886..72a1e9e4233 100644
--- a/src/Storages/System/StorageSystemQuotasUsage.h
+++ b/src/Storages/System/StorageSystemQuotasUsage.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -11,14 +11,14 @@ class Context;
 /** Implements the `quotas_usage` system table, which allows you to get information about
   * how all users use the quotas.
   */
-class StorageSystemQuotasUsage final : public ext::shared_ptr_helper<StorageSystemQuotasUsage>, public IStorageSystemOneBlock<StorageSystemQuotasUsage>
+class StorageSystemQuotasUsage final : public shared_ptr_helper<StorageSystemQuotasUsage>, public IStorageSystemOneBlock<StorageSystemQuotasUsage>
 {
 public:
     std::string getName() const override { return "SystemQuotasUsage"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemQuotasUsage>;
+    friend struct shared_ptr_helper<StorageSystemQuotasUsage>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemReplicas.h b/src/Storages/System/StorageSystemReplicas.h
index 2352d7ccdf2..1454628f363 100644
--- a/src/Storages/System/StorageSystemReplicas.h
+++ b/src/Storages/System/StorageSystemReplicas.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements `replicas` system table, which provides information about the status of the replicated tables.
   */
-class StorageSystemReplicas final : public ext::shared_ptr_helper<StorageSystemReplicas>, public IStorage
+class StorageSystemReplicas final : public shared_ptr_helper<StorageSystemReplicas>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemReplicas>;
+    friend struct shared_ptr_helper<StorageSystemReplicas>;
 public:
     std::string getName() const override { return "SystemReplicas"; }
 
diff --git a/src/Storages/System/StorageSystemReplicatedFetches.h b/src/Storages/System/StorageSystemReplicatedFetches.h
index ed25e75eb70..b7336dbf437 100644
--- a/src/Storages/System/StorageSystemReplicatedFetches.h
+++ b/src/Storages/System/StorageSystemReplicatedFetches.h
@@ -1,7 +1,7 @@
 #pragma once
 
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -11,9 +11,9 @@ namespace DB
 class Context;
 
 /// system.replicated_fetches table. Takes data from context.getReplicatedFetchList()
-class StorageSystemReplicatedFetches final : public ext::shared_ptr_helper<StorageSystemReplicatedFetches>, public IStorageSystemOneBlock<StorageSystemReplicatedFetches >
+class StorageSystemReplicatedFetches final : public shared_ptr_helper<StorageSystemReplicatedFetches>, public IStorageSystemOneBlock<StorageSystemReplicatedFetches >
 {
-    friend struct ext::shared_ptr_helper<StorageSystemReplicatedFetches>;
+    friend struct shared_ptr_helper<StorageSystemReplicatedFetches>;
 public:
     std::string getName() const override { return "SystemReplicatedFetches"; }
 
diff --git a/src/Storages/System/StorageSystemReplicationQueue.h b/src/Storages/System/StorageSystemReplicationQueue.h
index f85f23a2b20..c6403eb07a1 100644
--- a/src/Storages/System/StorageSystemReplicationQueue.h
+++ b/src/Storages/System/StorageSystemReplicationQueue.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements the `replication_queue` system table, which allows you to view the replication queues for the replicated tables.
   */
-class StorageSystemReplicationQueue final : public ext::shared_ptr_helper<StorageSystemReplicationQueue>, public IStorageSystemOneBlock<StorageSystemReplicationQueue>
+class StorageSystemReplicationQueue final : public shared_ptr_helper<StorageSystemReplicationQueue>, public IStorageSystemOneBlock<StorageSystemReplicationQueue>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemReplicationQueue>;
+    friend struct shared_ptr_helper<StorageSystemReplicationQueue>;
 public:
     std::string getName() const override { return "SystemReplicationQueue"; }
 
diff --git a/src/Storages/System/StorageSystemRoleGrants.h b/src/Storages/System/StorageSystemRoleGrants.h
index a290dcf320d..4507a8520b0 100644
--- a/src/Storages/System/StorageSystemRoleGrants.h
+++ b/src/Storages/System/StorageSystemRoleGrants.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `role_grants` system table, which allows you to get information about granted roles.
-class StorageSystemRoleGrants final : public ext::shared_ptr_helper<StorageSystemRoleGrants>, public IStorageSystemOneBlock<StorageSystemRoleGrants>
+class StorageSystemRoleGrants final : public shared_ptr_helper<StorageSystemRoleGrants>, public IStorageSystemOneBlock<StorageSystemRoleGrants>
 {
 public:
     std::string getName() const override { return "SystemRoleGrants"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemRoleGrants>;
+    friend struct shared_ptr_helper<StorageSystemRoleGrants>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemRoles.h b/src/Storages/System/StorageSystemRoles.h
index 38c7ed05f1e..e2eda32bf71 100644
--- a/src/Storages/System/StorageSystemRoles.h
+++ b/src/Storages/System/StorageSystemRoles.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `roles` system table, which allows you to get information about roles.
-class StorageSystemRoles final : public ext::shared_ptr_helper<StorageSystemRoles>, public IStorageSystemOneBlock<StorageSystemRoles>
+class StorageSystemRoles final : public shared_ptr_helper<StorageSystemRoles>, public IStorageSystemOneBlock<StorageSystemRoles>
 {
 public:
     std::string getName() const override { return "SystemRoles"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemRoles>;
+    friend struct shared_ptr_helper<StorageSystemRoles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemRowPolicies.cpp b/src/Storages/System/StorageSystemRowPolicies.cpp
index c7a403a4abe..a60e26d6f85 100644
--- a/src/Storages/System/StorageSystemRowPolicies.cpp
+++ b/src/Storages/System/StorageSystemRowPolicies.cpp
@@ -13,7 +13,7 @@
 #include <Access/AccessControlManager.h>
 #include <Access/RowPolicy.h>
 #include <Access/AccessFlags.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include <boost/range/algorithm_ext/push_back.hpp>
 
 
@@ -34,7 +34,7 @@ NamesAndTypesList StorageSystemRowPolicies::getNamesAndTypes()
         {"storage", std::make_shared<DataTypeString>()},
     };
 
-    for (auto type : ext::range(MAX_CONDITION_TYPE))
+    for (auto type : collections::range(MAX_CONDITION_TYPE))
     {
         const String & column_name = ConditionTypeInfo::get(type).name;
         names_and_types.push_back({column_name, std::make_shared<DataTypeNullable>(std::make_shared<DataTypeString>())});
@@ -68,7 +68,7 @@ void StorageSystemRowPolicies::fillData(MutableColumns & res_columns, ContextPtr
 
     ColumnString * column_condition[MAX_CONDITION_TYPE];
     NullMap * column_condition_null_map[MAX_CONDITION_TYPE];
-    for (auto condition_type : ext::range(MAX_CONDITION_TYPE))
+    for (auto condition_type : collections::range(MAX_CONDITION_TYPE))
     {
         column_condition[condition_type] = &assert_cast<ColumnString &>(assert_cast<ColumnNullable &>(*res_columns[column_index]).getNestedColumn());
         column_condition_null_map[condition_type] = &assert_cast<ColumnNullable &>(*res_columns[column_index++]).getNullMapData();
@@ -96,7 +96,7 @@ void StorageSystemRowPolicies::fillData(MutableColumns & res_columns, ContextPtr
         column_id.push_back(id.toUnderType());
         column_storage.insertData(storage_name.data(), storage_name.length());
 
-        for (auto condition_type : ext::range(MAX_CONDITION_TYPE))
+        for (auto condition_type : collections::range(MAX_CONDITION_TYPE))
         {
             const String & condition = conditions[condition_type];
             if (condition.empty())
diff --git a/src/Storages/System/StorageSystemRowPolicies.h b/src/Storages/System/StorageSystemRowPolicies.h
index 3b9ebfcc25a..637c91d5ded 100644
--- a/src/Storages/System/StorageSystemRowPolicies.h
+++ b/src/Storages/System/StorageSystemRowPolicies.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -11,14 +11,14 @@ class Context;
 
 
 /// Implements `row_policies` system table, which allows you to get information about row policies.
-class StorageSystemRowPolicies final : public ext::shared_ptr_helper<StorageSystemRowPolicies>, public IStorageSystemOneBlock<StorageSystemRowPolicies>
+class StorageSystemRowPolicies final : public shared_ptr_helper<StorageSystemRowPolicies>, public IStorageSystemOneBlock<StorageSystemRowPolicies>
 {
 public:
     std::string getName() const override { return "SystemRowPolicies"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemRowPolicies>;
+    friend struct shared_ptr_helper<StorageSystemRowPolicies>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemSettings.h b/src/Storages/System/StorageSystemSettings.h
index d93c09d3f80..c76e1609fc2 100644
--- a/src/Storages/System/StorageSystemSettings.h
+++ b/src/Storages/System/StorageSystemSettings.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** implements system table "settings", which allows to get information about the current settings.
   */
-class StorageSystemSettings final : public ext::shared_ptr_helper<StorageSystemSettings>, public IStorageSystemOneBlock<StorageSystemSettings>
+class StorageSystemSettings final : public shared_ptr_helper<StorageSystemSettings>, public IStorageSystemOneBlock<StorageSystemSettings>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemSettings>;
+    friend struct shared_ptr_helper<StorageSystemSettings>;
 public:
     std::string getName() const override { return "SystemSettings"; }
 
diff --git a/src/Storages/System/StorageSystemSettingsProfileElements.h b/src/Storages/System/StorageSystemSettingsProfileElements.h
index 2262ea96dde..ffeda5b7bf3 100644
--- a/src/Storages/System/StorageSystemSettingsProfileElements.h
+++ b/src/Storages/System/StorageSystemSettingsProfileElements.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `settings_profile_elements` system table, which allows you to get information about elements of settings profiles.
-class StorageSystemSettingsProfileElements final : public ext::shared_ptr_helper<StorageSystemSettingsProfileElements>, public IStorageSystemOneBlock<StorageSystemSettingsProfileElements>
+class StorageSystemSettingsProfileElements final : public shared_ptr_helper<StorageSystemSettingsProfileElements>, public IStorageSystemOneBlock<StorageSystemSettingsProfileElements>
 {
 public:
     std::string getName() const override { return "SystemSettingsProfileElements"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemSettingsProfileElements>;
+    friend struct shared_ptr_helper<StorageSystemSettingsProfileElements>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemSettingsProfiles.h b/src/Storages/System/StorageSystemSettingsProfiles.h
index 580430dc28b..edbb4084a66 100644
--- a/src/Storages/System/StorageSystemSettingsProfiles.h
+++ b/src/Storages/System/StorageSystemSettingsProfiles.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `settings_profiles` system table, which allows you to get information about profiles.
-class StorageSystemSettingsProfiles final : public ext::shared_ptr_helper<StorageSystemSettingsProfiles>, public IStorageSystemOneBlock<StorageSystemSettingsProfiles>
+class StorageSystemSettingsProfiles final : public shared_ptr_helper<StorageSystemSettingsProfiles>, public IStorageSystemOneBlock<StorageSystemSettingsProfiles>
 {
 public:
     std::string getName() const override { return "SystemSettingsProfiles"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemSettingsProfiles>;
+    friend struct shared_ptr_helper<StorageSystemSettingsProfiles>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemStackTrace.cpp b/src/Storages/System/StorageSystemStackTrace.cpp
index 406e154029d..8b119492340 100644
--- a/src/Storages/System/StorageSystemStackTrace.cpp
+++ b/src/Storages/System/StorageSystemStackTrace.cpp
@@ -6,7 +6,7 @@
 #include <mutex>
 #include <filesystem>
 
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <Storages/System/StorageSystemStackTrace.h>
 #include <DataTypes/DataTypeString.h>
diff --git a/src/Storages/System/StorageSystemStackTrace.h b/src/Storages/System/StorageSystemStackTrace.h
index 7f10e309775..bf3de40424c 100644
--- a/src/Storages/System/StorageSystemStackTrace.h
+++ b/src/Storages/System/StorageSystemStackTrace.h
@@ -3,7 +3,7 @@
 #ifdef OS_LINUX /// Because of 'sigqueue' functions and RT signals.
 
 #include <mutex>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 namespace Poco
@@ -20,9 +20,9 @@ class Context;
 /// Allows to introspect stack trace of all server threads.
 /// It acts like an embedded debugger.
 /// More than one instance of this table cannot be used.
-class StorageSystemStackTrace final : public ext::shared_ptr_helper<StorageSystemStackTrace>, public IStorageSystemOneBlock<StorageSystemStackTrace>
+class StorageSystemStackTrace final : public shared_ptr_helper<StorageSystemStackTrace>, public IStorageSystemOneBlock<StorageSystemStackTrace>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemStackTrace>;
+    friend struct shared_ptr_helper<StorageSystemStackTrace>;
 public:
     String getName() const override { return "SystemStackTrace"; }
     static NamesAndTypesList getNamesAndTypes();
diff --git a/src/Storages/System/StorageSystemStoragePolicies.h b/src/Storages/System/StorageSystemStoragePolicies.h
index 70053ebc1bc..25afd4166c8 100644
--- a/src/Storages/System/StorageSystemStoragePolicies.h
+++ b/src/Storages/System/StorageSystemStoragePolicies.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Formats/FormatSettings.h>
 #include <Storages/IStorage.h>
 #include <Storages/MergeTree/MergeTreeData.h>
@@ -14,9 +14,9 @@ class Context;
 
 /** Implements the system table `storage`, which allows you to get information about all disks.
 */
-class StorageSystemStoragePolicies final : public ext::shared_ptr_helper<StorageSystemStoragePolicies>, public IStorage
+class StorageSystemStoragePolicies final : public shared_ptr_helper<StorageSystemStoragePolicies>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemStoragePolicies>;
+    friend struct shared_ptr_helper<StorageSystemStoragePolicies>;
 public:
     std::string getName() const override { return "SystemStoragePolicies"; }
 
diff --git a/src/Storages/System/StorageSystemTableEngines.h b/src/Storages/System/StorageSystemTableEngines.h
index 37f7f354073..153032fdd51 100644
--- a/src/Storages/System/StorageSystemTableEngines.h
+++ b/src/Storages/System/StorageSystemTableEngines.h
@@ -2,15 +2,15 @@
 
 #include <DataTypes/DataTypeString.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 namespace DB
 {
 
-class StorageSystemTableEngines final : public ext::shared_ptr_helper<StorageSystemTableEngines>,
+class StorageSystemTableEngines final : public shared_ptr_helper<StorageSystemTableEngines>,
                                   public IStorageSystemOneBlock<StorageSystemTableEngines>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemTableEngines>;
+    friend struct shared_ptr_helper<StorageSystemTableEngines>;
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
 
diff --git a/src/Storages/System/StorageSystemTableFunctions.h b/src/Storages/System/StorageSystemTableFunctions.h
index a5db5450d20..de114654a92 100644
--- a/src/Storages/System/StorageSystemTableFunctions.h
+++ b/src/Storages/System/StorageSystemTableFunctions.h
@@ -2,14 +2,14 @@
 
 #include <DataTypes/DataTypeString.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 namespace DB
 {
 
-class StorageSystemTableFunctions final : public ext::shared_ptr_helper<StorageSystemTableFunctions>,
+class StorageSystemTableFunctions final : public shared_ptr_helper<StorageSystemTableFunctions>,
                                     public IStorageSystemOneBlock<StorageSystemTableFunctions>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemTableFunctions>;
+    friend struct shared_ptr_helper<StorageSystemTableFunctions>;
 protected:
 
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
diff --git a/src/Storages/System/StorageSystemTables.h b/src/Storages/System/StorageSystemTables.h
index da5e236b33f..b196a87b093 100644
--- a/src/Storages/System/StorageSystemTables.h
+++ b/src/Storages/System/StorageSystemTables.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/IStorage.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements the system table `tables`, which allows you to get information about all tables.
   */
-class StorageSystemTables final : public ext::shared_ptr_helper<StorageSystemTables>, public IStorage
+class StorageSystemTables final : public shared_ptr_helper<StorageSystemTables>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemTables>;
+    friend struct shared_ptr_helper<StorageSystemTables>;
 public:
     std::string getName() const override { return "SystemTables"; }
 
diff --git a/src/Storages/System/StorageSystemTimeZones.h b/src/Storages/System/StorageSystemTimeZones.h
index 0f68b2de293..7cc56bbe643 100644
--- a/src/Storages/System/StorageSystemTimeZones.h
+++ b/src/Storages/System/StorageSystemTimeZones.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Storages/System/IStorageSystemOneBlock.h>
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 
 
 namespace DB
@@ -11,10 +11,10 @@ class Context;
 
 /** System table "time_zones" with list of timezones pulled from /contrib/cctz/testdata/zoneinfo
   */
-class StorageSystemTimeZones final : public ext::shared_ptr_helper<StorageSystemTimeZones>,
+class StorageSystemTimeZones final : public shared_ptr_helper<StorageSystemTimeZones>,
                                      public IStorageSystemOneBlock<StorageSystemTimeZones>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemTimeZones>;
+    friend struct shared_ptr_helper<StorageSystemTimeZones>;
 
 protected:
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo & query_info) const override;
diff --git a/src/Storages/System/StorageSystemUserDirectories.cpp b/src/Storages/System/StorageSystemUserDirectories.cpp
index 7858af25365..d4a2d5169fa 100644
--- a/src/Storages/System/StorageSystemUserDirectories.cpp
+++ b/src/Storages/System/StorageSystemUserDirectories.cpp
@@ -5,7 +5,6 @@
 #include <Columns/ColumnsNumber.h>
 #include <Interpreters/Context.h>
 #include <Access/AccessControlManager.h>
-#include <ext/enumerate.h>
 
 
 namespace DB
@@ -45,8 +44,11 @@ void StorageSystemUserDirectories::fillData(MutableColumns & res_columns, Contex
         column_precedence.insert(precedence);
     };
 
-    for (auto [i, storage] : ext::enumerate(storages))
+    for (size_t i = 0; i < storages.size(); ++i)
+    {
+        const auto & storage = storages[i];
         add_row(*storage, i + 1);
+    }
 }
 
 }
diff --git a/src/Storages/System/StorageSystemUserDirectories.h b/src/Storages/System/StorageSystemUserDirectories.h
index 0ddb0ad49d8..38d2ddd9147 100644
--- a/src/Storages/System/StorageSystemUserDirectories.h
+++ b/src/Storages/System/StorageSystemUserDirectories.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `users_directories` system table, which allows you to get information about user directories.
-class StorageSystemUserDirectories final : public ext::shared_ptr_helper<StorageSystemUserDirectories>, public IStorageSystemOneBlock<StorageSystemUserDirectories>
+class StorageSystemUserDirectories final : public shared_ptr_helper<StorageSystemUserDirectories>, public IStorageSystemOneBlock<StorageSystemUserDirectories>
 {
 public:
     std::string getName() const override { return "SystemUserDirectories"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemUserDirectories>;
+    friend struct shared_ptr_helper<StorageSystemUserDirectories>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemUsers.cpp b/src/Storages/System/StorageSystemUsers.cpp
index 74ac48c145c..90b0a914d58 100644
--- a/src/Storages/System/StorageSystemUsers.cpp
+++ b/src/Storages/System/StorageSystemUsers.cpp
@@ -25,7 +25,7 @@ namespace
     DataTypeEnum8::Values getAuthenticationTypeEnumValues()
     {
         DataTypeEnum8::Values enum_values;
-        for (auto type : ext::range(Authentication::MAX_TYPE))
+        for (auto type : collections::range(Authentication::MAX_TYPE))
             enum_values.emplace_back(Authentication::TypeInfo::get(type).name, static_cast<Int8>(type));
         return enum_values;
     }
diff --git a/src/Storages/System/StorageSystemUsers.h b/src/Storages/System/StorageSystemUsers.h
index 3c463a23db9..886b91d04e9 100644
--- a/src/Storages/System/StorageSystemUsers.h
+++ b/src/Storages/System/StorageSystemUsers.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -9,14 +9,14 @@ namespace DB
 class Context;
 
 /// Implements `users` system table, which allows you to get information about users.
-class StorageSystemUsers final : public ext::shared_ptr_helper<StorageSystemUsers>, public IStorageSystemOneBlock<StorageSystemUsers>
+class StorageSystemUsers final : public shared_ptr_helper<StorageSystemUsers>, public IStorageSystemOneBlock<StorageSystemUsers>
 {
 public:
     std::string getName() const override { return "SystemUsers"; }
     static NamesAndTypesList getNamesAndTypes();
 
 protected:
-    friend struct ext::shared_ptr_helper<StorageSystemUsers>;
+    friend struct shared_ptr_helper<StorageSystemUsers>;
     using IStorageSystemOneBlock::IStorageSystemOneBlock;
     void fillData(MutableColumns & res_columns, ContextPtr context, const SelectQueryInfo &) const override;
 };
diff --git a/src/Storages/System/StorageSystemZeros.h b/src/Storages/System/StorageSystemZeros.h
index 2ccdcf9c944..d33d9b4b099 100644
--- a/src/Storages/System/StorageSystemZeros.h
+++ b/src/Storages/System/StorageSystemZeros.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <optional>
 #include <Storages/IStorage.h>
 
@@ -14,9 +14,9 @@ namespace DB
   * You could also specify a limit (how many zeros to give).
   * If multithreaded is specified, zeros will be generated in several streams.
   */
-class StorageSystemZeros final : public ext::shared_ptr_helper<StorageSystemZeros>, public IStorage
+class StorageSystemZeros final : public shared_ptr_helper<StorageSystemZeros>, public IStorage
 {
-    friend struct ext::shared_ptr_helper<StorageSystemZeros>;
+    friend struct shared_ptr_helper<StorageSystemZeros>;
 public:
     std::string getName() const override { return "SystemZeros"; }
 
diff --git a/src/Storages/System/StorageSystemZooKeeper.h b/src/Storages/System/StorageSystemZooKeeper.h
index 226ca79facf..a74fdac12e9 100644
--- a/src/Storages/System/StorageSystemZooKeeper.h
+++ b/src/Storages/System/StorageSystemZooKeeper.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <ext/shared_ptr_helper.h>
+#include <common/shared_ptr_helper.h>
 #include <Storages/System/IStorageSystemOneBlock.h>
 
 
@@ -12,9 +12,9 @@ class Context;
 
 /** Implements `zookeeper` system table, which allows you to view the data in ZooKeeper for debugging purposes.
   */
-class StorageSystemZooKeeper final : public ext::shared_ptr_helper<StorageSystemZooKeeper>, public IStorageSystemOneBlock<StorageSystemZooKeeper>
+class StorageSystemZooKeeper final : public shared_ptr_helper<StorageSystemZooKeeper>, public IStorageSystemOneBlock<StorageSystemZooKeeper>
 {
-    friend struct ext::shared_ptr_helper<StorageSystemZooKeeper>;
+    friend struct shared_ptr_helper<StorageSystemZooKeeper>;
 public:
     std::string getName() const override { return "SystemZooKeeper"; }
 
diff --git a/src/Storages/examples/get_abandonable_lock_in_all_partitions.cpp b/src/Storages/examples/get_abandonable_lock_in_all_partitions.cpp
index 7f50041e68e..9027ba53708 100644
--- a/src/Storages/examples/get_abandonable_lock_in_all_partitions.cpp
+++ b/src/Storages/examples/get_abandonable_lock_in_all_partitions.cpp
@@ -4,7 +4,7 @@
 #include <Common/Stopwatch.h>
 #include <Storages/MergeTree/EphemeralLockInZooKeeper.h>
 
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <iostream>
 
diff --git a/src/Storages/examples/get_current_inserts_in_replicated.cpp b/src/Storages/examples/get_current_inserts_in_replicated.cpp
index 56364997643..aa9e31792c1 100644
--- a/src/Storages/examples/get_current_inserts_in_replicated.cpp
+++ b/src/Storages/examples/get_current_inserts_in_replicated.cpp
@@ -4,7 +4,7 @@
 #include <Common/ZooKeeper/ZooKeeper.h>
 #include <Common/Exception.h>
 #include <Common/Stopwatch.h>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <filesystem>
 #include <iostream>
diff --git a/src/TableFunctions/ITableFunctionXDBC.cpp b/src/TableFunctions/ITableFunctionXDBC.cpp
index 9aa099c1333..58d71229b04 100644
--- a/src/TableFunctions/ITableFunctionXDBC.cpp
+++ b/src/TableFunctions/ITableFunctionXDBC.cpp
@@ -1,5 +1,5 @@
 #include <type_traits>
-#include <ext/scope_guard.h>
+#include <common/scope_guard.h>
 
 #include <Core/Defines.h>
 #include <DataTypes/DataTypeFactory.h>
diff --git a/src/TableFunctions/TableFunctionRemote.cpp b/src/TableFunctions/TableFunctionRemote.cpp
index 8539705a2d2..4d3524c7563 100644
--- a/src/TableFunctions/TableFunctionRemote.cpp
+++ b/src/TableFunctions/TableFunctionRemote.cpp
@@ -14,7 +14,7 @@
 #include <Common/parseRemoteDescription.h>
 #include <TableFunctions/TableFunctionFactory.h>
 #include <Core/Defines.h>
-#include <ext/range.h>
+#include <common/range.h>
 #include "registerTableFunctions.h"
 
 
diff --git a/tests/clickhouse-test b/tests/clickhouse-test
index f5346763e3a..e508abab70c 100755
--- a/tests/clickhouse-test
+++ b/tests/clickhouse-test
@@ -29,6 +29,7 @@ import string
 import multiprocessing
 from contextlib import closing
 
+DISTRIBUTED_DDL_TIMEOUT_MSG = "is executing longer than distributed_ddl_task_timeout (=120)"
 
 MESSAGES_TO_RETRY = [
     "DB::Exception: ZooKeeper session has been expired",
@@ -36,11 +37,15 @@ MESSAGES_TO_RETRY = [
     "Coordination::Exception: Session expired",
     "Coordination::Exception: Connection loss",
     "Coordination::Exception: Operation timeout",
+    "DB::Exception: Operation timeout",
     "Operation timed out",
     "ConnectionPoolWithFailover: Connection failed at try",
-    "DB::Exception: New table appeared in database being dropped or detached. Try again"
+    "DB::Exception: New table appeared in database being dropped or detached. Try again",
+    DISTRIBUTED_DDL_TIMEOUT_MSG # FIXME
 ]
 
+MAX_RETRIES = 5
+
 class Terminated(KeyboardInterrupt):
     pass
 def signal_handler(sig, frame):
@@ -258,7 +263,8 @@ def get_processlist(args):
         query = b"SHOW PROCESSLIST FORMAT Vertical"
         if args.replicated_database:
             query = b"SELECT materialize((hostName(), tcpPort())) as host, * " \
-                    b"FROM clusterAllReplicas('r', system.processes) WHERE query NOT LIKE '%system.processes%' FORMAT Vertical"
+                    b"FROM clusterAllReplicas('test_cluster_database_replicated', system.processes) " \
+                    b"WHERE query NOT LIKE '%system.processes%' FORMAT Vertical"
         clickhouse_proc = Popen(shlex.split(args.client), stdin=PIPE, stdout=PIPE, stderr=PIPE)
         (stdout, _) = clickhouse_proc.communicate((query), timeout=20)
         return False, stdout.decode('utf-8')
@@ -279,8 +285,16 @@ def get_stacktraces_from_gdb(server_pid):
 
 # collect server stacktraces from system.stack_trace table
 # it does not work in Sandbox
-def get_stacktraces_from_clickhouse(client):
+def get_stacktraces_from_clickhouse(client, replicated_database=False):
     try:
+        if replicated_database:
+            return subprocess.check_output("{} --allow_introspection_functions=1 --skip_unavailable_shards=1 --query "
+                "\"SELECT materialize((hostName(), tcpPort())) as host, thread_id, "
+                "arrayStringConcat(arrayMap(x, y -> concat(x, ': ', y), arrayMap(x -> addressToLine(x), trace), "
+                "arrayMap(x -> demangle(addressToSymbol(x)), trace)), '\n') as trace "
+                "FROM clusterAllReplicas('test_cluster_database_replicated', 'system.stack_trace') "
+                "ORDER BY host, thread_id format Vertical\"".format(client), shell=True, stderr=subprocess.STDOUT).decode('utf-8')
+
         return subprocess.check_output("{} --allow_introspection_functions=1 --query "
                "\"SELECT arrayStringConcat(arrayMap(x, y -> concat(x, ': ', y), arrayMap(x -> addressToLine(x), trace), "
                "arrayMap(x -> demangle(addressToSymbol(x)), trace)), '\n') as trace "
@@ -289,7 +303,6 @@ def get_stacktraces_from_clickhouse(client):
         print("Error occured while receiving stack traces from client: {}".format(str(ex)))
         return None
 
-
 def get_server_pid(server_tcp_port):
     # lsof does not work in stress tests for some reason
     cmd_lsof = "lsof -i tcp:{port} -s tcp:LISTEN -Fp | awk '/^p[0-9]+$/{{print substr($0, 2)}}'".format(port=server_tcp_port)
@@ -317,7 +330,7 @@ SERVER_DIED = False
 exit_code = 0
 stop_time = None
 queue = multiprocessing.Queue(maxsize=1)
-
+restarted_tests = []  # (test, stderr)
 
 # def run_tests_array(all_tests, suite, suite_dir, suite_tmp_dir, run_total):
 def run_tests_array(all_tests_with_params):
@@ -458,11 +471,15 @@ def run_tests_array(all_tests_with_params):
                     else:
                         counter = 1
                         while need_retry(stderr):
+                            restarted_tests.append((case_file, stderr))
                             testcase_args = configure_testcase_args(args, case_file, suite_tmp_dir, stderr_file)
                             proc, stdout, stderr, total_time = run_single_test(testcase_args, ext, server_logs_level, client_options, case_file, stdout_file, stderr_file)
                             sleep(2**counter)
                             counter += 1
-                            if counter > 6:
+                            if MAX_RETRIES < counter:
+                                if args.replicated_database:
+                                    if DISTRIBUTED_DDL_TIMEOUT_MSG in stderr:
+                                        SERVER_DIED = True
                                 break
 
                         if proc.returncode != 0:
@@ -522,13 +539,13 @@ def run_tests_array(all_tests_with_params):
                                 status += " - result differs with reference:\n{}\n".format(diff)
                                 status += 'Database: ' + testcase_args.testcase_database
                             else:
-                                if testcase_args.test_runs > 1 and total_time > 30 and 'long' not in name:
+                                if testcase_args.test_runs > 1 and total_time > 60 and 'long' not in name:
                                     # We're in Flaky Check mode, check the run time as well while we're at it.
                                     failures += 1
                                     failures_chain += 1
                                     status += MSG_FAIL
                                     status += print_test_time(total_time)
-                                    status += " - Test runs too long (> 30s). Make it faster.\n"
+                                    status += " - Test runs too long (> 60s). Make it faster.\n"
                                     status += 'Database: ' + testcase_args.testcase_database
                                 else:
                                     passed_total += 1
@@ -917,7 +934,7 @@ def main(args):
             clickhouse_tcp_port = os.getenv("CLICKHOUSE_PORT_TCP", '9000')
             server_pid = get_server_pid(clickhouse_tcp_port)
             bt = None
-            if server_pid:
+            if server_pid and not args.replicated_database:
                 print("\nLocated ClickHouse server process {} listening at TCP port {}".format(server_pid, clickhouse_tcp_port))
                 print("\nCollecting stacktraces from all running threads with gdb:")
                 bt = get_stacktraces_from_gdb(server_pid)
@@ -926,7 +943,7 @@ def main(args):
                     bt = None
             if bt is None:
                 print("\nCollecting stacktraces from system.stacktraces table:")
-                bt = get_stacktraces_from_clickhouse(args.client)
+                bt = get_stacktraces_from_clickhouse(args.client, args.replicated_database)
             if bt is None:
                 print(
                     colored(
@@ -941,6 +958,13 @@ def main(args):
         else:
             print(colored("\nNo queries hung.", args, "green", attrs=["bold"]))
 
+    if len(restarted_tests) > 0:
+        print("\nSome tests were restarted:\n")
+        for (test_case, stderr) in restarted_tests:
+            print(test_case)
+            print(stderr)
+            print("\n")
+
     if total_tests_run == 0:
         print("No tests were run.")
         sys.exit(1)
diff --git a/tests/config/users.d/database_replicated.xml b/tests/config/users.d/database_replicated.xml
index cf59054c4d7..b19026e4a54 100644
--- a/tests/config/users.d/database_replicated.xml
+++ b/tests/config/users.d/database_replicated.xml
@@ -3,8 +3,8 @@
         <default>
             <allow_experimental_database_replicated>1</allow_experimental_database_replicated>
             <distributed_ddl_output_mode>none</distributed_ddl_output_mode>
-            <database_replicated_initial_query_timeout_sec>100</database_replicated_initial_query_timeout_sec>
-            <distributed_ddl_task_timeout>100</distributed_ddl_task_timeout>
+            <database_replicated_initial_query_timeout_sec>120</database_replicated_initial_query_timeout_sec>
+            <distributed_ddl_task_timeout>120</distributed_ddl_task_timeout>
             <database_replicated_always_detach_permanently>1</database_replicated_always_detach_permanently>
             <distributed_ddl_entry_format_version>2</distributed_ddl_entry_format_version>
         </default>
diff --git a/tests/integration/test_storage_postgresql/test.py b/tests/integration/test_storage_postgresql/test.py
index abcfb03c750..f81033822c8 100644
--- a/tests/integration/test_storage_postgresql/test.py
+++ b/tests/integration/test_storage_postgresql/test.py
@@ -188,6 +188,11 @@ def test_non_default_scema(started_cluster):
     result = node1.query('SELECT * FROM test_pg_table_schema_with_dots')
     assert(result == expected)
 
+    cursor.execute('INSERT INTO "test_schema"."test_table" SELECT i FROM generate_series(100, 199) as t(i)')
+    result = node1.query('SELECT * FROM {}'.format(table_function))
+    expected = node1.query('SELECT number FROM numbers(200)')
+    assert(result == expected)
+
 
 def test_concurrent_queries(started_cluster):
     conn = get_postgres_conn(started_cluster, started_cluster.postgres_ip, True)
diff --git a/tests/integration/test_ttl_replicated/test.py b/tests/integration/test_ttl_replicated/test.py
index 4d8d36e538f..de5e5984082 100644
--- a/tests/integration/test_ttl_replicated/test.py
+++ b/tests/integration/test_ttl_replicated/test.py
@@ -394,14 +394,26 @@ def test_ttl_compatibility(started_cluster, node_left, node_right, num_run):
 
     # after restart table can be in readonly mode
     exec_query_with_retry(node_right, "OPTIMIZE TABLE test_ttl_delete FINAL")
-
     node_right.query("OPTIMIZE TABLE test_ttl_group_by FINAL")
     node_right.query("OPTIMIZE TABLE test_ttl_where FINAL")
-    exec_query_with_retry(node_left, "SYSTEM SYNC REPLICA test_ttl_delete")
 
+    exec_query_with_retry(node_left, "SYSTEM SYNC REPLICA test_ttl_delete")
     node_left.query("SYSTEM SYNC REPLICA test_ttl_group_by", timeout=20)
     node_left.query("SYSTEM SYNC REPLICA test_ttl_where", timeout=20)
 
+    # After OPTIMIZE TABLE, it is not guaranteed that everything is merged.
+    # Possible scenario (for test_ttl_group_by):
+    # 1. Two independent merges assigned: [0_0, 1_1] -> 0_1 and [2_2, 3_3] -> 2_3
+    # 2. Another one merge assigned: [0_1, 2_3] -> 0_3
+    # 3. Merge to 0_3 is delayed:
+    #    `Not executing log entry for part 0_3 because 2 merges with TTL already executing, maximum 2
+    # 4. OPTIMIZE FINAL does nothing, cause there is an entry for 0_3
+    #
+    # So, let's also sync replicas for node_right (for now).
+    exec_query_with_retry(node_right, "SYSTEM SYNC REPLICA test_ttl_delete")
+    node_right.query("SYSTEM SYNC REPLICA test_ttl_group_by", timeout=20)
+    node_right.query("SYSTEM SYNC REPLICA test_ttl_where", timeout=20)
+
     assert node_left.query("SELECT id FROM test_ttl_delete ORDER BY id") == "2\n4\n"
     assert node_right.query("SELECT id FROM test_ttl_delete ORDER BY id") == "2\n4\n"
 
diff --git a/tests/queries/0_stateless/00273_quantiles.reference b/tests/queries/0_stateless/00273_quantiles.reference
index aefb0084648..ac9db31bae4 100644
--- a/tests/queries/0_stateless/00273_quantiles.reference
+++ b/tests/queries/0_stateless/00273_quantiles.reference
@@ -6,17 +6,17 @@
 [0,1,10,50,100,200,300,400,500,600,700,800,900,950,990,999,1000]
 [0,1,10,50,99.6,199.7,299.8,399.9,500,600.1,700.2,800.3,900.4,950,990,999,1000]
 [0,1,10,50,100,200,300,400,500,600,700,800,900,950,990,999,1000]
-1	333334	[699144.2,835663,967429.2]	[699999,833333,966666]
-2	266667	[426549.5,536255.5,638957.6]	[426665,533332,639999]
+1	333334	[699140.3,835642,967430.8]	[699999,833333,966666]
+2	266667	[426546,536239,638933.4]	[426665,533332,639999]
 3	114285	[296938,342324,388778]	[297142,342856,388570]
-4	63492	[228370.2,254019.5,279351.4]	[228571,253968,279364]
-5	40404	[185603.4,202009,218107]	[185858,202020,218181]
-6	27972	[156598.7,167866,179118.3]	[156643,167832,179020]
+4	63492	[228369.80000000002,254011,279351.6]	[228571,253968,279364]
+5	40404	[185602.3,202005,218108.5]	[185858,202020,218181]
+6	27972	[156598.6,167864,179118.40000000002]	[156643,167832,179020]
 7	20513	[135400.8,143550,151792.6]	[135384,143589,151794]
 8	15686	[119239.20000000001,125463,131772.40000000002]	[119215,125490,131764]
-9	12384	[106510.20000000001,111539,116415.7]	[106501,111455,116408]
+9	12384	[106509.79999999999,111538,116415.8]	[106501,111455,116408]
 10	10025	[96223.2,100346,104288.7]	[96240,100250,104260]
-11	8282	[87732.8,91036,94410.20000000001]	[87784,91097,94409]
+11	8282	[87732.70000000001,91035,94408.6]	[87784,91097,94409]
 12	6957	[80694.6,83477,86259.4]	[80694,83477,86260]
 13	5925	[74666.40000000001,77036,79405.6]	[74666,77036,79406]
 14	5109	[69475.8,71519,73562.2]	[69475,71519,73563]
diff --git a/tests/queries/0_stateless/00601_kill_running_query.reference b/tests/queries/0_stateless/00601_kill_running_query.reference
index d00491fd7e5..3917ff89482 100644
--- a/tests/queries/0_stateless/00601_kill_running_query.reference
+++ b/tests/queries/0_stateless/00601_kill_running_query.reference
@@ -1 +1 @@
-1
+waiting	test_00601_default	default	SELECT sum(ignore(*)) FROM (SELECT number % 1000 AS k, groupArray(number) FROM numbers(50000000) GROUP BY k)
diff --git a/tests/queries/0_stateless/00601_kill_running_query.sh b/tests/queries/0_stateless/00601_kill_running_query.sh
index e4e3ee98877..3163f8146d0 100755
--- a/tests/queries/0_stateless/00601_kill_running_query.sh
+++ b/tests/queries/0_stateless/00601_kill_running_query.sh
@@ -6,7 +6,12 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 
 set -e -o pipefail
 
-${CLICKHOUSE_CURL_COMMAND} -q --max-time 30 -sS "$CLICKHOUSE_URL?query_id=hello" -d 'SELECT sum(ignore(*)) FROM (SELECT number % 1000 AS k, groupArray(number) FROM numbers(20000000) GROUP BY k)' | wc -l &
-sleep 0.1 # First query (usually) should be received by the server after this sleep.
-$CLICKHOUSE_CURL -sS "$CLICKHOUSE_URL" -d "KILL QUERY WHERE query_id = 'hello' FORMAT Null"
+function wait_for_query_to_start()
+{
+    while [[ $($CLICKHOUSE_CURL -sS "$CLICKHOUSE_URL" -d "SELECT count() FROM system.processes WHERE query_id = '$1'") == 0 ]]; do sleep 0.1; done
+}
+
+${CLICKHOUSE_CURL_COMMAND} -q --max-time 30 -sS "$CLICKHOUSE_URL&query_id=test_00601_$CLICKHOUSE_DATABASE" -d 'SELECT sum(ignore(*)) FROM (SELECT number % 1000 AS k, groupArray(number) FROM numbers(50000000) GROUP BY k)' > /dev/null &
+wait_for_query_to_start "test_00601_$CLICKHOUSE_DATABASE"
+$CLICKHOUSE_CURL -sS "$CLICKHOUSE_URL" -d "KILL QUERY WHERE query_id = 'test_00601_$CLICKHOUSE_DATABASE'"
 wait
diff --git a/tests/queries/0_stateless/00735_conditional.reference b/tests/queries/0_stateless/00735_long_conditional.reference
similarity index 83%
rename from tests/queries/0_stateless/00735_conditional.reference
rename to tests/queries/0_stateless/00735_long_conditional.reference
index 6bee974769d..6308a48218b 100644
--- a/tests/queries/0_stateless/00735_conditional.reference
+++ b/tests/queries/0_stateless/00735_long_conditional.reference
@@ -105,6 +105,9 @@ column vs value
 0	1	1	Int8	UInt32	Int64
 0	1	1	Int8	Float32	Float32
 0	1	1	Int8	Float64	Float64
+0	1	1	Int8	Decimal(9, 0)	Decimal(9, 0)
+0	1	1	Int8	Decimal(18, 0)	Decimal(18, 0)
+0	1	1	Int8	Decimal(38, 0)	Decimal(38, 0)
 0	1	1	Int16	Int8	Int16
 0	1	1	Int16	Int16	Int16
 0	1	1	Int16	Int32	Int32
@@ -114,6 +117,9 @@ column vs value
 0	1	1	Int16	UInt32	Int64
 0	1	1	Int16	Float32	Float32
 0	1	1	Int16	Float64	Float64
+0	1	1	Int16	Decimal(9, 0)	Decimal(9, 0)
+0	1	1	Int16	Decimal(18, 0)	Decimal(18, 0)
+0	1	1	Int16	Decimal(38, 0)	Decimal(38, 0)
 0	1	1	Int32	Int8	Int32
 0	1	1	Int32	Int16	Int32
 0	1	1	Int32	Int32	Int32
@@ -123,6 +129,9 @@ column vs value
 0	1	1	Int32	UInt32	Int64
 0	1	1	Int32	Float32	Float64
 0	1	1	Int32	Float64	Float64
+0	1	1	Int32	Decimal(9, 0)	Decimal(9, 0)
+0	1	1	Int32	Decimal(18, 0)	Decimal(18, 0)
+0	1	1	Int32	Decimal(38, 0)	Decimal(38, 0)
 0	1	1	Int64	Int8	Int64
 0	1	1	Int64	Int16	Int64
 0	1	1	Int64	Int32	Int64
@@ -130,6 +139,9 @@ column vs value
 0	1	1	Int64	UInt8	Int64
 0	1	1	Int64	UInt16	Int64
 0	1	1	Int64	UInt32	Int64
+0	1	1	Int64	Decimal(9, 0)	Decimal(18, 0)
+0	1	1	Int64	Decimal(18, 0)	Decimal(18, 0)
+0	1	1	Int64	Decimal(38, 0)	Decimal(38, 0)
 0	1	1	UInt8	Int8	Int16
 0	1	1	UInt8	Int16	Int16
 0	1	1	UInt8	Int32	Int32
@@ -140,6 +152,9 @@ column vs value
 0	1	1	UInt8	UInt64	UInt64
 0	1	1	UInt8	Float32	Float32
 0	1	1	UInt8	Float64	Float64
+0	1	1	UInt8	Decimal(9, 0)	Decimal(9, 0)
+0	1	1	UInt8	Decimal(18, 0)	Decimal(18, 0)
+0	1	1	UInt8	Decimal(38, 0)	Decimal(38, 0)
 0	1	1	UInt16	Int8	Int32
 0	1	1	UInt16	Int16	Int32
 0	1	1	UInt16	Int32	Int32
@@ -150,6 +165,9 @@ column vs value
 0	1	1	UInt16	UInt64	UInt64
 0	1	1	UInt16	Float32	Float32
 0	1	1	UInt16	Float64	Float64
+0	1	1	UInt16	Decimal(9, 0)	Decimal(9, 0)
+0	1	1	UInt16	Decimal(18, 0)	Decimal(18, 0)
+0	1	1	UInt16	Decimal(38, 0)	Decimal(38, 0)
 0	1	1	UInt32	Int8	Int64
 0	1	1	UInt32	Int16	Int64
 0	1	1	UInt32	Int32	Int64
@@ -160,10 +178,16 @@ column vs value
 0	1	1	UInt32	UInt64	UInt64
 0	1	1	UInt32	Float32	Float64
 0	1	1	UInt32	Float64	Float64
+0	1	1	UInt32	Decimal(9, 0)	Decimal(18, 0)
+0	1	1	UInt32	Decimal(18, 0)	Decimal(18, 0)
+0	1	1	UInt32	Decimal(38, 0)	Decimal(38, 0)
 0	1	1	UInt64	UInt8	UInt64
 0	1	1	UInt64	UInt16	UInt64
 0	1	1	UInt64	UInt32	UInt64
 0	1	1	UInt64	UInt64	UInt64
+0	1	1	UInt64	Decimal(9, 0)	Decimal(38, 0)
+0	1	1	UInt64	Decimal(18, 0)	Decimal(38, 0)
+0	1	1	UInt64	Decimal(38, 0)	Decimal(38, 0)
 1970-01-01	1970-01-02	1970-01-02	Date	Date	Date
 2000-01-01	2000-01-01 00:00:01	2000-01-01 00:00:01	Date	DateTime(\'Europe/Moscow\')	DateTime
 2000-01-01 00:00:00	2000-01-02	2000-01-02 00:00:00	DateTime(\'Europe/Moscow\')	Date	DateTime
diff --git a/tests/queries/0_stateless/00735_conditional.sql b/tests/queries/0_stateless/00735_long_conditional.sql
similarity index 98%
rename from tests/queries/0_stateless/00735_conditional.sql
rename to tests/queries/0_stateless/00735_long_conditional.sql
index 04439f4062e..a247ce003b3 100644
--- a/tests/queries/0_stateless/00735_conditional.sql
+++ b/tests/queries/0_stateless/00735_long_conditional.sql
@@ -176,9 +176,9 @@ SELECT materialize(toInt8(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z, t
 SELECT materialize(toInt8(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toInt8(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toInt8(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toInt8(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt8(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt8(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toInt8(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt8(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt8(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toInt16(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toInt16(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
@@ -192,9 +192,9 @@ SELECT materialize(toInt16(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z,
 SELECT materialize(toInt16(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toInt16(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toInt16(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toInt16(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt16(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt16(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toInt16(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt16(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt16(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toInt32(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toInt32(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
@@ -208,9 +208,9 @@ SELECT materialize(toInt32(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z,
 SELECT materialize(toInt32(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toInt32(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toInt32(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toInt32(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt32(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt32(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toInt32(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt32(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt32(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toInt64(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toInt64(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
@@ -224,9 +224,9 @@ SELECT materialize(toInt64(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z,
 SELECT materialize(toInt64(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
 SELECT materialize(toInt64(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toInt64(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toInt64(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt64(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toInt64(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toInt64(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt64(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toInt64(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toUInt8(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toUInt8(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
@@ -240,9 +240,9 @@ SELECT materialize(toUInt8(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z,
 SELECT materialize(toUInt8(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toUInt8(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toUInt8(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toUInt8(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt8(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt8(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toUInt8(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt8(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt8(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toUInt16(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toUInt16(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
@@ -256,9 +256,9 @@ SELECT materialize(toUInt16(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z,
 SELECT materialize(toUInt16(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toUInt16(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toUInt16(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toUInt16(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt16(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt16(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toUInt16(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt16(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt16(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toUInt32(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toUInt32(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
@@ -272,9 +272,9 @@ SELECT materialize(toUInt32(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z,
 SELECT materialize(toUInt32(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 SELECT materialize(toUInt32(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toUInt32(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toUInt32(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt32(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt32(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toUInt32(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt32(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt32(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toUInt64(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
 SELECT materialize(toUInt64(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
@@ -288,9 +288,9 @@ SELECT materialize(toUInt64(0)) AS x, toFloat32(1) AS y, ((x > y) ? x : y) AS z,
 SELECT materialize(toUInt64(0)) AS x, toFloat64(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
 SELECT materialize(toUInt64(0)) AS x, toDate(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toUInt64(0)) AS x, toDateTime(1, 'Europe/Moscow') AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 386 }
-SELECT materialize(toUInt64(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt64(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
-SELECT materialize(toUInt64(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
+SELECT materialize(toUInt64(0)) AS x, toDecimal32(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt64(0)) AS x, toDecimal64(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
+SELECT materialize(toUInt64(0)) AS x, toDecimal128(1, 0) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z);
 
 SELECT materialize(toDate(0)) AS x, toInt8(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
 SELECT materialize(toDate(0)) AS x, toInt16(1) AS y, ((x > y) ? x : y) AS z, toTypeName(x), toTypeName(y), toTypeName(z); -- { serverError 43 }
diff --git a/tests/queries/0_stateless/00825_protobuf_format_splitted_nested.reference b/tests/queries/0_stateless/00825_protobuf_format_splitted_nested.reference
new file mode 100644
index 00000000000..2fa8a590122
--- /dev/null
+++ b/tests/queries/0_stateless/00825_protobuf_format_splitted_nested.reference
@@ -0,0 +1,56 @@
+tags for first fixed value	1622559733	920	1	79034445678	250208889765444	35655678903421	79991232222	250	20	18122	22010	text for the first fixed value	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	3	172.18.20.11	47855	32705	26855	51940	0x1dbb09	_49597	msc_number_52317	0x750x830xa50xb	31453	49538	1	522d
+
+Binary representation:
+00000000  f7 01 0a 1a 74 61 67 73  20 66 6f 72 20 66 69 72  |....tags for fir|
+00000010  73 74 20 66 69 78 65 64  20 76 61 6c 75 65 10 f5  |st fixed value..|
+00000020  97 d9 85 06 18 98 07 20  01 28 01 32 0b 37 39 30  |....... .(.2.790|
+00000030  33 34 34 34 35 36 37 38  3a 0f 32 35 30 32 30 38  |34445678:.250208|
+00000040  38 38 39 37 36 35 34 34  34 42 0e 33 35 36 35 35  |889765444B.35655|
+00000050  36 37 38 39 30 33 34 32  31 4a 0b 37 39 39 39 31  |678903421J.79991|
+00000060  32 33 32 32 32 32 50 fa  01 58 14 60 ca 8d 01 68  |232222P..X.`...h|
+00000070  fa ab 01 72 1e 74 65 78  74 20 66 6f 72 20 74 68  |...r.text for th|
+00000080  65 20 66 69 72 73 74 20  66 69 78 65 64 20 76 61  |e first fixed va|
+00000090  6c 75 65 aa 06 63 08 03  1a 0c 31 37 32 2e 31 38  |lue..c....172.18|
+000000a0  2e 32 30 2e 31 31 20 ef  f5 02 28 c1 ff 01 30 e7  |.20.11 ...(...0.|
+000000b0  d1 01 38 e4 95 03 42 08  30 78 31 64 62 62 30 39  |..8...B.0x1dbb09|
+000000c0  4a 06 5f 34 39 35 39 37  52 10 6d 73 63 5f 6e 75  |J._49597R.msc_nu|
+000000d0  6d 62 65 72 5f 35 32 33  31 37 5a 0f 30 78 37 35  |mber_52317Z.0x75|
+000000e0  30 78 38 33 30 78 61 35  30 78 62 68 dd f5 01 70  |0x830xa50xbh...p|
+000000f0  82 83 03 7a 04 35 32 32  64                       |...z.522d|
+000000f9
+
+MESSAGE #1 AT 0x00000002
+a: "tags for first fixed value"
+b: 1622559733
+c: 920
+n: B
+d: E
+e: "79034445678"
+f: "250208889765444"
+g: "35655678903421"
+h: "79991232222"
+i: 250
+j: 20
+k: 18122
+l: 22010
+m: "text for the first fixed value"
+sub_2 {
+  a: 3
+  b: "172.18.20.11"
+  c: 47855
+  d: 32705
+  e: 26855
+  f: 51940
+  g: "0x1dbb09"
+  h: "_49597"
+  i: "msc_number_52317"
+  j: "0x750x830xa50xb"
+  k: 31453
+  l: 49538
+  random_name: "522d"
+}
+
+Binary representation is as expected
+
+tags for first fixed value	1622559733	920	1	79034445678	250208889765444	35655678903421	79991232222	250	20	18122	22010	text for the first fixed value	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	3	172.18.20.11	47855	32705	26855	51940	0x1dbb09	_49597	msc_number_52317	0x750x830xa50xb	31453	49538	1	522d
+tags for first fixed value	1622559733	920	1	79034445678	250208889765444	35655678903421	79991232222	250	20	18122	22010	text for the first fixed value	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	\N	3	172.18.20.11	47855	32705	26855	51940	0x1dbb09	_49597	msc_number_52317	0x750x830xa50xb	31453	49538	1	522d
diff --git a/tests/queries/0_stateless/00825_protobuf_format_splitted_nested.sh b/tests/queries/0_stateless/00825_protobuf_format_splitted_nested.sh
new file mode 100755
index 00000000000..ca915aca944
--- /dev/null
+++ b/tests/queries/0_stateless/00825_protobuf_format_splitted_nested.sh
@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+SCHEMADIR=$CURDIR/format_schemas
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+set -eo pipefail
+
+# Run the client.
+$CLICKHOUSE_CLIENT --multiquery <<EOF
+DROP TABLE IF EXISTS splitted_nested_protobuf_00825;
+
+CREATE TABLE splitted_nested_protobuf_00825 (
+  a String,
+  b Int64,
+  c Int32,
+  d Int32, 
+  e String, 
+  f String, 
+  g String, 
+  h String, 
+  i Int32, 
+  j Int32, 
+  k Nullable(Int32), 
+  l Nullable(Int32), 
+  m String, 
+  sub_1_a Nullable(Int32), 
+  sub_1_b Nullable(Int32), 
+  sub_1_c Nullable(String), 
+  sub_1_d Nullable(String), 
+  sub_1_e Nullable(String), 
+  sub_1_f Nullable(String), 
+  sub_1_g Nullable(String), 
+  sub_1_h Nullable(String), 
+  sub_1_i Nullable(String), 
+  sub_1_j Nullable(String), 
+  sub_1_k Nullable(String), 
+  sub_2_a Nullable(Int32),
+  sub_2_b Nullable(String), 
+  sub_2_c Nullable(Int32), 
+  sub_2_d Nullable(Int32), 
+  sub_2_e Nullable(Int32), 
+  sub_2_f Nullable(Int32), 
+  sub_2_g Nullable(String), 
+  sub_2_h Nullable(String), 
+  sub_2_i Nullable(String), 
+  sub_2_j Nullable(String), 
+  sub_2_k Nullable(Int64), 
+  sub_2_l Nullable(Int64), 
+  n Int32, 
+  sub_2_random_name Nullable(String)
+) ENGINE = MergeTree ORDER BY tuple();
+
+INSERT INTO splitted_nested_protobuf_00825 VALUES ('tags for first fixed value', 1622559733, 920, 1, '79034445678', '250208889765444', '35655678903421', '79991232222', 250, 20, 18122, 22010, 'text for the first fixed value', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 3, '172.18.20.11', 47855, 32705, 26855, 51940, '0x1dbb09', '_49597', 'msc_number_52317', '0x750x830xa50xb', 31453, 49538, 1, '522d');
+
+SELECT * FROM splitted_nested_protobuf_00825;
+EOF
+
+BINARY_FILE_PATH=$(mktemp "$CURDIR/00825_protobuf_format_splitted_nested.XXXXXX.binary")
+$CLICKHOUSE_CLIENT --query "SELECT * FROM splitted_nested_protobuf_00825 FORMAT Protobuf SETTINGS format_schema = '$SCHEMADIR/00825_protobuf_format_splitted_nested:Some'" > "$BINARY_FILE_PATH"
+
+# Check the output in the protobuf format
+echo
+$CURDIR/helpers/protobuf_length_delimited_encoder.py --decode_and_check --format_schema "$SCHEMADIR/00825_protobuf_format_splitted_nested:some.Some" --input "$BINARY_FILE_PATH"
+
+# Check the input in the protobuf format (now the table contains the same data twice).
+echo
+$CLICKHOUSE_CLIENT --query "INSERT INTO splitted_nested_protobuf_00825 FORMAT Protobuf SETTINGS format_schema='$SCHEMADIR/00825_protobuf_format_splitted_nested:Some'" < "$BINARY_FILE_PATH"
+$CLICKHOUSE_CLIENT --query "SELECT * FROM splitted_nested_protobuf_00825"
+
+rm "$BINARY_FILE_PATH"
+$CLICKHOUSE_CLIENT --query "DROP TABLE splitted_nested_protobuf_00825"
diff --git a/tests/queries/0_stateless/01035_avg.reference b/tests/queries/0_stateless/01035_avg.reference
index a9f31de57e1..f8768d911d6 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	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
+-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.000005	-0.000004999999999999992
 -2767.546272
 999999
--0.5000045261781699
+-0.50000449943727
diff --git a/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.reference b/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.reference
index 83a8162e5f4..d5ff3e12269 100644
--- a/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.reference
+++ b/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.reference
@@ -1,9 +1,9 @@
 1	1	1	-1
 2	2	2	-1
-CREATE TABLE default.table_with_version_replicated_1\n(\n    `key` UInt64,\n    `value` String,\n    `version` UInt8,\n    `sign` Int8\n)\nENGINE = ReplicatedVersionedCollapsingMergeTree(\'/clickhouse/default/test_01511/t\', \'1\', sign, version)\nORDER BY key\nSETTINGS index_granularity = 8192
+CREATE TABLE default.table_with_version_replicated_1\n(\n    `key` UInt64,\n    `value` String,\n    `version` UInt8,\n    `sign` Int8\n)\nENGINE = ReplicatedVersionedCollapsingMergeTree(\'/clickhouse/default/test_01511/{shard}/t\', \'1_{replica}\', sign, version)\nORDER BY key\nSETTINGS index_granularity = 8192
 1	1	1	-1
 2	2	2	-1
-CREATE TABLE default.table_with_version_replicated_1\n(\n    `key` UInt64,\n    `value` String,\n    `version` UInt32,\n    `sign` Int8\n)\nENGINE = ReplicatedVersionedCollapsingMergeTree(\'/clickhouse/default/test_01511/t\', \'1\', sign, version)\nORDER BY key\nSETTINGS index_granularity = 8192
+CREATE TABLE default.table_with_version_replicated_1\n(\n    `key` UInt64,\n    `value` String,\n    `version` UInt32,\n    `sign` Int8\n)\nENGINE = ReplicatedVersionedCollapsingMergeTree(\'/clickhouse/default/test_01511/{shard}/t\', \'1_{replica}\', sign, version)\nORDER BY key\nSETTINGS index_granularity = 8192
 1	1	2	1
 2	2	2	-1
 1	1	2	1
@@ -11,6 +11,6 @@ CREATE TABLE default.table_with_version_replicated_1\n(\n    `key` UInt64,\n
 3	3	65555	1
 1	1	2	1
 2	2	2	-1
-CREATE TABLE default.table_with_version_replicated_2\n(\n    `key` UInt64,\n    `value` String,\n    `version` UInt32,\n    `sign` Int8\n)\nENGINE = ReplicatedVersionedCollapsingMergeTree(\'/clickhouse/default/test_01511/t\', \'2\', sign, version)\nORDER BY key\nSETTINGS index_granularity = 8192
+CREATE TABLE default.table_with_version_replicated_2\n(\n    `key` UInt64,\n    `value` String,\n    `version` UInt32,\n    `sign` Int8\n)\nENGINE = ReplicatedVersionedCollapsingMergeTree(\'/clickhouse/default/test_01511/{shard}/t\', \'2_{replica}\', sign, version)\nORDER BY key\nSETTINGS index_granularity = 8192
 1	1	2	1
 2	2	2	-1
diff --git a/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.sql b/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.sql
index 9b6b81112f6..17a6b8883a4 100644
--- a/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.sql
+++ b/tests/queries/0_stateless/01511_alter_version_versioned_collapsing_merge_tree_zookeeper.sql
@@ -8,7 +8,7 @@ CREATE TABLE table_with_version_replicated_1
     version UInt8,
     sign Int8
 )
-ENGINE ReplicatedVersionedCollapsingMergeTree('/clickhouse/{database}/test_01511/t', '1', sign, version)
+ENGINE ReplicatedVersionedCollapsingMergeTree('/clickhouse/' || currentDatabase() || '/test_01511/{shard}/t', '1_{replica}', sign, version)
 ORDER BY key;
 
 CREATE TABLE table_with_version_replicated_2
@@ -18,7 +18,7 @@ CREATE TABLE table_with_version_replicated_2
     version UInt8,
     sign Int8
 )
-ENGINE ReplicatedVersionedCollapsingMergeTree('/clickhouse/{database}/test_01511/t', '2', sign, version)
+ENGINE ReplicatedVersionedCollapsingMergeTree('/clickhouse/' || currentDatabase() || '/test_01511/{shard}/t', '2_{replica}', sign, version)
 ORDER BY key;
 
 INSERT INTO table_with_version_replicated_1 VALUES (1, '1', 1, -1);
diff --git a/tests/queries/0_stateless/01533_quantile_deterministic_assert.reference b/tests/queries/0_stateless/01533_quantile_deterministic_assert.reference
index 231c72269ca..1f6132cdec2 100644
--- a/tests/queries/0_stateless/01533_quantile_deterministic_assert.reference
+++ b/tests/queries/0_stateless/01533_quantile_deterministic_assert.reference
@@ -1 +1 @@
-3998
+3997.5
diff --git a/tests/queries/0_stateless/01721_dictionary_decimal_p_s.reference b/tests/queries/0_stateless/01721_dictionary_decimal_p_s.reference
index 066b4bd1d97..cfc5444a56e 100644
--- a/tests/queries/0_stateless/01721_dictionary_decimal_p_s.reference
+++ b/tests/queries/0_stateless/01721_dictionary_decimal_p_s.reference
@@ -1,9 +1,9 @@
 -------- 42 --------
-42	14.0000	14.00000000	14.00000000	14.0000000000000000618637523926765281280
+42	14.0000	14.00000000	14.00000000	14.0000000000000000627860895963620057088
 42	14.0000	14.00000000	14.00000000
 14.0000	14.00000000	14.00000000
 -------- 4999 --------
-4999	1666.3333	1666.33333333	1666.33333333	1633.3553612205046244471093725648757194800
+4999	1666.3333	1666.33333333	1666.33333333	1666.3333333333331934501138529985348370480
 4999	1666.3333	1666.33333333	1666.33333333
 1666.3333	1666.33333333	1666.33333333
 -------- 5000 --------
diff --git a/tests/queries/0_stateless/01903_http_fields.reference b/tests/queries/0_stateless/01903_http_fields.reference
new file mode 100644
index 00000000000..c18b4e9b082
--- /dev/null
+++ b/tests/queries/0_stateless/01903_http_fields.reference
@@ -0,0 +1,8 @@
+1
+1
+1
+1
+1
+1
+1
+1
diff --git a/tests/queries/0_stateless/01903_http_fields.sh b/tests/queries/0_stateless/01903_http_fields.sh
new file mode 100755
index 00000000000..0f2b0df13d9
--- /dev/null
+++ b/tests/queries/0_stateless/01903_http_fields.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+DEFAULT_MAX_NAME_SIZE=$($CLICKHOUSE_CLIENT -q "SELECT value FROM system.settings WHERE name='http_max_field_name_size'")
+DEFAULT_MAX_VALUE_SIZE=$($CLICKHOUSE_CLIENT -q "SELECT value FROM system.settings WHERE name='http_max_field_value_size'")
+
+python3 -c "print('a'*($DEFAULT_MAX_NAME_SIZE-2) + ';')" > $CLICKHOUSE_TMP/short_name.txt
+python3 -c "print('a'*($DEFAULT_MAX_NAME_SIZE+1) + ';')" > $CLICKHOUSE_TMP/long_name.txt
+python3 -c "print('a'*($DEFAULT_MAX_NAME_SIZE-2) + ': ' + 'b'*($DEFAULT_MAX_VALUE_SIZE-2))" > $CLICKHOUSE_TMP/short_short.txt
+python3 -c "print('a'*($DEFAULT_MAX_NAME_SIZE-2) + ': ' + 'b'*($DEFAULT_MAX_VALUE_SIZE+1))" > $CLICKHOUSE_TMP/short_long.txt
+python3 -c "print('a'*($DEFAULT_MAX_NAME_SIZE+1) + ': ' + 'b'*($DEFAULT_MAX_VALUE_SIZE-2))" > $CLICKHOUSE_TMP/long_short.txt
+
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}" -H @$CLICKHOUSE_TMP/short_name.txt -d 'SELECT 1'
+${CLICKHOUSE_CURL} -sSv "${CLICKHOUSE_URL}" -H @$CLICKHOUSE_TMP/long_name.txt -d 'SELECT 1' 2>&1 | grep -Fc '400 Bad Request'
+${CLICKHOUSE_CURL} -sS "${CLICKHOUSE_URL}" -H @$CLICKHOUSE_TMP/short_short.txt -d 'SELECT 1'
+${CLICKHOUSE_CURL} -sSv "${CLICKHOUSE_URL}" -H @$CLICKHOUSE_TMP/short_long.txt -d 'SELECT 1' 2>&1 | grep -Fc '400 Bad Request'
+${CLICKHOUSE_CURL} -sSv "${CLICKHOUSE_URL}" -H @$CLICKHOUSE_TMP/long_short.txt -d 'SELECT 1' 2>&1 | grep -Fc '400 Bad Request'
+
+# Session and query settings shouldn't affect the HTTP field's name or value sizes.
+${CLICKHOUSE_CURL} -sSv "${CLICKHOUSE_URL}&http_max_field_name_size=$(($DEFAULT_MAX_NAME_SIZE+10))" -H @$CLICKHOUSE_TMP/long_name.txt -d 'SELECT 1' 2>&1 | grep -Fc '400 Bad Request'
+${CLICKHOUSE_CURL} -sSv "${CLICKHOUSE_URL}&http_max_field_value_size=$(($DEFAULT_MAX_VALUE_SIZE+10))" -H @$CLICKHOUSE_TMP/short_long.txt -d 'SELECT 1' 2>&1 | grep -Fc '400 Bad Request'
+${CLICKHOUSE_CURL} -sSv "${CLICKHOUSE_URL}&http_max_field_name_size=$(($DEFAULT_MAX_NAME_SIZE+10))" -H @$CLICKHOUSE_TMP/long_short.txt -d 'SELECT 1' 2>&1 | grep -Fc '400 Bad Request'
+
+# TODO: test that session context doesn't affect these settings either.
diff --git a/tests/queries/0_stateless/01906_bigint_accurate_cast_ubsan.reference b/tests/queries/0_stateless/01906_bigint_accurate_cast_ubsan.reference
new file mode 100644
index 00000000000..a293d9344f8
--- /dev/null
+++ b/tests/queries/0_stateless/01906_bigint_accurate_cast_ubsan.reference
@@ -0,0 +1,5 @@
+10000000000000000000
+10000000000000000000
+10000000000000000000
+10000000000000000000
+10000000000000000000
diff --git a/tests/queries/0_stateless/01906_bigint_accurate_cast_ubsan.sql b/tests/queries/0_stateless/01906_bigint_accurate_cast_ubsan.sql
new file mode 100644
index 00000000000..4b9fa9662a9
--- /dev/null
+++ b/tests/queries/0_stateless/01906_bigint_accurate_cast_ubsan.sql
@@ -0,0 +1,15 @@
+SELECT accurateCast(1e35, 'UInt32'); -- { serverError 70 }
+SELECT accurateCast(1e35, 'UInt64'); -- { serverError 70 }
+SELECT accurateCast(1e35, 'UInt128'); -- { serverError 70 }
+SELECT accurateCast(1e35, 'UInt256'); -- { serverError 70 }
+
+SELECT accurateCast(1e19, 'UInt64');
+SELECT accurateCast(1e19, 'UInt128');
+SELECT accurateCast(1e19, 'UInt256');
+SELECT accurateCast(1e20, 'UInt64'); -- { serverError 70 }
+SELECT accurateCast(1e20, 'UInt128'); -- { serverError 70 }
+SELECT accurateCast(1e20, 'UInt256'); -- { serverError 70 }
+
+SELECT accurateCast(1e19, 'Int64'); -- { serverError 70 }
+SELECT accurateCast(1e19, 'Int128');
+SELECT accurateCast(1e19, 'Int256');
diff --git a/tests/queries/0_stateless/01906_lc_in_bug.reference b/tests/queries/0_stateless/01906_lc_in_bug.reference
new file mode 100644
index 00000000000..9fe1650abf0
--- /dev/null
+++ b/tests/queries/0_stateless/01906_lc_in_bug.reference
@@ -0,0 +1,2 @@
+1	0
+3	1
diff --git a/tests/queries/0_stateless/01906_lc_in_bug.sql b/tests/queries/0_stateless/01906_lc_in_bug.sql
new file mode 100644
index 00000000000..f8f41da31ae
--- /dev/null
+++ b/tests/queries/0_stateless/01906_lc_in_bug.sql
@@ -0,0 +1,8 @@
+drop table if exists tab;
+create table tab (x LowCardinality(String)) engine = MergeTree order by tuple();
+
+insert into tab values ('a'), ('bb'), ('a'), ('cc');
+
+select count() as c, x in ('a', 'bb') as g from tab group by g order by c;
+
+drop table if exists tab;
diff --git a/tests/queries/0_stateless/01913_fix_column_transformer_replace_format.reference b/tests/queries/0_stateless/01913_fix_column_transformer_replace_format.reference
new file mode 100644
index 00000000000..c2ebb7fa4f4
--- /dev/null
+++ b/tests/queries/0_stateless/01913_fix_column_transformer_replace_format.reference
@@ -0,0 +1 @@
+CREATE VIEW default.my_view\n(\n    `Id` UInt32,\n    `Object.Key` Array(UInt16),\n    `Object.Value` Array(String)\n) AS\nSELECT * REPLACE arrayMap(x -> (x + 1), `Object.Key`) AS `Object.Key`\nFROM default.my_table
diff --git a/tests/queries/0_stateless/01913_fix_column_transformer_replace_format.sql b/tests/queries/0_stateless/01913_fix_column_transformer_replace_format.sql
new file mode 100644
index 00000000000..e17c202ccd9
--- /dev/null
+++ b/tests/queries/0_stateless/01913_fix_column_transformer_replace_format.sql
@@ -0,0 +1,9 @@
+drop table if exists my_table;
+drop view if exists my_view;
+create table my_table(Id UInt32, Object Nested(Key UInt8, Value String)) engine MergeTree order by Id;
+create view my_view as select * replace arrayMap(x -> x + 1,`Object.Key`) as `Object.Key` from my_table;
+
+show create my_view;
+
+drop table my_table;
+drop view my_view;
diff --git a/tests/queries/0_stateless/01913_if_int_decimal.reference b/tests/queries/0_stateless/01913_if_int_decimal.reference
new file mode 100644
index 00000000000..c54e91df3e4
--- /dev/null
+++ b/tests/queries/0_stateless/01913_if_int_decimal.reference
@@ -0,0 +1,3 @@
+2.0000000000
+1.0000000000
+2.0000000000
diff --git a/tests/queries/0_stateless/01913_if_int_decimal.sql b/tests/queries/0_stateless/01913_if_int_decimal.sql
new file mode 100644
index 00000000000..83fb4c352c1
--- /dev/null
+++ b/tests/queries/0_stateless/01913_if_int_decimal.sql
@@ -0,0 +1 @@
+select number % 2 ? materialize(1)::Decimal(18, 10) : 2 FROM numbers(3);
diff --git a/tests/queries/0_stateless/01913_quantile_deterministic.reference b/tests/queries/0_stateless/01913_quantile_deterministic.reference
new file mode 100644
index 00000000000..a39d3d91e8a
--- /dev/null
+++ b/tests/queries/0_stateless/01913_quantile_deterministic.reference
@@ -0,0 +1,20 @@
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
+492708
diff --git a/tests/queries/0_stateless/01913_quantile_deterministic.sh b/tests/queries/0_stateless/01913_quantile_deterministic.sh
new file mode 100755
index 00000000000..5a2c7279678
--- /dev/null
+++ b/tests/queries/0_stateless/01913_quantile_deterministic.sh
@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+${CLICKHOUSE_CLIENT} --query "DROP TABLE IF EXISTS d"
+${CLICKHOUSE_CLIENT} --query "CREATE TABLE d (oid UInt64) ENGINE = MergeTree ORDER BY oid"
+${CLICKHOUSE_CLIENT} --min_insert_block_size_rows 0 --min_insert_block_size_bytes 0 --max_block_size 8192 --query "insert into d select * from numbers(1000000)"
+
+# In previous ClickHouse versions there was a mistake that makes quantileDeterministic functions not really deterministic (in edge cases).
+
+for _ in {1..20};
+do
+    ${CLICKHOUSE_CLIENT} --query "SELECT medianDeterministic(oid, oid) FROM d"
+done
+
+${CLICKHOUSE_CLIENT} --query "DROP TABLE d"
diff --git a/tests/queries/0_stateless/01914_index_bgranvea.reference b/tests/queries/0_stateless/01914_index_bgranvea.reference
new file mode 100644
index 00000000000..85e6138dc5d
--- /dev/null
+++ b/tests/queries/0_stateless/01914_index_bgranvea.reference
@@ -0,0 +1,2 @@
+1	1	1
+1	1	1
diff --git a/tests/queries/0_stateless/01914_index_bgranvea.sql b/tests/queries/0_stateless/01914_index_bgranvea.sql
new file mode 100644
index 00000000000..817c9571088
--- /dev/null
+++ b/tests/queries/0_stateless/01914_index_bgranvea.sql
@@ -0,0 +1,9 @@
+DROP TABLE IF EXISTS test;
+create table test (id UInt64,insid UInt64,insidvalue Nullable(UInt64), index insid_idx (insid) type bloom_filter() granularity 1, index insidvalue_idx (insidvalue) type bloom_filter() granularity 1) ENGINE=MergeTree() ORDER BY (insid,id);
+
+insert into test values(1,1,1),(2,2,2);
+
+select * from test where insid IN (1) OR insidvalue IN (1);
+select * from test where insid IN (1) AND insidvalue IN (1);
+
+DROP TABLE test;
diff --git a/tests/queries/0_stateless/01914_ubsan_quantile_timing.reference b/tests/queries/0_stateless/01914_ubsan_quantile_timing.reference
new file mode 100644
index 00000000000..573541ac970
--- /dev/null
+++ b/tests/queries/0_stateless/01914_ubsan_quantile_timing.reference
@@ -0,0 +1 @@
+0
diff --git a/tests/queries/0_stateless/01914_ubsan_quantile_timing.sql b/tests/queries/0_stateless/01914_ubsan_quantile_timing.sql
new file mode 100644
index 00000000000..422dd3bbbad
--- /dev/null
+++ b/tests/queries/0_stateless/01914_ubsan_quantile_timing.sql
@@ -0,0 +1 @@
+SELECT quantileTiming(-0.)(number / 1.1754943508222875e-38) FROM numbers(257);
diff --git a/tests/queries/0_stateless/01915_for_each_crakjie.reference b/tests/queries/0_stateless/01915_for_each_crakjie.reference
new file mode 100644
index 00000000000..905658eb3f7
--- /dev/null
+++ b/tests/queries/0_stateless/01915_for_each_crakjie.reference
@@ -0,0 +1,2 @@
+b	[2,2.2,2.260035]
+a	[2,2.2,2.260035]
diff --git a/tests/queries/0_stateless/01915_for_each_crakjie.sql b/tests/queries/0_stateless/01915_for_each_crakjie.sql
new file mode 100644
index 00000000000..f65e08af61b
--- /dev/null
+++ b/tests/queries/0_stateless/01915_for_each_crakjie.sql
@@ -0,0 +1,10 @@
+WITH arrayJoin(['a', 'b']) AS z
+SELECT
+    z,
+    sumMergeForEach(x) AS x
+FROM
+(
+    SELECT sumStateForEach([1., 1.1, 1.1300175]) AS x
+    FROM remote('127.0.0.{1,2}', system.one)
+)
+GROUP BY z;
diff --git a/tests/queries/0_stateless/format_schemas/00825_protobuf_format_splitted_nested.proto b/tests/queries/0_stateless/format_schemas/00825_protobuf_format_splitted_nested.proto
new file mode 100644
index 00000000000..3157bfcd8c5
--- /dev/null
+++ b/tests/queries/0_stateless/format_schemas/00825_protobuf_format_splitted_nested.proto
@@ -0,0 +1,72 @@
+syntax = "proto3";
+package some;
+
+message Some {
+  
+  enum n_enum {
+    A = 0; 
+    B = 1; 
+    C = 2; 
+  }
+  
+  enum d_enum {
+    D =  0; 
+    E =  1; 
+    F =  2; 
+    G =  3; 
+    H =  4; 
+    I =  9; 
+    K = 10; 
+  }
+  string a = 1;
+  int64 b = 2;
+  int32 c  = 3;
+  n_enum n = 4;
+  d_enum  d  = 5;
+  string e = 6;
+  string f = 7;
+  string g = 8;
+  string h = 9;
+  int32 i  = 10;
+  int32 j  = 11;
+  int32 k = 12;
+  int32 l = 13;
+  string m = 14;
+  
+  oneof sub {
+    SubOne sub_1 = 100;
+    SubTwo sub_2 = 101;
+  }
+}
+
+message SubOne {
+  int32 a = 1;
+  int32 b = 2;
+  string c = 3;
+  string d = 4;
+  string e = 5;
+  string f = 6;
+  string g = 7;
+  string h = 8;
+  string i   = 9; 
+  string j  = 10;
+  string k = 11;
+}
+
+message SubTwo {
+  reserved 2,12;
+
+  int32  a = 1;
+  string b = 3;
+  int32 c  = 4;
+  int32 d = 5;
+  int32 e = 6;
+  int32 f = 7;
+  bytes g = 8;
+  string h = 9; 
+  string i = 10;
+  string j = 11;
+  int64 k = 13;
+  int64 l = 14;
+  bytes random_name = 15;
+}
diff --git a/tests/queries/skip_list.json b/tests/queries/skip_list.json
index 2deefff3057..5b7965812c9 100644
--- a/tests/queries/skip_list.json
+++ b/tests/queries/skip_list.json
@@ -205,6 +205,7 @@
         "00825_protobuf_format_nested_optional",
         "00825_protobuf_format_no_length_delimiter",
         "00825_protobuf_format_persons",
+        "00825_protobuf_format_splitted_nested",
         "00825_protobuf_format_squares",
         "00825_protobuf_format_table_default",
         "00826_cross_to_inner_join",
diff --git a/tests/testflows/ldap/authentication/tests/authentications.py b/tests/testflows/ldap/authentication/tests/authentications.py
index 184c6bc1b84..13bd225058a 100644
--- a/tests/testflows/ldap/authentication/tests/authentications.py
+++ b/tests/testflows/ldap/authentication/tests/authentications.py
@@ -661,7 +661,7 @@ def valid_verification_cooldown_value_ldap_unavailable(self, server, rbac=False)
                 delete_user_from_ldap(user, exitcode=None)
 
 @TestOutline
-def repeat_requests(self, server, iterations, vcd_value, rbac=False):
+def repeat_requests(self, server, iterations, vcd_value, rbac=False, timeout=600):
     """Run repeated requests from some user to the LDAP server.
     """
 
@@ -688,7 +688,7 @@ def repeat_requests(self, server, iterations, vcd_value, rbac=False):
             with ldap_authenticated_users({"username": user["cn"], "server": server}, config_file=f"ldap_users_{getuid()}.xml"):
                 with When(f"I login and execute some query {iterations} times"):
                     start_time = time.time()
-                    r = self.context.node.command(f"time for i in {{1..{iterations}}}; do clickhouse client -q \"SELECT 1\" --user {user['cn']} --password {user['userpassword']} > /dev/null; done")
+                    r = self.context.node.command(f"time for i in {{1..{iterations}}}; do clickhouse client -q \"SELECT 1\" --user {user['cn']} --password {user['userpassword']} > /dev/null; done", timeout=timeout)
                     end_time = time.time()
 
                     return end_time - start_time