diff --git a/metadata/INFORMATION_SCHEMA.sql b/metadata/INFORMATION_SCHEMA.sql
new file mode 100644
index 000000000000..291582fd1eb3
--- /dev/null
+++ b/metadata/INFORMATION_SCHEMA.sql
@@ -0,0 +1,2 @@
+ATTACH DATABASE INFORMATION_SCHEMA
+ENGINE = Memory
diff --git a/metadata/default b/metadata/default
new file mode 120000
index 000000000000..5f19e282b366
--- /dev/null
+++ b/metadata/default
@@ -0,0 +1 @@
+/home/syz/ClickHouse/store/5ab/5abc80be-7165-462e-9e28-94d4467dd408/
\ No newline at end of file
diff --git a/metadata/default.sql b/metadata/default.sql
new file mode 100644
index 000000000000..a5afca39d49b
--- /dev/null
+++ b/metadata/default.sql
@@ -0,0 +1,2 @@
+ATTACH DATABASE _ UUID '5abc80be-7165-462e-9e28-94d4467dd408'
+ENGINE = Atomic
diff --git a/metadata/information_schema.sql b/metadata/information_schema.sql
new file mode 100644
index 000000000000..6cea934b49d2
--- /dev/null
+++ b/metadata/information_schema.sql
@@ -0,0 +1,2 @@
+ATTACH DATABASE information_schema
+ENGINE = Memory
diff --git a/metadata/system b/metadata/system
new file mode 120000
index 000000000000..02305a85e524
--- /dev/null
+++ b/metadata/system
@@ -0,0 +1 @@
+/home/syz/ClickHouse/store/99a/99a3fa29-6efd-4622-b822-ba63a202d9f4/
\ No newline at end of file
diff --git a/metadata/system.sql b/metadata/system.sql
new file mode 100644
index 000000000000..4f0a02779677
--- /dev/null
+++ b/metadata/system.sql
@@ -0,0 +1,2 @@
+ATTACH DATABASE _ UUID '99a3fa29-6efd-4622-b822-ba63a202d9f4'
+ENGINE = Atomic
diff --git a/preprocessed_configs/config.xml b/preprocessed_configs/config.xml
new file mode 100644
index 000000000000..790297966d1b
--- /dev/null
+++ b/preprocessed_configs/config.xml
@@ -0,0 +1,44 @@
+<!-- This file was generated automatically.
+     Do not edit it: it is likely to be discarded and generated again before it's read next time.
+     Files used to generate this file:
+       config.xml      -->
+
+<!-- Config that is used when server is run without config file. -->
+<clickhouse>
+    <logger>
+        <level>trace</level>
+        <console>true</console>
+    </logger>
+
+    <http_port>8123</http_port>
+    <tcp_port>9000</tcp_port>
+    <mysql_port>9004</mysql_port>
+
+    <path>./</path>
+
+    <mlock_executable>true</mlock_executable>
+
+    <users>
+        <default>
+            <password/>
+
+            <networks>
+                <ip>::/0</ip>
+            </networks>
+
+            <profile>default</profile>
+            <quota>default</quota>
+
+            <access_management>1</access_management>
+            <named_collection_control>1</named_collection_control>
+        </default>
+    </users>
+
+    <profiles>
+        <default/>
+    </profiles>
+
+    <quotas>
+        <default/>
+    </quotas>
+</clickhouse>
diff --git a/programs/server/config.xml b/programs/server/config.xml
index 23f3458110e1..6e1708566293 100644
--- a/programs/server/config.xml
+++ b/programs/server/config.xml
@@ -21,7 +21,7 @@
 
             [1]: https://github.com/pocoproject/poco/blob/poco-1.9.4-release/Foundation/include/Poco/Logger.h#L105-L114
         -->
-        <level>trace</level>
+        <level>debug</level>
         <log>/var/log/clickhouse-server/clickhouse-server.log</log>
         <errorlog>/var/log/clickhouse-server/clickhouse-server.err.log</errorlog>
         <!-- Rotation policy
diff --git a/programs/server/udf.sql b/programs/server/udf.sql
new file mode 100644
index 000000000000..de156f48594a
--- /dev/null
+++ b/programs/server/udf.sql
@@ -0,0 +1,20 @@
+DROP FUNCTION IF EXISTS ai_estimate_rows;
+
+CREATE FUNCTION imdb.ai_estimate_rows
+RETURNS UInt64
+LANGUAGE PYTHON AS
+$code$
+from iudf import IUDF
+from overload import overload
+from BayesCard.Evaluation.cardinality_estimation import test_inference_result
+
+class ai_estimate_rows(IUDF):
+    @overload
+    def process(sql):
+        res = test_inference_result(sql)
+        return res
+$code$;
+
+DROP FUNCTION IF EXISTS ai_estimate_rows;
+
+select imdb.ai_estimate_rows('SELECT COUNT(*) FROM movie_info_idx WHERE id >= 713168 AND movie_id >= 2075341');
diff --git a/programs/server/user_defined/function_ai_estimate_rows.sql b/programs/server/user_defined/function_ai_estimate_rows.sql
new file mode 100644
index 000000000000..1cf1acf614b1
--- /dev/null
+++ b/programs/server/user_defined/function_ai_estimate_rows.sql
@@ -0,0 +1,12 @@
+CREATE FUCTION imdb.ai_estimate_rows TYPE SCALAR RETURNS UInt64 LANGUAGE PYTHON AS 
+$code$
+from iudf import IUDF
+from overload import overload
+from BayesCard.Evaluation.cardinality_estimation import test_inference_result
+
+class ai_estimate_rows(IUDF):
+    @overload
+    def process(sql):
+        res = test_inference_result(sql)
+        return res
+$code$
diff --git a/src/Common/BitHelpers.h b/src/Common/BitHelpers.h
index bb81d2711403..96fb89539189 100644
--- a/src/Common/BitHelpers.h
+++ b/src/Common/BitHelpers.h
@@ -127,3 +127,18 @@ constexpr bool isPowerOf2(T number)
 {
     return number > 0 && (number & (number - 1)) == 0;
 }
+
+template <typename E>
+constexpr auto to_underlying(E e) noexcept
+{
+    return static_cast<std::underlying_type_t<E>>(e);
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreserved-macro-identifier"
+#define __bf_shf(x) (__builtin_ffsll(x) - 1)
+#pragma clang diagnostic pop
+
+#define GENMASK(h, l) (((~0UL) - (1UL << (l)) + 1) & (~0UL >> (sizeof(long)*8 - 1 - (h))))
+#define FIELD_GET(_mask, _reg) (decltype(_mask))(((_reg) & (_mask)) >> __bf_shf(_mask))
+#define FIELD_PREP(_mask, _val) (((decltype(_mask))(_val) << __bf_shf(_mask)) & (_mask))
diff --git a/src/Functions/UDFFlags.h b/src/Functions/UDFFlags.h
new file mode 100644
index 000000000000..72fc8c1a2db5
--- /dev/null
+++ b/src/Functions/UDFFlags.h
@@ -0,0 +1,76 @@
+#pragma once
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <string.h>
+#include <Common/BitHelpers.h>
+#include <IO/ReadBufferFromMemory.h>
+
+
+
+namespace DB::UDF
+{
+constexpr auto SQL = "SQL";
+constexpr auto PYTHON = "PYTHON";
+constexpr auto SCALAR = "SCALAR";
+constexpr auto AGGREGATE = "AGGREGATE";
+constexpr auto ML = "ML";
+using UDFFlags = uint32_t;
+enum class UDFLanguage
+{
+    Sql,
+    Python
+};
+enum class UDFFunctionType
+{
+    Scalar,
+    Aggregate,
+    ML
+};
+static const char * Languages[2] = {SQL, PYTHON};
+static const char * FunctionTypes[3] = {SCALAR, AGGREGATE, ML};
+#define UDF_FIELD_TYPE GENMASK(28, 25)
+#define UDF_FIELD_LANG GENMASK(31, 29)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+static inline int getEnumValFromString(const char* enum_name, const char * const * arr, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+        if (strcmp(arr[i], enum_name) == 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+#pragma clang diagnostic pop
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wold-style-cast"
+static inline enum UDFLanguage getLanguage(UDFFlags flags) {
+    return static_cast<UDFLanguage>(FIELD_GET(UDF_FIELD_LANG, flags));
+}
+static inline enum UDFFunctionType getFunctionType(UDFFlags flags)
+{
+    return static_cast<UDFFunctionType>(FIELD_GET(UDF_FIELD_TYPE, flags));
+}
+static inline bool setFlag(UDFFlags &flags, const char *value, const char** enums, size_t n, uint64_t mask) {
+    int z = getEnumValFromString(value, enums, n);
+    if (z == -1) {
+        return false;
+    }
+    flags |= FIELD_PREP(mask, z);
+    return true;
+}
+#pragma clang diagnostic pop
+static inline const char * getLanguageStr(UDFLanguage language)  {
+    return Languages[to_underlying(language)];
+}
+static inline const char * getFunctionTypeStr(UDFFunctionType func_type)
+{
+    return FunctionTypes[to_underlying(func_type)];
+}
+static inline bool setFunctionType(UDFFlags &flags, const char *type) {
+    return setFlag(flags, type, FunctionTypes, sizeof(FunctionTypes), UDF_FIELD_TYPE);
+}
+static inline bool setLangauge(UDFFlags &flags, const char *language) {
+    return setFlag(flags, language, Languages, sizeof(Languages), UDF_FIELD_LANG);
+}
+}
diff --git a/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.cpp b/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.cpp
index e37e4a23b63c..fd19aa05971d 100644
--- a/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.cpp
+++ b/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.cpp
@@ -10,6 +10,7 @@
 #include <Interpreters/Context.h>
 #include <Interpreters/FunctionNameNormalizer.h>
 #include <Parsers/ASTCreateFunctionQuery.h>
+#include <Parsers/ASTCreateUserDefinedFunctionQuery.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTIdentifier.h>
 #include <Common/quoteString.h>
@@ -150,6 +151,34 @@ bool UserDefinedSQLFunctionFactory::registerFunction(const ContextMutablePtr & c
     return true;
 }
 
+bool UserDefinedSQLFunctionFactory::registerUserDefinedFunction(const ContextMutablePtr & context, const String & function_name, ASTPtr create_function_query)
+{
+    // checkCanBeRegistered(context, function_name, *create_function_query);
+    // create_function_query = normalizeCreateFunctionQuery(*create_function_query);
+
+    try
+    {
+        auto & loader = context->getUserDefinedSQLObjectsStorage();
+        bool stored = loader.storeObject(
+            context,
+            UserDefinedSQLObjectType::Function,
+            function_name,
+            create_function_query,
+            false,
+            true,
+            context->getSettingsRef());
+        if (!stored)
+            return false;
+    }
+    catch (Exception & exception)
+    {
+        exception.addMessage(fmt::format("while storing user defined function {}", backQuote(function_name)));
+        throw;
+    }
+
+    return true;
+}
+
 bool UserDefinedSQLFunctionFactory::unregisterFunction(const ContextMutablePtr & context, const String & function_name, bool throw_if_not_exists)
 {
     checkCanBeUnregistered(context, function_name);
@@ -174,6 +203,30 @@ bool UserDefinedSQLFunctionFactory::unregisterFunction(const ContextMutablePtr &
     return true;
 }
 
+bool UserDefinedSQLFunctionFactory::unregisterUserDefinedFunction(const ContextMutablePtr & context, const String & function_name)
+{
+    // checkCanBeUnregistered(context, function_name);
+
+    try
+    {
+        auto & storage = context->getUserDefinedSQLObjectsStorage();
+        bool removed = storage.removeObject(
+            context,
+            UserDefinedSQLObjectType::Function,
+            function_name,
+            false);
+        if (!removed)
+            return false;
+    }
+    catch (Exception & exception)
+    {
+        exception.addMessage(fmt::format("while removing user defined function {}", backQuote(function_name)));
+        throw;
+    }
+
+    return true;
+}
+
 ASTPtr UserDefinedSQLFunctionFactory::get(const String & function_name) const
 {
     return global_context->getUserDefinedSQLObjectsStorage().get(function_name);
diff --git a/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.h b/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.h
index b1f3940323a5..a2697d80ac54 100644
--- a/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.h
+++ b/src/Functions/UserDefined/UserDefinedSQLFunctionFactory.h
@@ -23,9 +23,12 @@ class UserDefinedSQLFunctionFactory : public IHints<>
     /// Register function for function_name in factory for specified create_function_query.
     bool registerFunction(const ContextMutablePtr & context, const String & function_name, ASTPtr create_function_query, bool throw_if_exists, bool replace_if_exists);
 
+    bool registerUserDefinedFunction(const ContextMutablePtr & context, const String & function_name, ASTPtr create_function_query);
     /// Unregister function for function_name.
     bool unregisterFunction(const ContextMutablePtr & context, const String & function_name, bool throw_if_not_exists);
 
+    bool unregisterUserDefinedFunction(const ContextMutablePtr & context, const String & function_name);
+
     /// Get function create query for function_name. If no function registered with function_name throws exception.
     ASTPtr get(const String & function_name) const;
 
diff --git a/src/IO/ReadHelpers.cpp b/src/IO/ReadHelpers.cpp
index bcfe5fd52305..7c46b961073e 100644
--- a/src/IO/ReadHelpers.cpp
+++ b/src/IO/ReadHelpers.cpp
@@ -1050,6 +1050,35 @@ template void readJSONStringInto<NullOutput>(NullOutput & s, ReadBuffer & buf);
 template void readJSONStringInto<String>(String & s, ReadBuffer & buf);
 template bool readJSONStringInto<String, bool>(String & s, ReadBuffer & buf);
 
+bool readDollarQuotedStringInto(String & s, ReadBuffer & buf, String & tag, size_t size) {
+    if (*buf.position() != '$') {
+        return false;
+    }
+
+    const char *tag_end = find_first_symbols<'$'>(buf.position()+1, buf.position() + size);
+
+    if (tag_end == nullptr) {
+        return false;
+    }
+
+    appendToStringOrVector(tag, buf, tag_end+1);
+    size_t tag_length = tag.length();
+
+    while(tag_length--) {
+        buf.position()++;
+    }
+
+    const char *output = strstr(buf.position(), &tag[0]);
+
+    if (output == nullptr) {
+        return false;
+    }
+
+    appendToStringOrVector(s, buf, output-1);
+
+    return true;
+}
+
 template <typename Vector, typename ReturnType, char opening_bracket, char closing_bracket>
 ReturnType readJSONObjectOrArrayPossiblyInvalid(Vector & s, ReadBuffer & buf)
 {
diff --git a/src/IO/ReadHelpers.h b/src/IO/ReadHelpers.h
index 49530f4787a2..8555021f9758 100644
--- a/src/IO/ReadHelpers.h
+++ b/src/IO/ReadHelpers.h
@@ -668,6 +668,8 @@ bool tryReadJSONStringInto(Vector & s, ReadBuffer & buf)
     return readJSONStringInto<Vector, bool>(s, buf);
 }
 
+bool readDollarQuotedStringInto(String & s, ReadBuffer & buf, String & tag, size_t size);
+
 template <bool enable_sql_style_quoting, typename Vector>
 bool tryReadQuotedStringInto(Vector & s, ReadBuffer & buf);
 
diff --git a/src/Interpreters/InterpreterCreateUserDefinedFunctionQuery.cpp b/src/Interpreters/InterpreterCreateUserDefinedFunctionQuery.cpp
new file mode 100644
index 000000000000..7a625cc91417
--- /dev/null
+++ b/src/Interpreters/InterpreterCreateUserDefinedFunctionQuery.cpp
@@ -0,0 +1,70 @@
+#include <Interpreters/InterpreterCreateUserDefinedFunctionQuery.h>
+#include <Interpreters/InterpreterFactory.h>
+
+#include <Access/ContextAccess.h>
+#include <Functions/UserDefined/IUserDefinedSQLObjectsStorage.h>
+#include <Functions/UserDefined/UserDefinedSQLFunctionFactory.h>
+#include <Interpreters/Context.h>
+// #include <Interpreters/executeDDLQueryOnCluster.h>
+// #include <Interpreters/removeOnClusterClauseIfNeeded.h>
+#include <Interpreters/FunctionNameNormalizer.h>
+#include <Parsers/ASTCreateUserDefinedFunctionQuery.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+extern const int INCORRECT_QUERY;
+}
+
+BlockIO InterpreterCreateUserDefinedFunctionQuery::execute()
+{
+    FunctionNameNormalizer().visit(query_ptr.get());
+    // const auto updated_query_ptr = removeOnClusterClauseIfNeeded(query_ptr, getContext());
+    auto * create_function_query = query_ptr->as<ASTCreateUserDefinedFunctionQuery>();
+    // ASTCreateUserDefinedFunctionQuery & create_function_query = query_ptr->as<ASTCreateUserDefinedFunctionQuery &>();
+
+    // AccessRightsElements access_rights_elements;
+    // access_rights_elements.emplace_back(AccessType::CREATE_FUNCTION);
+
+    // if (create_function_query.or_replace)
+    //     access_rights_elements.emplace_back(AccessType::DROP_FUNCTION);
+
+    // if (create_function_query->database_name.empty())
+    //     create_function_query->database_name = context.getCurrentDatabase();
+
+    // if (create_function_query->database_name == "default")
+    //     throw Exception("Must specify a database for UDF", ErrorCodes::UNKNOWN_DATABASE);
+    auto current_context = getContext();
+
+    // if (!create_function_query.cluster.empty())
+    // {
+    //     if (current_context->getUserDefinedSQLObjectsStorage().isReplicated())
+    //         throw Exception(ErrorCodes::INCORRECT_QUERY, "ON CLUSTER is not allowed because used-defined functions are replicated automatically");
+
+    //     DDLQueryOnClusterParams params;
+    //     params.access_to_check = std::move(access_rights_elements);
+    //     return executeDDLQueryOnCluster(updated_query_ptr, current_context, params);
+    // }
+
+    // current_context->checkAccess(access_rights_elements);
+
+    // auto function_name = create_function_query.getFunctionName();
+    // bool throw_if_exists = !create_function_query.if_not_exists && !create_function_query.or_replace;
+    // bool replace_if_exists = create_function_query.or_replace;
+
+    UserDefinedSQLFunctionFactory::instance().registerUserDefinedFunction(
+        current_context, create_function_query->function_name, query_ptr);
+    return {};
+}
+
+void registerInterpreterCreateUserDefinedFunctionQuery(InterpreterFactory & factory)
+{
+    auto create_fn = [](const InterpreterFactory::Arguments & args)
+    { return std::make_unique<InterpreterCreateUserDefinedFunctionQuery>(args.query, args.context); };
+    factory.registerInterpreter("InterpreterCreateUserDefinedFunctionQuery", create_fn);
+}
+
+}
diff --git a/src/Interpreters/InterpreterCreateUserDefinedFunctionQuery.h b/src/Interpreters/InterpreterCreateUserDefinedFunctionQuery.h
new file mode 100644
index 000000000000..f7ec0d9f2262
--- /dev/null
+++ b/src/Interpreters/InterpreterCreateUserDefinedFunctionQuery.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Interpreters/IInterpreter.h>
+
+
+namespace DB
+{
+
+class Context;
+
+class InterpreterCreateUserDefinedFunctionQuery : public IInterpreter, WithMutableContext
+{
+public:
+    InterpreterCreateUserDefinedFunctionQuery(const ASTPtr & query_ptr_, ContextMutablePtr context_)
+        : WithMutableContext(context_), query_ptr(query_ptr_)
+    {
+    }
+
+    BlockIO execute() override;
+
+private:
+    ASTPtr query_ptr;
+};
+
+}
diff --git a/src/Interpreters/InterpreterFactory.cpp b/src/Interpreters/InterpreterFactory.cpp
index 1b6e6be2ea20..f0970f8e34d7 100644
--- a/src/Interpreters/InterpreterFactory.cpp
+++ b/src/Interpreters/InterpreterFactory.cpp
@@ -3,6 +3,7 @@
 #include <Parsers/ASTCheckQuery.h>
 #include <Parsers/ASTCreateQuery.h>
 #include <Parsers/ASTCreateFunctionQuery.h>
+#include <Parsers/ASTCreateUserDefinedFunctionQuery.h>
 #include <Parsers/ASTCreateIndexQuery.h>
 #include <Parsers/ASTDeleteQuery.h>
 #include <Parsers/ASTDropFunctionQuery.h>
@@ -316,6 +317,10 @@ InterpreterFactory::InterpreterPtr InterpreterFactory::get(ASTPtr & query, Conte
     {
         interpreter_name = "InterpreterCreateFunctionQuery";
     }
+    else if (query->as<ASTCreateUserDefinedFunctionQuery>())
+    {
+        interpreter_name = "InterpreterCreateUserDefinedFunctionQuery";
+    }
     else if (query->as<ASTDropFunctionQuery>())
     {
         interpreter_name = "InterpreterDropFunctionQuery";
diff --git a/src/Interpreters/registerInterpreters.cpp b/src/Interpreters/registerInterpreters.cpp
index 481d0597a854..a1d767d128d8 100644
--- a/src/Interpreters/registerInterpreters.cpp
+++ b/src/Interpreters/registerInterpreters.cpp
@@ -51,6 +51,7 @@ void registerInterpreterShowPrivilegesQuery(InterpreterFactory & factory);
 void registerInterpreterExternalDDLQuery(InterpreterFactory & factory);
 void registerInterpreterTransactionControlQuery(InterpreterFactory & factory);
 void registerInterpreterCreateFunctionQuery(InterpreterFactory & factory);
+void registerInterpreterCreateUserDefinedFunctionQuery(InterpreterFactory & factory);
 void registerInterpreterDropFunctionQuery(InterpreterFactory & factory);
 void registerInterpreterCreateIndexQuery(InterpreterFactory & factory);
 void registerInterpreterCreateNamedCollectionQuery(InterpreterFactory & factory);
@@ -110,6 +111,7 @@ void registerInterpreters()
     registerInterpreterExternalDDLQuery(factory);
     registerInterpreterTransactionControlQuery(factory);
     registerInterpreterCreateFunctionQuery(factory);
+    registerInterpreterCreateUserDefinedFunctionQuery(factory);
     registerInterpreterDropFunctionQuery(factory);
     registerInterpreterCreateIndexQuery(factory);
     registerInterpreterCreateNamedCollectionQuery(factory);
diff --git a/src/Parsers/ASTCreateUserDefinedFunctionQuery.cpp b/src/Parsers/ASTCreateUserDefinedFunctionQuery.cpp
new file mode 100644
index 000000000000..46d989ae2142
--- /dev/null
+++ b/src/Parsers/ASTCreateUserDefinedFunctionQuery.cpp
@@ -0,0 +1,86 @@
+#include <IO/Operators.h>
+#include <Parsers/ASTCreateUserDefinedFunctionQuery.h>
+#include <Common/quoteString.h>
+
+namespace DB
+{
+ASTPtr ASTCreateUserDefinedFunctionQuery::clone() const
+{
+    auto res = std::make_shared<ASTCreateUserDefinedFunctionQuery>(*this);
+    // res->children.clear();
+
+    // res->function_name = function_name->clone();
+    // res->children.push_back(res->function_name);
+
+    // res->function_core = function_core->clone();
+    // res->children.push_back(res->function_core);
+    return res;
+}
+
+void ASTCreateUserDefinedFunctionQuery::formatImpl(
+    const IAST::FormatSettings & settings, IAST::FormatState & state, IAST::FormatStateStacked frame) const
+{
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << "CREATE FUCTION " << (settings.hilite ? hilite_none : "");
+    if (!database_name.empty())
+    {
+        settings.ostr << (settings.hilite ? hilite_identifier : "") << backQuoteIfNeed(database_name)
+                      << (settings.hilite ? hilite_none : "");
+        settings.ostr << (settings.hilite ? hilite_identifier : "") << "." << (settings.hilite ? hilite_none : "");
+    }
+
+    UDF::UDFLanguage language = UDF::getLanguage(flags);
+    UDF::UDFFunctionType type = UDF::getFunctionType(flags);
+    settings.ostr << (settings.hilite ? hilite_identifier : "") << backQuoteIfNeed(function_name) << (settings.hilite ? hilite_none : "");
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << " TYPE " << (settings.hilite ? hilite_none : "");
+    settings.ostr << (settings.hilite ? hilite_identifier : "") << UDF::getFunctionTypeStr(type) << (settings.hilite ? hilite_none : "");
+    if (return_type)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " RETURNS " << (settings.hilite ? hilite_none : "");
+        settings.ostr << (settings.hilite ? hilite_identifier : "") << return_type->getName() << (settings.hilite ? hilite_none : "");
+    }
+    if (state_type)
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " STATE_TYPE " << (settings.hilite ? hilite_none : "");
+        settings.ostr << (settings.hilite ? hilite_identifier : "") << state_type->getName() << (settings.hilite ? hilite_none : "");
+    }
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << " LANGUAGE " << (settings.hilite ? hilite_none : "");
+    settings.ostr << (settings.hilite ? hilite_identifier : "") << backQuoteIfNeed(UDF::getLanguageStr(language)) << (settings.hilite ? hilite_none : "");
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS " << (settings.hilite ? hilite_none : "");
+
+    switch (language)
+    {
+        case UDF::UDFLanguage::Sql:
+            function_core->formatImpl(settings, state, frame);
+            break;
+        case UDF::UDFLanguage::Python: {
+            settings.ostr << "\n" << tag << (settings.hilite ? hilite_none : "");
+            settings.ostr << function_body;
+            settings.ostr << "\n" << tag << (settings.hilite ? hilite_none : "");
+            break;
+        }
+    }
+    // if (or_replace)
+    //     settings.ostr << "OR REPLACE ";
+
+    // settings.ostr << "FUNCTION ";
+
+    // if (if_not_exists)
+    //     settings.ostr << "IF NOT EXISTS ";
+
+    // settings.ostr << (settings.hilite ? hilite_none : "");
+
+    // settings.ostr << (settings.hilite ? hilite_identifier : "") << backQuoteIfNeed(getFunctionName()) << (settings.hilite ? hilite_none : "");
+
+    // formatOnCluster(settings);
+
+    // settings.ostr << (settings.hilite ? hilite_keyword : "") << " AS " << (settings.hilite ? hilite_none : "");
+    // function_core->formatImpl(settings, state, frame);
+}
+
+// String ASTCreateFunctionQuery::getFunctionName() const
+// {
+//     String name;
+//     tryGetIdentifierNameInto(function_name, name);
+//     return name;
+// }
+}
diff --git a/src/Parsers/ASTCreateUserDefinedFunctionQuery.h b/src/Parsers/ASTCreateUserDefinedFunctionQuery.h
new file mode 100644
index 000000000000..5812f5d23ef4
--- /dev/null
+++ b/src/Parsers/ASTCreateUserDefinedFunctionQuery.h
@@ -0,0 +1,29 @@
+#pragma once
+#include <Parsers/IAST.h>
+#include <DataTypes/IDataType.h>
+#include <Functions/UDFFlags.h>
+
+namespace DB
+{
+class ASTCreateUserDefinedFunctionQuery : public IAST
+{
+public:
+    String function_name;
+    String database_name;
+    String function_language;
+    uint64_t version{0};
+    ASTPtr function_core;
+    String function_body;
+    DataTypePtr return_type;
+    DataTypePtr state_type;
+    String tag;
+    UDF::UDFFlags flags;
+
+
+    String getID(char) const override { return "CreateUserDefinedFunctionQuery"; }
+
+    ASTPtr clone() const override;
+
+    void formatImpl(const FormatSettings & s, FormatState & state, FormatStateStacked frame) const override;
+};
+}
diff --git a/src/Parsers/ParserCreateUserDefinedFunctionQuery.cpp b/src/Parsers/ParserCreateUserDefinedFunctionQuery.cpp
new file mode 100644
index 000000000000..4707590ee2c0
--- /dev/null
+++ b/src/Parsers/ParserCreateUserDefinedFunctionQuery.cpp
@@ -0,0 +1,148 @@
+#include <Parsers/ParserCreateUserDefinedFunctionQuery.h>
+#include <Parsers/ASTCreateUserDefinedFunctionQuery.h>
+#include <Parsers/ExpressionElementParsers.h>
+#include <Parsers/CommonParsers.h>
+#include <Parsers/ExpressionListParsers.h>
+#include <Parsers/ASTIdentifier.h>
+#include <DataTypes/DataTypeFactory.h>
+#include <IO/ReadBufferFromMemory.h>
+#include <IO/ReadHelpers.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes {
+    extern const int INCORRECT_UDF_FUNCTION_NAME;
+};
+bool ParserCreateUserDefinedFunctionQuery::parseImpl(IParser::Pos & pos, ASTPtr & node, Expected & expected)
+{
+    ParserKeyword s_create("CREATE");
+    ParserKeyword s_function("FUNCTION");
+    ParserIdentifier function_name_p;
+    ParserKeyword s_function_type("TYPE");
+    ParserIdentifier function_type_p;
+    ParserKeyword s_returns("RETURNS");
+    ParserIdentifierWithOptionalParameters return_type_p;
+    ParserKeyword s_state_type("STATE_TYPE");
+    ParserIdentifierWithOptionalParameters state_type_p;
+    ParserKeyword s_language("LANGUAGE");
+    ParserIdentifier function_language_p;
+    ParserKeyword s_as("AS");
+    ParserExpression lambda_p;
+
+    ASTPtr function_name;
+    ASTPtr database_name;
+    ASTPtr function_type;
+    ASTPtr function_language;
+    ASTPtr function_core;
+    String language = UDF::SQL;
+    String type = UDF::SCALAR;
+    ASTPtr return_type;
+    ASTPtr state_type;
+    DataTypePtr returnDataType = nullptr;
+    DataTypePtr stateDataType = nullptr;
+    ParserToken s_dot(TokenType::Dot);
+    UDF::UDFFlags flags = 0;
+
+    if (!s_create.ignore(pos, expected))
+        return false;
+
+    if (!s_function.ignore(pos, expected))
+        return false;
+
+    if (!function_name_p.parse(pos, function_name, expected))
+        return false;
+
+    if (s_dot.ignore(pos, expected))
+    {
+        database_name = function_name;
+        if (!function_name_p.parse(pos, function_name, expected))
+            return false;
+    }
+
+    if (s_function_type.ignore(pos, expected)) {
+        if (!function_type_p.parse(pos, function_type, expected)) {
+            return false;
+        } else {
+            type = function_type->as<ASTIdentifier &>().name();
+        }
+    }
+
+    if (!UDF::setFunctionType(flags, type.c_str())) {
+        return false;
+    }
+
+    if (s_returns.ignore(pos, expected)) {
+        if (!return_type_p.parse(pos, return_type, expected)) {
+            return false;
+        } else {
+            returnDataType = DataTypeFactory::instance().get(return_type);
+        }
+    }
+
+    if (s_state_type.ignore(pos, expected)) {
+        if (!state_type_p.parse(pos, state_type, expected)) {
+            return false;
+        } else {
+            stateDataType = DataTypeFactory::instance().get(state_type);
+        }
+    }
+
+    if (s_language.ignore(pos, expected)) {
+        if (!function_language_p.parse(pos, function_language, expected)) {
+            return false;
+        } else {
+            language = function_language->as<ASTIdentifier &>().name();
+        }
+    }
+
+    if (!UDF::setLangauge(flags, language.c_str())) {
+        return false;
+    }
+
+    if (!s_as.ignore(pos, expected))
+        return false;
+
+    String function_body;
+    String tag;
+
+    UDF::UDFLanguage lang = UDF::getLanguage(flags);
+
+    switch(lang) {
+        case UDF::UDFLanguage::Sql: {
+            if (!lambda_p.parse(pos, function_core, expected)) {
+                return false;
+            }
+            break;
+        }
+        case UDF::UDFLanguage::Python: {
+            ReadBufferFromMemory buf(pos->begin, pos->size());
+            if (!readDollarQuotedStringInto(function_body, buf, tag, pos->size())) {
+                return false;
+            }
+            ++pos;
+            break;
+        }
+    }
+
+    auto create_function_query = std::make_shared<ASTCreateUserDefinedFunctionQuery>();
+    node = create_function_query;
+
+    if (database_name) {
+        create_function_query->database_name = Poco::toLower(database_name->as<ASTIdentifier &>().name());
+    }
+
+    // const String &f_name = function_name->as<ASTIdentifier &>().name();
+
+    create_function_query->function_name = Poco::toLower(function_name->as<ASTIdentifier &>().name());
+    create_function_query->return_type = returnDataType;
+    create_function_query->state_type = stateDataType;
+    create_function_query->function_core = function_core;
+    create_function_query->flags = flags;
+    create_function_query->function_body = function_body;
+    create_function_query->tag = tag;
+
+    return true;
+}
+}
diff --git a/src/Parsers/ParserCreateUserDefinedFunctionQuery.h b/src/Parsers/ParserCreateUserDefinedFunctionQuery.h
new file mode 100644
index 000000000000..837db8c793b6
--- /dev/null
+++ b/src/Parsers/ParserCreateUserDefinedFunctionQuery.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "IParserBase.h"
+
+namespace DB
+{
+
+/// CREATE FUNCTION test AS x -> x || '1'
+class ParserCreateUserDefinedFunctionQuery : public IParserBase
+{
+protected:
+    const char * getName() const override { return "CREATE FUNCTION query"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
+};
+
+}
diff --git a/src/Parsers/ParserQuery.cpp b/src/Parsers/ParserQuery.cpp
index 22ddc25019f9..c537503d570b 100644
--- a/src/Parsers/ParserQuery.cpp
+++ b/src/Parsers/ParserQuery.cpp
@@ -1,5 +1,6 @@
 #include <Parsers/ParserAlterQuery.h>
 #include <Parsers/ParserCreateFunctionQuery.h>
+#include <Parsers/ParserCreateUserDefinedFunctionQuery.h>
 #include <Parsers/ParserCreateQuery.h>
 #include <Parsers/ParserCreateIndexQuery.h>
 #include <Parsers/ParserDropFunctionQuery.h>
@@ -47,6 +48,7 @@ bool ParserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     ParserCreateRowPolicyQuery create_row_policy_p;
     ParserCreateSettingsProfileQuery create_settings_profile_p;
     ParserCreateFunctionQuery create_function_p;
+    ParserCreateUserDefinedFunctionQuery create_user_defined_function_p; 
     ParserDropFunctionQuery drop_function_p;
     ParserCreateNamedCollectionQuery create_named_collection_p;
     ParserDropNamedCollectionQuery drop_named_collection_p;
@@ -73,6 +75,7 @@ bool ParserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
         || create_row_policy_p.parse(pos, node, expected)
         || create_settings_profile_p.parse(pos, node, expected)
         || create_function_p.parse(pos, node, expected)
+        || create_user_defined_function_p.parse(pos, node, expected)
         || drop_function_p.parse(pos, node, expected)
         || create_named_collection_p.parse(pos, node, expected)
         || drop_named_collection_p.parse(pos, node, expected)
diff --git a/uuid b/uuid
new file mode 100644
index 000000000000..6b328096ca63
--- /dev/null
+++ b/uuid
@@ -0,0 +1 @@
+f533abb6-2439-4724-bddf-83ab02e5e4ac
\ No newline at end of file