move default settings to different part of ast

src/Access/SettingsConstraints.cpp

@@ -118,8 +118,6 @@ bool SettingsConstraints::checkImpl(const Settings & current_settings, SettingCh
     bool cannot_cast;
     auto cast_value = [&](const Field & x) -> Field
     {
-        if (x.isNull())
-            return {};
         cannot_cast = false;
         if (reaction == THROW_ON_VIOLATION)
             return Settings::castValueUtil(setting_name, x);

src/Client/ClientBase.cpp

@@ -1498,6 +1498,7 @@ void ClientBase::processParsedSingleQuery(const String & full_query, const Strin
             if (!old_settings)
                 old_settings.emplace(global_context->getSettingsRef());
             global_context->applySettingsChanges(settings_ast.as<ASTSetQuery>()->changes);
+            global_context->resetSettingsToDefaultValue(settings_ast.as<ASTSetQuery>()->default_settings);
         };
 
         const auto * insert = parsed_query->as<ASTInsertQuery>();
@@ -1543,6 +1544,7 @@ void ClientBase::processParsedSingleQuery(const String & full_query, const Strin
                 else
                     global_context->applySettingChange(change);
             }
+            global_context->resetSettingsToDefaultValue(set_query->default_settings);
         }
         if (const auto * use_query = parsed_query->as<ASTUseQuery>())
         {

src/Core/Settings.cpp

@@ -148,11 +148,7 @@ std::vector<String> Settings::getAllRegisteredNames() const
 
 void Settings::set(std::string_view name, const Field & value)
 {
-    if (value.isNull()) {
-        resetToDefault(name);
-    } else {
-        BaseSettings::set(name, value);
-    }
+    BaseSettings::set(name, value);
 
     if (name == "compatibility")
         applyCompatibilitySetting();

src/Core/Settings.h

@@ -890,6 +890,8 @@ struct Settings : public BaseSettings<SettingsTraits>, public IHints<2, Settings
 
     void set(std::string_view name, const Field & value) override;
 
+    void setDefaultValue(const String & name) { resetToDefault(name); }
+
 private:
     void applyCompatibilitySetting();
 

src/Interpreters/Context.cpp

@@ -1374,6 +1374,15 @@ void Context::clampToSettingsConstraints(SettingsChanges & changes) const
     getSettingsConstraintsAndCurrentProfiles()->constraints.clamp(settings, changes);
 }
 
+void Context::resetSettingsToDefaultValue(const std::vector<String> & names)
+{
+    auto lock = getLock();
+    for (const String & name: names)
+    {
+        settings.setDefaultValue(name);
+    }
+}
+
 std::shared_ptr<const SettingsConstraintsAndProfileIDs> Context::getSettingsConstraintsAndCurrentProfiles() const
 {
     auto lock = getLock();

src/Interpreters/Context.h

@@ -647,6 +647,9 @@ public:
     void checkSettingsConstraints(SettingsChanges & changes) const;
     void clampToSettingsConstraints(SettingsChanges & changes) const;
 
+    /// Reset settings to default value
+    void resetSettingsToDefaultValue(const std::vector<String> & names);
+
     /// Returns the current constraints (can return null).
     std::shared_ptr<const SettingsConstraintsAndProfileIDs> getSettingsConstraintsAndCurrentProfiles() const;
 

src/Interpreters/InterpreterSetQuery.cpp

@@ -13,6 +13,7 @@ BlockIO InterpreterSetQuery::execute()
     auto session_context = getContext()->getSessionContext();
     session_context->applySettingsChanges(ast.changes);
     session_context->addQueryParameters(ast.query_parameters);
+    session_context->resetSettingsToDefaultValue(ast.default_settings);
     return {};
 }
 
@@ -22,6 +23,7 @@ void InterpreterSetQuery::executeForCurrentContext()
     const auto & ast = query_ptr->as<ASTSetQuery &>();
     getContext()->checkSettingsConstraints(ast.changes);
     getContext()->applySettingsChanges(ast.changes);
+    getContext()->resetSettingsToDefaultValue(ast.default_settings);
 }
 
 }

src/Parsers/ASTSetQuery.cpp

@@ -37,6 +37,17 @@ void ASTSetQuery::formatImpl(const FormatSettings & format, FormatState &, Forma
         format.ostr << " = " << applyVisitor(FieldVisitorToString(), change.value);
     }
 
+    for (const auto & setting_name : default_settings)
+    {
+        if (!first)
+            format.ostr << ", ";
+        else
+            first = false;
+
+        formatSettingName(setting_name, format.ostr);
+        format.ostr << " = DEFAULT";
+    }
+
     for (const auto & [name, value] : query_parameters)
     {
         if (!first)

src/Parsers/ASTSetQuery.h

@@ -23,6 +23,8 @@ public:
     bool print_in_format = true;
 
     SettingsChanges changes;
+    /// settings that will be reset to default value
+    std::vector<String> default_settings;
     NameToNameMap query_parameters;
 
     /** Get the text that identifies this element. */

src/Parsers/ParserSetQuery.cpp

@@ -109,8 +109,6 @@ bool ParserSetQuery::parseNameValuePair(SettingChange & change, IParser::Pos & p
         value = std::make_shared<ASTLiteral>(Field(static_cast<UInt64>(1)));
     else if (ParserKeyword("FALSE").ignore(pos, expected))
         value = std::make_shared<ASTLiteral>(Field(static_cast<UInt64>(0)));
-    else if (ParserKeyword("DEFAULT").ignore(pos, expected))
-        value = std::make_shared<ASTLiteral>(Field());
     else if (!value_p.parse(pos, value, expected))
         return false;
 
@@ -120,6 +118,40 @@ bool ParserSetQuery::parseNameValuePair(SettingChange & change, IParser::Pos & p
     return true;
 }
 
+bool ParserSetQuery::parseNameValuePairWithDefault(SettingChange & change, String & default_settings, IParser::Pos & pos, Expected & expected)
+{
+    ParserCompoundIdentifier name_p;
+    ParserLiteralOrMap value_p;
+    ParserToken s_eq(TokenType::Equals);
+
+    ASTPtr name;
+    ASTPtr value;
+    bool is_default = false;
+
+    if (!name_p.parse(pos, name, expected))
+        return false;
+
+    if (!s_eq.ignore(pos, expected))
+        return false;
+
+    if (ParserKeyword("TRUE").ignore(pos, expected))
+        value = std::make_shared<ASTLiteral>(Field(static_cast<UInt64>(1)));
+    else if (ParserKeyword("FALSE").ignore(pos, expected))
+        value = std::make_shared<ASTLiteral>(Field(static_cast<UInt64>(0)));
+    else if (ParserKeyword("DEFAULT").ignore(pos, expected))
+        is_default = true;
+    else if (!value_p.parse(pos, value, expected))
+        return false;
+
+    tryGetIdentifierNameInto(name, change.name);
+    if (is_default)
+        default_settings = change.name;
+    else
+        change.value = value->as<ASTLiteral &>().value;
+
+    return true;
+}
+
 
 bool ParserSetQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
@@ -139,20 +171,24 @@ bool ParserSetQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 
     SettingsChanges changes;
     NameToNameMap query_parameters;
+    std::vector<String> default_settings;
 
     while (true)
     {
-        if ((!changes.empty() || !query_parameters.empty()) && !s_comma.ignore(pos))
+        if ((!changes.empty() || !query_parameters.empty() || !default_settings.empty()) && !s_comma.ignore(pos))
             break;
 
         /// Either a setting or a parameter for prepared statement (if name starts with QUERY_PARAMETER_NAME_PREFIX)
         SettingChange current;
+        String name_of_default_setting;
 
-        if (!parseNameValuePair(current, pos, expected))
+        if (!parseNameValuePairWithDefault(current, name_of_default_setting, pos, expected))
             return false;
 
         if (current.name.starts_with(QUERY_PARAMETER_NAME_PREFIX))
             query_parameters.emplace(convertToQueryParameter(std::move(current)));
+        else if (!name_of_default_setting.empty())
+            default_settings.emplace_back(std::move(name_of_default_setting));
         else
             changes.push_back(std::move(current));
     }
@@ -163,6 +199,7 @@ bool ParserSetQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     query->is_standalone = !parse_only_internals;
     query->changes = std::move(changes);
     query->query_parameters = std::move(query_parameters);
+    query->default_settings = std::move(default_settings);
 
     return true;
 }

src/Parsers/ParserSetQuery.h

@@ -17,6 +17,7 @@ class ParserSetQuery : public IParserBase
 public:
     explicit ParserSetQuery(bool parse_only_internals_ = false) : parse_only_internals(parse_only_internals_) {}
     static bool parseNameValuePair(SettingChange & change, IParser::Pos & pos, Expected & expected);
+    static bool parseNameValuePairWithDefault(SettingChange & change, String & default_settings, IParser::Pos & pos, Expected & expected);
 protected:
     const char * getName() const override { return "SET query"; }
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;