diff --git a/CMakeLists.txt b/CMakeLists.txt
index f838efa71c6..66df4d3124a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -135,6 +135,7 @@ if (ENABLE_FUZZING)
     # And we don't want to enable coverage for it.
     message (STATUS "Fuzzing instrumentation enabled")
     set (FUZZER "libfuzzer")
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdlib++")
 endif()
 
 # Global libraries
diff --git a/base/base/CachedFn.h b/base/base/CachedFn.h
index 83e02073e1d..ed1dbdbd48c 100644
--- a/base/base/CachedFn.h
+++ b/base/base/CachedFn.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <map>
+#include <tuple>
 #include <mutex>
 #include "FnTraits.h"
 
@@ -17,7 +18,8 @@ struct CachedFn
 {
 private:
     using Traits = FnTraits<decltype(Func)>;
-    using Key = typename Traits::DecayedArgs;
+    using DecayedArgs = TLMap<std::decay_t, typename Traits::Args>;
+    using Key = TLChangeRoot<std::tuple, DecayedArgs>;
     using Result = typename Traits::Ret;
 
     std::map<Key, Result> cache; // Can't use hashmap as tuples are unhashable by default
diff --git a/base/base/FnTraits.h b/base/base/FnTraits.h
index d90cb530a09..6b8dc7cd0d2 100644
--- a/base/base/FnTraits.h
+++ b/base/base/FnTraits.h
@@ -1,8 +1,6 @@
 #pragma once
 
-#include <tuple>
-#include <concepts>
-#include <type_traits>
+#include "Typelist.h"
 
 namespace detail
 {
@@ -16,8 +14,7 @@ struct FnTraits<R(A...)>
     static constexpr bool value = std::is_invocable_r_v<R, F, A...>;
 
     using Ret = R;
-    using Args = std::tuple<A...>;
-    using DecayedArgs = std::tuple<typename std::decay<A>::type...>;
+    using Args = Typelist<A...>;
 };
 
 template <class R, class ...A>
diff --git a/base/base/TypeName.h b/base/base/TypeName.h
new file mode 100644
index 00000000000..b3ea47fad5d
--- /dev/null
+++ b/base/base/TypeName.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "Decimal.h"
+#include "UUID.h"
+
+namespace DB
+{
+struct Array;
+struct Tuple;
+struct Map;
+struct AggregateFunctionStateData;
+
+/**
+ * Obtain type string representation from real type if possible.
+ * @example TypeName<UInt8> == "UInt8"
+ */
+template <class T> constexpr inline std::string_view TypeName;
+
+#define TN_MAP(_A) \
+    template <> constexpr inline std::string_view TypeName<_A> = #_A;
+
+TN_MAP(UInt8)
+TN_MAP(UInt16)
+TN_MAP(UInt32)
+TN_MAP(UInt64)
+TN_MAP(UInt128)
+TN_MAP(UInt256)
+TN_MAP(Int8)
+TN_MAP(Int16)
+TN_MAP(Int32)
+TN_MAP(Int64)
+TN_MAP(Int128)
+TN_MAP(Int256)
+TN_MAP(Float32)
+TN_MAP(Float64)
+TN_MAP(String)
+TN_MAP(UUID)
+TN_MAP(Decimal32)
+TN_MAP(Decimal64)
+TN_MAP(Decimal128)
+TN_MAP(Decimal256)
+TN_MAP(DateTime64)
+TN_MAP(Array)
+TN_MAP(Tuple)
+TN_MAP(Map)
+
+/// Special case
+template <> constexpr inline std::string_view TypeName<AggregateFunctionStateData> = "AggregateFunctionState";
+
+#undef TN_MAP
+}
diff --git a/base/base/TypePair.h b/base/base/TypePair.h
new file mode 100644
index 00000000000..54f31831241
--- /dev/null
+++ b/base/base/TypePair.h
@@ -0,0 +1,4 @@
+#pragma once
+
+template <class T, class V> struct TypePair { };
+template <class T> struct Id { };
diff --git a/base/base/Typelist.h b/base/base/Typelist.h
new file mode 100644
index 00000000000..74abaf9e388
--- /dev/null
+++ b/base/base/Typelist.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include "defines.h"
+#include "TypePair.h"
+
+/// General-purpose typelist. Easy on compilation times as it does not use recursion.
+template <class ...Args>
+struct Typelist { static constexpr size_t size = sizeof...(Args); };
+
+namespace TLUtils /// In some contexts it's more handy to use functions instead of aliases
+{
+template <class ...LArgs, class ...RArgs>
+constexpr Typelist<LArgs..., RArgs...> concat(Typelist<LArgs...>, Typelist<RArgs...>) { return {}; }
+
+template <class T, class ...Args>
+constexpr Typelist<T, Args...> prepend(Typelist<Args...>) { return {}; }
+
+template <class T, class ...Args>
+constexpr Typelist<Args..., T> append(Typelist<Args...>) { return {}; }
+
+template <template<class> class F, class ...Args>
+constexpr Typelist<F<Args>...> map(Typelist<Args...>) { return {}; }
+
+template <template<class...> class Root, class ...Args>
+constexpr Root<Args...> changeRoot(Typelist<Args...>) { return {}; }
+
+template <class F, class ...Args>
+constexpr void forEach(Typelist<Args...>, F && f) { (std::forward<F>(f)(Id<Args>{}), ...); }
+}
+
+template <class TLLeft, class TLRight>
+using TLConcat = decltype(TLUtils::concat(TLLeft{}, TLRight{}));
+
+template <class T, class Typelist> using TLPrepend = decltype(TLUtils::prepend<T>(Typelist{}));
+template <class T, class Typelist> using TLAppend = decltype(TLUtils::append<T>(Typelist{}));
+
+template <template<class> class F, class Typelist>
+using TLMap = decltype(TLUtils::map<F>(Typelist{}));
+
+template <template<class...> class Root, class Typelist>
+using TLChangeRoot = decltype(TLUtils::changeRoot<Root>(Typelist{}));
diff --git a/base/base/Typelists.h b/base/base/Typelists.h
new file mode 100644
index 00000000000..d5d58be96cc
--- /dev/null
+++ b/base/base/Typelists.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Typelist.h"
+#include "extended_types.h"
+#include "Decimal.h"
+#include "UUID.h"
+
+namespace DB
+{
+using TLIntegral = Typelist<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
+using TLExtendedIntegral = Typelist<UInt128, Int128, UInt256, Int256>;
+using TLDecimals = Typelist<Decimal32, Decimal64, Decimal128, Decimal256>;
+
+using TLIntegralWithExtended = TLConcat<TLIntegral, TLExtendedIntegral>;
+
+using TLNumbers = TLConcat<TLIntegralWithExtended, TLDecimals>;
+using TLNumbersWithUUID = TLAppend<UUID, TLNumbers>;
+}
diff --git a/base/base/UUID.h b/base/base/UUID.h
new file mode 100644
index 00000000000..8b1ed16ea2f
--- /dev/null
+++ b/base/base/UUID.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "strong_typedef.h"
+#include "extended_types.h"
+
+namespace DB
+{
+using UUID = StrongTypedef<UInt128, struct UUIDTag>;
+}
diff --git a/docker/packager/other/fuzzer.sh b/docker/packager/other/fuzzer.sh
index 1a8b80c3f77..5eec51f9625 100755
--- a/docker/packager/other/fuzzer.sh
+++ b/docker/packager/other/fuzzer.sh
@@ -16,7 +16,7 @@ cmake --debug-trycompile --verbose=1 -DCMAKE_VERBOSE_MAKEFILE=1 -LA -DCMAKE_C_CO
     -DENABLE_LIBRARIES=0 -DENABLE_SSL=1 -DUSE_INTERNAL_SSL_LIBRARY=1 -DUSE_UNWIND=ON -DENABLE_EMBEDDED_COMPILER=0 \
     -DENABLE_EXAMPLES=0 -DENABLE_UTILS=0 -DENABLE_THINLTO=0 "-DSANITIZE=$SANITIZER" \
     -DENABLE_FUZZING=1 -DFUZZER='libfuzzer' -DENABLE_TCMALLOC=0 -DENABLE_JEMALLOC=0 \
-    -DENABLE_CHECK_HEAVY_BUILDS=1 "${CMAKE_FLAGS[@]}" ..
+    -DENABLE_CHECK_HEAVY_BUILDS=1 -DGLIBC_COMPATIBILITY=OFF "${CMAKE_FLAGS[@]}" ..
 
 FUZZER_TARGETS=$(find ../src -name '*_fuzzer.cpp' -execdir basename {} .cpp ';' | tr '\n' ' ')
 
diff --git a/docs/en/sql-reference/statements/alter/sample-by.md b/docs/en/sql-reference/statements/alter/sample-by.md
index df8ff90f196..21b20be8b78 100644
--- a/docs/en/sql-reference/statements/alter/sample-by.md
+++ b/docs/en/sql-reference/statements/alter/sample-by.md
@@ -16,5 +16,4 @@ The command changes the [sampling key](../../../engines/table-engines/mergetree-
 The command is lightweight in the sense that it only changes metadata. The primary key must contain the new sample key.
 
 !!! note "Note"
-    It only works for tables in the [MergeTree](../../../engines/table-engines/mergetree-family/mergetree.md) family (including
-[replicated](../../../engines/table-engines/mergetree-family/replication.md) tables).
\ No newline at end of file
+    It only works for tables in the [MergeTree](../../../engines/table-engines/mergetree-family/mergetree.md) family (including [replicated](../../../engines/table-engines/mergetree-family/replication.md) tables).
diff --git a/docs/en/sql-reference/statements/select/sample.md b/docs/en/sql-reference/statements/select/sample.md
index 2ed0a804736..2405cb0a03c 100644
--- a/docs/en/sql-reference/statements/select/sample.md
+++ b/docs/en/sql-reference/statements/select/sample.md
@@ -10,7 +10,7 @@ When data sampling is enabled, the query is not performed on all the data, but o
 
 Approximated query processing can be useful in the following cases:
 
--   When you have strict timing requirements (like \<100ms) but you can’t justify the cost of additional hardware resources to meet them.
+-   When you have strict latency requirements (like below 100ms) but you can’t justify the cost of additional hardware resources to meet them.
 -   When your raw data is not accurate, so approximation does not noticeably degrade the quality.
 -   Business requirements target approximate results (for cost-effectiveness, or to market exact results to premium users).
 
diff --git a/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.cpp b/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.cpp
index 697112dc443..482229233f5 100644
--- a/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.cpp
+++ b/src/AggregateFunctions/AggregateFunctionSimpleLinearRegression.cpp
@@ -3,9 +3,6 @@
 #include <AggregateFunctions/AggregateFunctionFactory.h>
 #include <AggregateFunctions/FactoryHelpers.h>
 
-#include <Core/TypeListNumber.h>
-
-
 namespace DB
 {
 struct Settings;
diff --git a/src/Columns/ColumnDecimal.h b/src/Columns/ColumnDecimal.h
index 30e73300a1e..542049c60a6 100644
--- a/src/Columns/ColumnDecimal.h
+++ b/src/Columns/ColumnDecimal.h
@@ -8,7 +8,7 @@
 #include <Common/typeid_cast.h>
 #include <base/sort.h>
 #include <Core/TypeId.h>
-#include <Core/TypeName.h>
+#include <base/TypeName.h>
 
 #include <cmath>
 
@@ -86,7 +86,7 @@ private:
     {}
 
 public:
-    const char * getFamilyName() const override { return TypeName<T>; }
+    const char * getFamilyName() const override { return TypeName<T>.data(); }
     TypeIndex getDataType() const override { return TypeId<T>; }
 
     bool isNumeric() const override { return false; }
diff --git a/src/Columns/ColumnVector.h b/src/Columns/ColumnVector.h
index b44126d73bf..eb0c08dcd1d 100644
--- a/src/Columns/ColumnVector.h
+++ b/src/Columns/ColumnVector.h
@@ -8,7 +8,7 @@
 #include <Core/Field.h>
 #include <Common/assert_cast.h>
 #include <Core/TypeId.h>
-#include <Core/TypeName.h>
+#include <base/TypeName.h>
 
 
 namespace DB
@@ -237,7 +237,7 @@ public:
         data.reserve(n);
     }
 
-    const char * getFamilyName() const override { return TypeName<T>; }
+    const char * getFamilyName() const override { return TypeName<T>.data(); }
     TypeIndex getDataType() const override { return TypeId<T>; }
 
     MutableColumnPtr cloneResized(size_t size) const override;
diff --git a/src/Common/TypeList.h b/src/Common/TypeList.h
deleted file mode 100644
index c011f226f87..00000000000
--- a/src/Common/TypeList.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <utility>
-#include <Core/Defines.h>
-
-namespace DB
-{
-
-template <typename... TTail>
-struct TypeList
-{
-    static constexpr size_t size = 0;
-
-    template <size_t I>
-    using At = std::nullptr_t;
-
-    template <typename Func, size_t index = 0>
-    static void forEach(Func && /*func*/)
-    {
-    }
-};
-
-
-template <typename THead, typename... TTail>
-struct TypeList<THead, TTail...>
-{
-    using Head = THead;
-    using Tail = TypeList<TTail...>;
-
-    static constexpr size_t size = 1 + sizeof...(TTail);
-
-    template <size_t I>
-    using At = typename std::template conditional_t<I == 0, Head, typename Tail::template At<I - 1>>;
-
-    template <typename Func, size_t index = 0>
-    static void ALWAYS_INLINE forEach(Func && func)
-    {
-        func.template operator()<Head, index>();
-        Tail::template forEach<Func, index + 1>(std::forward<Func>(func));
-    }
-};
-
-/// Prepend Type to TypeList
-/// Usage:
-///     using TypeListWithType = typename AppendToTypeList<Type, ConcreteTypeList>::Type;
-template <typename TypeToPrepend, typename List, typename ... Types>
-struct PrependToTypeList
-{
-    using Type = typename PrependToTypeList<TypeToPrepend, typename List::Tail, Types ..., typename List::Head>::Type;
-};
-
-template <typename TypeToPrepend, typename ... Types>
-struct PrependToTypeList<TypeToPrepend, TypeList<>, Types ...>
-{
-    using Type = TypeList<TypeToPrepend, Types ...>;
-};
-
-/// Append Type to TypeList
-/// Usage:
-///     using TypeListWithType = typename AppendToTypeList<Type, ConcreteTypeList>::Type;
-template <typename TypeToAppend, typename List, typename ... Types>
-struct AppendToTypeList
-{
-    using Type = typename AppendToTypeList<TypeToAppend, typename List::Tail, Types ..., typename List::Head>::Type;
-};
-
-template <typename TypeToAppend, typename ... Types>
-struct AppendToTypeList<TypeToAppend, TypeList<>, Types ...>
-{
-    using Type = TypeList<Types ..., TypeToAppend>;
-};
-
-/// Apply TypeList as variadic template argument of Class.
-/// Usage:
-///     using ClassWithAppliedTypeList = typename ApplyTypeListForClass<Class, ConcreteTypeList>::Type;
-template <template <typename ...> typename Class, typename List, typename ... Types>
-struct ApplyTypeListForClass
-{
-    using Type = typename ApplyTypeListForClass<Class, typename List::Tail, Types ..., typename List::Head>::Type;
-};
-
-template <template <typename ...> typename Class, typename ... Types>
-struct ApplyTypeListForClass<Class, TypeList<>, Types ...>
-{
-    using Type = Class<Types ...>;
-};
-
-/// TypeList concatenation.
-/// Usage:
-///     using ResultTypeList = typename TypeListConcat<LeftList, RightList>::Type;
-template <typename TypeListLeft, typename TypeListRight>
-struct TypeListConcat
-{
-    using Type = typename TypeListConcat<
-            typename AppendToTypeList<typename TypeListRight::Head, TypeListLeft>::Type,
-            typename TypeListRight::Tail>::Type;
-};
-
-template <typename TypeListLeft>
-struct TypeListConcat<TypeListLeft, TypeList<>>
-{
-    using Type = TypeListLeft;
-};
-
-/// TypeList Map function.
-/// Usage:
-///     using ResultTypeList = typename TypeListMap<Function, TypeListArgs>::Type;
-template <template <typename> typename Function, typename TypeListArgs>
-struct TypeListMap
-{
-    using Type = typename PrependToTypeList<
-            Function<typename TypeListArgs::Head>,
-            typename TypeListMap<Function, typename TypeListArgs::Tail>::Type>::Type;
-};
-
-template <template <typename> typename Function>
-struct TypeListMap<Function, TypeList<>>
-{
-    using Type = TypeList<>;
-};
-
-}
diff --git a/src/Common/Visitor.h b/src/Common/Visitor.h
index c46c1286324..53603130b2a 100644
--- a/src/Common/Visitor.h
+++ b/src/Common/Visitor.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <base/demangle.h>
-#include <Common/TypeList.h>
+#include <base/Typelist.h>
 #include <Common/Exception.h>
 
 /* Generic utils which are intended for visitor pattern implementation.
@@ -64,7 +64,7 @@ template <>
 class Visitor<>
 {
 public:
-    using List = TypeList<>;
+    using List = Typelist<>;
 
 protected:
     ~Visitor() = default;
@@ -74,7 +74,7 @@ template <typename Type>
 class Visitor<Type> : public Visitor<>
 {
 public:
-    using List = TypeList<Type>;
+    using List = Typelist<Type>;
 
     virtual void visit(Type &) = 0;
 
@@ -86,7 +86,7 @@ template <typename Type, typename ... Types>
 class Visitor<Type, Types ...> : public Visitor<Types ...>
 {
 public:
-    using List = TypeList<Type, Types ...>;
+    using List = Typelist<Type, Types ...>;
     using Visitor<Types ...>::visit;
 
     virtual void visit(Type &) = 0;
@@ -145,13 +145,13 @@ protected:
 
 template <typename Derived, typename VisitorBase>
 class VisitorImpl : public
-        ApplyTypeListForClass<
-                VisitorImplHelper,
-                typename TypeListConcat<
-                        TypeList<Derived, VisitorBase>,
-                        typename VisitorBase::List
-                >::Type
-        >::Type
+    TLChangeRoot<
+        VisitorImplHelper,
+        TLConcat<
+            Typelist<Derived, VisitorBase>,
+            typename VisitorBase::List
+        >
+    >
 {
 protected:
     ~VisitorImpl() = default;
diff --git a/src/Common/quoteString.cpp b/src/Common/quoteString.cpp
index 6fc928ff022..15901643f47 100644
--- a/src/Common/quoteString.cpp
+++ b/src/Common/quoteString.cpp
@@ -5,9 +5,9 @@
 
 namespace DB
 {
-String quoteString(const StringRef & x)
+String quoteString(std::string_view x)
 {
-    String res(x.size, '\0');
+    String res(x.size(), '\0');
     WriteBufferFromString wb(res);
     writeQuotedString(x, wb);
     return res;
diff --git a/src/Common/quoteString.h b/src/Common/quoteString.h
index e7aa62d99e5..0364efbdf14 100644
--- a/src/Common/quoteString.h
+++ b/src/Common/quoteString.h
@@ -2,12 +2,18 @@
 
 #include <base/types.h>
 #include <base/StringRef.h>
+#include <concepts>
 
 
 namespace DB
 {
-/// Quote the string.
-String quoteString(const StringRef & x);
+[[nodiscard]] String quoteString(std::string_view x);
+
+// Prefer string_view over StringRef for implicit conversions
+[[nodiscard]] inline String quoteString(std::same_as<StringRef> auto x)
+{
+    return quoteString(std::string_view{x.data, x.size});
+}
 
 /// Double quote the string.
 String doubleQuoteString(const StringRef & x);
diff --git a/src/Core/TypeListNumber.h b/src/Core/TypeListNumber.h
deleted file mode 100644
index b65bdef4e46..00000000000
--- a/src/Core/TypeListNumber.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <Core/Types.h>
-#include <Common/TypeList.h>
-
-namespace DB
-{
-
-using TypeListNativeNumbers = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
-using TypeListExtendedNumbers = TypeList<UInt128, Int128, UInt256, Int256>;
-using TypeListDecimalNumbers = TypeList<Decimal32, Decimal64, Decimal128, Decimal256>;
-
-using TypeListGeneralNumbers = typename TypeListConcat<TypeListNativeNumbers, TypeListExtendedNumbers>::Type;
-using TypeListNumbers = typename TypeListConcat<TypeListGeneralNumbers, TypeListDecimalNumbers>::Type;
-
-using TypeListNumbersAndUUID = typename TypeListConcat<TypeListNumbers, TypeList<UUID>>::Type;
-
-}
diff --git a/src/Core/TypeName.h b/src/Core/TypeName.h
deleted file mode 100644
index 1f2c9d8b3fe..00000000000
--- a/src/Core/TypeName.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include <Core/Types.h>
-
-namespace DB
-{
-struct Array;
-struct Tuple;
-struct Map;
-struct AggregateFunctionStateData;
-
-template <class T> constexpr const char * TypeName = "";
-
-template <> inline constexpr const char * TypeName<UInt8> = "UInt8";
-template <> inline constexpr const char * TypeName<UInt16> = "UInt16";
-template <> inline constexpr const char * TypeName<UInt32> = "UInt32";
-template <> inline constexpr const char * TypeName<UInt64> = "UInt64";
-template <> inline constexpr const char * TypeName<UInt128> = "UInt128";
-template <> inline constexpr const char * TypeName<UInt256> = "UInt256";
-template <> inline constexpr const char * TypeName<Int8> = "Int8";
-template <> inline constexpr const char * TypeName<Int16> = "Int16";
-template <> inline constexpr const char * TypeName<Int32> = "Int32";
-template <> inline constexpr const char * TypeName<Int64> = "Int64";
-template <> inline constexpr const char * TypeName<Int128> = "Int128";
-template <> inline constexpr const char * TypeName<Int256> = "Int256";
-template <> inline constexpr const char * TypeName<Float32> = "Float32";
-template <> inline constexpr const char * TypeName<Float64> = "Float64";
-template <> inline constexpr const char * TypeName<String> = "String";
-template <> inline constexpr const char * TypeName<UUID> = "UUID";
-template <> inline constexpr const char * TypeName<Decimal32> = "Decimal32";
-template <> inline constexpr const char * TypeName<Decimal64> = "Decimal64";
-template <> inline constexpr const char * TypeName<Decimal128> = "Decimal128";
-template <> inline constexpr const char * TypeName<Decimal256> = "Decimal256";
-template <> inline constexpr const char * TypeName<DateTime64> = "DateTime64";
-template <> inline constexpr const char * TypeName<Array> = "Array";
-template <> inline constexpr const char * TypeName<Tuple> = "Tuple";
-template <> inline constexpr const char * TypeName<Map> = "Map";
-template <> inline constexpr const char * TypeName<AggregateFunctionStateData> = "AggregateFunctionState";
-}
diff --git a/src/Core/Types.h b/src/Core/Types.h
index c0a6a0c3189..9d3ff15d29c 100644
--- a/src/Core/Types.h
+++ b/src/Core/Types.h
@@ -6,6 +6,7 @@
 #include <base/strong_typedef.h>
 #include <base/Decimal.h>
 #include <base/defines.h>
+#include <base/UUID.h>
 
 
 namespace DB
@@ -97,8 +98,6 @@ using UInt256 = ::UInt256;
 using Int128 = ::Int128;
 using Int256 = ::Int256;
 
-STRONG_TYPEDEF(UInt128, UUID)
-
 /// Not a data type in database, defined just for convenience.
 using Strings = std::vector<String>;
 }
diff --git a/src/DataTypes/DataTypeLowCardinality.cpp b/src/DataTypes/DataTypeLowCardinality.cpp
index 600d83bb112..6357ead0978 100644
--- a/src/DataTypes/DataTypeLowCardinality.cpp
+++ b/src/DataTypes/DataTypeLowCardinality.cpp
@@ -6,7 +6,7 @@
 #include <Common/assert_cast.h>
 #include <Common/typeid_cast.h>
 #include <Core/Field.h>
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
 #include <DataTypes/DataTypeFactory.h>
@@ -53,8 +53,8 @@ namespace
         {
         }
 
-        template <typename T, size_t>
-        void operator()()
+        template <class T>
+        void operator()(Id<T>)
         {
             if (typeid_cast<const DataTypeNumber<T> *>(&keys_type))
                 column = creator(static_cast<ColumnVector<T> *>(nullptr));
@@ -89,7 +89,7 @@ MutableColumnUniquePtr DataTypeLowCardinality::createColumnUniqueImpl(const IDat
     else if (which.isInt() || which.isUInt() || which.isFloat())
     {
         MutableColumnUniquePtr column;
-        TypeListNativeNumbers::forEach(CreateColumnVector(column, *type, creator));
+        TLUtils::forEach(TLIntegral{}, CreateColumnVector(column, *type, creator));
 
         if (!column)
             throw Exception("Unexpected numeric type: " + type->getName(), ErrorCodes::LOGICAL_ERROR);
diff --git a/src/DataTypes/DataTypeNumberBase.h b/src/DataTypes/DataTypeNumberBase.h
index c24778691d9..95975051600 100644
--- a/src/DataTypes/DataTypeNumberBase.h
+++ b/src/DataTypes/DataTypeNumberBase.h
@@ -24,7 +24,7 @@ public:
     using FieldType = T;
     using ColumnType = ColumnVector<T>;
 
-    const char * getFamilyName() const override { return TypeName<T>; }
+    const char * getFamilyName() const override { return TypeName<T>.data(); }
     TypeIndex getTypeId() const override { return TypeId<T>; }
 
     Field getDefault() const override;
diff --git a/src/Dictionaries/RangeHashedDictionary.cpp b/src/Dictionaries/RangeHashedDictionary.cpp
index 86dfaa615ed..2e677c163d6 100644
--- a/src/Dictionaries/RangeHashedDictionary.cpp
+++ b/src/Dictionaries/RangeHashedDictionary.cpp
@@ -1,7 +1,7 @@
 #include "RangeHashedDictionary.h"
 #include <Columns/ColumnNullable.h>
 #include <Functions/FunctionHelpers.h>
-#include <Common/TypeList.h>
+#include <base/Typelists.h>
 #include <Interpreters/castColumn.h>
 #include <DataTypes/DataTypesDecimal.h>
 #include <Dictionaries/DictionaryFactory.h>
@@ -650,8 +650,8 @@ struct RangeHashedDictionaryCallGetSourceImpl
     const Names * column_names;
     size_t max_block_size;
 
-    template <typename RangeType, size_t>
-    void operator()()
+    template <class RangeType>
+    void operator()(Id<RangeType>)
     {
         const auto & type = dict->dict_struct.range_min->type;
         if (pipe.empty() && dynamic_cast<const DataTypeNumberBase<RangeType> *>(type.get()))
@@ -662,14 +662,12 @@ struct RangeHashedDictionaryCallGetSourceImpl
 template <DictionaryKeyType dictionary_key_type>
 Pipe RangeHashedDictionary<dictionary_key_type>::read(const Names & column_names, size_t max_block_size) const
 {
-    using ListType = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Int128, Float32, Float64>;
-
     RangeHashedDictionaryCallGetSourceImpl<dictionary_key_type> callable;
     callable.dict = this;
     callable.column_names = &column_names;
     callable.max_block_size = max_block_size;
 
-    ListType::forEach(callable);
+    TLUtils::forEach(TLIntegral{}, callable);
 
     if (callable.pipe.empty())
         throw Exception(ErrorCodes::LOGICAL_ERROR,
diff --git a/src/Functions/FunctionBinaryArithmetic.h b/src/Functions/FunctionBinaryArithmetic.h
index f3f1956c01c..cfad40c615a 100644
--- a/src/Functions/FunctionBinaryArithmetic.h
+++ b/src/Functions/FunctionBinaryArithmetic.h
@@ -35,7 +35,7 @@
 #include <Common/typeid_cast.h>
 #include <Common/assert_cast.h>
 #include <Common/FieldVisitorsAccurateComparison.h>
-#include <Common/TypeList.h>
+#include <base/Typelist.h>
 #include <base/map.h>
 
 #if !defined(ARCADIA_BUILD)
@@ -577,20 +577,20 @@ class FunctionBinaryArithmetic : public IFunction
 
     static bool castType(const IDataType * type, auto && f)
     {
-        using Types = TypeList<
+        using Types = Typelist<
             DataTypeUInt8, DataTypeUInt16, DataTypeUInt32, DataTypeUInt64, DataTypeUInt128, DataTypeUInt256,
             DataTypeInt8, DataTypeInt16, DataTypeInt32, DataTypeInt64, DataTypeInt128, DataTypeInt256,
             DataTypeDecimal32, DataTypeDecimal64, DataTypeDecimal128, DataTypeDecimal256,
             DataTypeDate, DataTypeDateTime,
             DataTypeFixedString, DataTypeString>;
 
-        using Floats = TypeList<DataTypeFloat32, DataTypeFloat64>;
+        using Floats = Typelist<DataTypeFloat32, DataTypeFloat64>;
 
         using ValidTypes = std::conditional_t<valid_on_float_arguments,
-            typename TypeListConcat<Types, Floats>::Type,
+            TLConcat<Types, Floats>,
             Types>;
 
-        return castTypeToEitherTL<ValidTypes>(type, std::forward<decltype(f)>(f));
+        return castTypeToEither(ValidTypes{}, type, std::forward<decltype(f)>(f));
     }
 
     template <typename F>
diff --git a/src/Functions/GatherUtils/ArraySinkVisitor.h b/src/Functions/GatherUtils/ArraySinkVisitor.h
index 7a53da25869..245c5d4451d 100644
--- a/src/Functions/GatherUtils/ArraySinkVisitor.h
+++ b/src/Functions/GatherUtils/ArraySinkVisitor.h
@@ -1,6 +1,6 @@
 #pragma once
 #include <Common/Visitor.h>
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 
 namespace DB::GatherUtils
 {
@@ -14,12 +14,12 @@ struct GenericArraySink;
 template <typename ArraySink>
 struct NullableArraySink;
 
-using NumericArraySinks = typename TypeListMap<NumericArraySink, TypeListNumbersAndUUID>::Type;
-using BasicArraySinks = typename AppendToTypeList<GenericArraySink, NumericArraySinks>::Type;
-using NullableArraySinks = typename TypeListMap<NullableArraySink, BasicArraySinks>::Type;
-using TypeListArraySinks = typename TypeListConcat<BasicArraySinks, NullableArraySinks>::Type;
+using NumericArraySinks = TLMap<NumericArraySink, TLNumbersWithUUID>;
+using BasicArraySinks = TLAppend<GenericArraySink, NumericArraySinks>;
+using NullableArraySinks = TLMap<NullableArraySink, BasicArraySinks>;
+using TLArraySinks = TLConcat<BasicArraySinks, NullableArraySinks>;
 
-class ArraySinkVisitor : public ApplyTypeListForClass<Visitor, TypeListArraySinks>::Type
+class ArraySinkVisitor : public TLChangeRoot<Visitor, TLArraySinks>
 {
 protected:
     ~ArraySinkVisitor() = default;
diff --git a/src/Functions/GatherUtils/ArraySourceVisitor.h b/src/Functions/GatherUtils/ArraySourceVisitor.h
index 1b92a9d2e81..707503f35e8 100644
--- a/src/Functions/GatherUtils/ArraySourceVisitor.h
+++ b/src/Functions/GatherUtils/ArraySourceVisitor.h
@@ -1,6 +1,6 @@
 #pragma once
 #include <Common/Visitor.h>
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 
 namespace DB::GatherUtils
 {
@@ -17,10 +17,10 @@ struct NullableArraySource;
 template <typename Base>
 struct ConstSource;
 
-using NumericArraySources = typename TypeListMap<NumericArraySource, TypeListNumbersAndUUID>::Type;
-using BasicArraySources = typename AppendToTypeList<GenericArraySource, NumericArraySources>::Type;
+using NumericArraySources = TLMap<NumericArraySource, TLNumbersWithUUID>;
+using BasicArraySources = TLAppend<GenericArraySource, NumericArraySources>;
 
-class ArraySourceVisitor : public ApplyTypeListForClass<Visitor, BasicArraySources>::Type
+class ArraySourceVisitor : public TLChangeRoot<Visitor, BasicArraySources>
 {
 protected:
     ~ArraySourceVisitor() = default;
diff --git a/src/Functions/GatherUtils/ValueSourceVisitor.h b/src/Functions/GatherUtils/ValueSourceVisitor.h
index be503cdcfcf..6577afd5616 100644
--- a/src/Functions/GatherUtils/ValueSourceVisitor.h
+++ b/src/Functions/GatherUtils/ValueSourceVisitor.h
@@ -1,6 +1,6 @@
 #pragma once
 #include <Common/Visitor.h>
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 
 namespace DB::GatherUtils
 {
@@ -17,14 +17,14 @@ struct NullableValueSource;
 template <typename Base>
 struct ConstSource;
 
-using NumericValueSources = typename TypeListMap<NumericValueSource, TypeListNumbersAndUUID>::Type;
-using BasicValueSources = typename AppendToTypeList<GenericValueSource, NumericValueSources>::Type;
-using NullableValueSources = typename TypeListMap<NullableValueSource, BasicValueSources>::Type;
-using BasicAndNullableValueSources = typename TypeListConcat<BasicValueSources, NullableValueSources>::Type;
-using ConstValueSources = typename TypeListMap<ConstSource, BasicAndNullableValueSources>::Type;
-using TypeListValueSources = typename TypeListConcat<BasicAndNullableValueSources, ConstValueSources>::Type;
+using NumericValueSources = TLMap<NumericValueSource, TLNumbersWithUUID>;
+using BasicValueSources = TLAppend<GenericValueSource, NumericValueSources>;
+using NullableValueSources = TLMap<NullableValueSource, BasicValueSources>;
+using BasicAndNullableValueSources = TLConcat<BasicValueSources, NullableValueSources>;
+using ConstValueSources = TLMap<ConstSource, BasicAndNullableValueSources>;
+using TypeListValueSources = TLConcat<BasicAndNullableValueSources, ConstValueSources>;
 
-class ValueSourceVisitor : public ApplyTypeListForClass<Visitor, TypeListValueSources>::Type
+class ValueSourceVisitor : public TLChangeRoot<Visitor, TypeListValueSources>
 {
 protected:
     ~ValueSourceVisitor() = default;
diff --git a/src/Functions/GatherUtils/createArraySink.cpp b/src/Functions/GatherUtils/createArraySink.cpp
index c2f2530a318..f461790baf7 100644
--- a/src/Functions/GatherUtils/createArraySink.cpp
+++ b/src/Functions/GatherUtils/createArraySink.cpp
@@ -1,7 +1,7 @@
 #include "GatherUtils.h"
 #include "Sinks.h"
 #include "Sources.h"
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 
 namespace DB::GatherUtils
 {
@@ -55,7 +55,7 @@ struct ArraySinkCreator<>
 
 std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
 {
-    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumbersAndUUID>::Type;
+    using Creator = TLChangeRoot<ArraySinkCreator, TLNumbersWithUUID>;
     return Creator::create(col.getData(), col.getOffsets(), column_size);
 }
 }
diff --git a/src/Functions/GatherUtils/createArraySource.cpp b/src/Functions/GatherUtils/createArraySource.cpp
index ae672aa16af..605b2057e53 100644
--- a/src/Functions/GatherUtils/createArraySource.cpp
+++ b/src/Functions/GatherUtils/createArraySource.cpp
@@ -1,7 +1,7 @@
 #include "GatherUtils.h"
 #include "Sinks.h"
 #include "Sources.h"
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 
 namespace DB::GatherUtils
 {
@@ -58,7 +58,7 @@ struct ArraySourceCreator<>
 
 std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
 {
-    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumbersAndUUID>::Type;
+    using Creator = TLChangeRoot<ArraySourceCreator, TLNumbersWithUUID>;
     if (const auto * column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
     {
         auto column = ColumnArray::create(column_nullable->getNestedColumnPtr(), col.getOffsetsPtr());
diff --git a/src/Functions/GatherUtils/createValueSource.cpp b/src/Functions/GatherUtils/createValueSource.cpp
index 29c36f2728e..53cd26ffdd7 100644
--- a/src/Functions/GatherUtils/createValueSource.cpp
+++ b/src/Functions/GatherUtils/createValueSource.cpp
@@ -1,7 +1,7 @@
 #include "GatherUtils.h"
 #include "Sinks.h"
 #include "Sources.h"
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 
 namespace DB::GatherUtils
 {
@@ -58,7 +58,7 @@ struct ValueSourceCreator<>
 
 std::unique_ptr<IValueSource> createValueSource(const IColumn & col, bool is_const, size_t total_rows)
 {
-    using Creator = typename ApplyTypeListForClass<ValueSourceCreator, TypeListNumbersAndUUID>::Type;
+    using Creator = TLChangeRoot<ValueSourceCreator, TLNumbersWithUUID>;
     if (const auto * column_nullable = typeid_cast<const ColumnNullable *>(&col))
     {
         return Creator::create(column_nullable->getNestedColumn(), &column_nullable->getNullMapData(), is_const, total_rows);
diff --git a/src/Functions/PolygonUtils.h b/src/Functions/PolygonUtils.h
index 6cf4a46ca58..0f9b84344e6 100644
--- a/src/Functions/PolygonUtils.h
+++ b/src/Functions/PolygonUtils.h
@@ -2,7 +2,7 @@
 
 #include <base/types.h>
 #include <Core/Defines.h>
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 #include <Columns/IColumn.h>
 #include <Columns/ColumnVector.h>
 #include <Common/typeid_cast.h>
@@ -604,7 +604,7 @@ struct CallPointInPolygon<Type, Types ...>
     template <typename PointInPolygonImpl>
     static ColumnPtr call(const IColumn & x, const IColumn & y, PointInPolygonImpl && impl)
     {
-        using Impl = typename ApplyTypeListForClass<CallPointInPolygon, TypeListNativeNumbers>::Type;
+        using Impl = TLChangeRoot<CallPointInPolygon, TLIntegral>;
         if (auto column = typeid_cast<const ColumnVector<Type> *>(&x))
             return Impl::template call<Type>(*column, y, impl);
         return CallPointInPolygon<Types ...>::call(x, y, impl);
@@ -630,7 +630,7 @@ struct CallPointInPolygon<>
 template <typename PointInPolygonImpl>
 NO_INLINE ColumnPtr pointInPolygon(const IColumn & x, const IColumn & y, PointInPolygonImpl && impl)
 {
-    using Impl = typename ApplyTypeListForClass<CallPointInPolygon, TypeListNativeNumbers>::Type;
+    using Impl = TLChangeRoot<CallPointInPolygon, TLIntegral>;
     return Impl::call(x, y, impl);
 }
 
diff --git a/src/Functions/array/arrayIntersect.cpp b/src/Functions/array/arrayIntersect.cpp
index c18caf16ee3..7df14fd9981 100644
--- a/src/Functions/array/arrayIntersect.cpp
+++ b/src/Functions/array/arrayIntersect.cpp
@@ -20,7 +20,7 @@
 #include <Columns/ColumnTuple.h>
 #include <Common/HashTable/ClearableHashMap.h>
 #include <Common/assert_cast.h>
-#include <Core/TypeListNumber.h>
+#include <base/Typelists.h>
 #include <Interpreters/castColumn.h>
 #include <base/range.h>
 
@@ -106,8 +106,8 @@ private:
         NumberExecutor(const UnpackedArrays & arrays_, const DataTypePtr & data_type_, ColumnPtr & result_)
             : arrays(arrays_), data_type(data_type_), result(result_) {}
 
-        template <typename T, size_t>
-        void operator()();
+        template <class T>
+        void operator()(Id<T>);
     };
 
     struct DecimalExecutor
@@ -119,8 +119,8 @@ private:
         DecimalExecutor(const UnpackedArrays & arrays_, const DataTypePtr & data_type_, ColumnPtr & result_)
             : arrays(arrays_), data_type(data_type_), result(result_) {}
 
-        template <typename T, size_t>
-        void operator()();
+        template <class T>
+        void operator()(Id<T>);
     };
 };
 
@@ -403,8 +403,8 @@ ColumnPtr FunctionArrayIntersect::executeImpl(const ColumnsWithTypeAndName & arg
 
     ColumnPtr result_column;
     auto not_nullable_nested_return_type = removeNullable(nested_return_type);
-    TypeListNativeNumbers::forEach(NumberExecutor(arrays, not_nullable_nested_return_type, result_column));
-    TypeListDecimalNumbers::forEach(DecimalExecutor(arrays, not_nullable_nested_return_type, result_column));
+    TLUtils::forEach(TLIntegral{}, NumberExecutor(arrays, not_nullable_nested_return_type, result_column));
+    TLUtils::forEach(TLDecimals{}, DecimalExecutor(arrays, not_nullable_nested_return_type, result_column));
 
     using DateMap = ClearableHashMapWithStackMemory<DataTypeDate::FieldType,
         size_t, DefaultHash<DataTypeDate::FieldType>, INITIAL_SIZE_DEGREE>;
@@ -444,8 +444,8 @@ ColumnPtr FunctionArrayIntersect::executeImpl(const ColumnsWithTypeAndName & arg
     return result_column;
 }
 
-template <typename T, size_t>
-void FunctionArrayIntersect::NumberExecutor::operator()()
+template <class T>
+void FunctionArrayIntersect::NumberExecutor::operator()(Id<T>)
 {
     using Container = ClearableHashMapWithStackMemory<T, size_t, DefaultHash<T>,
         INITIAL_SIZE_DEGREE>;
@@ -454,8 +454,8 @@ void FunctionArrayIntersect::NumberExecutor::operator()()
         result = execute<Container, ColumnVector<T>, true>(arrays, ColumnVector<T>::create());
 }
 
-template <typename T, size_t>
-void FunctionArrayIntersect::DecimalExecutor::operator()()
+template <class T>
+void FunctionArrayIntersect::DecimalExecutor::operator()(Id<T>)
 {
     using Container = ClearableHashMapWithStackMemory<T, size_t, DefaultHash<T>,
         INITIAL_SIZE_DEGREE>;
diff --git a/src/Functions/castTypeToEither.h b/src/Functions/castTypeToEither.h
index 572c97841e1..c55336adb5a 100644
--- a/src/Functions/castTypeToEither.h
+++ b/src/Functions/castTypeToEither.h
@@ -1,24 +1,10 @@
 #pragma once
 
 #include <Common/typeid_cast.h>
+#include <base/Typelist.h>
 
 namespace DB
 {
-
-namespace detail
-{
-template <typename Typelist, size_t ...I>
-static bool castTypeToEither(const auto * type, auto && f, std::index_sequence<I...>)
-{
-    return (
-        (typeid_cast<const typename Typelist::template At<I> *>(type)
-            ? std::forward<decltype(f)>(f)(
-                *typeid_cast<const typename Typelist::template At<I> *>(type))
-            : false)
-        || ...);
-}
-}
-
 template <typename... Ts, typename T, typename F>
 static bool castTypeToEither(const T * type, F && f)
 {
@@ -26,12 +12,14 @@ static bool castTypeToEither(const T * type, F && f)
     return ((typeid_cast<const Ts *>(type) ? f(*typeid_cast<const Ts *>(type)) : false) || ...);
 }
 
-/// Use Common/TypeList as template argument
-template <class Typelist>
-static constexpr bool castTypeToEitherTL(const auto * type, auto && f)
+template <class ...Args>
+constexpr bool castTypeToEither(Typelist<Args...>, const auto * type, auto && f)
 {
-    return detail::castTypeToEither<Typelist>(
-            type, std::forward<decltype(f)>(f),
-            std::make_index_sequence<Typelist::size>());
+    return (
+        (typeid_cast<const Args *>(type) != nullptr
+            ? std::forward<decltype(f)>(f)(
+                *typeid_cast<const Args *>(type))
+            : false)
+        || ...);
 }
 }
diff --git a/src/Interpreters/CMakeLists.txt b/src/Interpreters/CMakeLists.txt
index 1068fee4cea..3f3c58ef63d 100644
--- a/src/Interpreters/CMakeLists.txt
+++ b/src/Interpreters/CMakeLists.txt
@@ -4,4 +4,8 @@ endif()
 
 if (ENABLE_EXAMPLES)
     add_subdirectory(examples)
-endif()
\ No newline at end of file
+endif()
+
+if (ENABLE_FUZZING)
+    add_subdirectory(fuzzers)
+endif()
diff --git a/src/Interpreters/TreeRewriter.cpp b/src/Interpreters/TreeRewriter.cpp
index 7f7603e9a25..8f923d82b27 100644
--- a/src/Interpreters/TreeRewriter.cpp
+++ b/src/Interpreters/TreeRewriter.cpp
@@ -250,6 +250,61 @@ using CustomizeAggregateFunctionsOrNullVisitor = InDepthNodeVisitor<OneTypeMatch
 using CustomizeAggregateFunctionsMoveOrNullVisitor = InDepthNodeVisitor<OneTypeMatcher<CustomizeAggregateFunctionsMoveSuffixData>, true>;
 using FuseSumCountAggregatesVisitor = InDepthNodeVisitor<OneTypeMatcher<FuseSumCountAggregatesVisitorData>, true>;
 
+
+struct ExistsExpressionData
+{
+    using TypeToVisit = ASTFunction;
+
+    static void visit(ASTFunction & func, ASTPtr)
+    {
+        bool exists_expression = func.name == "exists"
+            && func.arguments && func.arguments->children.size() == 1
+            && typeid_cast<const ASTSubquery *>(func.arguments->children[0].get());
+
+        if (!exists_expression)
+            return;
+
+        /// EXISTS(subquery) --> 1 IN (SELECT 1 FROM subquery LIMIT 1)
+
+        auto subquery_node = func.arguments->children[0];
+        auto table_expression = std::make_shared<ASTTableExpression>();
+        table_expression->subquery = std::move(subquery_node);
+        table_expression->children.push_back(table_expression->subquery);
+
+        auto tables_in_select_element = std::make_shared<ASTTablesInSelectQueryElement>();
+        tables_in_select_element->table_expression = std::move(table_expression);
+        tables_in_select_element->children.push_back(tables_in_select_element->table_expression);
+
+        auto tables_in_select = std::make_shared<ASTTablesInSelectQuery>();
+        tables_in_select->children.push_back(std::move(tables_in_select_element));
+
+        auto select_expr_list = std::make_shared<ASTExpressionList>();
+        select_expr_list->children.push_back(std::make_shared<ASTLiteral>(1u));
+
+        auto select_query = std::make_shared<ASTSelectQuery>();
+        select_query->children.push_back(select_expr_list);
+
+        select_query->setExpression(ASTSelectQuery::Expression::SELECT, select_expr_list);
+        select_query->setExpression(ASTSelectQuery::Expression::TABLES, tables_in_select);
+
+        ASTPtr limit_length_ast = std::make_shared<ASTLiteral>(Field(UInt64(1)));
+        select_query->setExpression(ASTSelectQuery::Expression::LIMIT_LENGTH, std::move(limit_length_ast));
+
+        auto select_with_union_query = std::make_shared<ASTSelectWithUnionQuery>();
+        select_with_union_query->list_of_selects = std::make_shared<ASTExpressionList>();
+        select_with_union_query->list_of_selects->children.push_back(std::move(select_query));
+        select_with_union_query->children.push_back(select_with_union_query->list_of_selects);
+
+        auto new_subquery = std::make_shared<ASTSubquery>();
+        new_subquery->children.push_back(select_with_union_query);
+
+        auto function = makeASTFunction("in", std::make_shared<ASTLiteral>(1u), new_subquery);
+        func = *function;
+    }
+};
+
+using ExistsExpressionVisitor = InDepthNodeVisitor<OneTypeMatcher<ExistsExpressionData>, false>;
+
 /// Translate qualified names such as db.table.column, table.column, table_alias.column to names' normal form.
 /// Expand asterisks and qualified asterisks with column names.
 /// There would be columns in normal form & column aliases after translation. Column & column alias would be normalized in QueryNormalizer.
@@ -1091,6 +1146,9 @@ void TreeRewriter::normalize(
     CustomizeIfDistinctVisitor::Data data_distinct_if{"DistinctIf"};
     CustomizeIfDistinctVisitor(data_distinct_if).visit(query);
 
+    ExistsExpressionVisitor::Data exists;
+    ExistsExpressionVisitor(exists).visit(query);
+
     if (settings.transform_null_in)
     {
         CustomizeInVisitor::Data data_null_in{"nullIn"};
diff --git a/src/Interpreters/fuzzers/CMakeLists.txt b/src/Interpreters/fuzzers/CMakeLists.txt
new file mode 100644
index 00000000000..dfe892b5249
--- /dev/null
+++ b/src/Interpreters/fuzzers/CMakeLists.txt
@@ -0,0 +1,10 @@
+add_executable(execute_query_fuzzer execute_query_fuzzer.cpp)
+target_link_libraries(execute_query_fuzzer PRIVATE
+    dbms
+    clickhouse_functions
+    clickhouse_table_functions
+    clickhouse_aggregate_functions
+    clickhouse_dictionaries
+    clickhouse_dictionaries_embedded
+    ${LIB_FUZZING_ENGINE})
+
diff --git a/src/Interpreters/fuzzers/execute_query_fuzzer.cpp b/src/Interpreters/fuzzers/execute_query_fuzzer.cpp
new file mode 100644
index 00000000000..f843c4880df
--- /dev/null
+++ b/src/Interpreters/fuzzers/execute_query_fuzzer.cpp
@@ -0,0 +1,56 @@
+#include <iostream>
+#include <Interpreters/executeQuery.h>
+#include <Interpreters/Context.h>
+#include "Processors/Executors/PullingPipelineExecutor.h"
+
+#include <Functions/registerFunctions.h>
+#include <AggregateFunctions/registerAggregateFunctions.h>
+#include <TableFunctions/registerTableFunctions.h>
+#include <Storages/registerStorages.h>
+#include <Dictionaries/registerDictionaries.h>
+#include <Disks/registerDisks.h>
+#include <Formats/registerFormats.h>
+
+using namespace DB;
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t * data, size_t size)
+try
+{
+    std::string input = std::string(reinterpret_cast<const char*>(data), size);
+
+    static SharedContextHolder shared_context;
+    static ContextMutablePtr context;
+
+    auto initialize = [&]() mutable
+    {
+        shared_context = Context::createShared();
+        context = Context::createGlobal(shared_context.get());
+        context->makeGlobalContext();
+        context->setApplicationType(Context::ApplicationType::LOCAL);
+
+        registerFunctions();
+        registerAggregateFunctions();
+        registerTableFunctions();
+        registerStorages();
+        registerDictionaries();
+        registerDisks();
+        registerFormats();
+
+        return true;
+    };
+
+    static bool initialized = initialize();
+    (void) initialized;
+
+    auto io = DB::executeQuery(input, context, true, QueryProcessingStage::Complete);
+
+    PullingPipelineExecutor executor(io.pipeline);
+    Block res;
+    while (!res && executor.pull(res));
+
+    return 0;
+}
+catch (...)
+{
+    return 1;
+}
diff --git a/src/Parsers/ExpressionElementParsers.cpp b/src/Parsers/ExpressionElementParsers.cpp
index d2fe79b2d06..e16a7605afc 100644
--- a/src/Parsers/ExpressionElementParsers.cpp
+++ b/src/Parsers/ExpressionElementParsers.cpp
@@ -2222,6 +2222,16 @@ bool ParserMySQLGlobalVariable::parseImpl(Pos & pos, ASTPtr & node, Expected & e
     return true;
 }
 
+bool ParserExistsExpression::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
+{
+    if (ParserKeyword("EXISTS").ignore(pos, expected) && ParserSubquery().parse(pos, node, expected))
+    {
+        node = makeASTFunction("exists", node);
+        return true;
+    }
+    return false;
+}
+
 
 bool ParserExpressionElement::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
@@ -2245,6 +2255,7 @@ bool ParserExpressionElement::parseImpl(Pos & pos, ASTPtr & node, Expected & exp
         || ParserFunction().parse(pos, node, expected)
         || ParserQualifiedAsterisk().parse(pos, node, expected)
         || ParserAsterisk().parse(pos, node, expected)
+        || ParserExistsExpression().parse(pos, node, expected)
         || ParserCompoundIdentifier(false, true).parse(pos, node, expected)
         || ParserSubstitution().parse(pos, node, expected)
         || ParserMySQLGlobalVariable().parse(pos, node, expected);
diff --git a/src/Parsers/ExpressionElementParsers.h b/src/Parsers/ExpressionElementParsers.h
index 7d1cfc196d6..91f1730f93d 100644
--- a/src/Parsers/ExpressionElementParsers.h
+++ b/src/Parsers/ExpressionElementParsers.h
@@ -325,6 +325,17 @@ protected:
 };
 
 
+/**
+  * Parse query with EXISTS expression.
+  */
+class ParserExistsExpression : public IParserBase
+{
+protected:
+    const char * getName() const override { return "exists expression"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
+};
+
+
 /** An array or tuple of literals.
   * Arrays can also be parsed as an application of [] operator and tuples as an application of 'tuple' function.
   * But parsing the whole array/tuple as a whole constant seriously speeds up the analysis of expressions in the case of very large collection.
diff --git a/tests/fuzz/README.md b/tests/fuzz/README.md
new file mode 100644
index 00000000000..440ae1aac1f
--- /dev/null
+++ b/tests/fuzz/README.md
@@ -0,0 +1,14 @@
+The list of funtions generated via following query
+
+```
+    clickhouse-client -q "select concat('\"', name, '\"') from system.functions union all select concat('\"', alias_to, '\"') from system.functions where alias_to != '' " > functions.dict
+```
+
+The list of datatypes generated via following query:
+
+```
+    clickhouse-client -q "select concat('\"', name, '\"') from system.data_type_families union all select concat('\"', alias_to, '\"') from system.data_type_families where alias_to != '' " > datatypes.dict
+```
+
+
+Then merge all dictionaries into one (all.dict)
diff --git a/tests/fuzz/all.dict b/tests/fuzz/all.dict
new file mode 100644
index 00000000000..73c86a13714
--- /dev/null
+++ b/tests/fuzz/all.dict
@@ -0,0 +1,1466 @@
+
+"abs"
+"accurate_Cast"
+"accurateCast"
+"accurate_CastOrNull"
+"accurateCastOrNull"
+"acos"
+"acosh"
+"ADD"
+"ADD COLUMN"
+"ADD CONSTRAINT"
+"addDays"
+"addHours"
+"ADD INDEX"
+"addMinutes"
+"addMonths"
+"addQuarters"
+"addressToLine"
+"addressToSymbol"
+"addSeconds"
+"addWeeks"
+"addYears"
+"aes_decrypt_mysql"
+"aes_encrypt_mysql"
+"AFTER"
+"AggregateFunction"
+"aggThrow"
+"ALIAS"
+"ALL"
+"alphaTokens"
+"ALTER"
+"ALTER LIVE VIEW"
+"ALTER TABLE"
+"and"
+"AND"
+"ANTI"
+"any"
+"ANY"
+"anyHeavy"
+"anyLast"
+"appendTrailingCharIfAbsent"
+"argMax"
+"argMin"
+"array"
+"Array"
+"ARRAY"
+"arrayAll"
+"arrayAUC"
+"arrayAvg"
+"arrayCompact"
+"arrayConcat"
+"arrayCount"
+"arrayCumSum"
+"arrayCumSumNonNegative"
+"arrayDifference"
+"arrayDistinct"
+"arrayElement"
+"arrayEnumerate"
+"arrayEnumerateDense"
+"arrayEnumerateDenseRanked"
+"arrayEnumerateUniq"
+"arrayEnumerateUniqRanked"
+"arrayExists"
+"arrayFill"
+"arrayFilter"
+"arrayFirst"
+"arrayFirstIndex"
+"arrayFlatten"
+"arrayIntersect"
+"arrayJoin"
+"ARRAY JOIN"
+"arrayMap"
+"arrayMax"
+"arrayMin"
+"arrayPopBack"
+"arrayPopFront"
+"arrayProduct"
+"arrayPushBack"
+"arrayPushFront"
+"arrayReduce"
+"arrayReduceInRanges"
+"arrayResize"
+"arrayReverse"
+"arrayReverseFill"
+"arrayReverseSort"
+"arrayReverseSplit"
+"arraySlice"
+"arraySort"
+"arraySplit"
+"arrayStringConcat"
+"arraySum"
+"arrayUniq"
+"arrayWithConstant"
+"arrayZip"
+"AS"
+"ASC"
+"ASCENDING"
+"asin"
+"asinh"
+"ASOF"
+"assumeNotNull"
+"AST"
+"ASYNC"
+"atan"
+"atan2"
+"atanh"
+"ATTACH"
+"ATTACH PART"
+"ATTACH PARTITION"
+"avg"
+"avgWeighted"
+"bar"
+"base64Decode"
+"base64Encode"
+"basename"
+"bayesAB"
+"BETWEEN"
+"BIGINT"
+"BIGINT SIGNED"
+"BIGINT UNSIGNED"
+"bin"
+"BINARY"
+"BINARY LARGE OBJECT"
+"BINARY VARYING"
+"bitAnd"
+"BIT_AND"
+"__bitBoolMaskAnd"
+"__bitBoolMaskOr"
+"bitCount"
+"bitHammingDistance"
+"bitmapAnd"
+"bitmapAndCardinality"
+"bitmapAndnot"
+"bitmapAndnotCardinality"
+"bitmapBuild"
+"bitmapCardinality"
+"bitmapContains"
+"bitmapHasAll"
+"bitmapHasAny"
+"bitmapMax"
+"bitmapMin"
+"bitmapOr"
+"bitmapOrCardinality"
+"bitmapSubsetInRange"
+"bitmapSubsetLimit"
+"bitmapToArray"
+"bitmapTransform"
+"bitmapXor"
+"bitmapXorCardinality"
+"bitmaskToArray"
+"bitmaskToList"
+"bitNot"
+"bitOr"
+"BIT_OR"
+"bitPositionsToArray"
+"bitRotateLeft"
+"bitRotateRight"
+"bitShiftLeft"
+"bitShiftRight"
+"__bitSwapLastTwo"
+"bitTest"
+"bitTestAll"
+"bitTestAny"
+"__bitWrapperFunc"
+"bitXor"
+"BIT_XOR"
+"BLOB"
+"blockNumber"
+"blockSerializedSize"
+"blockSize"
+"BOOL"
+"BOOLEAN"
+"BOTH"
+"boundingRatio"
+"buildId"
+"BY"
+"BYTE"
+"BYTEA"
+"byteSize"
+"CASE"
+"caseWithExpr"
+"caseWithExpression"
+"caseWithoutExpr"
+"caseWithoutExpression"
+"_CAST"
+"CAST"
+"categoricalInformationValue"
+"cbrt"
+"ceil"
+"ceiling"
+"char"
+"CHAR"
+"CHARACTER"
+"CHARACTER LARGE OBJECT"
+"CHARACTER_LENGTH"
+"CHARACTER VARYING"
+"CHAR LARGE OBJECT"
+"CHAR_LENGTH"
+"CHAR VARYING"
+"CHECK"
+"CHECK TABLE"
+"cityHash64"
+"CLEAR"
+"CLEAR COLUMN"
+"CLEAR INDEX"
+"CLOB"
+"CLUSTER"
+"coalesce"
+"CODEC"
+"COLLATE"
+"COLUMN"
+"COLUMNS"
+"COMMENT"
+"COMMENT COLUMN"
+"concat"
+"concatAssumeInjective"
+"connection_id"
+"connectionid"
+"connectionId"
+"CONSTRAINT"
+"convertCharset"
+"corr"
+"corrStable"
+"cos"
+"cosh"
+"count"
+"countDigits"
+"countEqual"
+"countMatches"
+"countMatchesCaseInsensitive"
+"countSubstrings"
+"countSubstringsCaseInsensitive"
+"countSubstringsCaseInsensitiveUTF8"
+"covarPop"
+"COVAR_POP"
+"covarPopStable"
+"covarSamp"
+"COVAR_SAMP"
+"covarSampStable"
+"CRC32"
+"CRC32IEEE"
+"CRC64"
+"CREATE"
+"CROSS"
+"CUBE"
+"currentDatabase"
+"currentProfiles"
+"currentRoles"
+"currentUser"
+"cutFragment"
+"cutIPv6"
+"cutQueryString"
+"cutQueryStringAndFragment"
+"cutToFirstSignificantSubdomain"
+"cutToFirstSignificantSubdomainCustom"
+"cutToFirstSignificantSubdomainCustomWithWWW"
+"cutToFirstSignificantSubdomainWithWWW"
+"cutURLParameter"
+"cutWWW"
+"D"
+"DATABASE"
+"DATABASES"
+"Date"
+"DATE"
+"Date32"
+"DATE_ADD"
+"DATEADD"
+"dateDiff"
+"DATE_DIFF"
+"DATEDIFF"
+"dateName"
+"DATE_SUB"
+"DATESUB"
+"DateTime"
+"DateTime32"
+"DateTime64"
+"dateTime64ToSnowflake"
+"dateTimeToSnowflake"
+"date_trunc"
+"dateTrunc"
+"DAY"
+"DAYOFMONTH"
+"DAYOFWEEK"
+"DAYOFYEAR"
+"DD"
+"DEC"
+"Decimal"
+"Decimal128"
+"Decimal256"
+"Decimal32"
+"Decimal64"
+"decodeURLComponent"
+"decodeXMLComponent"
+"decrypt"
+"DEDUPLICATE"
+"DEFAULT"
+"defaultProfiles"
+"defaultRoles"
+"defaultValueOfArgumentType"
+"defaultValueOfTypeName"
+"DELAY"
+"DELETE"
+"DELETE WHERE"
+"deltaSum"
+"deltaSumTimestamp"
+"demangle"
+"dense_rank"
+"DESC"
+"DESCENDING"
+"DESCRIBE"
+"DETACH"
+"DETACH PARTITION"
+"dictGet"
+"dictGetChildren"
+"dictGetDate"
+"dictGetDateOrDefault"
+"dictGetDateTime"
+"dictGetDateTimeOrDefault"
+"dictGetDescendants"
+"dictGetFloat32"
+"dictGetFloat32OrDefault"
+"dictGetFloat64"
+"dictGetFloat64OrDefault"
+"dictGetHierarchy"
+"dictGetInt16"
+"dictGetInt16OrDefault"
+"dictGetInt32"
+"dictGetInt32OrDefault"
+"dictGetInt64"
+"dictGetInt64OrDefault"
+"dictGetInt8"
+"dictGetInt8OrDefault"
+"dictGetOrDefault"
+"dictGetOrNull"
+"dictGetString"
+"dictGetStringOrDefault"
+"dictGetUInt16"
+"dictGetUInt16OrDefault"
+"dictGetUInt32"
+"dictGetUInt32OrDefault"
+"dictGetUInt64"
+"dictGetUInt64OrDefault"
+"dictGetUInt8"
+"dictGetUInt8OrDefault"
+"dictGetUUID"
+"dictGetUUIDOrDefault"
+"dictHas"
+"DICTIONARIES"
+"DICTIONARY"
+"dictIsIn"
+"DISK"
+"DISTINCT"
+"DISTRIBUTED"
+"divide"
+"domain"
+"domainWithoutWWW"
+"DOUBLE"
+"DOUBLE PRECISION"
+"DROP"
+"DROP COLUMN"
+"DROP CONSTRAINT"
+"DROP DETACHED PART"
+"DROP DETACHED PARTITION"
+"DROP INDEX"
+"DROP PARTITION"
+"dumpColumnStructure"
+"e"
+"ELSE"
+"empty"
+"emptyArrayDate"
+"emptyArrayDateTime"
+"emptyArrayFloat32"
+"emptyArrayFloat64"
+"emptyArrayInt16"
+"emptyArrayInt32"
+"emptyArrayInt64"
+"emptyArrayInt8"
+"emptyArrayString"
+"emptyArrayToSingle"
+"emptyArrayUInt16"
+"emptyArrayUInt32"
+"emptyArrayUInt64"
+"emptyArrayUInt8"
+"enabledProfiles"
+"enabledRoles"
+"encodeXMLComponent"
+"encrypt"
+"END"
+"endsWith"
+"ENGINE"
+"entropy"
+"Enum"
+"ENUM"
+"Enum16"
+"Enum8"
+"equals"
+"erf"
+"erfc"
+"errorCodeToName"
+"evalMLMethod"
+"EVENTS"
+"EXCHANGE TABLES"
+"EXISTS"
+"exp"
+"exp10"
+"exp2"
+"EXPLAIN"
+"exponentialMovingAverage"
+"EXPRESSION"
+"extract"
+"EXTRACT"
+"extractAll"
+"extractAllGroups"
+"extractAllGroupsHorizontal"
+"extractAllGroupsVertical"
+"extractGroups"
+"extractTextFromHTML"
+"extractURLParameter"
+"extractURLParameterNames"
+"extractURLParameters"
+"farmFingerprint64"
+"farmHash64"
+"FETCHES"
+"FETCH PART"
+"FETCH PARTITION"
+"file"
+"filesystemAvailable"
+"filesystemCapacity"
+"filesystemFree"
+"FINAL"
+"finalizeAggregation"
+"FIRST"
+"firstSignificantSubdomain"
+"firstSignificantSubdomainCustom"
+"first_value"
+"FIXED"
+"FixedString"
+"flatten"
+"FLOAT"
+"Float32"
+"Float64"
+"floor"
+"FLUSH"
+"FOR"
+"ForEach"
+"format"
+"FORMAT"
+"formatDateTime"
+"formatReadableQuantity"
+"formatReadableSize"
+"formatReadableTimeDelta"
+"formatRow"
+"formatRowNoNewline"
+"FQDN"
+"fragment"
+"FREEZE"
+"FROM"
+"FROM_BASE64"
+"fromModifiedJulianDay"
+"fromModifiedJulianDayOrNull"
+"FROM_UNIXTIME"
+"fromUnixTimestamp"
+"fromUnixTimestamp64Micro"
+"fromUnixTimestamp64Milli"
+"fromUnixTimestamp64Nano"
+"FULL"
+"fullHostName"
+"FUNCTION"
+"fuzzBits"
+"gccMurmurHash"
+"gcd"
+"generateUUIDv4"
+"geoDistance"
+"geohashDecode"
+"geohashEncode"
+"geohashesInBox"
+"geoToH3"
+"geoToS2"
+"getMacro"
+"__getScalar"
+"getServerPort"
+"getSetting"
+"getSizeOfEnumType"
+"GLOBAL"
+"globalIn"
+"globalInIgnoreSet"
+"globalNotIn"
+"globalNotInIgnoreSet"
+"globalNotNullIn"
+"globalNotNullInIgnoreSet"
+"globalNullIn"
+"globalNullInIgnoreSet"
+"globalVariable"
+"GRANULARITY"
+"greatCircleAngle"
+"greatCircleDistance"
+"greater"
+"greaterOrEquals"
+"greatest"
+"GROUP"
+"groupArray"
+"groupArrayInsertAt"
+"groupArrayMovingAvg"
+"groupArrayMovingSum"
+"groupArraySample"
+"groupBitAnd"
+"groupBitmap"
+"groupBitmapAnd"
+"groupBitmapOr"
+"groupBitmapXor"
+"groupBitOr"
+"groupBitXor"
+"GROUP BY"
+"groupUniqArray"
+"h3EdgeAngle"
+"h3EdgeLengthM"
+"h3GetBaseCell"
+"h3GetFaces"
+"h3GetResolution"
+"h3HexAreaM2"
+"h3IndexesAreNeighbors"
+"h3IsPentagon"
+"h3IsResClassIII"
+"h3IsValid"
+"h3kRing"
+"h3ToChildren"
+"h3ToGeo"
+"h3ToGeoBoundary"
+"h3ToParent"
+"h3ToString"
+"halfMD5"
+"has"
+"hasAll"
+"hasAny"
+"hasColumnInTable"
+"hasSubstr"
+"hasThreadFuzzer"
+"hasToken"
+"hasTokenCaseInsensitive"
+"HAVING"
+"hex"
+"HH"
+"HIERARCHICAL"
+"histogram"
+"hiveHash"
+"hostname"
+"hostName"
+"HOUR"
+"hypot"
+"ID"
+"identity"
+"if"
+"IF"
+"IF EXISTS"
+"IF NOT EXISTS"
+"ifNotFinite"
+"ifNull"
+"ignore"
+"ilike"
+"ILIKE"
+"in"
+"IN"
+"INDEX"
+"indexHint"
+"indexOf"
+"INET4"
+"INET6"
+"INET6_ATON"
+"INET6_NTOA"
+"INET_ATON"
+"INET_NTOA"
+"INF"
+"inIgnoreSet"
+"initializeAggregation"
+"initial_query_id"
+"initialQueryID"
+"INJECTIVE"
+"INNER"
+"IN PARTITION"
+"INSERT"
+"INSERT INTO"
+"INT"
+"INT1"
+"Int128"
+"Int16"
+"INT1 SIGNED"
+"INT1 UNSIGNED"
+"Int256"
+"Int32"
+"Int64"
+"Int8"
+"intDiv"
+"intDivOrZero"
+"INTEGER"
+"INTEGER SIGNED"
+"INTEGER UNSIGNED"
+"INTERVAL"
+"IntervalDay"
+"IntervalHour"
+"intervalLengthSum"
+"IntervalMinute"
+"IntervalMonth"
+"IntervalQuarter"
+"IntervalSecond"
+"IntervalWeek"
+"IntervalYear"
+"intExp10"
+"intExp2"
+"intHash32"
+"intHash64"
+"INTO"
+"INTO OUTFILE"
+"INT SIGNED"
+"INT UNSIGNED"
+"IPv4"
+"IPv4CIDRToRange"
+"IPv4NumToString"
+"IPv4NumToStringClassC"
+"IPv4StringToNum"
+"IPv4ToIPv6"
+"IPv6"
+"IPv6CIDRToRange"
+"IPv6NumToString"
+"IPv6StringToNum"
+"IS"
+"isConstant"
+"isDecimalOverflow"
+"isFinite"
+"isInfinite"
+"isIPAddressInRange"
+"isIPv4String"
+"isIPv6String"
+"isNaN"
+"isNotNull"
+"isNull"
+"IS_OBJECT_ID"
+"isValidJSON"
+"isValidUTF8"
+"isZeroOrNull"
+"javaHash"
+"javaHashUTF16LE"
+"JOIN"
+"joinGet"
+"joinGetOrNull"
+"JSON_EXISTS"
+"JSONExtract"
+"JSONExtractArrayRaw"
+"JSONExtractBool"
+"JSONExtractFloat"
+"JSONExtractInt"
+"JSONExtractKeysAndValues"
+"JSONExtractKeysAndValuesRaw"
+"JSONExtractRaw"
+"JSONExtractString"
+"JSONExtractUInt"
+"JSONHas"
+"JSONKey"
+"JSONLength"
+"JSON_QUERY"
+"JSONType"
+"JSON_VALUE"
+"jumpConsistentHash"
+"KEY"
+# Key words (based on keywords from antlr parser)
+"KILL"
+"kurtPop"
+"kurtSamp"
+"lagInFrame"
+"LAST"
+"last_value"
+"LAYOUT"
+"lcase"
+"lcm"
+"leadInFrame"
+"LEADING"
+"least"
+"LEFT"
+"LEFT ARRAY JOIN"
+"leftPad"
+"leftPadUTF8"
+"lemmatize"
+"length"
+"lengthUTF8"
+"less"
+"lessOrEquals"
+"lgamma"
+"LIFETIME"
+"like"
+"LIKE"
+"LIMIT"
+"LIVE"
+"ln"
+"LOCAL"
+"locate"
+"log"
+"log10"
+"log1p"
+"log2"
+"LOGS"
+"logTrace"
+"LONGBLOB"
+"LONGTEXT"
+"LowCardinality"
+"lowCardinalityIndices"
+"lowCardinalityKeys"
+"lower"
+"lowerUTF8"
+"lpad"
+"LTRIM"
+"M"
+"MACNumToString"
+"MACStringToNum"
+"MACStringToOUI"
+"mannWhitneyUTest"
+"map"
+"Map"
+"mapAdd"
+"mapContains"
+"mapKeys"
+"mapPopulateSeries"
+"mapSubtract"
+"mapValues"
+"match"
+"materialize"
+"MATERIALIZE"
+"MATERIALIZED"
+"MATERIALIZE INDEX"
+"MATERIALIZE TTL"
+"max"
+"MAX"
+"maxIntersections"
+"maxIntersectionsPosition"
+"maxMap"
+"MD4"
+"MD5"
+"median"
+"medianBFloat16"
+"medianBFloat16Weighted"
+"medianDeterministic"
+"medianExact"
+"medianExactHigh"
+"medianExactLow"
+"medianExactWeighted"
+"medianTDigest"
+"medianTDigestWeighted"
+"medianTiming"
+"medianTimingWeighted"
+"MEDIUMBLOB"
+"MEDIUMINT"
+"MEDIUMINT SIGNED"
+"MEDIUMINT UNSIGNED"
+"MEDIUMTEXT"
+"Merge"
+"MERGES"
+"metroHash64"
+"MI"
+"mid"
+"min"
+"MIN"
+"minMap"
+"minus"
+"MINUTE"
+"MM"
+"mod"
+"modelEvaluate"
+"MODIFY"
+"MODIFY COLUMN"
+"MODIFY ORDER BY"
+"MODIFY QUERY"
+"MODIFY SETTING"
+"MODIFY TTL"
+"modulo"
+"moduloLegacy"
+"moduloOrZero"
+"MONTH"
+"MOVE"
+"MOVE PART"
+"MOVE PARTITION"
+"movingXXX"
+"multiFuzzyMatchAllIndices"
+"multiFuzzyMatchAny"
+"multiFuzzyMatchAnyIndex"
+"multiIf"
+"multiMatchAllIndices"
+"multiMatchAny"
+"multiMatchAnyIndex"
+"multiply"
+"MultiPolygon"
+"multiSearchAllPositions"
+"multiSearchAllPositionsCaseInsensitive"
+"multiSearchAllPositionsCaseInsensitiveUTF8"
+"multiSearchAllPositionsUTF8"
+"multiSearchAny"
+"multiSearchAnyCaseInsensitive"
+"multiSearchAnyCaseInsensitiveUTF8"
+"multiSearchAnyUTF8"
+"multiSearchFirstIndex"
+"multiSearchFirstIndexCaseInsensitive"
+"multiSearchFirstIndexCaseInsensitiveUTF8"
+"multiSearchFirstIndexUTF8"
+"multiSearchFirstPosition"
+"multiSearchFirstPositionCaseInsensitive"
+"multiSearchFirstPositionCaseInsensitiveUTF8"
+"multiSearchFirstPositionUTF8"
+"murmurHash2_32"
+"murmurHash2_64"
+"murmurHash3_128"
+"murmurHash3_32"
+"murmurHash3_64"
+"MUTATION"
+"N"
+"NAME"
+"NAN_SQL"
+"NATIONAL CHAR"
+"NATIONAL CHARACTER"
+"NATIONAL CHARACTER LARGE OBJECT"
+"NATIONAL CHARACTER VARYING"
+"NATIONAL CHAR VARYING"
+"NCHAR"
+"NCHAR LARGE OBJECT"
+"NCHAR VARYING"
+"negate"
+"neighbor"
+"Nested"
+"netloc"
+"ngramDistance"
+"ngramDistanceCaseInsensitive"
+"ngramDistanceCaseInsensitiveUTF8"
+"ngramDistanceUTF8"
+"ngramMinHash"
+"ngramMinHashArg"
+"ngramMinHashArgCaseInsensitive"
+"ngramMinHashArgCaseInsensitiveUTF8"
+"ngramMinHashArgUTF8"
+"ngramMinHashCaseInsensitive"
+"ngramMinHashCaseInsensitiveUTF8"
+"ngramMinHashUTF8"
+"ngramSearch"
+"ngramSearchCaseInsensitive"
+"ngramSearchCaseInsensitiveUTF8"
+"ngramSearchUTF8"
+"ngramSimHash"
+"ngramSimHashCaseInsensitive"
+"ngramSimHashCaseInsensitiveUTF8"
+"ngramSimHashUTF8"
+"NO"
+"NO DELAY"
+"NONE"
+"normalizedQueryHash"
+"normalizedQueryHashKeepNames"
+"normalizeQuery"
+"normalizeQueryKeepNames"
+"not"
+"NOT"
+"notEmpty"
+"notEquals"
+"nothing"
+"Nothing"
+"notILike"
+"notIn"
+"notInIgnoreSet"
+"notLike"
+"notNullIn"
+"notNullInIgnoreSet"
+"now"
+"now64"
+"Null"
+"Nullable"
+"nullIf"
+"nullIn"
+"nullInIgnoreSet"
+"NULLS"
+"NULL_SQL"
+"NUMERIC"
+"NVARCHAR"
+"OFFSET"
+"ON"
+"ONLY"
+"OPTIMIZE"
+"OPTIMIZE TABLE"
+"or"
+"OR"
+"ORDER"
+"ORDER BY"
+"OR REPLACE"
+"OUTER"
+"OUTFILE"
+"parseDateTime32BestEffort"
+"parseDateTime32BestEffortOrNull"
+"parseDateTime32BestEffortOrZero"
+"parseDateTime64BestEffort"
+"parseDateTime64BestEffortOrNull"
+"parseDateTime64BestEffortOrZero"
+"parseDateTimeBestEffort"
+"parseDateTimeBestEffortOrNull"
+"parseDateTimeBestEffortOrZero"
+"parseDateTimeBestEffortUS"
+"parseDateTimeBestEffortUSOrNull"
+"parseDateTimeBestEffortUSOrZero"
+"PARTITION"
+"PARTITION BY"
+"partitionId"
+"path"
+"pathFull"
+"pi"
+"plus"
+"Point"
+"pointInEllipses"
+"pointInPolygon"
+"Polygon"
+"polygonAreaCartesian"
+"polygonAreaSpherical"
+"polygonConvexHullCartesian"
+"polygonPerimeterCartesian"
+"polygonPerimeterSpherical"
+"polygonsDistanceCartesian"
+"polygonsDistanceSpherical"
+"polygonsEqualsCartesian"
+"polygonsIntersectionCartesian"
+"polygonsIntersectionSpherical"
+"polygonsSymDifferenceCartesian"
+"polygonsSymDifferenceSpherical"
+"polygonsUnionCartesian"
+"polygonsUnionSpherical"
+"polygonsWithinCartesian"
+"polygonsWithinSpherical"
+"POPULATE"
+"port"
+"position"
+"positionCaseInsensitive"
+"positionCaseInsensitiveUTF8"
+"positionUTF8"
+"pow"
+"power"
+"PREWHERE"
+"PRIMARY"
+"PRIMARY KEY"
+"PROJECTION"
+"protocol"
+"Q"
+"QQ"
+"quantile"
+"quantileBFloat16"
+"quantileBFloat16Weighted"
+"quantileDeterministic"
+"quantileExact"
+"quantileExactExclusive"
+"quantileExactHigh"
+"quantileExactInclusive"
+"quantileExactLow"
+"quantileExactWeighted"
+"quantiles"
+"quantilesBFloat16"
+"quantilesBFloat16Weighted"
+"quantilesDeterministic"
+"quantilesExact"
+"quantilesExactExclusive"
+"quantilesExactHigh"
+"quantilesExactInclusive"
+"quantilesExactLow"
+"quantilesExactWeighted"
+"quantilesTDigest"
+"quantilesTDigestWeighted"
+"quantilesTiming"
+"quantilesTimingWeighted"
+"quantileTDigest"
+"quantileTDigestWeighted"
+"quantileTiming"
+"quantileTimingWeighted"
+"QUARTER"
+"query_id"
+"queryID"
+"queryString"
+"queryStringAndFragment"
+"rand"
+"rand32"
+"rand64"
+"randConstant"
+"randomFixedString"
+"randomPrintableASCII"
+"randomString"
+"randomStringUTF8"
+"range"
+"RANGE"
+"rank"
+"rankCorr"
+"readWktMultiPolygon"
+"readWktPoint"
+"readWktPolygon"
+"readWktRing"
+"REAL"
+"REFRESH"
+"regexpQuoteMeta"
+"regionHierarchy"
+"regionIn"
+"regionToArea"
+"regionToCity"
+"regionToContinent"
+"regionToCountry"
+"regionToDistrict"
+"regionToName"
+"regionToPopulation"
+"regionToTopContinent"
+"reinterpret"
+"reinterpretAsDate"
+"reinterpretAsDateTime"
+"reinterpretAsFixedString"
+"reinterpretAsFloat32"
+"reinterpretAsFloat64"
+"reinterpretAsInt128"
+"reinterpretAsInt16"
+"reinterpretAsInt256"
+"reinterpretAsInt32"
+"reinterpretAsInt64"
+"reinterpretAsInt8"
+"reinterpretAsString"
+"reinterpretAsUInt128"
+"reinterpretAsUInt16"
+"reinterpretAsUInt256"
+"reinterpretAsUInt32"
+"reinterpretAsUInt64"
+"reinterpretAsUInt8"
+"reinterpretAsUUID"
+"RELOAD"
+"REMOVE"
+"RENAME"
+"RENAME COLUMN"
+"RENAME TABLE"
+"repeat"
+"replace"
+"REPLACE"
+"replaceAll"
+"replaceOne"
+"REPLACE PARTITION"
+"replaceRegexpAll"
+"replaceRegexpOne"
+"REPLICA"
+"replicate"
+"REPLICATED"
+"Resample"
+"RESUME"
+"retention"
+"reverse"
+"reverseUTF8"
+"RIGHT"
+"rightPad"
+"rightPadUTF8"
+"Ring"
+"ROLLUP"
+"round"
+"roundAge"
+"roundBankers"
+"roundDown"
+"roundDuration"
+"roundToExp2"
+"row_number"
+"rowNumberInAllBlocks"
+"rowNumberInBlock"
+"rpad"
+"RTRIM"
+"runningAccumulate"
+"runningConcurrency"
+"runningDifference"
+"runningDifferenceStartingWithFirstValue"
+"S"
+"s2CapContains"
+"s2CapUnion"
+"s2CellsIntersect"
+"s2GetNeighbors"
+"s2RectAdd"
+"s2RectContains"
+"s2RectIntersection"
+"s2RectUnion"
+"s2ToGeo"
+"SAMPLE"
+"SAMPLE BY"
+"SECOND"
+"SELECT"
+"SEMI"
+"SENDS"
+"sequenceCount"
+"sequenceMatch"
+"sequenceNextNode"
+"serverUUID"
+"SET"
+"SETTINGS"
+"SHA1"
+"SHA224"
+"SHA256"
+"SHA384"
+"SHA512"
+"shardCount"
+"shardNum"
+"SHOW"
+"SHOW PROCESSLIST"
+"sigmoid"
+"sign"
+"SimpleAggregateFunction"
+"simpleJSONExtractBool"
+"simpleJSONExtractFloat"
+"simpleJSONExtractInt"
+"simpleJSONExtractRaw"
+"simpleJSONExtractString"
+"simpleJSONExtractUInt"
+"simpleJSONHas"
+"simpleLinearRegression"
+"sin"
+"SINGLE"
+"singleValueOrNull"
+"sinh"
+"sipHash128"
+"sipHash64"
+"skewPop"
+"skewSamp"
+"sleep"
+"sleepEachRow"
+"SMALLINT"
+"SMALLINT SIGNED"
+"SMALLINT UNSIGNED"
+"snowflakeToDateTime"
+"snowflakeToDateTime64"
+"SOURCE"
+"sparkbar"
+"splitByChar"
+"splitByNonAlpha"
+"splitByRegexp"
+"splitByString"
+"splitByWhitespace"
+"SQL_TSI_DAY"
+"SQL_TSI_HOUR"
+"SQL_TSI_MINUTE"
+"SQL_TSI_MONTH"
+"SQL_TSI_QUARTER"
+"SQL_TSI_SECOND"
+"SQL_TSI_WEEK"
+"SQL_TSI_YEAR"
+"sqrt"
+"SS"
+"START"
+"startsWith"
+"State"
+"stddevPop"
+"STDDEV_POP"
+"stddevPopStable"
+"stddevSamp"
+"STDDEV_SAMP"
+"stddevSampStable"
+"stem"
+"STEP"
+"stochasticLinearRegression"
+"stochasticLogisticRegression"
+"STOP"
+"String"
+"stringToH3"
+"studentTTest"
+"subBitmap"
+"substr"
+"substring"
+"SUBSTRING"
+"substringUTF8"
+"subtractDays"
+"subtractHours"
+"subtractMinutes"
+"subtractMonths"
+"subtractQuarters"
+"subtractSeconds"
+"subtractWeeks"
+"subtractYears"
+"sum"
+"sumCount"
+"sumKahan"
+"sumMap"
+"sumMapFiltered"
+"sumMapFilteredWithOverflow"
+"sumMapWithOverflow"
+"sumWithOverflow"
+"SUSPEND"
+"svg"
+"SYNC"
+"synonyms"
+"SYNTAX"
+"SYSTEM"
+"TABLE"
+"TABLES"
+"tan"
+"tanh"
+"tcpPort"
+"TEMPORARY"
+"TEST"
+"TEXT"
+"tgamma"
+"THEN"
+"throwIf"
+"tid"
+"TIES"
+"TIMEOUT"
+"timeSlot"
+"timeSlots"
+"TIMESTAMP"
+"TIMESTAMP_ADD"
+"TIMESTAMPADD"
+"TIMESTAMP_DIFF"
+"TIMESTAMPDIFF"
+"TIMESTAMP_SUB"
+"TIMESTAMPSUB"
+"timezone"
+"timeZone"
+"timezoneOf"
+"timeZoneOf"
+"timezoneOffset"
+"timeZoneOffset"
+"TINYBLOB"
+"TINYINT"
+"TINYINT SIGNED"
+"TINYINT UNSIGNED"
+"TINYTEXT"
+"TO"
+"TO_BASE64"
+"toColumnTypeName"
+"toDate"
+"toDate32"
+"toDate32OrNull"
+"toDate32OrZero"
+"toDateOrNull"
+"toDateOrZero"
+"toDateTime"
+"toDateTime32"
+"toDateTime64"
+"toDateTime64OrNull"
+"toDateTime64OrZero"
+"toDateTimeOrNull"
+"toDateTimeOrZero"
+"today"
+"toDayOfMonth"
+"toDayOfWeek"
+"toDayOfYear"
+"toDecimal128"
+"toDecimal128OrNull"
+"toDecimal128OrZero"
+"toDecimal256"
+"toDecimal256OrNull"
+"toDecimal256OrZero"
+"toDecimal32"
+"toDecimal32OrNull"
+"toDecimal32OrZero"
+"toDecimal64"
+"toDecimal64OrNull"
+"toDecimal64OrZero"
+"TO DISK"
+"toFixedString"
+"toFloat32"
+"toFloat32OrNull"
+"toFloat32OrZero"
+"toFloat64"
+"toFloat64OrNull"
+"toFloat64OrZero"
+"toHour"
+"toInt128"
+"toInt128OrNull"
+"toInt128OrZero"
+"toInt16"
+"toInt16OrNull"
+"toInt16OrZero"
+"toInt256"
+"toInt256OrNull"
+"toInt256OrZero"
+"toInt32"
+"toInt32OrNull"
+"toInt32OrZero"
+"toInt64"
+"toInt64OrNull"
+"toInt64OrZero"
+"toInt8"
+"toInt8OrNull"
+"toInt8OrZero"
+"toIntervalDay"
+"toIntervalHour"
+"toIntervalMinute"
+"toIntervalMonth"
+"toIntervalQuarter"
+"toIntervalSecond"
+"toIntervalWeek"
+"toIntervalYear"
+"toIPv4"
+"toIPv6"
+"toISOWeek"
+"toISOYear"
+"toJSONString"
+"toLowCardinality"
+"toMinute"
+"toModifiedJulianDay"
+"toModifiedJulianDayOrNull"
+"toMonday"
+"toMonth"
+"toNullable"
+"TOP"
+"topK"
+"topKWeighted"
+"topLevelDomain"
+"toQuarter"
+"toRelativeDayNum"
+"toRelativeHourNum"
+"toRelativeMinuteNum"
+"toRelativeMonthNum"
+"toRelativeQuarterNum"
+"toRelativeSecondNum"
+"toRelativeWeekNum"
+"toRelativeYearNum"
+"toSecond"
+"toStartOfDay"
+"toStartOfFifteenMinutes"
+"toStartOfFiveMinute"
+"toStartOfHour"
+"toStartOfInterval"
+"toStartOfISOYear"
+"toStartOfMinute"
+"toStartOfMonth"
+"toStartOfQuarter"
+"toStartOfSecond"
+"toStartOfTenMinutes"
+"toStartOfWeek"
+"toStartOfYear"
+"toString"
+"toStringCutToZero"
+"TO TABLE"
+"TOTALS"
+"toTime"
+"toTimezone"
+"toTimeZone"
+"toTypeName"
+"toUInt128"
+"toUInt128OrNull"
+"toUInt128OrZero"
+"toUInt16"
+"toUInt16OrNull"
+"toUInt16OrZero"
+"toUInt256"
+"toUInt256OrNull"
+"toUInt256OrZero"
+"toUInt32"
+"toUInt32OrNull"
+"toUInt32OrZero"
+"toUInt64"
+"toUInt64OrNull"
+"toUInt64OrZero"
+"toUInt8"
+"toUInt8OrNull"
+"toUInt8OrZero"
+"toUnixTimestamp"
+"toUnixTimestamp64Micro"
+"toUnixTimestamp64Milli"
+"toUnixTimestamp64Nano"
+"toUUID"
+"toUUIDOrNull"
+"toUUIDOrZero"
+"toValidUTF8"
+"TO VOLUME"
+"toWeek"
+"toYear"
+"toYearWeek"
+"toYYYYMM"
+"toYYYYMMDD"
+"toYYYYMMDDhhmmss"
+"TRAILING"
+"transform"
+"TRIM"
+"trimBoth"
+"trimLeft"
+"trimRight"
+"trunc"
+"truncate"
+"TRUNCATE"
+"tryBase64Decode"
+"TTL"
+"tuple"
+"Tuple"
+"tupleElement"
+"tupleHammingDistance"
+"tupleToNameValuePairs"
+"TYPE"
+"ucase"
+"UInt128"
+"UInt16"
+"UInt256"
+"UInt32"
+"UInt64"
+"UInt8"
+"unbin"
+"unhex"
+"UNION"
+"uniq"
+"uniqCombined"
+"uniqCombined64"
+"uniqExact"
+"uniqHLL12"
+"uniqTheta"
+"uniqUpTo"
+"UPDATE"
+"upper"
+"upperUTF8"
+"uptime"
+"URLHash"
+"URLHierarchy"
+"URLPathHierarchy"
+"USE"
+"user"
+"USING"
+"UUID"
+"UUIDNumToString"
+"UUIDStringToNum"
+"validateNestedArraySizes"
+"VALUES"
+"VARCHAR"
+"VARCHAR2"
+"varPop"
+"VAR_POP"
+"varPopStable"
+"varSamp"
+"VAR_SAMP"
+"varSampStable"
+"version"
+"VIEW"
+"visibleWidth"
+"visitParamExtractBool"
+"visitParamExtractFloat"
+"visitParamExtractInt"
+"visitParamExtractRaw"
+"visitParamExtractString"
+"visitParamExtractUInt"
+"visitParamHas"
+"VOLUME"
+"WATCH"
+"week"
+"WEEK"
+"welchTTest"
+"WHEN"
+"WHERE"
+"windowFunnel"
+"WITH"
+"WITH FILL"
+"WITH TIES"
+"WK"
+"wkt"
+"wordShingleMinHash"
+"wordShingleMinHashArg"
+"wordShingleMinHashArgCaseInsensitive"
+"wordShingleMinHashArgCaseInsensitiveUTF8"
+"wordShingleMinHashArgUTF8"
+"wordShingleMinHashCaseInsensitive"
+"wordShingleMinHashCaseInsensitiveUTF8"
+"wordShingleMinHashUTF8"
+"wordShingleSimHash"
+"wordShingleSimHashCaseInsensitive"
+"wordShingleSimHashCaseInsensitiveUTF8"
+"wordShingleSimHashUTF8"
+"WW"
+"xor"
+"xxHash32"
+"xxHash64"
+"yandexConsistentHash"
+"YEAR"
+"yearweek"
+"yesterday"
+"YY"
+"YYYY"
+"zookeeperSessionUptime"
diff --git a/tests/fuzz/create_parser_fuzzer.options b/tests/fuzz/create_parser_fuzzer.options
index fda41ea5398..cbe915d10fc 100644
--- a/tests/fuzz/create_parser_fuzzer.options
+++ b/tests/fuzz/create_parser_fuzzer.options
@@ -1,2 +1,3 @@
 [libfuzzer]
-dict = ast.dict
+dict = all.dict
+jobs = 8
diff --git a/tests/fuzz/datatypes.dict b/tests/fuzz/datatypes.dict
deleted file mode 100644
index 65141dfaf08..00000000000
--- a/tests/fuzz/datatypes.dict
+++ /dev/null
@@ -1,38 +0,0 @@
-"Nothing"
-"UUID"
-"Enum8"
-"Enum16"
-"Enum"
-"Date"
-"IntervalSecond"
-"IntervalMinute"
-"IntervalHour"
-"IntervalDay"
-"IntervalWeek"
-"IntervalMonth"
-"IntervalQuarter"
-"IntervalYear"
-"AggregateFunction"
-"FixedString"
-"LowCardinality"
-"DateTime"
-"Nullable"
-"String"
-"UInt8"
-"UInt16"
-"UInt32"
-"UInt64"
-"Int8"
-"Int16"
-"Int32"
-"Int64"
-"Float32"
-"Float64"
-"DateTime64"
-"Decimal32"
-"Decimal64"
-"Decimal128"
-"Decimal"
-"Tuple"
-"Nested"
-"Array"
diff --git a/tests/fuzz/dictionaries/datatypes.dict b/tests/fuzz/dictionaries/datatypes.dict
new file mode 100644
index 00000000000..e4983ae5f68
--- /dev/null
+++ b/tests/fuzz/dictionaries/datatypes.dict
@@ -0,0 +1,185 @@
+"Polygon"
+"Ring"
+"Point"
+"SimpleAggregateFunction"
+"MultiPolygon"
+"IPv6"
+"IntervalSecond"
+"IPv4"
+"UInt32"
+"IntervalYear"
+"IntervalQuarter"
+"IntervalMonth"
+"Int64"
+"IntervalDay"
+"IntervalHour"
+"Int16"
+"UInt256"
+"LowCardinality"
+"AggregateFunction"
+"Nothing"
+"Decimal256"
+"Tuple"
+"Array"
+"Enum16"
+"IntervalMinute"
+"FixedString"
+"String"
+"DateTime"
+"Map"
+"UUID"
+"Decimal64"
+"Nullable"
+"Enum"
+"Int32"
+"UInt8"
+"Date"
+"Decimal32"
+"UInt128"
+"Float64"
+"Nested"
+"Int128"
+"Decimal128"
+"Int8"
+"Decimal"
+"Int256"
+"DateTime64"
+"Enum8"
+"DateTime32"
+"Date32"
+"IntervalWeek"
+"UInt64"
+"UInt16"
+"Float32"
+"INET6"
+"INET4"
+"ENUM"
+"BINARY"
+"NATIONAL CHAR VARYING"
+"BINARY VARYING"
+"NCHAR LARGE OBJECT"
+"NATIONAL CHARACTER VARYING"
+"NATIONAL CHARACTER LARGE OBJECT"
+"NATIONAL CHARACTER"
+"NATIONAL CHAR"
+"CHARACTER VARYING"
+"LONGBLOB"
+"MEDIUMTEXT"
+"TEXT"
+"TINYBLOB"
+"VARCHAR2"
+"CHARACTER LARGE OBJECT"
+"DOUBLE PRECISION"
+"LONGTEXT"
+"NVARCHAR"
+"INT1 UNSIGNED"
+"VARCHAR"
+"CHAR VARYING"
+"MEDIUMBLOB"
+"NCHAR"
+"CHAR"
+"SMALLINT UNSIGNED"
+"TIMESTAMP"
+"FIXED"
+"TINYTEXT"
+"NUMERIC"
+"DEC"
+"TINYINT UNSIGNED"
+"INTEGER UNSIGNED"
+"INT UNSIGNED"
+"CLOB"
+"MEDIUMINT UNSIGNED"
+"BOOL"
+"SMALLINT"
+"INTEGER SIGNED"
+"NCHAR VARYING"
+"INT SIGNED"
+"TINYINT SIGNED"
+"BIGINT SIGNED"
+"BINARY LARGE OBJECT"
+"SMALLINT SIGNED"
+"MEDIUMINT"
+"INTEGER"
+"INT1 SIGNED"
+"BIGINT UNSIGNED"
+"BYTEA"
+"INT"
+"SINGLE"
+"FLOAT"
+"MEDIUMINT SIGNED"
+"BOOLEAN"
+"DOUBLE"
+"INT1"
+"CHAR LARGE OBJECT"
+"TINYINT"
+"BIGINT"
+"CHARACTER"
+"BYTE"
+"BLOB"
+"REAL"
+"IPv6"
+"IPv4"
+"Enum"
+"FixedString"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"String"
+"Float64"
+"String"
+"String"
+"UInt8"
+"String"
+"String"
+"String"
+"String"
+"String"
+"UInt16"
+"DateTime"
+"Decimal"
+"String"
+"Decimal"
+"Decimal"
+"UInt8"
+"UInt32"
+"UInt32"
+"String"
+"UInt32"
+"Int8"
+"Int16"
+"Int32"
+"String"
+"Int32"
+"Int8"
+"Int64"
+"String"
+"Int16"
+"Int32"
+"Int32"
+"Int8"
+"UInt64"
+"String"
+"Int32"
+"Float32"
+"Float32"
+"Int32"
+"Int8"
+"Float64"
+"Int8"
+"String"
+"Int8"
+"Int64"
+"String"
+"Int8"
+"String"
+"Float32"
diff --git a/tests/fuzz/dictionaries/functions.dict b/tests/fuzz/dictionaries/functions.dict
new file mode 100644
index 00000000000..ba9daa72199
--- /dev/null
+++ b/tests/fuzz/dictionaries/functions.dict
@@ -0,0 +1,1121 @@
+"logTrace"
+"aes_decrypt_mysql"
+"aes_encrypt_mysql"
+"decrypt"
+"encrypt"
+"bayesAB"
+"snowflakeToDateTime64"
+"snowflakeToDateTime"
+"validateNestedArraySizes"
+"wordShingleMinHashArgCaseInsensitiveUTF8"
+"wordShingleMinHashArgUTF8"
+"wordShingleMinHashArgCaseInsensitive"
+"wordShingleMinHashArg"
+"ngramMinHashArgCaseInsensitiveUTF8"
+"ngramMinHashArgUTF8"
+"ngramMinHashArgCaseInsensitive"
+"wordShingleMinHashCaseInsensitiveUTF8"
+"wordShingleMinHashUTF8"
+"ngramMinHashCaseInsensitiveUTF8"
+"ngramMinHashUTF8"
+"ngramMinHashCaseInsensitive"
+"wordShingleSimHashUTF8"
+"ngramSimHashUTF8"
+"ngramSimHashCaseInsensitive"
+"ngramSimHash"
+"toUnixTimestamp64Nano"
+"toUnixTimestamp64Micro"
+"jumpConsistentHash"
+"yandexConsistentHash"
+"addressToSymbol"
+"toJSONString"
+"JSON_VALUE"
+"JSONExtractKeysAndValuesRaw"
+"JSONExtractString"
+"JSONType"
+"JSONKey"
+"JSONLength"
+"isValidJSON"
+"isZeroOrNull"
+"assumeNotNull"
+"s2CapUnion"
+"s2CapContains"
+"s2CellsIntersect"
+"s2GetNeighbors"
+"s2ToGeo"
+"h3GetFaces"
+"h3IsResClassIII"
+"h3ToString"
+"stringToH3"
+"h3ToParent"
+"h3GetResolution"
+"h3EdgeLengthM"
+"svg"
+"equals"
+"geohashesInBox"
+"polygonsIntersectionCartesian"
+"polygonPerimeterSpherical"
+"bitHammingDistance"
+"polygonsDistanceSpherical"
+"polygonsSymDifferenceSpherical"
+"polygonAreaSpherical"
+"greatCircleDistance"
+"toInt256"
+"mapKeys"
+"sign"
+"reinterpretAsUInt8"
+"atanh"
+"formatReadableTimeDelta"
+"geohashEncode"
+"atan2"
+"acos"
+"SHA224"
+"visitParamExtractBool"
+"h3kRing"
+"asin"
+"sin"
+"reinterpretAsUInt128"
+"lgamma"
+"log2"
+"geoToH3"
+"toUnixTimestamp64Milli"
+"firstSignificantSubdomainCustom"
+"simpleJSONExtractBool"
+"visitParamExtractFloat"
+"visitParamExtractInt"
+"simpleJSONHas"
+"visitParamHas"
+"sigmoid"
+"cutQueryStringAndFragment"
+"dictGetInt16OrDefault"
+"cutToFirstSignificantSubdomainCustom"
+"URLHierarchy"
+"extractURLParameterNames"
+"toDecimal128OrZero"
+"extractURLParameters"
+"path"
+"pathFull"
+"port"
+"domain"
+"bitTest"
+"ngramSearchCaseInsensitiveUTF8"
+"bitmapMax"
+"ngramDistanceCaseInsensitiveUTF8"
+"ngramDistance"
+"extractAllGroupsHorizontal"
+"extractAllGroupsVertical"
+"multiFuzzyMatchAllIndices"
+"multiFuzzyMatchAnyIndex"
+"multiMatchAnyIndex"
+"replaceRegexpAll"
+"emptyArrayInt16"
+"dictGetOrDefault"
+"replaceOne"
+"emptyArrayInt32"
+"extract"
+"readWktPolygon"
+"notILike"
+"geohashDecode"
+"toModifiedJulianDay"
+"notLike"
+"countSubstringsCaseInsensitive"
+"IPv4StringToNum"
+"positionUTF8"
+"hasToken"
+"dictGetDate"
+"multiSearchFirstPosition"
+"multiSearchFirstIndexCaseInsensitiveUTF8"
+"atan"
+"rowNumberInAllBlocks"
+"multiSearchFirstIndexCaseInsensitive"
+"multiSearchAnyUTF8"
+"parseDateTime32BestEffortOrZero"
+"blockNumber"
+"cutURLParameter"
+"multiSearchFirstPositionCaseInsensitive"
+"positionCaseInsensitiveUTF8"
+"positionCaseInsensitive"
+"splitByRegexp"
+"toInt256OrZero"
+"pointInPolygon"
+"splitByWhitespace"
+"lemmatize"
+"synonyms"
+"tryBase64Decode"
+"multiSearchAllPositions"
+"FROM_BASE64"
+"replaceRegexpOne"
+"subBitmap"
+"defaultValueOfArgumentType"
+"base64Decode"
+"regionToContinent"
+"ilike"
+"fromModifiedJulianDay"
+"TO_BASE64"
+"dictIsIn"
+"base64Encode"
+"decodeXMLComponent"
+"countMatchesCaseInsensitive"
+"normalizeQuery"
+"erf"
+"trimBoth"
+"fromUnixTimestamp64Nano"
+"lessOrEquals"
+"subtractQuarters"
+"ngramSearch"
+"readWktRing"
+"trimRight"
+"endsWith"
+"ngramDistanceCaseInsensitive"
+"connectionId"
+"initialQueryID"
+"startsWith"
+"tan"
+"substring"
+"formatRow"
+"dictGetHierarchy"
+"notEmpty"
+"format"
+"murmurHash3_64"
+"reverseUTF8"
+"arrayEnumerateUniqRanked"
+"CRC64"
+"pow"
+"toInt16"
+"reverse"
+"lower"
+"toStartOfDay"
+"caseWithoutExpr"
+"CHAR_LENGTH"
+"lengthUTF8"
+"length"
+"bitTestAny"
+"floor"
+"round"
+"reinterpretAsFixedString"
+"reinterpretAsString"
+"h3ToChildren"
+"emptyArrayToSingle"
+"tgamma"
+"reinterpretAsInt128"
+"visitParamExtractRaw"
+"reinterpretAsInt64"
+"reinterpretAsUInt32"
+"reinterpretAsUInt16"
+"fuzzBits"
+"randomFixedString"
+"tupleHammingDistance"
+"JSONExtractBool"
+"ngramSearchUTF8"
+"generateUUIDv4"
+"multiSearchAllPositionsCaseInsensitive"
+"randConstant"
+"leftPad"
+"convertCharset"
+"extractURLParameter"
+"zookeeperSessionUptime"
+"serverUUID"
+"firstSignificantSubdomain"
+"rand64"
+"JSON_EXISTS"
+"isIPAddressInRange"
+"wordShingleSimHashCaseInsensitive"
+"parseDateTime32BestEffortOrNull"
+"cutToFirstSignificantSubdomainWithWWW"
+"roundToExp2"
+"mapSubtract"
+"partitionId"
+"intExp2"
+"byteSize"
+"errorCodeToName"
+"toDateTime64"
+"yesterday"
+"initializeAggregation"
+"globalVariable"
+"countDigits"
+"toStartOfHour"
+"toWeek"
+"isDecimalOverflow"
+"visitParamExtractString"
+"isConstant"
+"getSetting"
+"shardNum"
+"__getScalar"
+"position"
+"__bitBoolMaskOr"
+"cosh"
+"basename"
+"evalMLMethod"
+"filesystemFree"
+"filesystemCapacity"
+"reinterpretAsDate"
+"filesystemAvailable"
+"joinGet"
+"globalNullInIgnoreSet"
+"globalNotInIgnoreSet"
+"toRelativeDayNum"
+"splitByChar"
+"notInIgnoreSet"
+"globalInIgnoreSet"
+"notNullIn"
+"ngramSearchCaseInsensitive"
+"notIn"
+"trunc"
+"JSONExtractArrayRaw"
+"version"
+"joinGetOrNull"
+"globalIn"
+"toDate32"
+"lowCardinalityIndices"
+"toLowCardinality"
+"runningConcurrency"
+"runningDifferenceStartingWithFirstValue"
+"bitCount"
+"timezoneOf"
+"timezone"
+"uptime"
+"pi"
+"extractTextFromHTML"
+"UUIDStringToNum"
+"roundDown"
+"IPv6NumToString"
+"throwIf"
+"ifNotFinite"
+"FROM_UNIXTIME"
+"isInfinite"
+"arrayProduct"
+"polygonsIntersectionSpherical"
+"toRelativeHourNum"
+"hasColumnInTable"
+"bar"
+"JSONExtractKeysAndValues"
+"replicate"
+"arrayJoin"
+"s2RectUnion"
+"ngramDistanceUTF8"
+"identity"
+"indexHint"
+"ignore"
+"regionHierarchy"
+"toDateTime64OrNull"
+"polygonsWithinCartesian"
+"materialize"
+"sleepEachRow"
+"parseDateTimeBestEffortUSOrNull"
+"neighbor"
+"splitByString"
+"rowNumberInBlock"
+"blockSize"
+"defaultValueOfTypeName"
+"hiveHash"
+"randomStringUTF8"
+"blockSerializedSize"
+"visibleWidth"
+"fullHostName"
+"hostName"
+"arrayFilter"
+"defaultRoles"
+"currentRoles"
+"toUInt64OrZero"
+"dictGetUInt16"
+"DATABASE"
+"toUInt8OrZero"
+"reinterpretAsInt8"
+"not"
+"log1p"
+"and"
+"wordShingleMinHash"
+"arrayDifference"
+"arrayCumSumNonNegative"
+"wordShingleSimHash"
+"arrayCumSum"
+"arraySort"
+"dumpColumnStructure"
+"multiSearchFirstIndex"
+"arrayReverseSplit"
+"ifNull"
+"normalizeQueryKeepNames"
+"xxHash64"
+"in"
+"arrayReverseFill"
+"erfc"
+"cutToFirstSignificantSubdomainCustomWithWWW"
+"arrayFill"
+"substringUTF8"
+"arrayFirst"
+"arrayAvg"
+"cos"
+"arrayMax"
+"toColumnTypeName"
+"arrayMin"
+"toIntervalDay"
+"reinterpretAsFloat32"
+"arrayAll"
+"or"
+"arrayExists"
+"trimLeft"
+"arrayMap"
+"polygonsSymDifferenceCartesian"
+"gccMurmurHash"
+"exp2"
+"polygonPerimeterCartesian"
+"SHA384"
+"murmurHash3_128"
+"polygonConvexHullCartesian"
+"murmurHash3_32"
+"h3GetBaseCell"
+"murmurHash2_64"
+"globalNullIn"
+"javaHashUTF16LE"
+"URLHash"
+"reinterpretAsInt16"
+"regionToCountry"
+"toUUID"
+"intHash32"
+"metroHash64"
+"arrayPushFront"
+"bitmapAndnotCardinality"
+"toFloat32"
+"sipHash64"
+"JSONExtractFloat"
+"SHA512"
+"JSONExtractUInt"
+"arrayReduce"
+"SHA256"
+"array"
+"parseDateTimeBestEffortUSOrZero"
+"toInt32OrNull"
+"MD5"
+"randomString"
+"__bitBoolMaskAnd"
+"hasSubstr"
+"formatReadableQuantity"
+"replaceAll"
+"toIntervalWeek"
+"toRelativeSecondNum"
+"demangle"
+"toNullable"
+"concat"
+"formatReadableSize"
+"shardCount"
+"fromModifiedJulianDayOrNull"
+"toInt128OrZero"
+"bitmaskToList"
+"xor"
+"bitPositionsToArray"
+"empty"
+"ngramMinHashArg"
+"_CAST"
+"dictGetStringOrDefault"
+"arrayZip"
+"dictGetUUIDOrDefault"
+"dictGetFloat64OrDefault"
+"dictGetInt64OrDefault"
+"today"
+"dictGetUInt32OrDefault"
+"countSubstringsCaseInsensitiveUTF8"
+"h3IsPentagon"
+"dictGetUInt16OrDefault"
+"dictGetDescendants"
+"dictGetString"
+"inIgnoreSet"
+"dictGetUUID"
+"arraySlice"
+"reinterpretAsInt32"
+"dictGetFloat64"
+"globalNotNullInIgnoreSet"
+"arrayUniq"
+"polygonAreaCartesian"
+"intDiv"
+"cityHash64"
+"regionToTopContinent"
+"toInt32"
+"e"
+"wordShingleSimHashCaseInsensitiveUTF8"
+"formatRowNoNewline"
+"JSON_QUERY"
+"isIPv4String"
+"UUIDNumToString"
+"modulo"
+"reinterpret"
+"unbin"
+"regionToDistrict"
+"sinh"
+"date_trunc"
+"__bitSwapLastTwo"
+"formatDateTime"
+"dateDiff"
+"tanh"
+"multiSearchAnyCaseInsensitiveUTF8"
+"upperUTF8"
+"bitmaskToArray"
+"arrayAUC"
+"multiMatchAllIndices"
+"hasThreadFuzzer"
+"toDayOfWeek"
+"isFinite"
+"transform"
+"timezoneOffset"
+"toTimezone"
+"cutQueryString"
+"subtractYears"
+"tcpPort"
+"subtractHours"
+"tid"
+"toDateTime64OrZero"
+"subtractSeconds"
+"alphaTokens"
+"negate"
+"modelEvaluate"
+"file"
+"roundAge"
+"MACStringToOUI"
+"addQuarters"
+"arrayResize"
+"addWeeks"
+"HOUR"
+"addHours"
+"visitParamExtractUInt"
+"caseWithExpression"
+"rand"
+"addSeconds"
+"splitByNonAlpha"
+"arrayStringConcat"
+"randomPrintableASCII"
+"h3HexAreaM2"
+"toYYYYMMDDhhmmss"
+"toInt16OrNull"
+"timeSlots"
+"timeSlot"
+"dictGetInt16"
+"queryString"
+"javaHash"
+"acosh"
+"toRelativeMinuteNum"
+"toRelativeYearNum"
+"unhex"
+"toInt8OrNull"
+"regionToPopulation"
+"toStartOfISOYear"
+"getSizeOfEnumType"
+"toStartOfInterval"
+"toYYYYMMDD"
+"multiSearchFirstPositionUTF8"
+"CRC32"
+"toStartOfFifteenMinutes"
+"emptyArrayUInt8"
+"dictGetUInt8"
+"toStartOfFiveMinute"
+"cbrt"
+"toStartOfMinute"
+"dictGet"
+"toStartOfSecond"
+"hasTokenCaseInsensitive"
+"toStartOfYear"
+"farmHash64"
+"toStartOfMonth"
+"queryID"
+"wordShingleMinHashCaseInsensitive"
+"dictGetDateOrDefault"
+"dictGetUInt64OrDefault"
+"arrayElement"
+"sleep"
+"dictHas"
+"enabledProfiles"
+"toDecimal32OrNull"
+"multiFuzzyMatchAny"
+"toStartOfWeek"
+"isValidUTF8"
+"dictGetInt8"
+"dictGetInt32OrDefault"
+"toMonday"
+"multiSearchFirstIndexUTF8"
+"lowCardinalityKeys"
+"halfMD5"
+"domainWithoutWWW"
+"MINUTE"
+"addDays"
+"toMinute"
+"JSONExtractRaw"
+"toUInt16OrNull"
+"bin"
+"toDayOfYear"
+"log"
+"DAYOFMONTH"
+"toUInt32"
+"toDecimal32"
+"s2RectAdd"
+"dictGetFloat32OrDefault"
+"xxHash32"
+"DAY"
+"toISOWeek"
+"ngramMinHash"
+"toMonth"
+"countMatches"
+"toQuarter"
+"toISOYear"
+"YEAR"
+"toIntervalYear"
+"hypot"
+"multiSearchAny"
+"toIntervalQuarter"
+"toSecond"
+"accurate_CastOrNull"
+"reinterpretAsUInt64"
+"defaultProfiles"
+"toIntervalMonth"
+"bitRotateRight"
+"arrayReverseSort"
+"toInt8OrZero"
+"SHA1"
+"multiSearchFirstPositionCaseInsensitiveUTF8"
+"cutFragment"
+"toDecimal256"
+"toIntervalSecond"
+"toUInt256OrZero"
+"toStringCutToZero"
+"normalizedQueryHashKeepNames"
+"coalesce"
+"parseDateTime64BestEffortOrNull"
+"toIntervalHour"
+"bitmapSubsetLimit"
+"parseDateTimeBestEffortOrNull"
+"match"
+"fragment"
+"repeat"
+"parseDateTimeBestEffortOrZero"
+"toDecimal128OrNull"
+"parseDateTimeBestEffort"
+"simpleJSONExtractUInt"
+"multiMatchAny"
+"toDecimal256OrNull"
+"roundDuration"
+"addMinutes"
+"toStartOfQuarter"
+"exp10"
+"regionIn"
+"toDecimal64OrNull"
+"toDateTimeOrNull"
+"simpleJSONExtractFloat"
+"reinterpretAsUUID"
+"dictGetDateTimeOrDefault"
+"greater"
+"toRelativeMonthNum"
+"toDate32OrNull"
+"h3IndexesAreNeighbors"
+"toFloat32OrNull"
+"toInt256OrNull"
+"leftPadUTF8"
+"regionToArea"
+"toInt64OrNull"
+"toModifiedJulianDayOrNull"
+"toUInt64OrNull"
+"polygonsEqualsCartesian"
+"accurateCast"
+"toUInt32OrNull"
+"encodeXMLComponent"
+"toUInt8OrNull"
+"toUUIDOrZero"
+"arrayEnumerateDenseRanked"
+"toYYYYMM"
+"toDecimal256OrZero"
+"fromUnixTimestamp64Milli"
+"CHARACTER_LENGTH"
+"isNull"
+"isNaN"
+"multiSearchAllPositionsCaseInsensitiveUTF8"
+"FQDN"
+"currentProfiles"
+"toDateTime32"
+"arraySplit"
+"toIPv6"
+"toDecimal32OrZero"
+"bitmapCardinality"
+"arrayFlatten"
+"dateName"
+"s2RectIntersection"
+"CAST"
+"caseWithExpr"
+"nullIf"
+"toDateTimeOrZero"
+"bitOr"
+"CRC32IEEE"
+"emptyArrayDate"
+"toUInt128OrZero"
+"toUInt128OrNull"
+"toFloat32OrZero"
+"SECOND"
+"arrayCompact"
+"bitmapMin"
+"toInt16OrZero"
+"reinterpretAsUInt256"
+"dictGetOrNull"
+"map"
+"bitmapHasAny"
+"emptyArrayUInt16"
+"cutIPv6"
+"toUInt32OrZero"
+"toTypeName"
+"polygonsUnionCartesian"
+"char"
+"mapContains"
+"emptyArrayDateTime"
+"toUInt16OrZero"
+"toInt64"
+"wkt"
+"dictGetUInt64"
+"JSONHas"
+"runningDifference"
+"getServerPort"
+"IPv4ToIPv6"
+"__bitWrapperFunc"
+"multiply"
+"accurate_Cast"
+"toDecimal64"
+"toString"
+"arrayIntersect"
+"dictGetUInt8OrDefault"
+"toTime"
+"hasAll"
+"now"
+"parseDateTime64BestEffortOrZero"
+"rightPadUTF8"
+"emptyArrayInt64"
+"simpleJSONExtractInt"
+"toDecimal128"
+"toRelativeWeekNum"
+"toDateOrNull"
+"topLevelDomain"
+"greatest"
+"isIPv6String"
+"toHour"
+"toFixedString"
+"bitmapOrCardinality"
+"toInt128"
+"toDateOrZero"
+"emptyArrayUInt64"
+"toUInt128"
+"isNotNull"
+"toUInt16"
+"MACNumToString"
+"multiSearchAllPositionsUTF8"
+"toUInt8"
+"regionToCity"
+"DAYOFYEAR"
+"simpleJSONExtractRaw"
+"appendTrailingCharIfAbsent"
+"toUInt64"
+"regionToName"
+"IPv4NumToStringClassC"
+"upper"
+"greaterOrEquals"
+"s2RectContains"
+"toDate"
+"regexpQuoteMeta"
+"readWktMultiPolygon"
+"emptyArrayString"
+"bitmapOr"
+"cutWWW"
+"emptyArrayInt8"
+"less"
+"readWktPoint"
+"reinterpretAsDateTime"
+"notEquals"
+"geoToS2"
+"nullInIgnoreSet"
+"globalNotNullIn"
+"arrayConcat"
+"mapPopulateSeries"
+"parseDateTimeBestEffortUS"
+"toDayOfMonth"
+"gcd"
+"protocol"
+"currentUser"
+"if"
+"caseWithoutExpression"
+"currentDatabase"
+"log10"
+"moduloOrZero"
+"MD4"
+"toInt64OrZero"
+"arrayWithConstant"
+"IPv4NumToString"
+"dictGetUInt32"
+"multiSearchAnyCaseInsensitive"
+"countSubstrings"
+"reinterpretAsFloat64"
+"plus"
+"dictGetChildren"
+"IPv6CIDRToRange"
+"toIntervalMinute"
+"bitRotateLeft"
+"geoDistance"
+"mapValues"
+"toIPv4"
+"extractGroups"
+"toYearWeek"
+"polygonsDistanceCartesian"
+"lowerUTF8"
+"toUInt256OrNull"
+"IPv4CIDRToRange"
+"MACStringToNum"
+"toFloat64OrNull"
+"sipHash128"
+"toFloat64"
+"arrayPopFront"
+"bitmapAnd"
+"bitmapHasAll"
+"subtractWeeks"
+"arrayFirstIndex"
+"bitmapXorCardinality"
+"bitmapAndnot"
+"asinh"
+"dictGetInt32"
+"toFloat64OrZero"
+"toInt8"
+"polygonsWithinSpherical"
+"bitmapXor"
+"intExp10"
+"dictGetDateTime"
+"h3ToGeoBoundary"
+"decodeURLComponent"
+"bitAnd"
+"toUUIDOrNull"
+"notNullInIgnoreSet"
+"tupleElement"
+"tupleToNameValuePairs"
+"tuple"
+"ceil"
+"DAYOFWEEK"
+"toDateTime"
+"bitNot"
+"rightPad"
+"has"
+"bitmapToArray"
+"arrayCount"
+"arrayDistinct"
+"greatCircleAngle"
+"IPv6StringToNum"
+"dictGetInt64"
+"toUnixTimestamp"
+"getMacro"
+"runningAccumulate"
+"multiIf"
+"abs"
+"toValidUTF8"
+"arrayEnumerateUniq"
+"moduloLegacy"
+"JSONExtractInt"
+"subtractMonths"
+"dateTimeToSnowflake"
+"cutToFirstSignificantSubdomain"
+"roundBankers"
+"toUInt256"
+"arrayEnumerateDense"
+"stem"
+"bitmapAndCardinality"
+"bitTestAll"
+"normalizedQueryHash"
+"toYear"
+"emptyArrayFloat64"
+"bitmapTransform"
+"JSONExtract"
+"bitShiftRight"
+"bitmapContains"
+"sqrt"
+"minus"
+"QUARTER"
+"parseDateTime64BestEffort"
+"h3IsValid"
+"h3EdgeAngle"
+"concatAssumeInjective"
+"emptyArrayUInt32"
+"intHash64"
+"enabledRoles"
+"fromUnixTimestamp64Micro"
+"range"
+"subtractMinutes"
+"farmFingerprint64"
+"arrayReduceInRanges"
+"bitmapBuild"
+"bitmapSubsetInRange"
+"arrayPopBack"
+"h3ToGeo"
+"hex"
+"arrayPushBack"
+"subtractDays"
+"buildId"
+"URLPathHierarchy"
+"addMonths"
+"parseDateTime32BestEffort"
+"indexOf"
+"polygonsUnionSpherical"
+"arraySum"
+"dictGetFloat32"
+"ngramSimHashCaseInsensitiveUTF8"
+"finalizeAggregation"
+"divide"
+"netloc"
+"bitShiftLeft"
+"toInt32OrZero"
+"extractAll"
+"toInt128OrNull"
+"bitXor"
+"lcm"
+"accurateCastOrNull"
+"toDate32OrZero"
+"simpleJSONExtractString"
+"least"
+"nullIn"
+"MONTH"
+"arrayReverse"
+"now64"
+"DATE"
+"addressToLine"
+"globalNotIn"
+"dateTime64ToSnowflake"
+"dictGetInt8OrDefault"
+"exp"
+"toRelativeQuarterNum"
+"arrayEnumerate"
+"mapAdd"
+"murmurHash2_32"
+"toStartOfTenMinutes"
+"intDivOrZero"
+"addYears"
+"queryStringAndFragment"
+"emptyArrayFloat32"
+"countEqual"
+"pointInEllipses"
+"like"
+"toDecimal64OrZero"
+"reinterpretAsInt256"
+"hasAny"
+"ln"
+"replace"
+"rpad"
+"mid"
+"lcase"
+"fromUnixTimestamp"
+"truncate"
+"ceiling"
+"ucase"
+"rand32"
+"power"
+"initial_query_id"
+"timeZone"
+"hostname"
+"yearweek"
+"timeZoneOffset"
+"extractAllGroups"
+"lpad"
+"substr"
+"INET6_NTOA"
+"INET6_ATON"
+"INET_ATON"
+"timeZoneOf"
+"locate"
+"INET_NTOA"
+"connection_id"
+"user"
+"toTimeZone"
+"week"
+"flatten"
+"query_id"
+"dateTrunc"
+"mod"
+"lagInFrame"
+"dense_rank"
+"rank"
+"exponentialMovingAverage"
+"sparkbar"
+"singleValueOrNull"
+"studentTTest"
+"aggThrow"
+"categoricalInformationValue"
+"groupArrayMovingAvg"
+"groupArrayMovingSum"
+"simpleLinearRegression"
+"entropy"
+"quantilesBFloat16"
+"maxIntersectionsPosition"
+"groupBitmapXor"
+"groupBitmap"
+"skewPop"
+"groupBitXor"
+"groupBitOr"
+"groupBitmapAnd"
+"topKWeighted"
+"stochasticLinearRegression"
+"corr"
+"uniqCombined64"
+"intervalLengthSum"
+"uniqCombined"
+"rankCorr"
+"maxMap"
+"minMap"
+"sumMapFiltered"
+"quantileExactWeighted"
+"sumMapFilteredWithOverflow"
+"sumMap"
+"histogram"
+"quantiles"
+"sum"
+"covarPop"
+"row_number"
+"kurtPop"
+"kurtSamp"
+"skewSamp"
+"uniqExact"
+"sumMapWithOverflow"
+"stddevSamp"
+"varPop"
+"corrStable"
+"quantileTimingWeighted"
+"covarPopStable"
+"stddevSampStable"
+"varSamp"
+"topK"
+"last_value"
+"mannWhitneyUTest"
+"maxIntersections"
+"quantilesExact"
+"uniqHLL12"
+"quantileBFloat16"
+"uniq"
+"min"
+"sequenceNextNode"
+"quantilesTimingWeighted"
+"boundingRatio"
+"any"
+"anyLast"
+"deltaSum"
+"retention"
+"sequenceMatch"
+"uniqUpTo"
+"windowFunnel"
+"deltaSumTimestamp"
+"varSampStable"
+"uniqTheta"
+"quantilesExactWeighted"
+"max"
+"quantilesBFloat16Weighted"
+"quantileBFloat16Weighted"
+"sumKahan"
+"quantilesTDigestWeighted"
+"groupBitAnd"
+"quantileTDigest"
+"quantileTDigestWeighted"
+"argMax"
+"quantileDeterministic"
+"quantilesTDigest"
+"stochasticLogisticRegression"
+"argMin"
+"avg"
+"covarSampStable"
+"quantilesTiming"
+"welchTTest"
+"covarSamp"
+"varPopStable"
+"quantileTiming"
+"quantileExactInclusive"
+"quantileExactHigh"
+"groupArraySample"
+"quantilesExactLow"
+"groupBitmapOr"
+"first_value"
+"quantileExactExclusive"
+"quantileExact"
+"sumCount"
+"groupArrayInsertAt"
+"quantilesExactHigh"
+"sumWithOverflow"
+"sequenceCount"
+"quantilesDeterministic"
+"groupUniqArray"
+"groupArray"
+"anyHeavy"
+"stddevPop"
+"quantile"
+"leadInFrame"
+"quantilesExactExclusive"
+"count"
+"quantilesExactInclusive"
+"stddevPopStable"
+"quantileExactLow"
+"avgWeighted"
+"BIT_AND"
+"VAR_SAMP"
+"COVAR_SAMP"
+"VAR_POP"
+"medianTDigest"
+"medianBFloat16"
+"medianTimingWeighted"
+"medianTiming"
+"medianExactHigh"
+"BIT_OR"
+"medianDeterministic"
+"STDDEV_POP"
+"STDDEV_SAMP"
+"medianExactLow"
+"medianTDigestWeighted"
+"medianExact"
+"COVAR_POP"
+"medianBFloat16Weighted"
+"medianExactWeighted"
+"BIT_XOR"
+"median"
+"log"
+"replaceAll"
+"rightPad"
+"substring"
+"lower"
+"FROM_UNIXTIME"
+"trunc"
+"ceil"
+"upper"
+"rand"
+"pow"
+"initialQueryID"
+"timezone"
+"hostName"
+"toYearWeek"
+"timezoneOffset"
+"extractAllGroupsVertical"
+"leftPad"
+"substring"
+"IPv6NumToString"
+"IPv6StringToNum"
+"IPv4StringToNum"
+"timezoneOf"
+"position"
+"IPv4NumToString"
+"connectionid"
+"currentUser"
+"toTimezone"
+"toWeek"
+"arrayFlatten"
+"queryID"
+"date_trunc"
+"modulo"
+"groupBitAnd"
+"varSamp"
+"covarSamp"
+"varPop"
+"quantileTDigest"
+"quantileBFloat16"
+"quantileTimingWeighted"
+"quantileTiming"
+"quantileExactHigh"
+"groupBitOr"
+"quantileDeterministic"
+"stddevPop"
+"stddevSamp"
+"quantileExactLow"
+"quantileTDigestWeighted"
+"quantileExact"
+"covarPop"
+"quantileBFloat16Weighted"
+"quantileExactWeighted"
+"groupBitXor"
+"quantile"
diff --git a/tests/fuzz/dictionaries/key_words.dict b/tests/fuzz/dictionaries/key_words.dict
new file mode 100644
index 00000000000..0db2d159759
--- /dev/null
+++ b/tests/fuzz/dictionaries/key_words.dict
@@ -0,0 +1,183 @@
+# Key words (based on keywords from antlr parser)
+
+"ADD"
+"AFTER"
+"ALIAS"
+"ALL"
+"ALTER"
+"AND"
+"ANTI"
+"ANY"
+"ARRAY"
+"AS"
+"ASCENDING"
+"ASOF"
+"AST"
+"ASYNC"
+"ATTACH"
+"BETWEEN"
+"BOTH"
+"BY"
+"CASE"
+"CAST"
+"CHECK"
+"CLEAR"
+"CLUSTER"
+"CODEC"
+"COLLATE"
+"COLUMN"
+"COMMENT"
+"CONSTRAINT"
+"CREATE"
+"CROSS"
+"CUBE"
+"DATABASE"
+"DATABASES"
+"DATE"
+"DAY"
+"DEDUPLICATE"
+"DEFAULT"
+"DELAY"
+"DELETE"
+"DESC"
+"DESCENDING"
+"DESCRIBE"
+"DETACH"
+"DICTIONARIES"
+"DICTIONARY"
+"DISK"
+"DISTINCT"
+"DISTRIBUTED"
+"DROP"
+"ELSE"
+"END"
+"ENGINE"
+"EVENTS"
+"EXISTS"
+"EXPLAIN"
+"EXPRESSION"
+"EXTRACT"
+"FETCHES"
+"FINAL"
+"FIRST"
+"FLUSH"
+"FOR"
+"FORMAT"
+"FREEZE"
+"FROM"
+"FULL"
+"FUNCTION"
+"GLOBAL"
+"GRANULARITY"
+"GROUP"
+"HAVING"
+"HIERARCHICAL"
+"HOUR"
+"ID"
+"IF"
+"ILIKE"
+"IN"
+"INDEX"
+"INF"
+"INJECTIVE"
+"INNER"
+"INSERT"
+"INTERVAL"
+"INTO"
+"IS"
+"IS_OBJECT_ID"
+"JOIN"
+"KEY"
+"KILL"
+"LAST"
+"LAYOUT"
+"LEADING"
+"LEFT"
+"LIFETIME"
+"LIKE"
+"LIMIT"
+"LIVE"
+"LOCAL"
+"LOGS"
+"MATERIALIZE"
+"MATERIALIZED"
+"MAX"
+"MERGES"
+"MIN"
+"MINUTE"
+"MODIFY"
+"MONTH"
+"MOVE"
+"MUTATION"
+"NAN_SQL"
+"NO"
+"NOT"
+"NULL_SQL"
+"NULLS"
+"OFFSET"
+"ON"
+"OPTIMIZE"
+"OR"
+"ORDER"
+"OUTER"
+"OUTFILE"
+"PARTITION"
+"POPULATE"
+"PREWHERE"
+"PRIMARY"
+"PROJECTION"
+"QUARTER"
+"RANGE"
+"RELOAD"
+"REMOVE"
+"RENAME"
+"REPLACE"
+"REPLICA"
+"REPLICATED"
+"RIGHT"
+"ROLLUP"
+"SAMPLE"
+"SECOND"
+"SELECT"
+"SEMI"
+"SENDS"
+"SET"
+"SETTINGS"
+"SHOW"
+"SOURCE"
+"START"
+"STOP"
+"SUBSTRING"
+"SYNC"
+"SYNTAX"
+"SYSTEM"
+"TABLE"
+"TABLES"
+"TEMPORARY"
+"TEST"
+"THEN"
+"TIES"
+"TIMEOUT"
+"TIMESTAMP"
+"TO"
+"TOP"
+"TOTALS"
+"TRAILING"
+"TRIM"
+"TRUNCATE"
+"TTL"
+"TYPE"
+"UNION"
+"UPDATE"
+"USE"
+"USING"
+"UUID"
+"VALUES"
+"VIEW"
+"VOLUME"
+"WATCH"
+"WEEK"
+"WHEN"
+"WHERE"
+"WITH"
+"YEAR"
diff --git a/tests/fuzz/ast.dict b/tests/fuzz/dictionaries/old.dict
similarity index 100%
rename from tests/fuzz/ast.dict
rename to tests/fuzz/dictionaries/old.dict
diff --git a/tests/fuzz/execute_query_fuzzer.options b/tests/fuzz/execute_query_fuzzer.options
new file mode 100644
index 00000000000..cbe915d10fc
--- /dev/null
+++ b/tests/fuzz/execute_query_fuzzer.options
@@ -0,0 +1,3 @@
+[libfuzzer]
+dict = all.dict
+jobs = 8
diff --git a/tests/fuzz/lexer_fuzzer.options b/tests/fuzz/lexer_fuzzer.options
index fda41ea5398..cbe915d10fc 100644
--- a/tests/fuzz/lexer_fuzzer.options
+++ b/tests/fuzz/lexer_fuzzer.options
@@ -1,2 +1,3 @@
 [libfuzzer]
-dict = ast.dict
+dict = all.dict
+jobs = 8
diff --git a/tests/fuzz/names_and_types_fuzzer.options b/tests/fuzz/names_and_types_fuzzer.options
index a98c23185e1..cbe915d10fc 100644
--- a/tests/fuzz/names_and_types_fuzzer.options
+++ b/tests/fuzz/names_and_types_fuzzer.options
@@ -1,2 +1,3 @@
 [libfuzzer]
-dict = datatypes.dict
+dict = all.dict
+jobs = 8
diff --git a/tests/fuzz/select_parser_fuzzer.options b/tests/fuzz/select_parser_fuzzer.options
index fda41ea5398..cbe915d10fc 100644
--- a/tests/fuzz/select_parser_fuzzer.options
+++ b/tests/fuzz/select_parser_fuzzer.options
@@ -1,2 +1,3 @@
 [libfuzzer]
-dict = ast.dict
+dict = all.dict
+jobs = 8
diff --git a/tests/integration/02044_exists_operator.reference b/tests/integration/02044_exists_operator.reference
new file mode 100644
index 00000000000..fa0cdd3e109
--- /dev/null
+++ b/tests/integration/02044_exists_operator.reference
@@ -0,0 +1,17 @@
+-- { echo }
+select exists(select 1);
+1
+select exists(select 1 except select 1);
+0
+select exists(select number from numbers(10) where number > 0);
+1
+select exists(select number from numbers(10) where number < 0);
+0
+select count() from numbers(10) where exists(select 1 except select 1);
+0
+select count() from numbers(10) where exists(select 1 intersect select 1);
+10
+select count() from numbers(10) where exists(select number from numbers(10) where number > 8);
+10
+select count() from numbers(10) where exists(select number from numbers(10) where number > 9);
+0
diff --git a/tests/integration/02044_exists_operator.sql b/tests/integration/02044_exists_operator.sql
new file mode 100644
index 00000000000..bec191ecdaa
--- /dev/null
+++ b/tests/integration/02044_exists_operator.sql
@@ -0,0 +1,11 @@
+-- { echo }
+select exists(select 1);
+select exists(select 1 except select 1);
+select exists(select number from numbers(10) where number > 0);
+select exists(select number from numbers(10) where number < 0);
+
+select count() from numbers(10) where exists(select 1 except select 1);
+select count() from numbers(10) where exists(select 1 intersect select 1);
+
+select count() from numbers(10) where exists(select number from numbers(10) where number > 8);
+select count() from numbers(10) where exists(select number from numbers(10) where number > 9);