2011-08-28 05:13:24 +00:00
|
|
|
#pragma once
|
|
|
|
|
2018-07-19 13:36:21 +00:00
|
|
|
#include <memory>
|
|
|
|
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Core/QueryProcessingStage.h>
|
|
|
|
#include <Interpreters/ExpressionActions.h>
|
2018-02-23 06:00:48 +00:00
|
|
|
#include <Interpreters/ExpressionAnalyzer.h>
|
2020-11-01 13:54:07 +00:00
|
|
|
#include <Interpreters/IInterpreterUnionOrSelectQuery.h>
|
2021-10-29 11:51:41 +00:00
|
|
|
#include <Interpreters/PreparedSets.h>
|
2020-11-01 13:54:07 +00:00
|
|
|
#include <Interpreters/StorageID.h>
|
|
|
|
#include <Parsers/ASTSelectQuery.h>
|
|
|
|
#include <Storages/ReadInOrderOptimizer.h>
|
2018-09-05 09:47:57 +00:00
|
|
|
#include <Storages/SelectQueryInfo.h>
|
2020-06-22 09:49:21 +00:00
|
|
|
#include <Storages/TableLockHolder.h>
|
2022-05-20 19:49:31 +00:00
|
|
|
#include <QueryPipeline/Pipe.h>
|
2011-08-28 05:13:24 +00:00
|
|
|
|
2019-10-27 18:12:40 +00:00
|
|
|
#include <Columns/FilterDescription.h>
|
2017-01-21 04:24:28 +00:00
|
|
|
|
2021-02-10 14:12:49 +00:00
|
|
|
namespace Poco
|
|
|
|
{
|
|
|
|
class Logger;
|
|
|
|
}
|
2017-01-21 04:24:28 +00:00
|
|
|
|
2011-08-28 05:13:24 +00:00
|
|
|
namespace DB
|
|
|
|
{
|
2022-07-19 10:28:21 +00:00
|
|
|
class SubqueryForSet;
|
2018-07-19 13:36:21 +00:00
|
|
|
class InterpreterSelectWithUnionQuery;
|
2020-05-20 20:16:32 +00:00
|
|
|
class Context;
|
2020-06-18 13:38:45 +00:00
|
|
|
class QueryPlan;
|
2015-05-06 23:35:37 +00:00
|
|
|
|
2022-05-10 16:12:03 +00:00
|
|
|
struct GroupingSetsParams;
|
|
|
|
using GroupingSetsParamsList = std::vector<GroupingSetsParams>;
|
|
|
|
|
2020-07-22 17:13:05 +00:00
|
|
|
struct TreeRewriterResult;
|
|
|
|
using TreeRewriterResultPtr = std::shared_ptr<const TreeRewriterResult>;
|
2015-05-06 23:35:37 +00:00
|
|
|
|
2019-03-15 13:49:58 +00:00
|
|
|
|
2017-06-02 21:37:28 +00:00
|
|
|
/** Interprets the SELECT query. Returns the stream of blocks with the results of the query before `to_stage` stage.
|
2011-08-28 05:13:24 +00:00
|
|
|
*/
|
2020-11-01 13:54:07 +00:00
|
|
|
class InterpreterSelectQuery : public IInterpreterUnionOrSelectQuery
|
2011-08-28 05:13:24 +00:00
|
|
|
{
|
|
|
|
public:
|
2017-11-05 17:48:50 +00:00
|
|
|
/**
|
|
|
|
* query_ptr
|
|
|
|
* - A query AST to interpret.
|
|
|
|
*
|
2018-02-27 19:00:55 +00:00
|
|
|
* required_result_column_names
|
2018-03-02 04:05:20 +00:00
|
|
|
* - don't calculate all columns except the specified ones from the query
|
|
|
|
* - it is used to remove calculation (and reading) of unnecessary columns from subqueries.
|
|
|
|
* empty means - use all columns.
|
2014-12-19 12:48:09 +00:00
|
|
|
*/
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2014-12-19 12:48:09 +00:00
|
|
|
InterpreterSelectQuery(
|
2017-05-23 18:24:43 +00:00
|
|
|
const ASTPtr & query_ptr_,
|
2022-07-05 22:47:00 +00:00
|
|
|
const ContextPtr & context_,
|
2019-03-15 13:49:58 +00:00
|
|
|
const SelectQueryOptions &,
|
2019-08-03 11:02:40 +00:00
|
|
|
const Names & required_result_column_names_ = Names{});
|
2018-07-17 13:09:33 +00:00
|
|
|
|
2022-05-30 08:57:51 +00:00
|
|
|
InterpreterSelectQuery(
|
|
|
|
const ASTPtr & query_ptr_,
|
2022-07-05 22:47:00 +00:00
|
|
|
const ContextMutablePtr & context_,
|
2022-05-30 08:57:51 +00:00
|
|
|
const SelectQueryOptions &,
|
|
|
|
const Names & required_result_column_names_ = Names{});
|
|
|
|
|
2020-01-29 15:04:46 +00:00
|
|
|
/// Read data not from the table specified in the query, but from the prepared pipe `input`.
|
|
|
|
InterpreterSelectQuery(
|
2021-06-03 14:05:37 +00:00
|
|
|
const ASTPtr & query_ptr_,
|
2022-07-05 22:47:00 +00:00
|
|
|
const ContextPtr & context_,
|
2021-06-03 14:05:37 +00:00
|
|
|
Pipe input_pipe_,
|
|
|
|
const SelectQueryOptions & = {});
|
2020-01-29 15:04:46 +00:00
|
|
|
|
2018-07-18 12:17:48 +00:00
|
|
|
/// Read data not from the table specified in the query, but from the specified `storage_`.
|
|
|
|
InterpreterSelectQuery(
|
|
|
|
const ASTPtr & query_ptr_,
|
2022-07-05 22:47:00 +00:00
|
|
|
const ContextPtr & context_,
|
2018-07-18 12:17:48 +00:00
|
|
|
const StoragePtr & storage_,
|
2020-06-17 11:52:19 +00:00
|
|
|
const StorageMetadataPtr & metadata_snapshot_ = nullptr,
|
2019-03-15 13:49:58 +00:00
|
|
|
const SelectQueryOptions & = {});
|
2018-07-18 12:17:48 +00:00
|
|
|
|
2022-07-18 15:53:30 +00:00
|
|
|
/// Reuse existing prepared_sets for another pass of analysis. It's used for projection.
|
2022-03-26 02:17:23 +00:00
|
|
|
/// TODO: Find a general way of sharing sets among different interpreters, such as subqueries.
|
2021-10-29 11:51:41 +00:00
|
|
|
InterpreterSelectQuery(
|
|
|
|
const ASTPtr & query_ptr_,
|
2022-07-05 22:47:00 +00:00
|
|
|
const ContextPtr & context_,
|
2021-10-29 11:51:41 +00:00
|
|
|
const SelectQueryOptions &,
|
2022-07-18 15:53:30 +00:00
|
|
|
PreparedSetsPtr prepared_sets_);
|
2021-10-29 11:51:41 +00:00
|
|
|
|
2018-06-03 20:39:06 +00:00
|
|
|
~InterpreterSelectQuery() override;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-02-25 00:50:53 +00:00
|
|
|
/// Execute a query. Get the stream of blocks to read.
|
2015-06-18 02:11:05 +00:00
|
|
|
BlockIO execute() override;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2020-06-18 17:45:00 +00:00
|
|
|
/// Builds QueryPlan for current query.
|
2022-07-05 20:55:19 +00:00
|
|
|
void buildQueryPlan(QueryPlan & query_plan) override;
|
2020-06-18 17:45:00 +00:00
|
|
|
|
2019-11-11 01:11:32 +00:00
|
|
|
bool ignoreLimits() const override { return options.ignore_limits; }
|
|
|
|
bool ignoreQuota() const override { return options.ignore_quota; }
|
|
|
|
|
2022-07-05 20:55:19 +00:00
|
|
|
void ignoreWithTotals() override;
|
2020-03-16 18:45:39 +00:00
|
|
|
|
2021-02-10 14:12:49 +00:00
|
|
|
ASTPtr getQuery() const { return query_ptr; }
|
|
|
|
|
2020-06-15 12:36:10 +00:00
|
|
|
const SelectQueryInfo & getQueryInfo() const { return query_info; }
|
|
|
|
|
2021-10-29 11:51:41 +00:00
|
|
|
SelectQueryExpressionAnalyzer * getQueryAnalyzer() const { return query_analyzer.get(); }
|
2021-04-21 16:00:27 +00:00
|
|
|
|
2021-04-22 17:04:12 +00:00
|
|
|
const ExpressionAnalysisResult & getAnalysisResult() const { return analysis_result; }
|
|
|
|
|
2021-02-10 14:12:49 +00:00
|
|
|
const Names & getRequiredColumns() const { return required_columns; }
|
|
|
|
|
|
|
|
bool hasAggregation() const { return query_analyzer->hasAggregation(); }
|
|
|
|
|
|
|
|
static void addEmptySourceToQueryPlan(
|
2022-07-06 12:59:25 +00:00
|
|
|
QueryPlan & query_plan, const Block & source_header, const SelectQueryInfo & query_info, const ContextPtr & context_);
|
2020-09-25 13:19:26 +00:00
|
|
|
|
2021-02-28 05:24:39 +00:00
|
|
|
Names getRequiredColumns() { return required_columns; }
|
|
|
|
|
2022-01-31 22:27:55 +00:00
|
|
|
bool supportsTransactions() const override { return true; }
|
|
|
|
|
2022-04-22 13:52:38 +00:00
|
|
|
/// This is tiny crutch to support reading from localhost replica during distributed query
|
|
|
|
/// Replica need to talk to the initiator through a connection to ask for a next task
|
|
|
|
/// but there will be no connection if we create Interpreter explicitly.
|
|
|
|
/// The other problem is that context is copied inside Interpreter's constructor
|
|
|
|
/// And with this method we can change the internals of cloned one
|
|
|
|
void setMergeTreeReadTaskCallbackAndClientInfo(MergeTreeReadTaskCallback && callback);
|
|
|
|
|
|
|
|
/// It will set shard_num and shard_count to the client_info
|
2022-06-02 09:46:33 +00:00
|
|
|
void setProperClientInfo(size_t replica_num, size_t replica_count);
|
2022-04-22 13:52:38 +00:00
|
|
|
|
2022-07-28 09:40:09 +00:00
|
|
|
FilterDAGInfoPtr getAdditionalQueryInfo() const { return additional_filter_info; }
|
|
|
|
|
2022-07-06 12:59:25 +00:00
|
|
|
static SortDescription getSortDescription(const ASTSelectQuery & query, const ContextPtr & context);
|
|
|
|
static UInt64 getLimitForSorting(const ASTSelectQuery & query, const ContextPtr & context);
|
2021-11-02 15:40:37 +00:00
|
|
|
|
2011-08-28 05:13:24 +00:00
|
|
|
private:
|
2018-07-17 13:09:33 +00:00
|
|
|
InterpreterSelectQuery(
|
|
|
|
const ASTPtr & query_ptr_,
|
2022-07-05 22:47:00 +00:00
|
|
|
const ContextPtr & context_,
|
2020-01-29 15:04:46 +00:00
|
|
|
std::optional<Pipe> input_pipe,
|
2018-07-17 13:09:33 +00:00
|
|
|
const StoragePtr & storage_,
|
2019-03-15 13:49:58 +00:00
|
|
|
const SelectQueryOptions &,
|
2020-06-17 11:52:19 +00:00
|
|
|
const Names & required_result_column_names = {},
|
2021-10-29 11:51:41 +00:00
|
|
|
const StorageMetadataPtr & metadata_snapshot_ = nullptr,
|
2022-07-18 15:53:30 +00:00
|
|
|
PreparedSetsPtr prepared_sets_ = nullptr);
|
2018-07-17 13:09:33 +00:00
|
|
|
|
2022-05-30 08:57:51 +00:00
|
|
|
InterpreterSelectQuery(
|
|
|
|
const ASTPtr & query_ptr_,
|
2022-07-05 22:47:00 +00:00
|
|
|
const ContextMutablePtr & context_,
|
2022-05-30 08:57:51 +00:00
|
|
|
std::optional<Pipe> input_pipe,
|
|
|
|
const StoragePtr & storage_,
|
|
|
|
const SelectQueryOptions &,
|
|
|
|
const Names & required_result_column_names = {},
|
|
|
|
const StorageMetadataPtr & metadata_snapshot_ = nullptr,
|
2022-07-18 15:53:30 +00:00
|
|
|
PreparedSetsPtr prepared_sets_ = nullptr);
|
2022-05-30 08:57:51 +00:00
|
|
|
|
2019-03-15 16:14:13 +00:00
|
|
|
ASTSelectQuery & getSelectQuery() { return query_ptr->as<ASTSelectQuery &>(); }
|
2019-03-12 14:07:02 +00:00
|
|
|
|
2021-05-02 13:38:19 +00:00
|
|
|
void addPrewhereAliasActions();
|
2021-07-03 22:53:51 +00:00
|
|
|
bool shouldMoveToPrewhere();
|
2021-05-02 13:38:19 +00:00
|
|
|
|
2020-05-20 09:29:23 +00:00
|
|
|
Block getSampleBlockImpl();
|
2018-07-17 13:09:33 +00:00
|
|
|
|
2021-10-13 18:22:02 +00:00
|
|
|
void executeImpl(QueryPlan & query_plan, std::optional<Pipe> prepared_pipe);
|
2018-02-23 06:00:48 +00:00
|
|
|
|
2017-06-02 21:37:28 +00:00
|
|
|
/// Different stages of query execution.
|
2021-02-15 19:48:06 +00:00
|
|
|
void executeFetchColumns(QueryProcessingStage::Enum processing_stage, QueryPlan & query_plan);
|
2020-11-03 11:28:28 +00:00
|
|
|
void executeWhere(QueryPlan & query_plan, const ActionsDAGPtr & expression, bool remove_filter);
|
2021-02-10 14:12:49 +00:00
|
|
|
void executeAggregation(
|
|
|
|
QueryPlan & query_plan, const ActionsDAGPtr & expression, bool overflow_row, bool final, InputOrderInfoPtr group_by_info);
|
2022-05-05 13:56:16 +00:00
|
|
|
void executeMergeAggregated(QueryPlan & query_plan, bool overflow_row, bool final, bool has_grouping_sets);
|
2021-09-28 10:01:47 +00:00
|
|
|
void executeTotalsAndHaving(QueryPlan & query_plan, bool has_having, const ActionsDAGPtr & expression, bool remove_filter, bool overflow_row, bool final);
|
|
|
|
void executeHaving(QueryPlan & query_plan, const ActionsDAGPtr & expression, bool remove_filter);
|
2020-11-03 11:28:28 +00:00
|
|
|
static void executeExpression(QueryPlan & query_plan, const ActionsDAGPtr & expression, const std::string & description);
|
2020-12-10 19:06:52 +00:00
|
|
|
/// FIXME should go through ActionsDAG to behave as a proper function
|
|
|
|
void executeWindow(QueryPlan & query_plan);
|
2020-06-18 13:38:45 +00:00
|
|
|
void executeOrder(QueryPlan & query_plan, InputOrderInfoPtr sorting_info);
|
|
|
|
void executeOrderOptimized(QueryPlan & query_plan, InputOrderInfoPtr sorting_info, UInt64 limit, SortDescription & output_order_descr);
|
|
|
|
void executeWithFill(QueryPlan & query_plan);
|
|
|
|
void executeMergeSorted(QueryPlan & query_plan, const std::string & description);
|
|
|
|
void executePreLimit(QueryPlan & query_plan, bool do_not_skip_offset);
|
|
|
|
void executeLimitBy(QueryPlan & query_plan);
|
|
|
|
void executeLimit(QueryPlan & query_plan);
|
|
|
|
void executeOffset(QueryPlan & query_plan);
|
2020-11-03 11:28:28 +00:00
|
|
|
static void executeProjection(QueryPlan & query_plan, const ActionsDAGPtr & expression);
|
2020-06-18 13:38:45 +00:00
|
|
|
void executeDistinct(QueryPlan & query_plan, bool before_order, Names columns, bool pre_distinct);
|
|
|
|
void executeExtremes(QueryPlan & query_plan);
|
2022-08-11 12:51:45 +00:00
|
|
|
void executeSubqueriesInSetsAndJoins(QueryPlan & query_plan);
|
2019-03-26 18:28:37 +00:00
|
|
|
|
2018-09-20 17:51:42 +00:00
|
|
|
enum class Modificator
|
|
|
|
{
|
|
|
|
ROLLUP = 0,
|
2021-08-23 06:28:49 +00:00
|
|
|
CUBE = 1,
|
2018-09-20 17:51:42 +00:00
|
|
|
};
|
2018-09-20 20:57:06 +00:00
|
|
|
|
2020-06-18 13:38:45 +00:00
|
|
|
void executeRollupOrCube(QueryPlan & query_plan, Modificator modificator);
|
2019-03-26 18:28:37 +00:00
|
|
|
|
2017-06-02 21:37:28 +00:00
|
|
|
/** If there is a SETTINGS section in the SELECT query, then apply settings from it.
|
2015-06-05 21:28:04 +00:00
|
|
|
*
|
2017-06-02 21:37:28 +00:00
|
|
|
* Section SETTINGS - settings for a specific query.
|
|
|
|
* Normally, the settings can be passed in other ways, not inside the query.
|
|
|
|
* But the use of this section is justified if you need to set the settings for one subquery.
|
2015-06-05 21:28:04 +00:00
|
|
|
*/
|
|
|
|
void initSettings();
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2020-07-22 17:13:05 +00:00
|
|
|
TreeRewriterResultPtr syntax_analyzer_result;
|
2019-08-14 19:30:30 +00:00
|
|
|
std::unique_ptr<SelectQueryExpressionAnalyzer> query_analyzer;
|
2019-07-19 10:14:27 +00:00
|
|
|
SelectQueryInfo query_info;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2019-10-03 11:58:52 +00:00
|
|
|
/// Is calculated in getSampleBlock. Is used later in readImpl.
|
2020-02-10 15:50:12 +00:00
|
|
|
ExpressionAnalysisResult analysis_result;
|
2020-06-13 20:59:20 +00:00
|
|
|
/// For row-level security.
|
2021-02-16 09:37:19 +00:00
|
|
|
ASTPtr row_policy_filter;
|
2021-02-13 22:07:13 +00:00
|
|
|
FilterDAGInfoPtr filter_info;
|
2019-10-03 11:58:52 +00:00
|
|
|
|
2022-06-21 11:24:46 +00:00
|
|
|
/// For additional_filter setting.
|
|
|
|
FilterDAGInfoPtr additional_filter_info;
|
|
|
|
|
2019-10-03 15:47:42 +00:00
|
|
|
QueryProcessingStage::Enum from_stage = QueryProcessingStage::FetchColumns;
|
|
|
|
|
2018-07-19 13:36:21 +00:00
|
|
|
/// List of columns to read to execute the query.
|
|
|
|
Names required_columns;
|
|
|
|
/// Structure of query source (table, subquery, etc).
|
|
|
|
Block source_header;
|
|
|
|
|
2021-05-02 13:38:19 +00:00
|
|
|
/// Actions to calculate ALIAS if required.
|
|
|
|
ActionsDAGPtr alias_actions;
|
|
|
|
|
2018-07-19 13:36:21 +00:00
|
|
|
/// The subquery interpreter, if the subquery
|
|
|
|
std::unique_ptr<InterpreterSelectWithUnionQuery> interpreter_subquery;
|
|
|
|
|
2017-06-02 21:37:28 +00:00
|
|
|
/// Table from where to read data, if not subquery.
|
2014-12-19 12:48:09 +00:00
|
|
|
StoragePtr storage;
|
2021-02-10 14:12:49 +00:00
|
|
|
StorageID table_id = StorageID::createEmpty(); /// Will be initialized if storage is not nullptr
|
2020-06-18 16:10:47 +00:00
|
|
|
TableLockHolder table_lock;
|
2017-04-01 07:20:54 +00:00
|
|
|
|
2018-02-21 03:26:06 +00:00
|
|
|
/// Used when we read from prepared input, not table or subquery.
|
2020-01-29 15:04:46 +00:00
|
|
|
std::optional<Pipe> input_pipe;
|
2018-02-21 03:26:06 +00:00
|
|
|
|
2017-01-21 04:24:28 +00:00
|
|
|
Poco::Logger * log;
|
2020-06-17 11:52:19 +00:00
|
|
|
StorageMetadataPtr metadata_snapshot;
|
2021-07-09 03:15:41 +00:00
|
|
|
StorageSnapshotPtr storage_snapshot;
|
2021-10-29 11:51:41 +00:00
|
|
|
|
|
|
|
/// Reuse already built sets for multiple passes of analysis, possibly across interpreters.
|
2022-07-18 15:53:30 +00:00
|
|
|
PreparedSetsPtr prepared_sets;
|
2011-08-28 05:13:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|