{

return query.length() >= prefix.length()

&& std::equal(prefix.begin(), prefix.end(), query.begin(), [](char a, char b) { return std::tolower(a) == std::tolower(b); });

{

re2::RE2::Options regexp_options;

regexp_options.set_case_sensitive(false);

static const re2::RE2 expr(

"(^(SET NAMES(.*)))"

"|(^(SET character_set_results(.*)))"

"|(^(SET FOREIGN_KEY_CHECKS(.*)))"

"|(^(SET AUTOCOMMIT(.*)))"

"|(^(SET sql_mode(.*)))"

"|(^(SET @@(.*)))"

"|(^(SET SESSION TRANSACTION ISOLATION LEVEL(.*)))", regexp_options);

chassert(expr.ok());

return re2::RE2::FullMatch(query, expr);

{

std::ignore = query;

return "select ''";

{

Tokens tokens(text.data(), text.data() + text.size(), DBMS_DEFAULT_MAX_QUERY_SIZE);

IParser::Pos pos(tokens, DBMS_DEFAULT_MAX_PARSER_DEPTH, DBMS_DEFAULT_MAX_PARSER_BACKTRACKS);

Expected expected;

ASTPtr ast;

if (!ParserStringLiteral().parse(pos, ast, expected))

return std::nullopt;

/// Accept one optional trailing ';' then end-of-stream: executeQuery treats ';' as

/// end-of-query, so a benign programmatic client may send "SHOW TABLE STATUS LIKE 'x';".

/// A second statement after the ';' leaves pos before end -> rejected, so this stays injection-safe.

ParserToken(TokenType::Semicolon).ignore(pos, expected);

if (!pos->isEnd())

return std::nullopt;

return ast->as<ASTLiteral &>().value.safeGet<String>();

{

const String prefix = "SHOW TABLE STATUS LIKE ";

String pattern;

/// The dispatcher matched the key "SHOW TABLE STATUS LIKE" (22 chars, no separator) but we slice

/// at prefix.length() (23, includes the space). Require that separator byte to be whitespace,

/// else "SHOW TABLE STATUS LIKEx'a'" would skip the stray byte and be coerced into a lookup.

if (query.size() > prefix.size() && isWhitespaceASCII(query[prefix.size() - 1]))

{

/// Parse the LIKE argument as a single string literal and re-quote it. The raw client

/// suffix must never be concatenated verbatim: that allowed injecting an arbitrary tail

/// (e.g. "" UNION SELECT ... FROM system.users) into the generated query. If the suffix

/// is not exactly one string literal, match nothing rather than risk injection.

if (auto parsed = tryParseSingleStringLiteral(query.data() + prefix.length()))

pattern = *parsed;

}

return (

"SELECT"

" table_name AS Name,"

" engine AS Engine,"

" version AS Version,"

" row_format AS Row_format,"

" table_rows AS Rows,"

" avg_row_length AS Avg_row_length,"

" data_length AS Data_length,"

" max_data_length AS Max_data_length,"

" index_length AS Index_length,"

" data_free AS Data_free,"

" auto_increment AS Auto_increment,"

" create_time AS Create_time,"

" update_time AS Update_time,"

" check_time AS Check_time,"

" table_collation AS Collation,"

" checksum AS Checksum,"

" create_options AS Create_options,"

" table_comment AS Comment"

" FROM INFORMATION_SCHEMA.TABLES"

/// MySQL scopes SHOW TABLE STATUS to the session's default database, so the translation

/// must constrain table_schema too, or a lookup would also return same-named tables from

/// other databases. The replacement is executed with the session's query context, so

/// currentDatabase() resolves to that session database (it also tracks later USE

/// statements). MySQL's "No database selected" state cannot arise here: a ClickHouse

/// session always has a current database (the server default when the client sent none).

" WHERE table_schema = currentDatabase() AND table_name LIKE "

+ quoteString(pattern));

{

const String prefix = "SET " + mysql_setting;

if (!checkShouldReplaceQuery(query, prefix))

return std::nullopt;

/// checkShouldReplaceQuery is only a byte-prefix check, so it also matches a longer variable

/// that merely starts with the mapped name (e.g. "SET SQL_SELECT_LIMITED=1" matches the

/// "SET SQL_SELECT_LIMIT" prefix). Require a word boundary after the name: the next character

/// must not continue an identifier. Otherwise this is a different variable, so leave the query

/// untranslated (it passes through and errors safely as an unknown setting) instead of resetting

/// the unrelated mapped setting below.

if (query.length() > prefix.length() && isWordCharASCII(query[prefix.length()]))

return std::nullopt;

/// Parse the "= <value>" tail and re-serialize the value rather than concatenating the raw

/// client suffix. Concatenation let a client smuggle a tail into the generated query

/// (e.g. "SET SQL_SELECT_LIMIT=1, max_threads=42" became "SET limit=1, max_threads=42").

/// Only translate when the full tail is exactly "= <literal|DEFAULT>" with an optional single

/// trailing ';' (executeQuery treats ';' as end-of-query, so a benign programmatic client may

/// send "SET SQL_SELECT_LIMIT=2;"). Anything else (a malformed value, or an injected tail such

/// as ", max_threads=42" or a second statement after ';') is rejected: throw instead of

/// silently resetting the mapped setting to DEFAULT, which would change the caller's session

/// state on a malformed input and report success.

const String tail = query.data() + prefix.length();

Tokens tokens(tail.data(), tail.data() + tail.size(), DBMS_DEFAULT_MAX_QUERY_SIZE);

IParser::Pos pos(tokens, DBMS_DEFAULT_MAX_PARSER_DEPTH, DBMS_DEFAULT_MAX_PARSER_BACKTRACKS);

Expected expected;

if (!ParserToken(TokenType::Equals).ignore(pos, expected))

throw Exception(ErrorCodes::SYNTAX_ERROR, "Expected '=' after '{}'", prefix);

String value;

ASTPtr ast;

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

value = "DEFAULT";

else if (ParserLiteral().parse(pos, ast, expected))

value = applyVisitor(FieldVisitorToString(), ast->as<ASTLiteral &>().value);

else

throw Exception(ErrorCodes::SYNTAX_ERROR, "Expected a single value after '{} ='", prefix);

ParserToken(TokenType::Semicolon).ignore(pos, expected);

if (!pos->isEnd())

throw Exception(ErrorCodes::SYNTAX_ERROR, "Unexpected trailing tokens after '{} = <value>'", prefix);

return "SET " + clickhouse_setting + " = " + value;

{

const String prefix = "KILL QUERY ";

/// The dispatcher matched the key "KILL QUERY" (10 chars, no separator) but we slice at

/// prefix.length() (11, includes the space). Require that separator byte to be whitespace,

/// else "KILL QUERY;12"/"KILL QUERYx12" would skip the stray byte and be coerced into a cancel.

if (query.size() > prefix.size() && isWhitespaceASCII(query[prefix.size() - 1]))

{

String suffix = query.data() + prefix.length();

/// Capture the digits of the connection id and accept one optional trailing ';' plus

/// surrounding whitespace: "^[0-9]" accepted only a single digit and silently dropped every

/// multi-digit id (e.g. "KILL QUERY 12"), and a benign programmatic client may send

/// "KILL QUERY 12;" (executeQuery treats ';' as end-of-query). Only the captured digits are

/// substituted, so any other tail (a non-numeric id, or a second statement after ';') fails

/// the match and stays injection-safe.

static const re2::RE2 expr(R"(^\s*([0-9]+)\s*;?\s*$)");

String connection_id_str;

if (re2::RE2::FullMatch(suffix, expr, &connection_id_str))

{

String replacement = fmt::format("KILL QUERY WHERE query_id LIKE 'mysql:{}:%'", connection_id_str);

return replacement;

}

}

return query;

{

if (auto * literal = node->as<ASTLiteral>())

{

if (literal->value.getType() == Field::Types::String)

{

literal->value = Poco::toLower(literal->value.safeGet<String>());

return true;

}

if (literal->value.getType() == Field::Types::Tuple || literal->value.getType() == Field::Types::Array)

{

bool lowered = false;

auto lower_elements = [&](auto & elements)

{

for (auto & element : elements)

{

if (element.getType() == Field::Types::String)

{

element = Poco::toLower(element.template safeGet<String>());

lowered = true;

}

}

};

if (literal->value.getType() == Field::Types::Tuple)

{

auto elements = literal->value.safeGet<Tuple>();

lower_elements(elements);

literal->value = std::move(elements);

}

else

{

auto elements = literal->value.safeGet<Array>();

lower_elements(elements);

literal->value = std::move(elements);

}

return lowered;

}

return false;

}

if (const auto * function = node->as<ASTFunction>();

function && (function->name == "tuple" || function->name == "array") && function->arguments)

{

bool lowered = false;

for (auto & argument : function->arguments->children)

lowered |= lowercaseStringLiterals(argument);

return lowered;

}

return false;

{

static constexpr std::array string_columns{"Collation", "Charset", "Default", "Compiled", "Pad_attribute"};

return std::any_of(string_columns.begin(), string_columns.end(), [&](const auto * column) { return name == column; });

{

if (auto * identifier = node->as<ASTIdentifier>())

{

static constexpr std::array canonical_columns{"Collation", "Charset", "Id", "Default", "Compiled", "Sortlen", "Pad_attribute"};

for (const auto * column : canonical_columns)

{

if (Poco::icompare(identifier->name(), column) == 0)

{

node = make_intrusive<ASTIdentifier>(String(column));

break;

}

}

return;

}

if (auto * function = node->as<ASTFunction>();

function && function->arguments && function->arguments->children.size() == 2

&& (function->name == "equals" || function->name == "notEquals" || function->name == "like"

|| function->name == "notLike" || function->name == "ilike" || function->name == "notILike"

|| function->name == "in" || function->name == "notIn"))

{

/// Canonicalize identifiers first, then decide by the canonical name whether this

/// comparison targets a string-valued column.

for (auto & argument : function->arguments->children)

makeShowCollationsFilterCaseInsensitive(argument);

bool string_column = false;

for (const auto & argument : function->arguments->children)

if (const auto * argument_identifier = argument->as<ASTIdentifier>();

argument_identifier && isStringValuedCollationColumn(argument_identifier->name()))

string_column = true;

if (string_column)

{

bool lowered_literal = false;

for (auto & argument : function->arguments->children)

lowered_literal |= lowercaseStringLiterals(argument);

if (lowered_literal)

for (auto & argument : function->arguments->children)

if (argument->as<ASTIdentifier>())

argument = makeASTFunction("lower", argument);

}

return;

}

for (auto & child : node->children)

makeShowCollationsFilterCaseInsensitive(child);

{

static constexpr auto collations = "SELECT"

" 'utf8mb4_0900_ai_ci' AS `Collation`,"

" 'utf8mb4' AS `Charset`,"

" 255 AS `Id`,"

" 'Yes' AS `Default`,"

" 'Yes' AS `Compiled`,"

" 0 AS `Sortlen`,"

" 'NO PAD' AS `Pad_attribute`"

" UNION ALL SELECT"

" 'binary' AS `Collation`,"

" 'binary' AS `Charset`,"

" 63 AS `Id`,"

" 'Yes' AS `Default`,"

" 'Yes' AS `Compiled`,"

" 1 AS `Sortlen`,"

" 'NO PAD' AS `Pad_attribute`";

const String prefix = "SHOW COLLATION";

const String tail = query.size() > prefix.size() ? String(query.data() + prefix.size()) : String();

/// The dispatcher is only a byte-prefix check; a word character right after the prefix means

/// a different statement (e.g. "SHOW COLLATIONX"), so leave it untranslated to error naturally.

if (!tail.empty() && isWordCharASCII(tail[0]))

return query;

/// The dispatcher routes every prefix match here, so the filtered forms of the statement

/// ("SHOW COLLATION LIKE 'pattern'", "SHOW COLLATION WHERE <expr>") also land in this

/// function and their filter must be honored, not dropped. Parse the tail and re-serialize

/// the filter instead of concatenating the raw client suffix (which would allow SQL injection

/// over the MySQL wire). Any malformed tail is left untranslated so the client gets a syntax

/// error rather than a silently unfiltered result.

Tokens tokens(tail.data(), tail.data() + tail.size(), DBMS_DEFAULT_MAX_QUERY_SIZE);

IParser::Pos pos(tokens, DBMS_DEFAULT_MAX_PARSER_DEPTH, DBMS_DEFAULT_MAX_PARSER_BACKTRACKS);

Expected expected;

String filter;

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

{

ASTPtr ast;

if (!ParserStringLiteral().parse(pos, ast, expected))

return query;

/// MySQL matches collation names case-insensitively, so use ILIKE.

filter = " WHERE `Collation` ILIKE " + quoteString(ast->as<ASTLiteral &>().value.safeGet<String>());

}

else if (ParserKeyword(Keyword::WHERE).ignore(pos, expected))

{

ASTPtr ast;

if (!ParserExpression().parse(pos, ast, expected))

return query;

makeShowCollationsFilterCaseInsensitive(ast);

filter = " WHERE " + ast->formatWithSecretsOneLine();

}

/// Accept one optional trailing ';' then end-of-stream (executeQuery treats ';' as

/// end-of-query). Anything else is a tail this translation does not understand.

ParserToken(TokenType::Semicolon).ignore(pos, expected);

if (!pos->isEnd())

return query;

return "SELECT * FROM (" + String(collations) + ")" + filter;

IServer & server_,

TCPServer & tcp_server_,

const Poco::Net::StreamSocket & socket_,

bool ssl_enabled, bool secure_required_,

uint32_t connection_id_,

std::optional<String> default_session_user_,

const ProfileEvents::Event & read_event_,

const ProfileEvents::Event & write_event_)

: Poco::Net::TCPServerConnection(socket_)

, server(server_)

, tcp_server(tcp_server_)

, log(getLogger("MySQLHandler"))

, secure_required(secure_required_)

, connection_id(connection_id_)

, default_session_user(std::move(default_session_user_))

, auth_plugin(new MySQLProtocol::Authentication::Native41())

, read_event(read_event_)

, write_event(write_event_)

{

server_capabilities = CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION | CLIENT_PLUGIN_AUTH | CLIENT_PLUGIN_AUTH_LENENC_CLIENT_DATA | CLIENT_CONNECT_WITH_DB | CLIENT_DEPRECATE_EOF;

if (ssl_enabled)

server_capabilities |= CLIENT_SSL;

queries_replacements.emplace("SHOW WARNINGS", showWarningsReplacementQuery);

queries_replacements.emplace("SHOW COUNT(*) WARNINGS", showCountWarningsReplacementQuery);

queries_replacements.emplace("KILL QUERY", killConnectionIdReplacementQuery);

queries_replacements.emplace("SHOW TABLE STATUS LIKE", showTableStatusReplacementQuery);

queries_replacements.emplace("SHOW VARIABLES", selectEmptyReplacementQuery);

queries_replacements.emplace("SHOW COLLATION", showCollationsReplacementQuery);

settings_replacements.emplace("SQL_SELECT_LIMIT", "limit");

settings_replacements.emplace("NET_WRITE_TIMEOUT", "send_timeout");

settings_replacements.emplace("NET_READ_TIMEOUT", "receive_timeout");

{

DB::setThreadName(ThreadName::MYSQL_HANDLER);

session = std::make_unique<Session>(server.context(), ClientInfo::Interface::MYSQL);

SCOPE_EXIT({ session.reset(); });

session->setClientConnectionId(connection_id);

const Settings & settings = server.context()->getSettingsRef();

socket().setReceiveTimeout(settings[Setting::receive_timeout]);

socket().setSendTimeout(settings[Setting::send_timeout]);

in = std::make_shared<ReadBufferFromPocoSocket>(socket(), read_event);

out = std::make_shared<AutoCanceledWriteBuffer<WriteBufferFromPocoSocket>>(socket(), write_event);

packet_endpoint = std::make_shared<MySQLProtocol::PacketEndpoint>(*in, *out, sequence_id);

try

{

Handshake handshake(server_capabilities, connection_id, VERSION_STRING + String("-") + VERSION_NAME,

auth_plugin->getName(), auth_plugin->getAuthPluginData(), CharacterSet::utf8mb4_0900_ai_ci);

packet_endpoint->sendPacket<Handshake>(handshake);

LOG_TRACE(log, "Sent handshake");

HandshakeResponse handshake_response;

finishHandshake(handshake_response);

client_capabilities = handshake_response.capability_flags;

max_packet_size = handshake_response.max_packet_size ? handshake_response.max_packet_size : MAX_PACKET_LENGTH;

LOG_TRACE(log,

"Capabilities: {}, max_packet_size: {}, character_set: {}, user: {}, auth_response length: {}, database: {}, auth_plugin_name: {}",

handshake_response.capability_flags,

handshake_response.max_packet_size,

static_cast<int>(handshake_response.character_set),

handshake_response.username,

handshake_response.auth_response.length(),

handshake_response.database,

handshake_response.auth_plugin_name);

if (!(client_capabilities & CLIENT_PROTOCOL_41))

throw Exception(ErrorCodes::MYSQL_CLIENT_INSUFFICIENT_CAPABILITIES, "Required capability: CLIENT_PROTOCOL_41.");

/// Check the actual state of the transport, not the capability bit advertised by the client:

/// a client can set `CLIENT_SSL` in a plaintext `HandshakeResponse` without ever sending an

/// `SSLRequest`, and then the connection stays unencrypted.

if (secure_required && !secure_connection)

throw Exception(ErrorCodes::OPENSSL_ERROR, "SSL connection required.");

/// An empty user name means the default session user: the `default_session_user`

/// server setting, possibly overridden for this listener in the `protocols` section.

/// If the resolved name is empty too (explicitly configured to prohibit connections

/// without a user name), authentication fails on the empty user name below.

if (handshake_response.username.empty())

handshake_response.username = default_session_user

? *default_session_user

: String(server.context()->getServerSettings()[ServerSetting::default_session_user]);

if (handshake_response.username.empty())

{

auto exception = Exception(ErrorCodes::AUTHENTICATION_FAILED, "Got an empty user name from MySQL handshake");

session->onAuthenticationFailure(handshake_response.username, socket().peerAddress(), exception);

packet_endpoint->sendPacket(ERRPacket(exception.code(), mysql_error_code, exception.message()));

return;

}

authenticate(handshake_response.username, handshake_response.auth_plugin_name, handshake_response.auth_response);

try

{

session->makeSessionContext();

session->sessionContext()->setDefaultFormat("MySQLWire");

if (!handshake_response.database.empty())

{

/// `database` is a real setting, so enforce its constraints on the handshake database

/// too, consistently with `USE`, `SET database = ...` and the HTTP `?database=...`

/// parameter.

SettingsChanges database_change;

database_change.setSetting("database", handshake_response.database);

session->sessionContext()->checkSettingsConstraints(database_change, SettingSource::QUERY);

session->sessionContext()->setCurrentDatabase(handshake_response.database);

}

}

catch (const Exception & exc)

{

log->log(exc);

packet_endpoint->sendPacket(ERRPacket(exc.code(), mysql_error_code, exc.message()));

}

OKPacket ok_packet(0, handshake_response.capability_flags, 0, 0, 0);

packet_endpoint->sendPacket(ok_packet);

while (tcp_server.isOpen())

{

packet_endpoint->resetSequenceId();

MySQLPacketPayloadReadBuffer payload = packet_endpoint->getPayload();

while (!in->poll(1000000))

if (!tcp_server.isOpen())

return;

char command = 0;

payload.readStrict(command);

// For commands which are executed without MemoryTracker.

LimitReadBuffer limited_payload(payload, {.read_no_more = 1000, .expect_eof = true, .excetion_hint = "too long MySQL packet."});

LOG_DEBUG(log, "Received command: {}. Connection id: {}.",

static_cast<int>(static_cast<unsigned char>(command)), connection_id);

if (!tcp_server.isOpen())

return;

try

{

switch (command)

{

case COM_QUIT:

return;

case COM_INIT_DB:

comInitDB(limited_payload);

break;

case COM_QUERY:

comQuery(payload, false);

break;

case COM_FIELD_LIST:

comFieldList(limited_payload);

break;

case COM_PING:

comPing();

break;

case COM_STMT_PREPARE:

comStmtPrepare(payload);

break;

case COM_STMT_EXECUTE:

comStmtExecute(payload);

break;

case COM_STMT_CLOSE:

comStmtClose(payload);

break;

default:

throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Command {} is not implemented.", command);

}

}

catch (const NetException & exc)

{

log->log(exc);

throw;

}

catch (...)

{

tryLogCurrentException(log, "MySQLHandler: Cannot read packet: ");

packet_endpoint->sendPacket(ERRPacket(getCurrentExceptionCode(), mysql_error_code, getCurrentExceptionMessage(false)));

}

}

}

catch (const Poco::Exception & exc)

{

log->log(exc);

}

{

size_t packet_size = PACKET_HEADER_SIZE + SSL_REQUEST_PAYLOAD_SIZE;

/// Buffer for SSLRequest or part of HandshakeResponse.

std::vector<char> buf(packet_size);

size_t pos = 0;

/// Reads at least count and at most packet_size bytes.

auto read_bytes = [this, &buf, &pos, &packet_size](size_t count) -> void {

while (pos < count)

{

int ret = socket().receiveBytes(buf.data() + pos, static_cast<uint32_t>(packet_size - pos));

if (ret == 0)

{

throw Exception(ErrorCodes::CANNOT_READ_ALL_DATA, "Cannot read all data. Bytes read: {}. Bytes expected: 3", std::to_string(pos));

}

pos += ret;

}

};

read_bytes(3); /// We can find out whether it is SSLRequest of HandshakeResponse by first 3 bytes.

size_t payload_size = unalignedLoad<uint32_t>(buf.data()) & 0xFFFFFFu;

LOG_TRACE(log, "payload size: {}", payload_size);

if (payload_size == SSL_REQUEST_PAYLOAD_SIZE)

{

finishHandshakeSSL(packet_size, buf.data(), pos, read_bytes, packet);

}

else

{

if (payload_size > MAX_HANDSHAKE_RESPONSE_PAYLOAD_SIZE)

throw Exception(ErrorCodes::UNKNOWN_PACKET_FROM_CLIENT,

"Handshake response declares a payload of {} bytes, while it must be at most {} bytes",

payload_size, MAX_HANDSHAKE_RESPONSE_PAYLOAD_SIZE);

/// Reading rest of HandshakeResponse.

packet_size = PACKET_HEADER_SIZE + payload_size;

WriteBufferFromOwnString buf_for_handshake_response;

buf_for_handshake_response.write(buf.data(), pos);

copyData(*packet_endpoint->in, buf_for_handshake_response, packet_size - pos);

ReadBufferFromString payload(buf_for_handshake_response.str());

payload.ignore(PACKET_HEADER_SIZE);

packet.readPayloadWithUnpacked(payload);

packet_endpoint->sequence_id++;

}

{

try

{

const auto user_authentication_types = session->getAuthenticationTypesOrLogInFailure(user_name);

for (const auto user_authentication_type : user_authentication_types)

{

// For compatibility with JavaScript MySQL client, Native41 authentication plugin is used when possible

// (if password is specified using double SHA1). Otherwise, SHA256 plugin is used.

if (user_authentication_type == DB::AuthenticationType::SHA256_PASSWORD)

{

authPluginSSL();

}

}

std::optional<String> auth_response = auth_plugin_name == auth_plugin->getName() ? std::make_optional<String>(initial_auth_response) : std::nullopt;

auth_plugin->authenticate(user_name, *session, auth_response, packet_endpoint, secure_connection, socket().peerAddress());

}

catch (const Exception & exc)

{

LOG_ERROR(log, "Authentication for user {} failed.", user_name);

packet_endpoint->sendPacket(ERRPacket(exc.code(), mysql_error_code, exc.message()));

throw;

}

LOG_DEBUG(log, "Authentication for user {} succeeded.", user_name);

{

String database;

readStringUntilEOF(database, payload);

LOG_DEBUG(log, "Setting current database to {}", database);

/// Mirror the access check of the SQL `USE database` statement (InterpreterUseQuery).

session->sessionContext()->checkAccess(AccessType::SHOW_DATABASES, database);

/// ... and its settings-constraint check on the `database` setting.

SettingsChanges database_change;

database_change.setSetting("database", database);

session->sessionContext()->checkSettingsConstraints(database_change, SettingSource::QUERY);

session->sessionContext()->setCurrentDatabase(database);

packet_endpoint->sendPacket(OKPacket(0, client_capabilities, 0, 0, 1));

{

ComFieldList packet;

packet.readPayloadWithUnpacked(payload);

const auto session_context = session->sessionContext();

String database = session_context->getCurrentDatabase();

/// Mirror the access check of the SQL `DESCRIBE`/`SHOW COLUMNS` statements (InterpreterDescribeQuery).

/// Check before getTable() so this command does not become a table-existence oracle.

session_context->checkAccess(AccessType::SHOW_COLUMNS, database, packet.table);

StoragePtr table_ptr = DatabaseCatalog::instance().getTable({database, packet.table}, session_context);

auto metadata_snapshot = table_ptr->getInMemoryMetadataPtr(session_context, false);

for (const NameAndTypePair & column : metadata_snapshot->getColumns().getAll())

{

/// Report the same type, charset and flags as result-set metadata (`getColumnDefinition`) does

/// for this column, so `COM_FIELD_LIST` and a plain `SELECT` describe the column identically:

/// string columns as `utf8mb4_0900_ai_ci` strings (matching the handshake collation),

/// numeric and other non-string columns as `binary` with their native wire types.

ColumnDefinition type_definition = getColumnDefinition(column.name, column.type);

ColumnDefinition column_definition(

database, packet.table, packet.table, column.name, column.name,

type_definition.character_set, type_definition.column_length, type_definition.column_type,

type_definition.flags, type_definition.decimals, true

);

packet_endpoint->sendPacket(column_definition);

}

packet_endpoint->sendPacket(OKPacket(0xfe, client_capabilities, 0, 0, 0));

{

String query = String(payload.position(), payload.buffer().end());

// This is a workaround in order to support adding ClickHouse to MySQL using federated server.

// As ClickHouse doesn't support these statements, we just send OK packet in response.

if (isFederatedServerSetupSetCommand(query))

{

packet_endpoint->sendPacket(OKPacket(0x00, client_capabilities, 0, 0, 0));

}

else

{

String replacement_query;

bool should_replace = false;

bool with_output = false;

// Queries replacements

for (auto const & [query_to_replace, replacement_fn] : queries_replacements)

{

if (checkShouldReplaceQuery(query, query_to_replace))

{

should_replace = true;

replacement_query = replacement_fn(query);

break;

}

}

// Settings replacements

if (!should_replace)

{

for (auto const & [mysql_setting, clickhouse_setting] : settings_replacements)

{

const auto replacement_query_opt = setSettingReplacementQuery(query, mysql_setting, clickhouse_setting);

if (replacement_query_opt.has_value())

{

should_replace = true;

replacement_query = replacement_query_opt.value();

break;

}

}

}

auto query_context = session->makeQueryContext();

query_context->setCurrentQueryId(fmt::format("mysql:{}:{}", connection_id, toString(UUIDHelpers::generateV4())));

/// --- Workaround for Bug 56173.

auto settings = query_context->getSettingsCopy();

if (!settings[Setting::allow_experimental_analyzer])

{

settings[Setting::prefer_column_name_to_alias] = true;

query_context->setSettings(settings);

}

/// Update timeouts

socket().setReceiveTimeout(settings[Setting::receive_timeout]);

socket().setSendTimeout(settings[Setting::send_timeout]);

QueryScope query_scope = QueryScope::create(query_context);

std::atomic<size_t> affected_rows {0};

auto prev = query_context->getProgressCallback();

query_context->setProgressCallback([&, my_prev = prev](const Progress & progress)

{

if (my_prev)

my_prev(progress);

affected_rows += progress.written_rows;

});

FormatSettings format_settings;

format_settings.mysql_wire.client_capabilities = client_capabilities;

format_settings.mysql_wire.max_packet_size = max_packet_size;

format_settings.mysql_wire.sequence_id = &sequence_id;

format_settings.mysql_wire.binary_protocol = binary_protocol;

auto set_result_details = [&with_output](const QueryResultDetails & details)

{

if (details.format)

{

if (*details.format != "MySQLWire")

throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "MySQL protocol does not support custom output formats");

with_output = true;

}

};

if (should_replace)

{

ReadBufferFromString replacement(replacement_query);

executeQuery(replacement, *out, query_context, set_result_details, QueryFlags{}, format_settings);

}

else

executeQuery(payload, *out, query_context, set_result_details, QueryFlags{}, format_settings);

if (!with_output)

packet_endpoint->sendPacket(OKPacket(0x00, client_capabilities, affected_rows, 0, 0));

}

{

String statement;

readStringUntilEOF(statement, payload);

auto statement_id_opt = emplacePreparedStatement(std::move(statement));

if (statement_id_opt.has_value())

packet_endpoint->sendPacket(PreparedStatementResponseOK(statement_id_opt.value(), 0, 0, 0));

else

packet_endpoint->sendPacket(ERRPacket());

{

uint32_t statement_id = 0;

payload.readStrict(reinterpret_cast<char *>(&statement_id), 4);

auto statement_opt = getPreparedStatement(statement_id);

if (statement_opt.has_value())

MySQLHandler::comQuery(statement_opt.value(), true);

else

packet_endpoint->sendPacket(ERRPacket());

{

uint32_t statement_id = 0;

payload.readStrict(reinterpret_cast<char *>(&statement_id), 4);

// https://dev.mysql.com/doc/dev/mysql-server/latest/page_protocol_com_stmt_close.html

// No response packet is sent back to the client.

erasePreparedStatement(statement_id);

{

static constexpr size_t MAX_PREPARED_STATEMENTS = 10'000;

std::lock_guard<std::mutex> lock(prepared_statements_mutex);

if (prepared_statements.size() > MAX_PREPARED_STATEMENTS) /// Shouldn't happen in reality as COM_STMT_CLOSE cleans up the elements

{

LOG_ERROR(log, "Too many prepared statements");

current_prepared_statement_id = 0;

prepared_statements.clear();

return {};

}

uint32_t statement_id = current_prepared_statement_id;

++current_prepared_statement_id;

// Key collisions should not happen here, as we remove the elements from the map with COM_STMT_CLOSE,

// and we have quite a big range of available identifiers with 32-bit unsigned integer

if (prepared_statements.contains(statement_id))

{

LOG_ERROR(

log,

"Failed to store a new statement `{}` with id {}; it is already taken by `{}`",

statement,

statement_id,

prepared_statements.at(statement_id));

return {};

}

prepared_statements.emplace(statement_id, statement);