{

template <class T>

String operator() (const T & x) const

{

FieldVisitorToString visitor;

return visitor(x);

}

String operator() (const Array & x) const

{

WriteBufferFromOwnString wb;

wb << '[';

for (Array::const_iterator it = x.begin(); it != x.end(); ++it)

{

if (it != x.begin())

wb.write(", ", 2);

wb << applyVisitor(*this, *it);

}

wb << ']';

return wb.str();

}

String operator() (const Map & x) const

{

WriteBufferFromOwnString wb;

wb << '{';

auto it = x.begin();

while (it != x.end())

{

if (it != x.begin())

wb << ", ";

wb << applyVisitor(*this, *it);

++it;

if (it != x.end())

{

wb << ':';

wb << applyVisitor(*this, *it);

++it;

}

}

wb << '}';

return wb.str();

}

String operator() (const Tuple & x) const

{

WriteBufferFromOwnString wb;

wb << '(';

for (auto it = x.begin(); it != x.end(); ++it)

{

if (it != x.begin())

wb << ", ";

wb << applyVisitor(*this, *it);

}

wb << ')';

return wb.str();

}

{

const char * getName() const override { return "literal or map"; }

bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override

{

{

ParserLiteral literal;

if (literal.parse(pos, node, expected))

return true;

}

ParserToken l_br(TokenType::OpeningCurlyBrace);

ParserToken r_br(TokenType::ClosingCurlyBrace);

ParserToken comma(TokenType::Comma);

ParserToken colon(TokenType::Colon);

ParserStringLiteral literal;

if (!l_br.ignore(pos, expected))

return false;

Map map;

while (!r_br.ignore(pos, expected))

{

if (!map.empty() && !comma.ignore(pos, expected))

return false;

ASTPtr key;

ASTPtr val;

if (!literal.parse(pos, key, expected))

return false;

if (!colon.ignore(pos, expected))

return false;

if (!literal.parse(pos, val, expected))

return false;

Tuple tuple;

tuple.push_back(std::move(key->as<ASTLiteral>()->value));

tuple.push_back(std::move(val->as<ASTLiteral>()->value));

map.push_back(std::move(tuple));

}

node = make_intrusive<ASTLiteral>(std::move(map));

return true;

}

{

ASTPtr node;

/// 1. Identifier

ParserCompoundIdentifier identifier_p;

if (identifier_p.parse(pos, node, expected))

{

tryGetIdentifierNameInto(node, value);

return true;

}

/// 2. Literal

ParserLiteral literal_p;

if (literal_p.parse(pos, node, expected))

{

value = applyVisitor(FieldVisitorToString(), node->as<ASTLiteral>()->value);

/// writeQuoted is not always quoted in line with SQL standard https://github.com/ClickHouse/ClickHouse/blob/master/src/IO/WriteHelpers.h

if (value.starts_with('\''))

{

ReadBufferFromOwnString buf(value);

readQuoted(value, buf);

}

return true;

}

/// 3. Map, Array, Tuple of literals and their combination

ParserAllCollectionsOfLiterals all_collections_p;

if (all_collections_p.parse(pos, node, expected))

{

value = applyVisitor(ParameterFieldVisitorToString(), node->as<ASTLiteral>()->value);

return true;

}

return false;

{

ParserCompoundIdentifier name_p;

ParserLiteralOrMap literal_or_map_p;

ParserToken s_eq(TokenType::Equals);

ParserSetQuery set_p(true);

ParserFunction function_p;

ASTPtr name;

ASTPtr value;

ASTPtr function_ast;

if (!name_p.parse(pos, name, expected))

return false;

if (!s_eq.ignore(pos, expected))

return false;

/// for SETTINGS disk=disk(type='s3', path='', ...)

{

auto pos_before_func = pos;

if (function_p.parse(pos, function_ast, expected) && function_ast->as<ASTFunction>()->name == "disk")

{

tryGetIdentifierNameInto(name, change.name);

change.value = createFieldFromAST(function_ast);

return true;

}

pos = pos_before_func;

}

if (!literal_or_map_p.parse(pos, value, expected))

return false;

tryGetIdentifierNameInto(name, change.name);

change.value = value->as<ASTLiteral &>().value;

return true;

SettingChange & change, String & default_settings, ParserSetQuery::Parameter & parameter, IParser::Pos & pos, Expected & expected, bool enable_shorthand_syntax)

{

ParserCompoundIdentifier name_p;

ParserLiteralOrMap value_p;

ParserToken s_eq(TokenType::Equals);

ParserFunction function_p;

ASTPtr node;

String name;

ASTPtr function_ast;

bool have_eq;

if (!name_p.parse(pos, node, expected))

return false;

have_eq = s_eq.ignore(pos, expected);

if (!enable_shorthand_syntax && !have_eq)

return false;

tryGetIdentifierNameInto(node, name);

/// Parameter

if (name.starts_with(QUERY_PARAMETER_NAME_PREFIX))

{

if (!have_eq)

return false;

name = name.substr(strlen(QUERY_PARAMETER_NAME_PREFIX));

if (name.empty())

throw Exception(ErrorCodes::BAD_ARGUMENTS, "Parameter name cannot be empty");

String value;

if (!parseParameterValueIntoString(pos, value, expected))

return false;

parameter = {std::move(name), std::move(value)};

return true;

}

if (have_eq)

{

/// Default

if (ParserKeyword(Keyword::DEFAULT).ignore(pos, expected))

{

default_settings = name;

return true;

}

/// Setting

{

auto pos_before_func = pos;

if (function_p.parse(pos, function_ast, expected) && function_ast->as<ASTFunction>()->name == "disk")

{

change.name = name;

change.value = createFieldFromAST(function_ast);

return true;

}

pos = pos_before_func;

}

if (!value_p.parse(pos, node, expected))

return false;

}

else

{

try

{

Field type_test = Settings::castValueUtil(name, true);

if (type_test.getType() == Field::Types::Which::Bool)

node = make_intrusive<ASTLiteral>(Field(true));

else

return false;

}

catch (const Exception &)

{

return false;

}

}

change.name = name;

change.value = node->as<ASTLiteral &>().value;

return true;

{

ParserToken s_comma(TokenType::Comma);

if (!parse_only_internals)

{

ParserKeyword s_set(Keyword::SET);

if (!s_set.ignore(pos, expected))

return false;

/// Parse SET TRANSACTION ... queries using ParserTransactionControl

if (ParserKeyword{Keyword::TRANSACTION}.check(pos, expected))

return false;

/// Parse SET TIME ZONE 'tz' as an alias for SET session_timezone = 'tz'

if (ParserKeyword{Keyword::TIME_ZONE}.ignore(pos, expected))

{

ParserToken eq(TokenType::Equals);

eq.ignore(pos, expected); // optional, for PostgreSQL compatibility

ASTPtr value_node;

ParserLiteralOrMap literal_parser;

if (!literal_parser.parse(pos, value_node, expected))

return false;

auto query = make_intrusive<ASTSetQuery>();

node = query;

query->is_standalone = !parse_only_internals;

SettingChange change;

change.name = "session_timezone";

change.value = value_node->as<ASTLiteral &>().value;

query->changes.push_back(std::move(change));

return true;

}

}

SettingsChanges changes;

NameToNameVector query_parameters;

std::vector<String> default_settings;

while (true)

{

if ((!changes.empty() || !query_parameters.empty() || !default_settings.empty()) && !s_comma.ignore(pos))

break;

SettingChange setting;

String name_of_default_setting;

Parameter parameter;

if (!parseNameValuePairWithParameterOrDefault(setting, name_of_default_setting, parameter, pos, expected, shorthand_syntax))

return false;

if (!parameter.first.empty())

query_parameters.emplace_back(std::move(parameter));

else if (!name_of_default_setting.empty())

default_settings.emplace_back(std::move(name_of_default_setting));

else

changes.push_back(std::move(setting));

}

auto query = make_intrusive<ASTSetQuery>();

node = query;

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;