{

Client() = default;

using StringSet = std::unordered_set<String>;

StringSet exit_strings

{

"exit", "quit", "logout",

"учше", "йгше", "дщпщге",

"exit;", "quit;", "logout;",

"учшеж", "йгшеж", "дщпщгеж",

"q", "й", "\\q", "\\Q", "\\й", "\\Й", ":q", "Жй"

};

bool is_interactive = true; /// Use either interactive line editing interface or batch mode.

bool need_render_progress = true; /// Render query execution progress.

bool send_logs = false; /// send_logs_level passed, do not use previous cursor position, to avoid overlaps with logs

bool echo_queries = false; /// Print queries before execution in batch mode.

bool ignore_error = false; /// In case of errors, don't print error message, continue to next query. Only applicable for non-interactive mode.

bool print_time_to_stderr = false; /// Output execution time to stderr in batch mode.

bool stdin_is_a_tty = false; /// stdin is a terminal.

bool stdout_is_a_tty = false; /// stdout is a terminal.

std::unique_ptr<Connection> connection; /// Connection to DB.

String query_id; /// Current query_id.

String query; /// Current query.

String format; /// Query results output format.

bool is_default_format = true; /// false, if format is set in the config or command line.

size_t format_max_block_size = 0; /// Max block size for console output.

String insert_format; /// Format of INSERT data that is read from stdin in batch mode.

size_t insert_format_max_block_size = 0; /// Max block size when reading INSERT data.

size_t max_client_network_bandwidth = 0; /// The maximum speed of data exchange over the network for the client in bytes per second.

bool has_vertical_output_suffix = false; /// Is \G present at the end of the query string?

SharedContextHolder shared_context = Context::createShared();

Context context = Context::createGlobal(shared_context.get());

/// Buffer that reads from stdin in batch mode.

ReadBufferFromFileDescriptor std_in {STDIN_FILENO};

/// Console output.

WriteBufferFromFileDescriptor std_out {STDOUT_FILENO};

std::unique_ptr<ShellCommand> pager_cmd;

/// The user can specify to redirect query output to a file.

std::optional<WriteBufferFromFile> out_file_buf;

BlockOutputStreamPtr block_out_stream;

/// The user could specify special file for server logs (stderr by default)

std::unique_ptr<WriteBuffer> out_logs_buf;

String server_logs_file;

BlockOutputStreamPtr logs_out_stream;

String home_path;

String current_profile;

String prompt_by_server_display_name;

/// Path to a file containing command history.

String history_file;

/// How many rows have been read or written.

size_t processed_rows = 0;

/// Parsed query. Is used to determine some settings (e.g. format, output file).

ASTPtr parsed_query;

/// The last exception that was received from the server. Is used for the return code in batch mode.

std::unique_ptr<Exception> last_exception;

/// If the last query resulted in exception.

bool got_exception = false;

int expected_server_error = 0;

int expected_client_error = 0;

int actual_server_error = 0;

int actual_client_error = 0;

UInt64 server_revision = 0;

String server_version;

String server_display_name;

Stopwatch watch;

/// The server periodically sends information about how much data was read since last time.

Progress progress;

bool show_progress_bar = false;

size_t written_progress_chars = 0;

bool written_first_block = false;

/// External tables info.

std::list<ExternalTable> external_tables;

/// Dictionary with query parameters for prepared statements.

NameToNameMap query_parameters;

ConnectionParameters connection_parameters;

void initialize(Poco::Util::Application & self) override

{

Poco::Util::Application::initialize(self);

const char * home_path_cstr = getenv("HOME");

if (home_path_cstr)

home_path = home_path_cstr;

configReadClient(config(), home_path);

context.setApplicationType(Context::ApplicationType::CLIENT);

context.setQueryParameters(query_parameters);

/// settings and limits could be specified in config file, but passed settings has higher priority

for (const auto & setting : context.getSettingsRef())

{

const String & name = setting.getName().toString();

if (config().has(name) && !setting.isChanged())

context.setSetting(name, config().getString(name));

}

/// Set path for format schema files

if (config().has("format_schema_path"))

context.setFormatSchemaPath(Poco::Path(config().getString("format_schema_path")).toString());

}

int main(const std::vector<std::string> & /*args*/) override

{

try

{

return mainImpl();

}

catch (const Exception & e)

{

bool print_stack_trace = config().getBool("stacktrace", false);

std::string text = e.displayText();

/** If exception is received from server, then stack trace is embedded in message.

auto embedded_stack_trace_pos = text.find("Stack trace");

if (std::string::npos != embedded_stack_trace_pos && !print_stack_trace)

text.resize(embedded_stack_trace_pos);

std::cerr << "Code: " << e.code() << ". " << text << std::endl << std::endl;

/// Don't print the stack trace on the client if it was logged on the server.

/// Also don't print the stack trace in case of network errors.

if (print_stack_trace

&& e.code() != ErrorCodes::NETWORK_ERROR

&& std::string::npos == embedded_stack_trace_pos)

{

std::cerr << "Stack trace:" << std::endl

<< e.getStackTraceString();

}

/// If exception code isn't zero, we should return non-zero return code anyway.

return e.code() ? e.code() : -1;

}

catch (...)

{

std::cerr << getCurrentExceptionMessage(false) << std::endl;

return getCurrentExceptionCode();

}

}

/// Should we celebrate a bit?

static bool isNewYearMode()

{

time_t current_time = time(nullptr);

/// It's bad to be intrusive.

if (current_time % 3 != 0)

return false;

LocalDate now(current_time);

return (now.month() == 12 && now.day() >= 20)

|| (now.month() == 1 && now.day() <= 5);

}

static bool isChineseNewYearMode(const String & local_tz)

{

/// Days of Dec. 20 in Chinese calendar starting from year 2019 to year 2105

static constexpr UInt16 chineseNewYearIndicators[]

= {18275, 18659, 19014, 19368, 19752, 20107, 20491, 20845, 21199, 21583, 21937, 22292, 22676, 23030, 23414, 23768, 24122, 24506,

24860, 25215, 25599, 25954, 26308, 26692, 27046, 27430, 27784, 28138, 28522, 28877, 29232, 29616, 29970, 30354, 30708, 31062,

31446, 31800, 32155, 32539, 32894, 33248, 33632, 33986, 34369, 34724, 35078, 35462, 35817, 36171, 36555, 36909, 37293, 37647,

38002, 38386, 38740, 39095, 39479, 39833, 40187, 40571, 40925, 41309, 41664, 42018, 42402, 42757, 43111, 43495, 43849, 44233,

44587, 44942, 45326, 45680, 46035, 46418, 46772, 47126, 47510, 47865, 48249, 48604, 48958, 49342};

/// All time zone names are acquired from https://www.iana.org/time-zones

static constexpr const char * chineseNewYearTimeZoneIndicators[] = {

/// Time zones celebrating Chinese new year.

"Asia/Shanghai",

"Asia/Chongqing",

"Asia/Harbin",

"Asia/Urumqi",

"Asia/Hong_Kong",

"Asia/Chungking",

"Asia/Macao",

"Asia/Macau",

"Asia/Taipei",

"Asia/Singapore",

/// Time zones celebrating Chinese new year but with different festival names. Let's not print the message for now.

// "Asia/Brunei",

// "Asia/Ho_Chi_Minh",

// "Asia/Hovd",

// "Asia/Jakarta",

// "Asia/Jayapura",

// "Asia/Kashgar",

// "Asia/Kuala_Lumpur",

// "Asia/Kuching",

// "Asia/Makassar",

// "Asia/Pontianak",

// "Asia/Pyongyang",

// "Asia/Saigon",

// "Asia/Seoul",

// "Asia/Ujung_Pandang",

// "Asia/Ulaanbaatar",

// "Asia/Ulan_Bator",

};

static constexpr size_t M = sizeof(chineseNewYearTimeZoneIndicators) / sizeof(chineseNewYearTimeZoneIndicators[0]);

time_t current_time = time(nullptr);

if (chineseNewYearTimeZoneIndicators + M

== std::find_if(chineseNewYearTimeZoneIndicators, chineseNewYearTimeZoneIndicators + M, [&local_tz](const char * tz)

{

return tz == local_tz;

}))

return false;

/// It's bad to be intrusive.

if (current_time % 3 != 0)

return false;

auto days = DateLUT::instance().toDayNum(current_time).toUnderType();

for (auto d : chineseNewYearIndicators)

{

/// Let's celebrate until Lantern Festival

if (d <= days && d + 25u >= days)

return true;

else if (d > days)

return false;

}

return false;

}

int mainImpl()

{

UseSSL use_ssl;

registerFunctions();

registerAggregateFunctions();

/// Batch mode is enabled if one of the following is true:

/// - -e (--query) command line option is present.

/// The value of the option is used as the text of query (or of multiple queries).

/// If stdin is not a terminal, INSERT data for the first query is read from it.

/// - stdin is not a terminal. In this case queries are read from it.

if (!stdin_is_a_tty || config().has("query"))

is_interactive = false;

std::cout << std::fixed << std::setprecision(3);

std::cerr << std::fixed << std::setprecision(3);

if (is_interactive)

showClientVersion();

is_default_format = !config().has("vertical") && !config().has("format");

if (config().has("vertical"))

format = config().getString("format", "Vertical");

else

format = config().getString("format", is_interactive ? "PrettyCompact" : "TabSeparated");

format_max_block_size = config().getInt("format_max_block_size", context.getSettingsRef().max_block_size);

insert_format = "Values";

/// Setting value from cmd arg overrides one from config

if (context.getSettingsRef().max_insert_block_size.changed)

insert_format_max_block_size = context.getSettingsRef().max_insert_block_size;

else

insert_format_max_block_size = config().getInt("insert_format_max_block_size", context.getSettingsRef().max_insert_block_size);

if (!is_interactive)

{

need_render_progress = config().getBool("progress", false);

echo_queries = config().getBool("echo", false);

ignore_error = config().getBool("ignore-error", false);

}

connect();

/// Initialize DateLUT here to avoid counting time spent here as query execution time.

const auto local_tz = DateLUT::instance().getTimeZone();

if (!context.getSettingsRef().use_client_time_zone)

{

const auto & time_zone = connection->getServerTimezone(connection_parameters.timeouts);

if (!time_zone.empty())

{

try

{

DateLUT::setDefaultTimezone(time_zone);

}

catch (...)

{

std::cerr << "Warning: could not switch to server time zone: " << time_zone

<< ", reason: " << getCurrentExceptionMessage(/* with_stacktrace = */ false) << std::endl

<< "Proceeding with local time zone."

<< std::endl << std::endl;

}

}

else

{

std::cerr << "Warning: could not determine server time zone. "

<< "Proceeding with local time zone."

<< std::endl << std::endl;

}

}

Strings keys;

prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name.default", "{display_name} :) ");

config().keys("prompt_by_server_display_name", keys);

for (const String & key : keys)

{

if (key != "default" && server_display_name.find(key) != std::string::npos)

{

prompt_by_server_display_name = config().getRawString("prompt_by_server_display_name." + key);

break;

}

}

/// Prompt may contain escape sequences including \e[ or \x1b[ sequences to set terminal color.

{

String unescaped_prompt_by_server_display_name;

ReadBufferFromString in(prompt_by_server_display_name);

readEscapedString(unescaped_prompt_by_server_display_name, in);

prompt_by_server_display_name = std::move(unescaped_prompt_by_server_display_name);

}

/// Prompt may contain the following substitutions in a form of {name}.

std::map<String, String> prompt_substitutions

{

{"host", connection_parameters.host},

{"port", toString(connection_parameters.port)},

{"user", connection_parameters.user},

{"display_name", server_display_name},

};

/// Quite suboptimal.

for (const auto & [key, value]: prompt_substitutions)

boost::replace_all(prompt_by_server_display_name, "{" + key + "}", value);

if (is_interactive)

{

if (!query_id.empty())

throw Exception("query_id could be specified only in non-interactive mode", ErrorCodes::BAD_ARGUMENTS);

if (print_time_to_stderr)

throw Exception("time option could be specified only in non-interactive mode", ErrorCodes::BAD_ARGUMENTS);

if (server_revision >= Suggest::MIN_SERVER_REVISION && !config().getBool("disable_suggestion", false))

{

/// Load suggestion data from the server.

Suggest::instance().load(connection_parameters, config().getInt("suggestion_limit"));

}

/// Load command history if present.

if (config().has("history_file"))

history_file = config().getString("history_file");

else

{

auto history_file_from_env = getenv("CLICKHOUSE_HISTORY_FILE");

if (history_file_from_env)

history_file = history_file_from_env;

else if (!home_path.empty())

history_file = home_path + "/.clickhouse-client-history";

}

if (!history_file.empty() && !Poco::File(history_file).exists())

Poco::File(history_file).createFile();

#if USE_REPLXX

ReplxxLineReader lr(Suggest::instance(), history_file, '\\', config().has("multiline") ? ';' : 0);

#elif defined(USE_READLINE) && USE_READLINE

ReadlineLineReader lr(Suggest::instance(), history_file, '\\', config().has("multiline") ? ';' : 0);

#else

LineReader lr(history_file, '\\', config().has("multiline") ? ';' : 0);

#endif

/// Enable bracketed-paste-mode only when multiquery is enabled and multiline is

/// disabled, so that we are able to paste and execute multiline queries in a whole

/// instead of erroring out, while be less intrusive.

if (config().has("multiquery") && !config().has("multiline"))

lr.enableBracketedPaste();

do

{

auto input = lr.readLine(prompt(), ":-] ");

if (input.empty())

break;

has_vertical_output_suffix = false;

if (input.ends_with("\\G"))

{

input.resize(input.size() - 2);

has_vertical_output_suffix = true;

}

try

{

if (!process(input))

break;

}

catch (const Exception & e)

{

actual_client_error = e.code();

if (!actual_client_error || actual_client_error != expected_client_error)

{

std::cerr << std::endl

<< "Exception on client:" << std::endl

<< "Code: " << e.code() << ". " << e.displayText() << std::endl;

if (config().getBool("stacktrace", false))

std::cerr << "Stack trace:" << std::endl << e.getStackTraceString() << std::endl;

std::cerr << std::endl;

}

/// Client-side exception during query execution can result in the loss of

/// sync in the connection protocol.

/// So we reconnect and allow to enter the next query.

connect();

}

}

while (true);

if (isNewYearMode())

std::cout << "Happy new year." << std::endl;

else if (isChineseNewYearMode(local_tz))

std::cout << "Happy Chinese new year. 春节快乐!" << std::endl;

else

std::cout << "Bye." << std::endl;

return 0;

}

else

{

query_id = config().getString("query_id", "");

nonInteractive();

/// If exception code isn't zero, we should return non-zero return code anyway.

if (last_exception)

return last_exception->code() != 0 ? last_exception->code() : -1;

return 0;

}

}

void connect()

{

connection_parameters = ConnectionParameters(config());

if (is_interactive)

std::cout << "Connecting to "

<< (!connection_parameters.default_database.empty() ? "database " + connection_parameters.default_database + " at " : "")

<< connection_parameters.host << ":" << connection_parameters.port

<< (!connection_parameters.user.empty() ? " as user " + connection_parameters.user : "")

<< "." << std::endl;

connection = std::make_unique<Connection>(

connection_parameters.host,

connection_parameters.port,

connection_parameters.default_database,

connection_parameters.user,

connection_parameters.password,

"client",

connection_parameters.compression,

connection_parameters.security);

String server_name;

UInt64 server_version_major = 0;

UInt64 server_version_minor = 0;

UInt64 server_version_patch = 0;

if (max_client_network_bandwidth)

{

ThrottlerPtr throttler = std::make_shared<Throttler>(max_client_network_bandwidth, 0, "");

connection->setThrottler(throttler);

}

connection->getServerVersion(connection_parameters.timeouts,

server_name, server_version_major, server_version_minor, server_version_patch, server_revision);

server_version = toString(server_version_major) + "." + toString(server_version_minor) + "." + toString(server_version_patch);

if (

server_display_name = connection->getServerDisplayName(connection_parameters.timeouts);

server_display_name.length() == 0)

{

server_display_name = config().getString("host", "localhost");

}

if (is_interactive)

{

std::cout << "Connected to " << server_name

<< " server version " << server_version

<< " revision " << server_revision

<< "." << std::endl << std::endl;

auto client_version_tuple = std::make_tuple(VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH);

auto server_version_tuple = std::make_tuple(server_version_major, server_version_minor, server_version_patch);

if (client_version_tuple < server_version_tuple)

{

std::cout << "ClickHouse client version is older than ClickHouse server. "

<< "It may lack support for new features."

<< std::endl << std::endl;

}

else if (client_version_tuple > server_version_tuple)

{

std::cout << "ClickHouse server version is older than ClickHouse client. "

<< "It may indicate that the server is out of date and can be upgraded."

<< std::endl << std::endl;

}

}

}

inline String prompt() const

{

return boost::replace_all_copy(prompt_by_server_display_name, "{database}", config().getString("database", "default"));

}

void nonInteractive()

{

String text;

if (config().has("query"))

text = config().getRawString("query"); /// Poco configuration should not process substitutions in form of ${...} inside query.

else

{

/// If 'query' parameter is not set, read a query from stdin.

/// The query is read entirely into memory (streaming is disabled).

ReadBufferFromFileDescriptor in(STDIN_FILENO);

readStringUntilEOF(text, in);

}

process(text);

}

bool process(const String & text)

{

if (exit_strings.end() != exit_strings.find(trim(text, [](char c){ return isWhitespaceASCII(c) || c == ';'; })))

return false;

const bool test_mode = config().has("testmode");

if (config().has("multiquery"))

{

{ /// disable logs if expects errors

TestHint test_hint(test_mode, text);

if (test_hint.clientError() || test_hint.serverError())

process("SET send_logs_level = 'none'");

}

/// Several queries separated by ';'.

/// INSERT data is ended by the end of line, not ';'.

const char * begin = text.data();

const char * end = begin + text.size();

while (begin < end)

{

const char * pos = begin;

ASTPtr ast = parseQuery(pos, end, true);

if (!ast)

{

if (ignore_error)

{

Tokens tokens(begin, end);

IParser::Pos token_iterator(tokens, context.getSettingsRef().max_parser_depth);

while (token_iterator->type != TokenType::Semicolon && token_iterator.isValid())

++token_iterator;

begin = token_iterator->end;

continue;

}

return true;

}

auto * insert = ast->as<ASTInsertQuery>();

if (insert && insert->data)

{

pos = find_first_symbols<'\n'>(insert->data, end);

insert->end = pos;

}

String str = text.substr(begin - text.data(), pos - begin);

begin = pos;

while (isWhitespaceASCII(*begin) || *begin == ';')

++begin;

TestHint test_hint(test_mode, str);

expected_client_error = test_hint.clientError();

expected_server_error = test_hint.serverError();

try

{

auto ast_to_process = ast;

if (insert && insert->data)

ast_to_process = nullptr;

if (!processSingleQuery(str, ast_to_process) && !ignore_error)

return false;

}

catch (...)

{

last_exception = std::make_unique<Exception>(getCurrentExceptionMessage(true), getCurrentExceptionCode());

actual_client_error = last_exception->code();

if (!ignore_error && (!actual_client_error || actual_client_error != expected_client_error))

std::cerr << "Error on processing query: " << str << std::endl << last_exception->message();

got_exception = true;

}

if (!test_hint.checkActual(actual_server_error, actual_client_error, got_exception, last_exception))

connection->forceConnected(connection_parameters.timeouts);

if (got_exception && !ignore_error)

{

if (is_interactive)

break;

else

return false;

}

}

return true;

}

else

{

return processSingleQuery(text);

}

}

bool processSingleQuery(const String & line, ASTPtr parsed_query_ = nullptr)

{

resetOutput();

got_exception = false;

if (echo_queries)

{

writeString(line, std_out);

writeChar('\n', std_out);

std_out.next();

}

watch.restart();

query = line;

/// Some parts of a query (result output and formatting) are executed client-side.

/// Thus we need to parse the query.

parsed_query = parsed_query_;

if (!parsed_query)

{

const char * begin = query.data();

parsed_query = parseQuery(begin, begin + query.size(), false);

}

if (!parsed_query)

return true;

processed_rows = 0;

progress.reset();

show_progress_bar = false;

written_progress_chars = 0;

written_first_block = false;

{

/// Temporarily apply query settings to context.

std::optional<Settings> old_settings;

SCOPE_EXIT({ if (old_settings) context.setSettings(*old_settings); });

auto apply_query_settings = [&](const IAST & settings_ast)

{

if (!old_settings)

old_settings.emplace(context.getSettingsRef());

context.applySettingsChanges(settings_ast.as<ASTSetQuery>()->changes);

};

const auto * insert = parsed_query->as<ASTInsertQuery>();

if (insert && insert->settings_ast)

apply_query_settings(*insert->settings_ast);

/// FIXME: try to prettify this cast using `as<>()`

const auto * with_output = dynamic_cast<const ASTQueryWithOutput *>(parsed_query.get());

if (with_output && with_output->settings_ast)

apply_query_settings(*with_output->settings_ast);

connection->forceConnected(connection_parameters.timeouts);

send_logs = context.getSettingsRef().send_logs_level != LogsLevel::none;

ASTPtr input_function;

if (insert && insert->select)

insert->tryFindInputFunction(input_function);

/// INSERT query for which data transfer is needed (not an INSERT SELECT or input()) is processed separately.

if (insert && (!insert->select || input_function) && !insert->watch)

{

if (input_function && insert->format.empty())

throw Exception("FORMAT must be specified for function input()", ErrorCodes::INVALID_USAGE_OF_INPUT);

processInsertQuery();

}

else

processOrdinaryQuery();

}

/// Do not change context (current DB, settings) in case of an exception.

if (!got_exception)

{

if (const auto * set_query = parsed_query->as<ASTSetQuery>())

{

/// Save all changes in settings to avoid losing them if the connection is lost.

for (const auto & change : set_query->changes)

{

if (change.name == "profile")

current_profile = change.value.safeGet<String>();

else

context.applySettingChange(change);

}

}

if (const auto * use_query = parsed_query->as<ASTUseQuery>())

{

const String & new_database = use_query->database;

/// If the client initiates the reconnection, it takes the settings from the config.

config().setString("database", new_database);

/// If the connection initiates the reconnection, it uses its variable.

connection->setDefaultDatabase(new_database);

}

}

if (is_interactive)

{

std::cout << std::endl

<< processed_rows << " rows in set. Elapsed: " << watch.elapsedSeconds() << " sec. ";

if (progress.read_rows >= 1000)

writeFinalProgress();

std::cout << std::endl << std::endl;

}

else if (print_time_to_stderr)

{

std::cerr << watch.elapsedSeconds() << "\n";

}

return true;

}

/// Convert external tables to ExternalTableData and send them using the connection.

void sendExternalTables()

{

const auto * select = parsed_query->as<ASTSelectWithUnionQuery>();

if (!select && !external_tables.empty())

throw Exception("External tables could be sent only with select query", ErrorCodes::BAD_ARGUMENTS);

std::vector<ExternalTableDataPtr> data;

for (auto & table : external_tables)

data.emplace_back(table.getData(context));

connection->sendExternalTablesData(data);

}

/// Process the query that doesn't require transferring data blocks to the server.

void processOrdinaryQuery()

{

/// We will always rewrite query (even if there are no query_parameters) because it will help to find errors in query formatter.

{

/// Replace ASTQueryParameter with ASTLiteral for prepared statements.

ReplaceQueryParameterVisitor visitor(query_parameters);

visitor.visit(parsed_query);

/// Get new query after substitutions. Note that it cannot be done for INSERT query with embedded data.

query = serializeAST(*parsed_query);

}

static constexpr size_t max_retries = 10;

for (size_t retry = 0; retry < max_retries; ++retry)

{

try

{

connection->sendQuery(

connection_parameters.timeouts,

query,

query_id,

QueryProcessingStage::Complete,

&context.getSettingsRef(),

nullptr,

true);

sendExternalTables();

receiveResult();

break;

}

catch (const Exception & e)

{

/// Retry when the server said "Client should retry" and no rows has been received yet.

if (processed_rows == 0 && e.code() == ErrorCodes::DEADLOCK_AVOIDED && retry + 1 < max_retries)

continue;

throw;

}

}

}

/// Process the query that requires transferring data blocks to the server.

void processInsertQuery()

{

/// Send part of query without data, because data will be sent separately.

const auto & parsed_insert_query = parsed_query->as<ASTInsertQuery &>();

String query_without_data = parsed_insert_query.data

? query.substr(0, parsed_insert_query.data - query.data())

: query;

if (!parsed_insert_query.data && (is_interactive || (!stdin_is_a_tty && std_in.eof())))

throw Exception("No data to insert", ErrorCodes::NO_DATA_TO_INSERT);

connection->sendQuery(connection_parameters.timeouts, query_without_data, query_id, QueryProcessingStage::Complete, &context.getSettingsRef(), nullptr, true);

sendExternalTables();

/// Receive description of table structure.

Block sample;

ColumnsDescription columns_description;

if (receiveSampleBlock(sample, columns_description))

{

/// If structure was received (thus, server has not thrown an exception),

/// send our data with that structure.

sendData(sample, columns_description);

receiveEndOfQuery();

}

}

ASTPtr parseQuery(const char * & pos, const char * end, bool allow_multi_statements)

{

ParserQuery parser(end, true);

ASTPtr res;

const auto & settings = context.getSettingsRef();

size_t max_length = 0;

if (!allow_multi_statements)

max_length = settings.max_query_size;

if (is_interactive || ignore_error)

{

String message;

res = tryParseQuery(parser, pos, end, message, true, "", allow_multi_statements, max_length, settings.max_parser_depth);

if (!res)

{

std::cerr << std::endl << message << std::endl << std::endl;

return nullptr;

}

}

else

res = parseQueryAndMovePosition(parser, pos, end, "", allow_multi_statements, max_length, settings.max_parser_depth);

if (is_interactive)

{

std::cout << std::endl;

formatAST(*res, std::cout);

std::cout << std::endl << std::endl;

}

return res;

}

void sendData(Block & sample, const ColumnsDescription & columns_description)