ClickHouse/src/Storages/StorageView.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

257 lines
10 KiB
C++
Raw Normal View History

#include <Interpreters/InterpreterSelectQuery.h>
2018-02-25 06:34:20 +00:00
#include <Interpreters/InterpreterSelectWithUnionQuery.h>
#include <Interpreters/Context.h>
#include <DataTypes/DataTypeLowCardinality.h>
2019-07-21 02:13:42 +00:00
#include <Parsers/ASTCreateQuery.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Parsers/ASTSelectWithUnionQuery.h>
#include <Parsers/ASTSubquery.h>
#include <Parsers/ASTTablesInSelectQuery.h>
#include <Storages/StorageView.h>
#include <Storages/StorageFactory.h>
#include <Storages/SelectQueryDescription.h>
#include <Common/typeid_cast.h>
2019-07-21 02:13:42 +00:00
2021-10-16 14:03:50 +00:00
#include <QueryPipeline/Pipe.h>
#include <Processors/Transforms/MaterializingTransform.h>
2021-09-08 18:29:38 +00:00
#include <Processors/QueryPlan/QueryPlan.h>
2020-11-17 17:16:55 +00:00
#include <Processors/QueryPlan/ExpressionStep.h>
2021-03-04 17:38:12 +00:00
#include <Processors/QueryPlan/BuildQueryPipelineSettings.h>
#include <Processors/QueryPlan/Optimizations/QueryPlanOptimizationSettings.h>
#include <Interpreters/ReplaceQueryParameterVisitor.h>
namespace DB
{
namespace ErrorCodes
{
extern const int INCORRECT_QUERY;
extern const int LOGICAL_ERROR;
}
namespace
{
bool isNullableOrLcNullable(DataTypePtr type)
{
if (type->isNullable())
return true;
if (const auto * lc_type = typeid_cast<const DataTypeLowCardinality *>(type.get()))
return lc_type->getDictionaryType()->isNullable();
return false;
}
/// Returns `true` if there are nullable column in src but corresponding column in dst is not
bool changedNullabilityOneWay(const Block & src_block, const Block & dst_block)
{
std::unordered_map<String, bool> src_nullable;
for (const auto & col : src_block)
src_nullable[col.name] = isNullableOrLcNullable(col.type);
for (const auto & col : dst_block)
{
if (!isNullableOrLcNullable(col.type) && src_nullable[col.name])
return true;
}
return false;
}
2021-08-06 10:48:47 +00:00
bool hasJoin(const ASTSelectQuery & select)
{
const auto & tables = select.tables();
if (!tables || tables->children.size() < 2)
return false;
const auto & joined_table = tables->children[1]->as<ASTTablesInSelectQueryElement &>();
return joined_table.table_join != nullptr;
}
bool hasJoin(const ASTSelectWithUnionQuery & ast)
{
for (const auto & child : ast.list_of_selects->children)
{
2021-08-06 10:48:47 +00:00
if (const auto * select = child->as<ASTSelectQuery>(); select && hasJoin(*select))
return true;
}
return false;
}
}
StorageView::StorageView(
2019-12-04 16:06:55 +00:00
const StorageID & table_id_,
const ASTCreateQuery & query,
2021-05-13 14:21:55 +00:00
const ColumnsDescription & columns_,
const String & comment)
2019-12-04 16:06:55 +00:00
: IStorage(table_id_)
{
2020-06-19 15:39:41 +00:00
StorageInMemoryMetadata storage_metadata;
storage_metadata.setColumns(columns_);
2021-04-23 12:18:23 +00:00
storage_metadata.setComment(comment);
2019-08-24 21:20:20 +00:00
if (!query.select)
throw Exception("SELECT query is not specified for " + getName(), ErrorCodes::INCORRECT_QUERY);
SelectQueryDescription description;
description.inner_query = query.select->ptr();
is_parameterized_view = query.isParameterizedView();
2020-06-19 15:39:41 +00:00
storage_metadata.setSelectQuery(description);
setInMemoryMetadata(storage_metadata);
}
void StorageView::read(
QueryPlan & query_plan,
const Names & column_names,
const StorageSnapshotPtr & storage_snapshot,
SelectQueryInfo & query_info,
ContextPtr context,
QueryProcessingStage::Enum /*processed_stage*/,
const size_t /*max_block_size*/,
const size_t /*num_streams*/)
{
ASTPtr current_inner_query = storage_snapshot->metadata->getSelectQuery().inner_query;
if (query_info.view_query)
{
if (!query_info.view_query->as<ASTSelectWithUnionQuery>())
throw Exception("Unexpected optimized VIEW query", ErrorCodes::LOGICAL_ERROR);
current_inner_query = query_info.view_query->clone();
}
auto options = SelectQueryOptions(QueryProcessingStage::Complete, 0, false, query_info.settings_limit_offset_done);
InterpreterSelectWithUnionQuery interpreter(current_inner_query, context, options, column_names);
2022-05-31 14:43:38 +00:00
interpreter.addStorageLimits(*query_info.storage_limits);
interpreter.buildQueryPlan(query_plan);
/// It's expected that the columns read from storage are not constant.
/// Because method 'getSampleBlockForColumns' is used to obtain a structure of result in InterpreterSelectQuery.
2021-02-18 11:15:16 +00:00
auto materializing_actions = std::make_shared<ActionsDAG>(query_plan.getCurrentDataStream().header.getColumnsWithTypeAndName());
materializing_actions->addMaterializingOutputActions();
2021-03-04 17:38:12 +00:00
auto materializing = std::make_unique<ExpressionStep>(query_plan.getCurrentDataStream(), std::move(materializing_actions));
materializing->setStepDescription("Materialize constants after VIEW subquery");
query_plan.addStep(std::move(materializing));
/// And also convert to expected structure.
const auto & expected_header = storage_snapshot->getSampleBlockForColumns(column_names);
const auto & header = query_plan.getCurrentDataStream().header;
const auto * select_with_union = current_inner_query->as<ASTSelectWithUnionQuery>();
if (select_with_union && hasJoin(*select_with_union) && changedNullabilityOneWay(header, expected_header))
{
throw DB::Exception(ErrorCodes::INCORRECT_QUERY,
"Query from view {} returned Nullable column having not Nullable type in structure. "
"If query from view has JOIN, it may be cause by different values of 'join_use_nulls' setting. "
"You may explicitly specify 'join_use_nulls' in 'CREATE VIEW' query to avoid this error",
getStorageID().getFullTableName());
}
2020-11-17 17:16:55 +00:00
auto convert_actions_dag = ActionsDAG::makeConvertingActions(
header.getColumnsWithTypeAndName(),
expected_header.getColumnsWithTypeAndName(),
2020-11-17 17:16:55 +00:00
ActionsDAG::MatchColumnsMode::Name);
2021-03-04 17:38:12 +00:00
auto converting = std::make_unique<ExpressionStep>(query_plan.getCurrentDataStream(), convert_actions_dag);
converting->setStepDescription("Convert VIEW subquery result to VIEW table structure");
query_plan.addStep(std::move(converting));
}
static ASTTableExpression * getFirstTableExpression(ASTSelectQuery & select_query)
2020-03-18 00:57:00 +00:00
{
2021-02-25 14:43:58 +00:00
if (!select_query.tables() || select_query.tables()->children.empty())
throw Exception("Logical error: no table expression in view select AST", ErrorCodes::LOGICAL_ERROR);
auto * select_element = select_query.tables()->children[0]->as<ASTTablesInSelectQueryElement>();
2020-03-18 00:57:00 +00:00
if (!select_element->table_expression)
throw Exception("Logical error: incorrect table expression", ErrorCodes::LOGICAL_ERROR);
return select_element->table_expression->as<ASTTableExpression>();
}
void StorageView::replaceQueryParametersIfParametrizedView(ASTPtr & outer_query, const NameToNameMap & parameter_values)
{
ReplaceQueryParameterVisitor visitor(parameter_values);
visitor.visit(outer_query);
}
void StorageView::replaceWithSubquery(ASTSelectQuery & outer_query, ASTPtr view_query, ASTPtr & view_name, bool parameterized_view)
{
ASTTableExpression * table_expression = getFirstTableExpression(outer_query);
2020-03-18 00:57:00 +00:00
if (!table_expression->database_and_table_name)
2020-08-28 14:07:14 +00:00
{
/// If it's a view or merge table function, add a fake db.table name.
/// For parameterized view, the function name is the db.view name, so add the function name
if (table_expression->table_function)
{
auto table_function_name = table_expression->table_function->as<ASTFunction>()->name;
if (table_function_name == "view" || table_function_name == "viewIfPermitted")
table_expression->database_and_table_name = std::make_shared<ASTTableIdentifier>("__view");
else if (table_function_name == "merge")
table_expression->database_and_table_name = std::make_shared<ASTTableIdentifier>("__merge");
else if (parameterized_view)
table_expression->database_and_table_name = std::make_shared<ASTTableIdentifier>(table_function_name);
}
if (!table_expression->database_and_table_name)
2020-08-28 14:07:14 +00:00
throw Exception("Logical error: incorrect table expression", ErrorCodes::LOGICAL_ERROR);
}
2020-03-18 00:57:00 +00:00
DatabaseAndTableWithAlias db_table(table_expression->database_and_table_name);
String alias = db_table.alias.empty() ? db_table.table : db_table.alias;
view_name = table_expression->database_and_table_name;
2020-03-18 00:57:00 +00:00
table_expression->database_and_table_name = {};
table_expression->subquery = std::make_shared<ASTSubquery>();
table_expression->subquery->children.push_back(view_query);
table_expression->subquery->setAlias(alias);
2020-03-18 00:57:00 +00:00
for (auto & child : table_expression->children)
if (child.get() == view_name.get())
child = view_query;
else if (child.get()
&& child->as<ASTFunction>()
&& table_expression->table_function
&& table_expression->table_function->as<ASTFunction>()
&& child->as<ASTFunction>()->name == table_expression->table_function->as<ASTFunction>()->name)
child = view_query;
}
2020-03-18 00:57:00 +00:00
ASTPtr StorageView::restoreViewName(ASTSelectQuery & select_query, const ASTPtr & view_name)
{
ASTTableExpression * table_expression = getFirstTableExpression(select_query);
if (!table_expression->subquery)
throw Exception("Logical error: incorrect table expression", ErrorCodes::LOGICAL_ERROR);
ASTPtr subquery = table_expression->subquery;
table_expression->subquery = {};
table_expression->database_and_table_name = view_name;
for (auto & child : table_expression->children)
if (child.get() == subquery.get())
child = view_name;
return subquery->children[0];
}
void registerStorageView(StorageFactory & factory)
{
factory.registerStorage("View", [](const StorageFactory::Arguments & args)
{
if (args.query.storage)
throw Exception("Specifying ENGINE is not allowed for a View", ErrorCodes::INCORRECT_QUERY);
return std::make_shared<StorageView>(args.table_id, args.query, args.columns, args.comment);
});
}
}