mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-12-12 09:22:05 +00:00
ee37f551a2
* make interpreter factory an instance * add registerInterpreter * register interpreters individually * try wire everything up * fix style * fix test
285 lines
9.5 KiB
C++
285 lines
9.5 KiB
C++
#include <Storages/IStorage.h>
|
|
#include <Processors/Sources/SourceFromSingleChunk.h>
|
|
#include <QueryPipeline/BlockIO.h>
|
|
#include <DataTypes/DataTypeString.h>
|
|
#include <Parsers/queryToString.h>
|
|
#include <Common/typeid_cast.h>
|
|
#include <TableFunctions/ITableFunction.h>
|
|
#include <TableFunctions/TableFunctionFactory.h>
|
|
#include <Interpreters/InterpreterSelectWithUnionQuery.h>
|
|
#include <Interpreters/InterpreterSelectQueryAnalyzer.h>
|
|
#include <Interpreters/Context.h>
|
|
#include <Interpreters/InterpreterFactory.h>
|
|
#include <Interpreters/InterpreterDescribeQuery.h>
|
|
#include <Interpreters/IdentifierSemantic.h>
|
|
#include <Access/Common/AccessFlags.h>
|
|
#include <Parsers/ASTIdentifier.h>
|
|
#include <Parsers/ASTFunction.h>
|
|
#include <Parsers/ASTTablesInSelectQuery.h>
|
|
#include <Parsers/TablePropertiesQueriesASTs.h>
|
|
#include <DataTypes/NestedUtils.h>
|
|
|
|
namespace DB
|
|
{
|
|
|
|
InterpreterDescribeQuery::InterpreterDescribeQuery(const ASTPtr & query_ptr_, ContextPtr context_)
|
|
: WithContext(context_)
|
|
, query_ptr(query_ptr_)
|
|
, settings(getContext()->getSettingsRef())
|
|
{
|
|
}
|
|
|
|
Block InterpreterDescribeQuery::getSampleBlock(bool include_subcolumns, bool include_virtuals, bool compact)
|
|
{
|
|
Block block;
|
|
|
|
ColumnWithTypeAndName col;
|
|
col.name = "name";
|
|
col.type = std::make_shared<DataTypeString>();
|
|
col.column = col.type->createColumn();
|
|
block.insert(col);
|
|
|
|
col.name = "type";
|
|
block.insert(col);
|
|
|
|
if (!compact)
|
|
{
|
|
col.name = "default_type";
|
|
block.insert(col);
|
|
|
|
col.name = "default_expression";
|
|
block.insert(col);
|
|
|
|
col.name = "comment";
|
|
block.insert(col);
|
|
|
|
col.name = "codec_expression";
|
|
block.insert(col);
|
|
|
|
col.name = "ttl_expression";
|
|
block.insert(col);
|
|
}
|
|
|
|
if (include_subcolumns)
|
|
{
|
|
col.name = "is_subcolumn";
|
|
col.type = std::make_shared<DataTypeUInt8>();
|
|
col.column = col.type->createColumn();
|
|
block.insert(col);
|
|
}
|
|
|
|
if (include_virtuals)
|
|
{
|
|
col.name = "is_virtual";
|
|
col.type = std::make_shared<DataTypeUInt8>();
|
|
col.column = col.type->createColumn();
|
|
block.insert(col);
|
|
}
|
|
|
|
return block;
|
|
}
|
|
|
|
BlockIO InterpreterDescribeQuery::execute()
|
|
{
|
|
const auto & ast = query_ptr->as<ASTDescribeQuery &>();
|
|
const auto & table_expression = ast.table_expression->as<ASTTableExpression &>();
|
|
|
|
if (table_expression.subquery)
|
|
fillColumnsFromSubquery(table_expression);
|
|
else if (table_expression.table_function)
|
|
fillColumnsFromTableFunction(table_expression);
|
|
else
|
|
fillColumnsFromTable(table_expression);
|
|
|
|
Block sample_block = getSampleBlock(
|
|
settings.describe_include_subcolumns,
|
|
settings.describe_include_virtual_columns,
|
|
settings.describe_compact_output);
|
|
|
|
MutableColumns res_columns = sample_block.cloneEmptyColumns();
|
|
|
|
for (const auto & column : columns)
|
|
addColumn(column, false, res_columns);
|
|
|
|
for (const auto & column : virtual_columns)
|
|
addColumn(column, true, res_columns);
|
|
|
|
if (settings.describe_include_subcolumns)
|
|
{
|
|
for (const auto & column : columns)
|
|
addSubcolumns(column, false, res_columns);
|
|
|
|
for (const auto & column : virtual_columns)
|
|
addSubcolumns(column, true, res_columns);
|
|
}
|
|
|
|
BlockIO res;
|
|
size_t num_rows = res_columns[0]->size();
|
|
auto source = std::make_shared<SourceFromSingleChunk>(sample_block, Chunk(std::move(res_columns), num_rows));
|
|
res.pipeline = QueryPipeline(std::move(source));
|
|
|
|
return res;
|
|
}
|
|
|
|
void InterpreterDescribeQuery::fillColumnsFromSubquery(const ASTTableExpression & table_expression)
|
|
{
|
|
NamesAndTypesList names_and_types;
|
|
auto select_query = table_expression.subquery->children.at(0);
|
|
auto current_context = getContext();
|
|
|
|
if (settings.allow_experimental_analyzer)
|
|
{
|
|
SelectQueryOptions select_query_options;
|
|
names_and_types = InterpreterSelectQueryAnalyzer(select_query, current_context, select_query_options).getSampleBlock().getNamesAndTypesList();
|
|
}
|
|
else
|
|
{
|
|
names_and_types = InterpreterSelectWithUnionQuery::getSampleBlock(select_query, current_context).getNamesAndTypesList();
|
|
}
|
|
|
|
for (auto && [name, type] : names_and_types)
|
|
columns.emplace_back(std::move(name), std::move(type));
|
|
}
|
|
|
|
void InterpreterDescribeQuery::fillColumnsFromTableFunction(const ASTTableExpression & table_expression)
|
|
{
|
|
auto current_context = getContext();
|
|
TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression.table_function, current_context);
|
|
auto column_descriptions = table_function_ptr->getActualTableStructure(getContext(), /*is_insert_query*/ true);
|
|
for (const auto & column : column_descriptions)
|
|
columns.emplace_back(column);
|
|
|
|
if (settings.describe_include_virtual_columns)
|
|
{
|
|
auto table = table_function_ptr->execute(table_expression.table_function, getContext(), table_function_ptr->getName());
|
|
if (table)
|
|
{
|
|
for (const auto & column : table->getVirtuals())
|
|
{
|
|
if (!column_descriptions.has(column.name))
|
|
virtual_columns.emplace_back(column.name, column.type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void InterpreterDescribeQuery::fillColumnsFromTable(const ASTTableExpression & table_expression)
|
|
{
|
|
auto table_id = getContext()->resolveStorageID(table_expression.database_and_table_name);
|
|
getContext()->checkAccess(AccessType::SHOW_COLUMNS, table_id);
|
|
auto table = DatabaseCatalog::instance().getTable(table_id, getContext());
|
|
auto table_lock = table->lockForShare(getContext()->getInitialQueryId(), settings.lock_acquire_timeout);
|
|
|
|
auto metadata_snapshot = table->getInMemoryMetadataPtr();
|
|
const auto & column_descriptions = metadata_snapshot->getColumns();
|
|
for (const auto & column : column_descriptions)
|
|
columns.emplace_back(column);
|
|
|
|
if (settings.describe_include_virtual_columns)
|
|
{
|
|
for (const auto & column : table->getVirtuals())
|
|
{
|
|
if (!column_descriptions.has(column.name))
|
|
virtual_columns.emplace_back(column.name, column.type);
|
|
}
|
|
}
|
|
|
|
if (settings.describe_extend_object_types)
|
|
storage_snapshot = table->getStorageSnapshot(metadata_snapshot, getContext());
|
|
}
|
|
|
|
void InterpreterDescribeQuery::addColumn(const ColumnDescription & column, bool is_virtual, MutableColumns & res_columns)
|
|
{
|
|
size_t i = 0;
|
|
res_columns[i++]->insert(column.name);
|
|
|
|
auto type = storage_snapshot ? storage_snapshot->getConcreteType(column.name) : column.type;
|
|
if (settings.print_pretty_type_names)
|
|
res_columns[i++]->insert(type->getPrettyName());
|
|
else
|
|
res_columns[i++]->insert(type->getName());
|
|
|
|
if (!settings.describe_compact_output)
|
|
{
|
|
if (column.default_desc.expression)
|
|
{
|
|
res_columns[i++]->insert(toString(column.default_desc.kind));
|
|
res_columns[i++]->insert(queryToString(column.default_desc.expression));
|
|
}
|
|
else
|
|
{
|
|
res_columns[i++]->insertDefault();
|
|
res_columns[i++]->insertDefault();
|
|
}
|
|
|
|
res_columns[i++]->insert(column.comment);
|
|
|
|
if (column.codec)
|
|
res_columns[i++]->insert(queryToString(column.codec->as<ASTFunction>()->arguments));
|
|
else
|
|
res_columns[i++]->insertDefault();
|
|
|
|
if (column.ttl)
|
|
res_columns[i++]->insert(queryToString(column.ttl));
|
|
else
|
|
res_columns[i++]->insertDefault();
|
|
}
|
|
|
|
if (settings.describe_include_subcolumns)
|
|
res_columns[i++]->insertDefault();
|
|
|
|
if (settings.describe_include_virtual_columns)
|
|
res_columns[i++]->insert(is_virtual);
|
|
}
|
|
|
|
void InterpreterDescribeQuery::addSubcolumns(const ColumnDescription & column, bool is_virtual, MutableColumns & res_columns)
|
|
{
|
|
auto type = storage_snapshot ? storage_snapshot->getConcreteType(column.name) : column.type;
|
|
|
|
IDataType::forEachSubcolumn([&](const auto & path, const auto & name, const auto & data)
|
|
{
|
|
size_t i = 0;
|
|
res_columns[i++]->insert(Nested::concatenateName(column.name, name));
|
|
|
|
if (settings.print_pretty_type_names)
|
|
res_columns[i++]->insert(data.type->getPrettyName());
|
|
else
|
|
res_columns[i++]->insert(data.type->getName());
|
|
|
|
if (!settings.describe_compact_output)
|
|
{
|
|
/// It's not trivial to calculate default expression for subcolumn.
|
|
/// So, leave it empty.
|
|
res_columns[i++]->insertDefault();
|
|
res_columns[i++]->insertDefault();
|
|
res_columns[i++]->insert(column.comment);
|
|
|
|
if (column.codec && ISerialization::isSpecialCompressionAllowed(path))
|
|
res_columns[i++]->insert(queryToString(column.codec->as<ASTFunction>()->arguments));
|
|
else
|
|
res_columns[i++]->insertDefault();
|
|
|
|
if (column.ttl)
|
|
res_columns[i++]->insert(queryToString(column.ttl));
|
|
else
|
|
res_columns[i++]->insertDefault();
|
|
}
|
|
|
|
res_columns[i++]->insert(1U);
|
|
|
|
if (settings.describe_include_virtual_columns)
|
|
res_columns[i++]->insert(is_virtual);
|
|
|
|
}, ISerialization::SubstreamData(type->getDefaultSerialization()).withType(type));
|
|
}
|
|
|
|
void registerInterpreterDescribeQuery(InterpreterFactory & factory)
|
|
{
|
|
auto create_fn = [] (const InterpreterFactory::Arguments & args)
|
|
{
|
|
return std::make_unique<InterpreterDescribeQuery>(args.query, args.context);
|
|
};
|
|
factory.registerInterpreter("InterpreterDescribeQuery", create_fn);
|
|
}
|
|
|
|
}
|