2012-03-09 15:46:52 +00:00
|
|
|
#pragma once
|
|
|
|
|
2017-08-09 14:33:07 +00:00
|
|
|
#include <Poco/Net/TCPServerConnection.h>
|
|
|
|
|
2021-10-02 07:13:14 +00:00
|
|
|
#include <base/getFQDNOrHostName.h>
|
2022-02-15 08:25:07 +00:00
|
|
|
#include <Common/ProfileEvents.h>
|
2017-08-09 14:33:07 +00:00
|
|
|
#include <Common/CurrentMetrics.h>
|
|
|
|
#include <Common/Stopwatch.h>
|
2022-02-15 08:25:07 +00:00
|
|
|
#include <Common/ThreadStatus.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Core/Protocol.h>
|
|
|
|
#include <Core/QueryProcessingStage.h>
|
2018-06-15 17:32:35 +00:00
|
|
|
#include <IO/Progress.h>
|
2021-03-03 17:47:27 +00:00
|
|
|
#include <IO/TimeoutSetter.h>
|
2021-10-15 20:18:20 +00:00
|
|
|
#include <QueryPipeline/BlockIO.h>
|
2018-06-15 17:32:35 +00:00
|
|
|
#include <Interpreters/InternalTextLogsQueue.h>
|
2021-03-05 14:57:16 +00:00
|
|
|
#include <Interpreters/Context_fwd.h>
|
2022-02-15 08:25:07 +00:00
|
|
|
#include <Interpreters/ProfileEventsExt.h>
|
2012-03-09 15:46:52 +00:00
|
|
|
|
2021-12-09 10:39:28 +00:00
|
|
|
#include <Storages/MergeTree/ParallelReplicasReadingCoordinator.h>
|
|
|
|
|
2017-08-09 14:33:07 +00:00
|
|
|
#include "IServer.h"
|
2021-11-08 09:40:31 +00:00
|
|
|
#include "base/types.h"
|
2018-06-06 20:57:07 +00:00
|
|
|
|
2012-03-09 15:46:52 +00:00
|
|
|
|
2016-10-24 04:06:27 +00:00
|
|
|
namespace CurrentMetrics
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
extern const Metric TCPConnection;
|
2016-10-24 04:06:27 +00:00
|
|
|
}
|
|
|
|
|
2017-09-01 19:04:46 +00:00
|
|
|
namespace Poco { class Logger; }
|
2016-10-24 04:06:27 +00:00
|
|
|
|
2012-03-09 15:46:52 +00:00
|
|
|
namespace DB
|
|
|
|
{
|
|
|
|
|
2021-03-05 14:57:16 +00:00
|
|
|
class Session;
|
2021-08-01 14:12:34 +00:00
|
|
|
struct Settings;
|
2019-03-15 18:52:45 +00:00
|
|
|
class ColumnsDescription;
|
2021-10-15 20:18:20 +00:00
|
|
|
struct ProfileInfo;
|
2021-10-22 07:15:34 +00:00
|
|
|
class TCPServer;
|
2022-02-15 08:25:07 +00:00
|
|
|
class NativeWriter;
|
|
|
|
class NativeReader;
|
2012-03-11 08:52:56 +00:00
|
|
|
|
2016-07-07 01:57:48 +00:00
|
|
|
/// State of query processing.
|
2012-03-11 08:52:56 +00:00
|
|
|
struct QueryState
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
/// Identifier of the query.
|
|
|
|
String query_id;
|
|
|
|
|
|
|
|
QueryProcessingStage::Enum stage = QueryProcessingStage::Complete;
|
2017-10-03 14:52:08 +00:00
|
|
|
Protocol::Compression compression = Protocol::Compression::Disable;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2019-07-04 16:21:24 +00:00
|
|
|
/// A queue with internal logs that will be passed to client. It must be
|
|
|
|
/// destroyed after input/output blocks, because they may contain other
|
|
|
|
/// threads that use this queue.
|
|
|
|
InternalTextLogsQueuePtr logs_queue;
|
2021-10-08 17:21:19 +00:00
|
|
|
std::unique_ptr<NativeWriter> logs_block_out;
|
2019-07-04 16:21:24 +00:00
|
|
|
|
2021-09-02 14:27:19 +00:00
|
|
|
InternalProfileEventsQueuePtr profile_queue;
|
2021-08-30 11:04:59 +00:00
|
|
|
std::unique_ptr<NativeWriter> profile_events_block_out;
|
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// From where to read data for INSERT.
|
|
|
|
std::shared_ptr<ReadBuffer> maybe_compressed_in;
|
2021-10-08 17:21:19 +00:00
|
|
|
std::unique_ptr<NativeReader> block_in;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
|
|
|
/// Where to write result data.
|
|
|
|
std::shared_ptr<WriteBuffer> maybe_compressed_out;
|
2021-10-08 17:21:19 +00:00
|
|
|
std::unique_ptr<NativeWriter> block_out;
|
2021-09-02 11:29:20 +00:00
|
|
|
Block block_for_insert;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
|
|
|
/// Query text.
|
|
|
|
String query;
|
|
|
|
/// Streams of blocks, that are processing the query.
|
|
|
|
BlockIO io;
|
|
|
|
|
|
|
|
/// Is request cancelled
|
|
|
|
bool is_cancelled = false;
|
2020-10-24 03:41:47 +00:00
|
|
|
bool is_connection_closed = false;
|
2017-04-01 07:20:54 +00:00
|
|
|
/// empty or not
|
|
|
|
bool is_empty = true;
|
|
|
|
/// Data was sent.
|
|
|
|
bool sent_all_data = false;
|
|
|
|
/// Request requires data from the client (INSERT, but not INSERT SELECT).
|
|
|
|
bool need_receive_data_for_insert = false;
|
2021-08-01 14:12:34 +00:00
|
|
|
/// Data was read.
|
|
|
|
bool read_all_data = false;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2020-11-20 17:23:53 +00:00
|
|
|
/// A state got uuids to exclude from a query
|
2021-08-01 14:12:34 +00:00
|
|
|
std::optional<std::vector<UUID>> part_uuids_to_ignore;
|
2020-11-20 17:23:53 +00:00
|
|
|
|
2019-05-28 18:30:10 +00:00
|
|
|
/// Request requires data from client for function input()
|
|
|
|
bool need_receive_data_for_input = false;
|
|
|
|
/// temporary place for incoming data block for input()
|
|
|
|
Block block_for_input;
|
|
|
|
/// sample block from StorageInput
|
|
|
|
Block input_header;
|
|
|
|
|
2021-08-01 14:12:34 +00:00
|
|
|
/// If true, the data packets will be skipped instead of reading. Used to recover after errors.
|
|
|
|
bool skipping_data = false;
|
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// To output progress, the difference after the previous sending of progress.
|
|
|
|
Progress progress;
|
|
|
|
|
2018-03-28 14:07:28 +00:00
|
|
|
/// Timeouts setter for current query
|
|
|
|
std::unique_ptr<TimeoutSetter> timeout_setter;
|
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
void reset()
|
|
|
|
{
|
|
|
|
*this = QueryState();
|
|
|
|
}
|
|
|
|
|
2021-03-16 18:41:29 +00:00
|
|
|
bool empty() const
|
2017-04-01 07:20:54 +00:00
|
|
|
{
|
|
|
|
return is_empty;
|
|
|
|
}
|
2012-03-11 08:52:56 +00:00
|
|
|
};
|
|
|
|
|
2019-09-03 13:55:26 +00:00
|
|
|
|
2019-09-03 09:36:16 +00:00
|
|
|
struct LastBlockInputParameters
|
|
|
|
{
|
|
|
|
Protocol::Compression compression = Protocol::Compression::Disable;
|
|
|
|
};
|
|
|
|
|
2012-03-09 15:46:52 +00:00
|
|
|
class TCPHandler : public Poco::Net::TCPServerConnection
|
|
|
|
{
|
|
|
|
public:
|
2020-12-02 21:05:51 +00:00
|
|
|
/** parse_proxy_protocol_ - if true, expect and parse the header of PROXY protocol in every connection
|
|
|
|
* and set the information about forwarded address accordingly.
|
|
|
|
* See https://github.com/wolfeidau/proxyv2/blob/master/docs/proxy-protocol.txt
|
2020-12-02 21:09:46 +00:00
|
|
|
*
|
|
|
|
* Note: immediate IP address is always used for access control (accept-list of IP networks),
|
|
|
|
* because it allows to check the IP ranges of the trusted proxy.
|
|
|
|
* Proxy-forwarded (original client) IP address is used for quota accounting if quota is keyed by forwarded IP.
|
2020-12-02 21:05:51 +00:00
|
|
|
*/
|
2021-10-22 07:15:34 +00:00
|
|
|
TCPHandler(IServer & server_, TCPServer & tcp_server_, const Poco::Net::StreamSocket & socket_, bool parse_proxy_protocol_, std::string server_display_name_);
|
2021-01-28 04:07:51 +00:00
|
|
|
~TCPHandler() override;
|
2012-03-09 15:46:52 +00:00
|
|
|
|
2020-01-21 08:54:26 +00:00
|
|
|
void run() override;
|
2012-03-09 15:46:52 +00:00
|
|
|
|
2019-03-06 16:41:35 +00:00
|
|
|
/// This method is called right before the query execution.
|
2021-06-01 09:27:05 +00:00
|
|
|
virtual void customizeContext(ContextMutablePtr /*context*/) {}
|
2019-03-06 16:41:35 +00:00
|
|
|
|
2012-03-09 15:46:52 +00:00
|
|
|
private:
|
2017-08-09 11:57:09 +00:00
|
|
|
IServer & server;
|
2021-10-22 07:15:34 +00:00
|
|
|
TCPServer & tcp_server;
|
2020-12-02 21:05:51 +00:00
|
|
|
bool parse_proxy_protocol = false;
|
2017-09-01 19:04:46 +00:00
|
|
|
Poco::Logger * log;
|
2012-03-09 15:46:52 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
String client_name;
|
|
|
|
UInt64 client_version_major = 0;
|
|
|
|
UInt64 client_version_minor = 0;
|
2018-07-31 21:36:18 +00:00
|
|
|
UInt64 client_version_patch = 0;
|
2020-09-17 12:15:05 +00:00
|
|
|
UInt64 client_tcp_protocol_version = 0;
|
2013-02-01 19:02:04 +00:00
|
|
|
|
2021-08-01 14:12:34 +00:00
|
|
|
/// Connection settings, which are extracted from a context.
|
|
|
|
bool send_exception_with_stack_trace = true;
|
|
|
|
Poco::Timespan send_timeout = DBMS_DEFAULT_SEND_TIMEOUT_SEC;
|
|
|
|
Poco::Timespan receive_timeout = DBMS_DEFAULT_RECEIVE_TIMEOUT_SEC;
|
|
|
|
UInt64 poll_interval = DBMS_DEFAULT_POLL_INTERVAL;
|
|
|
|
UInt64 idle_connection_timeout = 3600;
|
|
|
|
UInt64 interactive_delay = 100000;
|
|
|
|
Poco::Timespan sleep_in_send_tables_status;
|
|
|
|
UInt64 unknown_packet_in_send_data = 0;
|
|
|
|
Poco::Timespan sleep_in_receive_cancel;
|
|
|
|
|
2021-03-05 14:57:16 +00:00
|
|
|
std::unique_ptr<Session> session;
|
2021-05-31 14:49:02 +00:00
|
|
|
ContextMutablePtr query_context;
|
2012-05-17 19:15:53 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// Streams for reading/writing from/to client connection socket.
|
|
|
|
std::shared_ptr<ReadBuffer> in;
|
|
|
|
std::shared_ptr<WriteBuffer> out;
|
2012-05-21 06:49:05 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// Time after the last check to stop the request and send the progress.
|
|
|
|
Stopwatch after_check_cancelled;
|
|
|
|
Stopwatch after_send_progress;
|
2012-05-30 06:46:57 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
String default_database;
|
2012-12-06 17:32:48 +00:00
|
|
|
|
2020-09-14 21:55:43 +00:00
|
|
|
/// For inter-server secret (remote_server.*.secret)
|
2021-08-01 14:12:34 +00:00
|
|
|
bool is_interserver_mode = false;
|
2020-09-14 21:55:43 +00:00
|
|
|
String salt;
|
|
|
|
String cluster;
|
|
|
|
String cluster_secret;
|
|
|
|
|
2021-04-08 19:00:39 +00:00
|
|
|
std::mutex task_callback_mutex;
|
2021-12-12 02:35:33 +00:00
|
|
|
std::mutex fatal_error_mutex;
|
2020-09-14 21:55:43 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// At the moment, only one ongoing query in the connection is supported at a time.
|
|
|
|
QueryState state;
|
2012-12-06 17:32:48 +00:00
|
|
|
|
2019-09-03 09:36:16 +00:00
|
|
|
/// Last block input parameters are saved to be able to receive unexpected data packet sent after exception.
|
|
|
|
LastBlockInputParameters last_block_in;
|
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
CurrentMetrics::Increment metric_increment{CurrentMetrics::TCPConnection};
|
2018-05-07 02:01:11 +00:00
|
|
|
|
2022-02-15 08:25:07 +00:00
|
|
|
ProfileEvents::ThreadIdToCountersSnapshot last_sent_snapshots;
|
2021-11-08 09:40:31 +00:00
|
|
|
|
2018-05-07 02:01:11 +00:00
|
|
|
/// It is the name of the server that will be sent to the client.
|
2018-03-08 07:36:58 +00:00
|
|
|
String server_display_name;
|
2012-05-09 08:16:09 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
void runImpl();
|
2012-03-11 08:52:56 +00:00
|
|
|
|
2021-08-01 14:12:34 +00:00
|
|
|
void extractConnectionSettingsFromContext(const ContextPtr & context);
|
|
|
|
|
2020-12-02 21:05:51 +00:00
|
|
|
bool receiveProxyHeader();
|
2017-04-01 07:20:54 +00:00
|
|
|
void receiveHello();
|
|
|
|
bool receivePacket();
|
|
|
|
void receiveQuery();
|
2020-11-20 17:23:53 +00:00
|
|
|
void receiveIgnoredPartUUIDs();
|
2021-04-13 10:59:02 +00:00
|
|
|
String receiveReadTaskResponseAssumeLocked();
|
2021-12-09 10:39:28 +00:00
|
|
|
std::optional<PartitionReadResponse> receivePartitionMergeTreeReadTaskResponseAssumeLocked();
|
2019-10-19 20:36:35 +00:00
|
|
|
bool receiveData(bool scalar);
|
2021-08-01 14:12:34 +00:00
|
|
|
bool readDataNext();
|
|
|
|
void readData();
|
|
|
|
void skipData();
|
2021-04-10 02:35:07 +00:00
|
|
|
void receiveClusterNameAndSalt();
|
2012-05-17 19:15:53 +00:00
|
|
|
|
2021-08-01 14:12:34 +00:00
|
|
|
bool receiveUnexpectedData(bool throw_exception = true);
|
2019-09-03 09:36:16 +00:00
|
|
|
[[noreturn]] void receiveUnexpectedQuery();
|
2021-08-01 14:12:34 +00:00
|
|
|
[[noreturn]] void receiveUnexpectedIgnoredPartUUIDs();
|
2019-09-03 09:36:16 +00:00
|
|
|
[[noreturn]] void receiveUnexpectedHello();
|
2019-09-03 13:55:26 +00:00
|
|
|
[[noreturn]] void receiveUnexpectedTablesStatusRequest();
|
2019-09-03 09:36:16 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// Process INSERT query
|
2021-08-01 14:12:34 +00:00
|
|
|
void processInsertQuery();
|
2012-05-17 19:15:53 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// Process a request that does not require the receiving of data blocks from the client
|
|
|
|
void processOrdinaryQuery();
|
2012-03-11 08:52:56 +00:00
|
|
|
|
2020-03-15 21:22:55 +00:00
|
|
|
void processOrdinaryQueryWithProcessors();
|
2019-03-26 18:28:37 +00:00
|
|
|
|
2017-04-17 16:02:48 +00:00
|
|
|
void processTablesStatusRequest();
|
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
void sendHello();
|
2018-01-07 00:35:44 +00:00
|
|
|
void sendData(const Block & block); /// Write a block to the network.
|
2018-06-06 20:57:07 +00:00
|
|
|
void sendLogData(const Block & block);
|
2018-12-04 20:03:04 +00:00
|
|
|
void sendTableColumns(const ColumnsDescription & columns);
|
2018-08-24 07:30:53 +00:00
|
|
|
void sendException(const Exception & e, bool with_stack_trace);
|
2017-04-01 07:20:54 +00:00
|
|
|
void sendProgress();
|
2018-06-06 20:57:07 +00:00
|
|
|
void sendLogs();
|
2017-04-01 07:20:54 +00:00
|
|
|
void sendEndOfStream();
|
2020-11-20 17:23:53 +00:00
|
|
|
void sendPartUUIDs();
|
2021-04-10 02:21:18 +00:00
|
|
|
void sendReadTaskRequestAssumeLocked();
|
2022-01-07 16:03:46 +00:00
|
|
|
void sendMergeTreeReadTaskRequestAssumeLocked(PartitionReadRequest request);
|
2021-10-15 20:18:20 +00:00
|
|
|
void sendProfileInfo(const ProfileInfo & info);
|
2019-03-26 18:28:37 +00:00
|
|
|
void sendTotals(const Block & totals);
|
|
|
|
void sendExtremes(const Block & extremes);
|
2021-08-30 11:04:59 +00:00
|
|
|
void sendProfileEvents();
|
2013-09-05 20:22:43 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// Creates state.block_in/block_out for blocks read/write, depending on whether compression is enabled.
|
|
|
|
void initBlockInput();
|
2018-02-19 00:45:32 +00:00
|
|
|
void initBlockOutput(const Block & block);
|
2018-06-06 20:57:07 +00:00
|
|
|
void initLogsBlockOutput(const Block & block);
|
2021-08-30 11:04:59 +00:00
|
|
|
void initProfileEventsBlockOutput(const Block & block);
|
2012-05-09 08:16:09 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
bool isQueryCancelled();
|
2012-07-21 07:02:55 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
/// This function is called from different threads.
|
|
|
|
void updateProgress(const Progress & value);
|
2012-03-09 15:46:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|