thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-09-21 17:20:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

CLICKHOUSE-3772: Change base class of almost all StorageSystem* tables and fix remarks

Browse Source
This commit is contained in:
alesapin 2018-07-24 17:28:56 +03:00 committed by alexey-milovidov
parent 177f2801fd
commit 5459ca1401
51 changed files with 390 additions and 930 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp
View File

@ -103,8 +103,8 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(
if (AggregateFunctionCombinatorPtr combinator = AggregateFunctionCombinatorFactory::instance().tryFindSuffix(name))
{
if (combinator->getName() == "Null")
throw Exception("Aggregate function combinator 'Null' is only for internal usage", ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION);
if (combinator->isForInternalUsageOnly())
throw Exception("Aggregate function combinator '" + combinator->getName() + "' is only for internal usage", ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION);
String nested_name = name.substr(0, name.size() - combinator->getName().size());
DataTypes nested_types = combinator->transformArguments(argument_types);

2
dbms/src/AggregateFunctions/AggregateFunctionNull.cpp
View File

@ -18,6 +18,8 @@ class AggregateFunctionCombinatorNull final : public IAggregateFunctionCombinato
public:
String getName() const override { return "Null"; }
bool isForInternalUsageOnly() const override { return true; }
DataTypes transformArguments(const DataTypes & arguments) const override
{
size_t size = arguments.size();

2
dbms/src/AggregateFunctions/IAggregateFunctionCombinator.h
View File

@ -32,6 +32,8 @@ class IAggregateFunctionCombinator
public:
virtual String getName() const = 0;
virtual bool isForInternalUsageOnly() const { return false; }
/** From the arguments for combined function (ex: UInt64, UInt8 for sumIf),
* get the arguments for nested function (ex: UInt64 for sum).
* If arguments are not suitable for combined function, throw an exception.

2
dbms/src/DataTypes/DataTypeFactory.cpp
View File

@ -115,7 +115,7 @@ void DataTypeFactory::registerAlias(const String & alias_name, const String & re
throw Exception("DataTypeFactory: the alias name " + alias_name + " is already registered as datatype", ErrorCodes::LOGICAL_ERROR);
if (case_sensitiveness == CaseInsensitive)
if(!case_insensitive_aliases.emplace(alias_name_lowercase, real_type_dict_name).second)
if (!case_insensitive_aliases.emplace(alias_name_lowercase, real_type_dict_name).second)
throw Exception("DataTypeFactory: case insensitive alias name '" + alias_name + "' is not unique", ErrorCodes::LOGICAL_ERROR);
if (!aliases.emplace(alias_name, real_type_dict_name).second)

8
dbms/src/Storages/System/IStorageSystemOneBlock.h
View File

@ -17,7 +17,7 @@ template <typename Self>
class IStorageSystemOneBlock : public IStorage
{
protected:
virtual void fillData(MutableColumns & res_columns) const = 0;
virtual void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const = 0;
public:
IStorageSystemOneBlock(const String & name_) : name(name_)
@ -31,8 +31,8 @@ public:
}
BlockInputStreams read(const Names & column_names,
const SelectQueryInfo & /*query_info*/,
const Context & /*context*/,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t /*max_block_size*/,
unsigned /*num_streams*/) override
@ -42,7 +42,7 @@ public:
Block sample_block = getSampleBlock();
MutableColumns res_columns = sample_block.cloneEmptyColumns();
fillData(res_columns);
fillData(res_columns, context, query_info);
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(sample_block.cloneWithColumns(std::move(res_columns))));
}

18
dbms/src/Storages/System/StorageSystemAggregateFunctionCombinators.cpp
View File

@ -3,16 +3,26 @@
namespace DB
{
void StorageSystemAggregateFunctionCombinators::fillData(MutableColumns & res_columns) const
NamesAndTypesList StorageSystemAggregateFunctionCombinators::getNamesAndTypes()
{
return {
{"name", std::make_shared<DataTypeString>()},
{"is_internal", std::make_shared<DataTypeUInt8>()},
};
}
void StorageSystemAggregateFunctionCombinators::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
const auto & combinators = AggregateFunctionCombinatorFactory::instance().getAllAggregateFunctionCombinators();
for (const auto & pair : combinators)
{
res_columns[0]->insert(pair.first);
if (pair.first != "Null")
res_columns[1]->insert(UInt64(0));
else
if (pair.second->isForInternalUsageOnly())
res_columns[1]->insert(UInt64(1));
else
res_columns[1]->insert(UInt64(0));
}
}
}

12
dbms/src/Storages/System/StorageSystemAggregateFunctionCombinators.h
View File

@ -10,22 +10,16 @@ class StorageSystemAggregateFunctionCombinators : public ext::shared_ptr_helper<
public IStorageSystemOneBlock<StorageSystemAggregateFunctionCombinators>
{
protected:
void fillData(MutableColumns & res_columns) const override;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
public:
using IStorageSystemOneBlock::IStorageSystemOneBlock;
public:
std::string getName() const override
{
return "SystemAggregateFunctionCombinators";
}
static NamesAndTypesList getNamesAndTypes()
{
return {
{"name", std::make_shared<DataTypeString>()},
{"is_internal", std::make_shared<DataTypeUInt8>()},
};
}
static NamesAndTypesList getNamesAndTypes();
};
}

37
dbms/src/Storages/System/StorageSystemAsynchronousMetrics.cpp
View File

@ -1,51 +1,32 @@
#include <Storages/System/StorageSystemAsynchronousMetrics.h>
#include <Interpreters/AsynchronousMetrics.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Storages/System/StorageSystemAsynchronousMetrics.h>
namespace DB
{
StorageSystemAsynchronousMetrics::StorageSystemAsynchronousMetrics(const std::string & name_, const AsynchronousMetrics & async_metrics_)
: name(name_),
async_metrics(async_metrics_)
NamesAndTypesList StorageSystemAsynchronousMetrics::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
{"metric", std::make_shared<DataTypeString>()},
{"value", std::make_shared<DataTypeFloat64>()},
}));
};
}
BlockInputStreams StorageSystemAsynchronousMetrics::read(
const Names & column_names,
const SelectQueryInfo &,
const Context &,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
StorageSystemAsynchronousMetrics::StorageSystemAsynchronousMetrics(const std::string & name_, const AsynchronousMetrics & async_metrics_)
: IStorageSystemOneBlock(name_), async_metrics(async_metrics_)
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
}
void StorageSystemAsynchronousMetrics::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
auto async_metrics_values = async_metrics.getValues();
for (const auto & name_value : async_metrics_values)
{
res_columns[0]->insert(name_value.first);
res_columns[1]->insert(name_value.second);
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

20
dbms/src/Storages/System/StorageSystemAsynchronousMetrics.h
View File

@ -1,8 +1,10 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
{
@ -13,26 +15,20 @@ class Context;
/** Implements system table asynchronous_metrics, which allows to get values of periodically (asynchronously) updated metrics.
*/
class StorageSystemAsynchronousMetrics : public ext::shared_ptr_helper<StorageSystemAsynchronousMetrics>, public IStorage
class StorageSystemAsynchronousMetrics : public ext::shared_ptr_helper<StorageSystemAsynchronousMetrics>, public IStorageSystemOneBlock<StorageSystemAsynchronousMetrics>
{
public:
std::string getName() const override { return "SystemAsynchronousMetrics"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
static NamesAndTypesList getNamesAndTypes();
private:
const std::string name;
const AsynchronousMetrics & async_metrics;
protected:
StorageSystemAsynchronousMetrics(const std::string & name_, const AsynchronousMetrics & async_metrics_);
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

33
dbms/src/Storages/System/StorageSystemBuildOptions.cpp
View File

@ -1,7 +1,3 @@
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Interpreters/Settings.h>
#include <Storages/System/StorageSystemBuildOptions.h>
#include <Common/config_build.h>
@ -9,38 +5,21 @@
namespace DB
{
StorageSystemBuildOptions::StorageSystemBuildOptions(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemBuildOptions::getNamesAndTypes()
{
setColumns(ColumnsDescription({
{ "name", std::make_shared<DataTypeString>() },
{ "value", std::make_shared<DataTypeString>() },
}));
return {
{"name", std::make_shared<DataTypeString>()},
{"value", std::make_shared<DataTypeString>()},
};
}
BlockInputStreams StorageSystemBuildOptions::read(
const Names & column_names,
const SelectQueryInfo &,
const Context &,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemBuildOptions::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (auto it = auto_config_build; *it; it += 2)
{
res_columns[0]->insert(String(it[0]));
res_columns[1]->insert(String(it[1]));
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

30
dbms/src/Storages/System/StorageSystemBuildOptions.h
View File

@ -1,7 +1,8 @@
#pragma once
#include <DataTypes/DataTypeString.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +13,18 @@ class Context;
/** System table "build_options" with many params used for clickhouse building
*/
class StorageSystemBuildOptions : public ext::shared_ptr_helper<StorageSystemBuildOptions>, public IStorage
class StorageSystemBuildOptions : public ext::shared_ptr_helper<StorageSystemBuildOptions>, public IStorageSystemOneBlock<StorageSystemBuildOptions>
{
public:
std::string getName() const override { return "SystemBuildOptions"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
protected:
StorageSystemBuildOptions(const std::string & name_);
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
using IStorageSystemOneBlock::IStorageSystemOneBlock;
public:
std::string getName() const override { return "SystemBuildOptions"; }
static NamesAndTypesList getNamesAndTypes();
};
}

59
dbms/src/Storages/System/StorageSystemClusters.cpp
View File

@ -1,51 +1,29 @@
#include <Storages/System/StorageSystemClusters.h>
#include <Interpreters/Cluster.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Common/DNSResolver.h>
#include <Interpreters/Context.h>
#include <Storages/System/StorageSystemClusters.h>
#include <Common/DNSResolver.h>
namespace DB
{
StorageSystemClusters::StorageSystemClusters(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemClusters::getNamesAndTypes()
{
setColumns(ColumnsDescription({
{ "cluster", std::make_shared<DataTypeString>() },
{ "shard_num", std::make_shared<DataTypeUInt32>() },
{ "shard_weight", std::make_shared<DataTypeUInt32>() },
{ "replica_num", std::make_shared<DataTypeUInt32>() },
{ "host_name", std::make_shared<DataTypeString>() },
{ "host_address", std::make_shared<DataTypeString>() },
{ "port", std::make_shared<DataTypeUInt16>() },
{ "is_local", std::make_shared<DataTypeUInt8>() },
{ "user", std::make_shared<DataTypeString>() },
{ "default_database", std::make_shared<DataTypeString>() },
}));
return {
{"cluster", std::make_shared<DataTypeString>()},
{"shard_num", std::make_shared<DataTypeUInt32>()},
{"shard_weight", std::make_shared<DataTypeUInt32>()},
{"replica_num", std::make_shared<DataTypeUInt32>()},
{"host_name", std::make_shared<DataTypeString>()},
{"host_address", std::make_shared<DataTypeString>()},
{"port", std::make_shared<DataTypeUInt16>()},
{"is_local", std::make_shared<DataTypeUInt8>()},
{"user", std::make_shared<DataTypeString>()},
{"default_database", std::make_shared<DataTypeString>()},
};
}
BlockInputStreams StorageSystemClusters::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemClusters::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
auto updateColumns = [&](const std::string & cluster_name, const Cluster::ShardInfo & shard_info,
const Cluster::Address & address)
{
auto updateColumns = [&](const std::string & cluster_name, const Cluster::ShardInfo & shard_info, const Cluster::Address & address) {
size_t i = 0;
res_columns[i++]->insert(cluster_name);
res_columns[i++]->insert(static_cast<UInt64>(shard_info.shard_num));
@ -85,8 +63,5 @@ BlockInputStreams StorageSystemClusters::read(
}
}
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

22
dbms/src/Storages/System/StorageSystemClusters.h
View File

@ -1,7 +1,9 @@
#pragma once
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -13,25 +15,17 @@ class Context;
* that allows to obtain information about available clusters
* (which may be specified in Distributed tables).
*/
class StorageSystemClusters : public ext::shared_ptr_helper<StorageSystemClusters>, public IStorage
class StorageSystemClusters : public ext::shared_ptr_helper<StorageSystemClusters>, public IStorageSystemOneBlock<StorageSystemClusters>
{
public:
std::string getName() const override { return "SystemClusters"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemClusters(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

13
dbms/src/Storages/System/StorageSystemCollations.cpp
View File

@ -3,11 +3,18 @@
namespace DB
{
void StorageSystemCollations::fillData(MutableColumns & res_columns) const
NamesAndTypesList StorageSystemCollations::getNamesAndTypes()
{
return {
{"name", std::make_shared<DataTypeString>()},
};
}
void StorageSystemCollations::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
for (const auto & collation_name : Collator::getAvailableCollations())
{
res_columns[0]->insert(collation_name);
}
}
}

18
dbms/src/Storages/System/StorageSystemCollations.h
View File

@ -4,25 +4,19 @@
namespace DB
{
class StorageSystemCollations : public ext::shared_ptr_helper<StorageSystemCollations>,
public IStorageSystemOneBlock<StorageSystemCollations>
{
protected:
void fillData(MutableColumns & res_columns) const override;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
public:
using IStorageSystemOneBlock::IStorageSystemOneBlock;
public:
std::string getName() const override
{
return "SystemTableCollations";
}
std::string getName() const override { return "SystemTableCollations"; }
static NamesAndTypesList getNamesAndTypes()
{
return {
{"name", std::make_shared<DataTypeString>()},
};
}
static NamesAndTypesList getNamesAndTypes();
};
}

28
dbms/src/Storages/System/StorageSystemColumns.cpp
View File

@ -15,10 +15,8 @@
namespace DB
{
StorageSystemColumns::StorageSystemColumns(const std::string & name_)
: name(name_)
{
setColumns(ColumnsDescription({
NamesAndTypesList StorageSystemColumns::getNamesAndTypes() {
return {
{ "database", std::make_shared<DataTypeString>() },
{ "table", std::make_shared<DataTypeString>() },
{ "name", std::make_shared<DataTypeString>() },
@ -28,21 +26,11 @@ StorageSystemColumns::StorageSystemColumns(const std::string & name_)
{ "data_compressed_bytes", std::make_shared<DataTypeUInt64>() },
{ "data_uncompressed_bytes", std::make_shared<DataTypeUInt64>() },
{ "marks_bytes", std::make_shared<DataTypeUInt64>() },
}));
};
}
BlockInputStreams StorageSystemColumns::read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemColumns::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
Block block_to_filter;
std::map<std::pair<std::string, std::string>, StoragePtr> storages;
@ -60,7 +48,7 @@ BlockInputStreams StorageSystemColumns::read(
VirtualColumnUtils::filterBlockWithQuery(query_info.query, block_to_filter, context);
if (!block_to_filter.rows())
return BlockInputStreams();
return;
ColumnPtr database_column = block_to_filter.getByName("database").column;
size_t rows = database_column->size();
@ -98,14 +86,12 @@ BlockInputStreams StorageSystemColumns::read(
VirtualColumnUtils::filterBlockWithQuery(query_info.query, block_to_filter, context);
if (!block_to_filter.rows())
return BlockInputStreams();
return;
ColumnPtr filtered_database_column = block_to_filter.getByName("database").column;
ColumnPtr filtered_table_column = block_to_filter.getByName("table").column;
/// We compose the result.
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
size_t rows = filtered_database_column->size();
for (size_t i = 0; i < rows; ++i)
{
@ -193,8 +179,6 @@ BlockInputStreams StorageSystemColumns::read(
}
}
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

18
dbms/src/Storages/System/StorageSystemColumns.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -11,25 +11,17 @@ class Context;
/** Implements system table 'columns', that allows to get information about columns for every table.
*/
class StorageSystemColumns : public ext::shared_ptr_helper<StorageSystemColumns>, public IStorage
class StorageSystemColumns : public ext::shared_ptr_helper<StorageSystemColumns>, public IStorageSystemOneBlock<StorageSystemColumns>
{
public:
std::string getName() const override { return "SystemColumns"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemColumns(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
private:
const std::string name;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

98
dbms/src/Storages/System/StorageSystemDataTypeFamilies.cpp
View File

@ -1,70 +1,20 @@
#include <Core/Field.h>
#include <DataTypes/DataTypeFactory.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTLiteral.h>
#include <Storages/System/StorageSystemDataTypeFamilies.h>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/predicate.hpp>
namespace DB
{
namespace
NamesAndTypesList StorageSystemDataTypeFamilies::getNamesAndTypes()
{
void setTypePropertries(const DataTypePtr data_type, MutableColumns & res_columns)
{
res_columns[4]->insert(UInt64(data_type->isParametric()));
res_columns[5]->insert(UInt64(data_type->haveSubtypes()));
res_columns[6]->insert(UInt64(data_type->cannotBeStoredInTables()));
res_columns[7]->insert(UInt64(data_type->isComparable()));
res_columns[8]->insert(UInt64(data_type->canBeComparedWithCollation()));
res_columns[9]->insert(UInt64(data_type->canBeUsedAsVersion()));
res_columns[10]->insert(UInt64(data_type->isSummable()));
res_columns[11]->insert(UInt64(data_type->canBeUsedInBitOperations()));
res_columns[12]->insert(UInt64(data_type->canBeUsedInBooleanContext()));
res_columns[13]->insert(UInt64(data_type->isCategorial()));
res_columns[14]->insert(UInt64(data_type->isNullable()));
res_columns[15]->insert(UInt64(data_type->onlyNull()));
res_columns[16]->insert(UInt64(data_type->canBeInsideNullable()));
}
void setComplexTypeProperties(const String & name, MutableColumns & res_columns)
{
res_columns[3]->insert(Null());
res_columns[4]->insert(UInt64(1)); //complex types are always parametric
if (name == "AggregateFunction")
res_columns[5]->insert(UInt64(0));
else if (name == "Tuple")
res_columns[5]->insert(Null());
else
res_columns[5]->insert(UInt64(1));
for (size_t i = 6; i < StorageSystemDataTypeFamilies::getNamesAndTypes().size(); ++i)
res_columns[i]->insert(Null());
}
ASTPtr createFakeEnumCreationAst()
{
String fakename{"e"};
ASTPtr name = std::make_shared<ASTLiteral>(Field(fakename.c_str(), fakename.size()));
ASTPtr value = std::make_shared<ASTLiteral>(Field(UInt64(1)));
ASTPtr ast_func = makeASTFunction("equals", name, value);
ASTPtr clone = ast_func->clone();
clone->children.clear();
clone->children.push_back(ast_func);
return clone;
}
ASTPtr createFakeFixedStringAst()
{
ASTPtr result = std::make_shared<ASTLiteral>(Field(UInt64(1)));
auto clone = result->clone();
clone->children.clear();
clone->children.push_back(result);
return clone;
}
return {
{"name", std::make_shared<DataTypeString>()},
{"case_insensivie", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"alias_to", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeString>())},
};
}
void StorageSystemDataTypeFamilies::fillData(MutableColumns & res_columns) const
void StorageSystemDataTypeFamilies::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
const auto & factory = DataTypeFactory::instance();
auto names = factory.getAllDataTypeNames();
@ -77,37 +27,7 @@ void StorageSystemDataTypeFamilies::fillData(MutableColumns & res_columns) const
res_columns[2]->insert(factory.aliasTo(name));
else
res_columns[2]->insert(String(""));
try
{
DataTypePtr type_ptr;
Field size = Null();
// hardcoded cases for simple parametric types
if (boost::starts_with(name, "Enum"))
{
type_ptr = factory.get(name, createFakeEnumCreationAst());
size = type_ptr->getMaximumSizeOfValueInMemory();
}
else if (name == "FixedString" || name == "BINARY")
{
type_ptr = factory.get(name, createFakeFixedStringAst());
}
else
{
type_ptr = factory.get(name);
if (type_ptr->haveMaximumSizeOfValue())
size = type_ptr->getMaximumSizeOfValueInMemory();
}
res_columns[3]->insert(size);
setTypePropertries(type_ptr, res_columns);
}
catch (Exception & ex)
{
setComplexTypeProperties(name, res_columns);
}
}
}
}

34
dbms/src/Storages/System/StorageSystemDataTypeFamilies.h
View File

@ -7,41 +7,19 @@
#include <ext/shared_ptr_helper.h>
namespace DB
{
class StorageSystemDataTypeFamilies : public ext::shared_ptr_helper<StorageSystemDataTypeFamilies>,
public IStorageSystemOneBlock<StorageSystemDataTypeFamilies>
{
protected:
void fillData(MutableColumns & res_columns) const override;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
public:
using IStorageSystemOneBlock::IStorageSystemOneBlock;
std::string getName() const override
{
return "SystemTableDataTypeFamilies";
}
public:
std::string getName() const override { return "SystemTableDataTypeFamilies"; }
static NamesAndTypesList getNamesAndTypes()
{
return {
{"name", std::make_shared<DataTypeString>()},
{"case_insensivie", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"alias_to", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeString>())},
{"size_in_bytes", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt16>())},
{"parametric", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"have_subtypes", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"cannot_be_stored_in_tables", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"comparable", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"can_be_compared_with_collation", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"can_be_used_as_version", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"is_summable", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"can_be_used_in_bit_operations", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"can_be_used_in_boolean_context", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"categorial", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"nullable", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"only_null", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
{"can_be_inside_nullable", std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>())},
};
}
static NamesAndTypesList getNamesAndTypes();
};
}

30
dbms/src/Storages/System/StorageSystemDatabases.cpp
View File

@ -1,40 +1,23 @@
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Databases/IDatabase.h>
#include <Storages/System/StorageSystemDatabases.h>
#include <Interpreters/Context.h>
#include <Storages/System/StorageSystemDatabases.h>
namespace DB
{
StorageSystemDatabases::StorageSystemDatabases(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemDatabases::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
{"name", std::make_shared<DataTypeString>()},
{"engine", std::make_shared<DataTypeString>()},
{"data_path", std::make_shared<DataTypeString>()},
{"metadata_path", std::make_shared<DataTypeString>()},
}));
};
}
BlockInputStreams StorageSystemDatabases::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemDatabases::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
auto databases = context.getDatabases();
for (const auto & database : databases)
{
@ -43,9 +26,6 @@ BlockInputStreams StorageSystemDatabases::read(
res_columns[2]->insert(database.second->getDataPath());
res_columns[3]->insert(database.second->getMetadataPath());
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

26
dbms/src/Storages/System/StorageSystemDatabases.h
View File

@ -1,7 +1,8 @@
#pragma once
#include <DataTypes/DataTypeString.h>
#include <Storages/System/IStorageSystemOneBlock.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
namespace DB
@ -12,25 +13,20 @@ class Context;
/** Implements `databases` system table, which allows you to get information about all databases.
*/
class StorageSystemDatabases : public ext::shared_ptr_helper<StorageSystemDatabases>, public IStorage
class StorageSystemDatabases : public ext::shared_ptr_helper<StorageSystemDatabases>, public IStorageSystemOneBlock<StorageSystemDatabases>
{
public:
std::string getName() const override { return "SystemDatabases"; }
std::string getTableName() const override { return name; }
std::string getName() const override
{
return "SystemDatabases";
}
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemDatabases(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
};
}

33
dbms/src/Storages/System/StorageSystemDictionaries.cpp
View File

@ -1,12 +1,4 @@
#include <Storages/System/StorageSystemDictionaries.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeDateTime.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnArray.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Interpreters/Context.h>
#include <Dictionaries/IDictionary.h>
#include <Dictionaries/IDictionarySource.h>
@ -18,10 +10,9 @@
namespace DB
{
StorageSystemDictionaries::StorageSystemDictionaries(const std::string & name)
: name{name}
NamesAndTypesList StorageSystemDictionaries::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
{ "name", std::make_shared<DataTypeString>() },
{ "origin", std::make_shared<DataTypeString>() },
{ "type", std::make_shared<DataTypeString>() },
@ -36,27 +27,13 @@ StorageSystemDictionaries::StorageSystemDictionaries(const std::string & name)
{ "creation_time", std::make_shared<DataTypeDateTime>() },
{ "source", std::make_shared<DataTypeString>() },
{ "last_exception", std::make_shared<DataTypeString>() },
}));
};
}
BlockInputStreams StorageSystemDictionaries::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t,
const unsigned)
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
void StorageSystemDictionaries::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const {
const auto & external_dictionaries = context.getExternalDictionaries();
auto objects_map = external_dictionaries.getObjectsMap();
const auto & dictionaries = objects_map.get();
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (const auto & dict_info : dictionaries)
{
size_t i = 0;
@ -102,8 +79,6 @@ BlockInputStreams StorageSystemDictionaries::read(
else
res_columns[i++]->insertDefault();
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

24
dbms/src/Storages/System/StorageSystemDictionaries.h
View File

@ -1,7 +1,11 @@
#pragma once
#include <DataTypes/DataTypeArray.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeString.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -10,25 +14,17 @@ namespace DB
class Context;
class StorageSystemDictionaries : public ext::shared_ptr_helper<StorageSystemDictionaries>, public IStorage
class StorageSystemDictionaries : public ext::shared_ptr_helper<StorageSystemDictionaries>, public IStorageSystemOneBlock<StorageSystemDictionaries>
{
public:
std::string getName() const override { return "SystemDictionaries"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemDictionaries(const std::string & name);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

31
dbms/src/Storages/System/StorageSystemEvents.cpp
View File

@ -1,39 +1,19 @@
#include <Common/ProfileEvents.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Storages/System/StorageSystemEvents.h>
namespace DB
{
StorageSystemEvents::StorageSystemEvents(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemEvents::getNamesAndTypes()
{
setColumns(ColumnsDescription(
{
return {
{"event", std::make_shared<DataTypeString>()},
{"value", std::make_shared<DataTypeUInt64>()},
}));
};
}
BlockInputStreams StorageSystemEvents::read(
const Names & column_names,
const SelectQueryInfo &,
const Context &,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemEvents::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (size_t i = 0, end = ProfileEvents::end(); i < end; ++i)
{
UInt64 value = ProfileEvents::counters[i];
@ -44,9 +24,6 @@ BlockInputStreams StorageSystemEvents::read(
res_columns[1]->insert(value);
}
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

23
dbms/src/Storages/System/StorageSystemEvents.h
View File

@ -1,8 +1,9 @@
#pragma once
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
{
@ -12,25 +13,17 @@ class Context;
/** Implements `events` system table, which allows you to obtain information for profiling.
*/
class StorageSystemEvents : public ext::shared_ptr_helper<StorageSystemEvents>, public IStorage
class StorageSystemEvents : public ext::shared_ptr_helper<StorageSystemEvents>, public IStorageSystemOneBlock<StorageSystemEvents>
{
public:
std::string getName() const override { return "SystemEvents"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemEvents(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

13
dbms/src/Storages/System/StorageSystemFormats.cpp
View File

@ -3,7 +3,17 @@
namespace DB
{
void StorageSystemFormats::fillData(MutableColumns & res_columns) const
NamesAndTypesList StorageSystemFormats::getNamesAndTypes()
{
return {
{"name", std::make_shared<DataTypeString>()},
{"is_input", std::make_shared<DataTypeUInt8>()},
{"is_output", std::make_shared<DataTypeUInt8>()},
};
}
void StorageSystemFormats::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
const auto & formats = FormatFactory::instance().getAllFormats();
for (const auto & pair : formats)
@ -16,4 +26,5 @@ void StorageSystemFormats::fillData(MutableColumns & res_columns) const
res_columns[2]->insert(has_output_format);
}
}
}

13
dbms/src/Storages/System/StorageSystemFormats.h
View File

@ -10,23 +10,16 @@ namespace DB
class StorageSystemFormats : public ext::shared_ptr_helper<StorageSystemFormats>, public IStorageSystemOneBlock<StorageSystemFormats>
{
protected:
void fillData(MutableColumns & res_columns) const override;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
public:
using IStorageSystemOneBlock::IStorageSystemOneBlock;
public:
std::string getName() const override
{
return "SystemFormats";
}
static NamesAndTypesList getNamesAndTypes()
{
return {
{"name", std::make_shared<DataTypeString>()},
{"is_input", std::make_shared<DataTypeUInt8>()},
{"is_output", std::make_shared<DataTypeUInt8>()},
};
}
static NamesAndTypesList getNamesAndTypes();
};
}

35
dbms/src/Storages/System/StorageSystemFunctions.cpp
View File

@ -1,41 +1,28 @@
#include <Storages/System/StorageSystemFunctions.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <AggregateFunctions/AggregateFunctionFactory.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Functions/FunctionFactory.h>
#include <Functions/IFunction.h>
#include <Interpreters/Context.h>
#include <Storages/System/StorageSystemFunctions.h>
namespace DB
{
StorageSystemFunctions::StorageSystemFunctions(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemFunctions::getNamesAndTypes()
{
setColumns(ColumnsDescription({
{ "name", std::make_shared<DataTypeString>() },
{ "is_aggregate", std::make_shared<DataTypeUInt8>() },
}));
return {
{"name", std::make_shared<DataTypeString>()},
{"is_aggregate", std::make_shared<DataTypeUInt8>()},
};
}
BlockInputStreams StorageSystemFunctions::read(
const Names & column_names,
const SelectQueryInfo &,
const Context &,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemFunctions::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
const auto & functions = FunctionFactory::instance().functions;
for (const auto & it : functions)
{
@ -49,8 +36,6 @@ BlockInputStreams StorageSystemFunctions::read(
res_columns[0]->insert(it.first);
res_columns[1]->insert(UInt64(1));
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

20
dbms/src/Storages/System/StorageSystemFunctions.h
View File

@ -1,7 +1,9 @@
#pragma once
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -13,25 +15,17 @@ class Context;
/** Implements `functions`system table, which allows you to get a list
* all normal and aggregate functions.
*/
class StorageSystemFunctions : public ext::shared_ptr_helper<StorageSystemFunctions>, public IStorage
class StorageSystemFunctions : public ext::shared_ptr_helper<StorageSystemFunctions>, public IStorageSystemOneBlock<StorageSystemFunctions>
{
public:
std::string getName() const override { return "SystemFunctions"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemFunctions(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
private:
const std::string name;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

22
dbms/src/Storages/System/StorageSystemGraphite.cpp
View File

@ -124,10 +124,9 @@ static Strings getAllGraphiteSections(const AbstractConfiguration & config)
} // namespace
StorageSystemGraphite::StorageSystemGraphite(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemGraphite::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
{"config_name", std::make_shared<DataTypeString>()},
{"regexp", std::make_shared<DataTypeString>()},
{"function", std::make_shared<DataTypeString>()},
@ -135,23 +134,12 @@ StorageSystemGraphite::StorageSystemGraphite(const std::string & name_)
{"precision", std::make_shared<DataTypeUInt64>()},
{"priority", std::make_shared<DataTypeUInt16>()},
{"is_default", std::make_shared<DataTypeUInt8>()},
}));
};
}
BlockInputStreams StorageSystemGraphite::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t /*max_block_size*/,
unsigned /*num_streams*/)
void StorageSystemGraphite::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
const auto & config = context.getConfigRef();
Strings sections = getAllGraphiteSections(config);
@ -172,8 +160,6 @@ BlockInputStreams StorageSystemGraphite::read(
}
}
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

22
dbms/src/Storages/System/StorageSystemGraphite.h
View File

@ -1,31 +1,25 @@
#pragma once
#include <Storages/IStorage.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <Storages/System/IStorageSystemOneBlock.h>
#include <ext/shared_ptr_helper.h>
namespace DB
{
/// Provides information about Graphite configuration.
class StorageSystemGraphite : public ext::shared_ptr_helper<StorageSystemGraphite>, public IStorage
class StorageSystemGraphite : public ext::shared_ptr_helper<StorageSystemGraphite>, public IStorageSystemOneBlock<StorageSystemGraphite>
{
public:
std::string getName() const override { return "SystemGraphite"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemGraphite(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

36
dbms/src/Storages/System/StorageSystemMacros.cpp
View File

@ -1,38 +1,21 @@
#include <Common/Macros.h>
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Storages/System/StorageSystemMacros.h>
#include <Interpreters/Context.h>
#include <Storages/System/StorageSystemMacros.h>
#include <Common/Macros.h>
namespace DB
{
StorageSystemMacros::StorageSystemMacros(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemMacros::getNamesAndTypes()
{
setColumns(ColumnsDescription({
{"macro", std::make_shared<DataTypeString>()},
{"substitution", std::make_shared<DataTypeString>()},
}));
return {
{"macro", std::make_shared<DataTypeString>()},
{"substitution", std::make_shared<DataTypeString>()},
};
}
BlockInputStreams StorageSystemMacros::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemMacros::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
auto macros = context.getMacros();
for (const auto & macro : macros->getMacroMap())
@ -40,9 +23,6 @@ BlockInputStreams StorageSystemMacros::read(
res_columns[0]->insert(macro.first);
res_columns[1]->insert(macro.second);
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

21
dbms/src/Storages/System/StorageSystemMacros.h
View File

@ -1,7 +1,8 @@
#pragma once
#include <DataTypes/DataTypeString.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +13,17 @@ class Context;
/** Information about macros for introspection.
*/
class StorageSystemMacros : public ext::shared_ptr_helper<StorageSystemMacros>, public IStorage
class StorageSystemMacros : public ext::shared_ptr_helper<StorageSystemMacros>, public IStorageSystemOneBlock<StorageSystemMacros>
{
public:
std::string getName() const override { return "SystemMacros"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemMacros(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

61
dbms/src/Storages/System/StorageSystemMerges.cpp
View File

@ -1,53 +1,36 @@
#include <Storages/System/StorageSystemMerges.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <Columns/ColumnString.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Interpreters/Context.h>
#include <Storages/MergeTree/MergeList.h>
#include <Storages/System/StorageSystemMerges.h>
namespace DB
{
StorageSystemMerges::StorageSystemMerges(const std::string & name)
: name{name}
NamesAndTypesList StorageSystemMerges::getNamesAndTypes()
{
setColumns(ColumnsDescription({
{ "database", std::make_shared<DataTypeString>() },
{ "table", std::make_shared<DataTypeString>() },
{ "elapsed", std::make_shared<DataTypeFloat64>() },
{ "progress", std::make_shared<DataTypeFloat64>() },
{ "num_parts", std::make_shared<DataTypeUInt64>() },
{ "source_part_names", std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>()) },
{ "result_part_name", std::make_shared<DataTypeString>() },
{ "total_size_bytes_compressed", std::make_shared<DataTypeUInt64>() },
{ "total_size_marks", std::make_shared<DataTypeUInt64>() },
{ "bytes_read_uncompressed", std::make_shared<DataTypeUInt64>() },
{ "rows_read", std::make_shared<DataTypeUInt64>() },
{ "bytes_written_uncompressed", std::make_shared<DataTypeUInt64>() },
{ "rows_written", std::make_shared<DataTypeUInt64>() },
{ "columns_written", std::make_shared<DataTypeUInt64>() },
{ "memory_usage", std::make_shared<DataTypeUInt64>() },
{ "thread_number", std::make_shared<DataTypeUInt64>() },
}));
return {
{"database", std::make_shared<DataTypeString>()},
{"table", std::make_shared<DataTypeString>()},
{"elapsed", std::make_shared<DataTypeFloat64>()},
{"progress", std::make_shared<DataTypeFloat64>()},
{"num_parts", std::make_shared<DataTypeUInt64>()},
{"source_part_names", std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>())},
{"result_part_name", std::make_shared<DataTypeString>()},
{"total_size_bytes_compressed", std::make_shared<DataTypeUInt64>()},
{"total_size_marks", std::make_shared<DataTypeUInt64>()},
{"bytes_read_uncompressed", std::make_shared<DataTypeUInt64>()},
{"rows_read", std::make_shared<DataTypeUInt64>()},
{"bytes_written_uncompressed", std::make_shared<DataTypeUInt64>()},
{"rows_written", std::make_shared<DataTypeUInt64>()},
{"columns_written", std::make_shared<DataTypeUInt64>()},
{"memory_usage", std::make_shared<DataTypeUInt64>()},
{"thread_number", std::make_shared<DataTypeUInt64>()},
};
}
BlockInputStreams StorageSystemMerges::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t,
const unsigned)
void StorageSystemMerges::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (const auto & merge : context.getMergeList().get())
{
size_t i = 0;
@ -68,8 +51,6 @@ BlockInputStreams StorageSystemMerges::read(
res_columns[i++]->insert(merge.memory_usage);
res_columns[i++]->insert(merge.thread_number);
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

23
dbms/src/Storages/System/StorageSystemMerges.h
View File

@ -1,7 +1,10 @@
#pragma once
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeArray.h>
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -10,25 +13,17 @@ namespace DB
class Context;
class StorageSystemMerges : public ext::shared_ptr_helper<StorageSystemMerges>, public IStorage
class StorageSystemMerges : public ext::shared_ptr_helper<StorageSystemMerges>, public IStorageSystemOneBlock<StorageSystemMerges>
{
public:
std::string getName() const override { return "SystemMerges"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemMerges(const std::string & name);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

31
dbms/src/Storages/System/StorageSystemMetrics.cpp
View File

@ -1,39 +1,23 @@
#include <Common/CurrentMetrics.h>
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Storages/System/StorageSystemMetrics.h>
namespace DB
{
StorageSystemMetrics::StorageSystemMetrics(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemMetrics::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
{"metric", std::make_shared<DataTypeString>()},
{"value", std::make_shared<DataTypeInt64>()},
}));
{"value", std::make_shared<DataTypeInt64>()},
};
}
BlockInputStreams StorageSystemMetrics::read(
const Names & column_names,
const SelectQueryInfo &,
const Context &,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemMetrics::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (size_t i = 0, end = CurrentMetrics::end(); i < end; ++i)
{
Int64 value = CurrentMetrics::values[i].load(std::memory_order_relaxed);
@ -41,9 +25,6 @@ BlockInputStreams StorageSystemMetrics::read(
res_columns[0]->insert(String(CurrentMetrics::getDescription(CurrentMetrics::Metric(i))));
res_columns[1]->insert(value);
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

20
dbms/src/Storages/System/StorageSystemMetrics.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +12,17 @@ class Context;
/** Implements `metrics` system table, which provides information about the operation of the server.
*/
class StorageSystemMetrics : public ext::shared_ptr_helper<StorageSystemMetrics>, public IStorage
class StorageSystemMetrics : public ext::shared_ptr_helper<StorageSystemMetrics>, public IStorageSystemOneBlock<StorageSystemMetrics>
{
public:
std::string getName() const override { return "SystemMetrics"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemMetrics(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

26
dbms/src/Storages/System/StorageSystemModels.cpp
View File

@ -2,45 +2,29 @@
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeDateTime.h>
#include <Columns/ColumnsNumber.h>
#include <Columns/ColumnString.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Interpreters/Context.h>
#include <Interpreters/ExternalModels.h>
#include <Dictionaries/CatBoostModel.h>
namespace DB
{
StorageSystemModels::StorageSystemModels(const std::string & name)
: name{name}
NamesAndTypesList StorageSystemModels::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
{ "name", std::make_shared<DataTypeString>() },
{ "origin", std::make_shared<DataTypeString>() },
{ "type", std::make_shared<DataTypeString>() },
{ "creation_time", std::make_shared<DataTypeDateTime>() },
{ "last_exception", std::make_shared<DataTypeString>() },
}));
};
}
BlockInputStreams StorageSystemModels::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t,
const unsigned)
void StorageSystemModels::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
const auto & external_models = context.getExternalModels();
auto objects_map = external_models.getObjectsMap();
const auto & models = objects_map.get();
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (const auto & model_info : models)
{
res_columns[0]->insert(model_info.first);
@ -73,8 +57,6 @@ BlockInputStreams StorageSystemModels::read(
else
res_columns[4]->insertDefault();
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

20
dbms/src/Storages/System/StorageSystemModels.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -10,25 +10,17 @@ namespace DB
class Context;
class StorageSystemModels : public ext::shared_ptr_helper<StorageSystemModels>, public IStorage
class StorageSystemModels : public ext::shared_ptr_helper<StorageSystemModels>, public IStorageSystemOneBlock<StorageSystemModels>
{
public:
std::string getName() const override { return "SystemModels"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemModels(const std::string & name);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

28
dbms/src/Storages/System/StorageSystemMutations.cpp
View File

@ -13,10 +13,10 @@
namespace DB
{
StorageSystemMutations::StorageSystemMutations(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemMutations::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
{ "database", std::make_shared<DataTypeString>() },
{ "table", std::make_shared<DataTypeString>() },
{ "mutation_id", std::make_shared<DataTypeString>() },
@ -28,21 +28,12 @@ StorageSystemMutations::StorageSystemMutations(const std::string & name_)
std::make_shared<DataTypeInt64>()) },
{ "parts_to_do", std::make_shared<DataTypeInt64>() },
{ "is_done", std::make_shared<DataTypeUInt8>() },
}));
};
}
BlockInputStreams StorageSystemMutations::read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemMutations::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
/// Collect a set of *MergeTree tables.
std::map<String, std::map<String, StoragePtr>> merge_tree_tables;
for (const auto & db : context.getDatabases())
@ -83,13 +74,12 @@ BlockInputStreams StorageSystemMutations::read(
VirtualColumnUtils::filterBlockWithQuery(query_info.query, filtered_block, context);
if (!filtered_block.rows())
return BlockInputStreams();
return;
col_database = filtered_block.getByName("database").column;
col_table = filtered_block.getByName("table").column;
}
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (size_t i_storage = 0; i_storage < col_database->size(); ++i_storage)
{
auto database = (*col_database)[i_storage].safeGet<String>();
@ -129,12 +119,6 @@ BlockInputStreams StorageSystemMutations::read(
res_columns[col_num++]->insert(UInt64(status.is_done));
}
}
Block res = getSampleBlock().cloneEmpty();
for (size_t i_col = 0; i_col < res.columns(); ++i_col)
res.getByPosition(i_col).column = std::move(res_columns[i_col]);
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(res));
}
}

20
dbms/src/Storages/System/StorageSystemMutations.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +12,17 @@ class Context;
/// Implements the `mutations` system table, which provides information about the status of mutations
/// in the MergeTree tables.
class StorageSystemMutations : public ext::shared_ptr_helper<StorageSystemMutations>, public IStorage
class StorageSystemMutations : public ext::shared_ptr_helper<StorageSystemMutations>, public IStorageSystemOneBlock<StorageSystemMutations>
{
public:
String getName() const override { return "SystemMutations"; }
String getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const String name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemMutations(const String & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

86
dbms/src/Storages/System/StorageSystemProcesses.cpp
View File

@ -1,75 +1,60 @@
#include <Columns/ColumnString.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Interpreters/Context.h>
#include <Interpreters/ProcessList.h>
#include <Storages/System/StorageSystemProcesses.h>
#include <Interpreters/Context.h>
namespace DB
{
StorageSystemProcesses::StorageSystemProcesses(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemProcesses::getNamesAndTypes()
{
setColumns(ColumnsDescription({
{ "is_initial_query", std::make_shared<DataTypeUInt8>() },
return {
{"is_initial_query", std::make_shared<DataTypeUInt8>()},
{ "user", std::make_shared<DataTypeString>() },
{ "query_id", std::make_shared<DataTypeString>() },
{ "address", std::make_shared<DataTypeString>() },
{ "port", std::make_shared<DataTypeUInt16>() },
{"user", std::make_shared<DataTypeString>()},
{"query_id", std::make_shared<DataTypeString>()},
{"address", std::make_shared<DataTypeString>()},
{"port", std::make_shared<DataTypeUInt16>()},
{ "initial_user", std::make_shared<DataTypeString>() },
{ "initial_query_id", std::make_shared<DataTypeString>() },
{ "initial_address", std::make_shared<DataTypeString>() },
{ "initial_port", std::make_shared<DataTypeUInt16>() },
{"initial_user", std::make_shared<DataTypeString>()},
{"initial_query_id", std::make_shared<DataTypeString>()},
{"initial_address", std::make_shared<DataTypeString>()},
{"initial_port", std::make_shared<DataTypeUInt16>()},
{ "interface", std::make_shared<DataTypeUInt8>() },
{"interface", std::make_shared<DataTypeUInt8>()},
{ "os_user", std::make_shared<DataTypeString>() },
{ "client_hostname", std::make_shared<DataTypeString>() },
{ "client_name", std::make_shared<DataTypeString>() },
{ "client_version_major", std::make_shared<DataTypeUInt64>() },
{ "client_version_minor", std::make_shared<DataTypeUInt64>() },
{ "client_revision", std::make_shared<DataTypeUInt64>() },
{"os_user", std::make_shared<DataTypeString>()},
{"client_hostname", std::make_shared<DataTypeString>()},
{"client_name", std::make_shared<DataTypeString>()},
{"client_version_major", std::make_shared<DataTypeUInt64>()},
{"client_version_minor", std::make_shared<DataTypeUInt64>()},
{"client_revision", std::make_shared<DataTypeUInt64>()},
{ "http_method", std::make_shared<DataTypeUInt8>() },
{ "http_user_agent", std::make_shared<DataTypeString>() },
{"http_method", std::make_shared<DataTypeUInt8>()},
{"http_user_agent", std::make_shared<DataTypeString>()},
{ "quota_key", std::make_shared<DataTypeString>() },
{"quota_key", std::make_shared<DataTypeString>()},
{ "elapsed", std::make_shared<DataTypeFloat64>() },
{ "is_cancelled", std::make_shared<DataTypeUInt8>() },
{ "read_rows", std::make_shared<DataTypeUInt64>() },
{ "read_bytes", std::make_shared<DataTypeUInt64>() },
{ "total_rows_approx", std::make_shared<DataTypeUInt64>() },
{ "written_rows", std::make_shared<DataTypeUInt64>() },
{ "written_bytes", std::make_shared<DataTypeUInt64>() },
{ "memory_usage", std::make_shared<DataTypeInt64>() },
{ "peak_memory_usage", std::make_shared<DataTypeInt64>() },
{ "query", std::make_shared<DataTypeString>() },
}));
{"elapsed", std::make_shared<DataTypeFloat64>()},
{"is_cancelled", std::make_shared<DataTypeUInt8>()},
{"read_rows", std::make_shared<DataTypeUInt64>()},
{"read_bytes", std::make_shared<DataTypeUInt64>()},
{"total_rows_approx", std::make_shared<DataTypeUInt64>()},
{"written_rows", std::make_shared<DataTypeUInt64>()},
{"written_bytes", std::make_shared<DataTypeUInt64>()},
{"memory_usage", std::make_shared<DataTypeInt64>()},
{"peak_memory_usage", std::make_shared<DataTypeInt64>()},
{"query", std::make_shared<DataTypeString>()},
};
}
BlockInputStreams StorageSystemProcesses::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemProcesses::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
ProcessList::Info info = context.getProcessList().getInfo();
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (const auto & process : info)
{
size_t i = 0;
@ -103,9 +88,6 @@ BlockInputStreams StorageSystemProcesses::read(
res_columns[i++]->insert(process.peak_memory_usage);
res_columns[i++]->insert(process.query);
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

20
dbms/src/Storages/System/StorageSystemProcesses.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +12,17 @@ class Context;
/** Implements `processes` system table, which allows you to get information about the queries that are currently executing.
*/
class StorageSystemProcesses : public ext::shared_ptr_helper<StorageSystemProcesses>, public IStorage
class StorageSystemProcesses : public ext::shared_ptr_helper<StorageSystemProcesses>, public IStorageSystemOneBlock<StorageSystemProcesses>
{
public:
std::string getName() const override { return "SystemProcesses"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemProcesses(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

27
dbms/src/Storages/System/StorageSystemReplicationQueue.cpp
View File

@ -5,7 +5,6 @@
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataTypes/DataTypeArray.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Storages/System/StorageSystemReplicationQueue.h>
#include <Storages/StorageReplicatedMergeTree.h>
#include <Storages/VirtualColumnUtils.h>
@ -17,10 +16,10 @@ namespace DB
{
StorageSystemReplicationQueue::StorageSystemReplicationQueue(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemReplicationQueue::getNamesAndTypes()
{
setColumns(ColumnsDescription({
return {
/// Table properties.
{ "database", std::make_shared<DataTypeString>() },
{ "table", std::make_shared<DataTypeString>() },
@ -43,21 +42,12 @@ StorageSystemReplicationQueue::StorageSystemReplicationQueue(const std::string &
{ "num_postponed", std::make_shared<DataTypeUInt32>() },
{ "postpone_reason", std::make_shared<DataTypeString>() },
{ "last_postpone_time", std::make_shared<DataTypeDateTime>() },
}));
};
}
BlockInputStreams StorageSystemReplicationQueue::read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemReplicationQueue::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
std::map<String, std::map<String, StoragePtr>> replicated_tables;
for (const auto & db : context.getDatabases())
for (auto iterator = db.second->getIterator(context); iterator->isValid(); iterator->next())
@ -90,7 +80,7 @@ BlockInputStreams StorageSystemReplicationQueue::read(
VirtualColumnUtils::filterBlockWithQuery(query_info.query, filtered_block, context);
if (!filtered_block.rows())
return BlockInputStreams();
return;
col_database_to_filter = filtered_block.getByName("database").column;
col_table_to_filter = filtered_block.getByName("table").column;
@ -99,8 +89,6 @@ BlockInputStreams StorageSystemReplicationQueue::read(
StorageReplicatedMergeTree::LogEntriesData queue;
String replica_name;
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (size_t i = 0, tables_size = col_database_to_filter->size(); i < tables_size; ++i)
{
String database = (*col_database_to_filter)[i].safeGet<const String &>();
@ -139,9 +127,6 @@ BlockInputStreams StorageSystemReplicationQueue::read(
res_columns[col_num++]->insert(UInt64(entry.last_postpone_time));
}
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

20
dbms/src/Storages/System/StorageSystemReplicationQueue.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +12,17 @@ class Context;
/** Implements the `replication_queue` system table, which allows you to view the replication queues for the replicated tables.
*/
class StorageSystemReplicationQueue : public ext::shared_ptr_helper<StorageSystemReplicationQueue>, public IStorage
class StorageSystemReplicationQueue : public ext::shared_ptr_helper<StorageSystemReplicationQueue>, public IStorageSystemOneBlock<StorageSystemReplicationQueue>
{
public:
std::string getName() const override { return "SystemReplicationQueue"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemReplicationQueue(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

42
dbms/src/Storages/System/StorageSystemSettings.cpp
View File

@ -1,8 +1,5 @@
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Interpreters/Context.h>
#include <Storages/System/StorageSystemSettings.h>
@ -10,44 +7,27 @@
namespace DB
{
StorageSystemSettings::StorageSystemSettings(const std::string & name_)
: name(name_)
NamesAndTypesList StorageSystemSettings::getNamesAndTypes()
{
setColumns(ColumnsDescription({
{ "name", std::make_shared<DataTypeString>() },
{ "value", std::make_shared<DataTypeString>() },
{ "changed", std::make_shared<DataTypeUInt8>() },
{ "description", std::make_shared<DataTypeString>() },
}));
return {
{"name", std::make_shared<DataTypeString>()},
{"value", std::make_shared<DataTypeString>()},
{"changed", std::make_shared<DataTypeUInt8>()},
{"description", std::make_shared<DataTypeString>()},
};
}
BlockInputStreams StorageSystemSettings::read(
const Names & column_names,
const SelectQueryInfo &,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemSettings::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
const Settings & settings = context.getSettingsRef();
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
#define ADD_SETTING(TYPE, NAME, DEFAULT, DESCRIPTION) \
res_columns[0]->insert(String(#NAME)); \
res_columns[1]->insert(settings.NAME.toString()); \
#define ADD_SETTING(TYPE, NAME, DEFAULT, DESCRIPTION) \
res_columns[0]->insert(String(#NAME)); \
res_columns[1]->insert(settings.NAME.toString()); \
res_columns[2]->insert(UInt64(settings.NAME.changed)); \
res_columns[3]->insert(String(DESCRIPTION));
APPLY_FOR_SETTINGS(ADD_SETTING)
#undef ADD_SETTING
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}
}

20
dbms/src/Storages/System/StorageSystemSettings.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +12,17 @@ class Context;
/** implements system table "settings", which allows to get information about the current settings.
*/
class StorageSystemSettings : public ext::shared_ptr_helper<StorageSystemSettings>, public IStorage
class StorageSystemSettings : public ext::shared_ptr_helper<StorageSystemSettings>, public IStorageSystemOneBlock<StorageSystemSettings>
{
public:
std::string getName() const override { return "SystemSettings"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemSettings(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}

9
dbms/src/Storages/System/StorageSystemTableFunctions.cpp
View File

@ -3,7 +3,13 @@
#include <TableFunctions/TableFunctionFactory.h>
namespace DB
{
void StorageSystemTableFunctions::fillData(MutableColumns & res_columns) const
NamesAndTypesList StorageSystemTableFunctions::getNamesAndTypes()
{
return {{"name", std::make_shared<DataTypeString>()}};
}
void StorageSystemTableFunctions::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const
{
const auto & functions = TableFunctionFactory::instance().getAllTableFunctions();
for (const auto & pair : functions)
@ -11,4 +17,5 @@ void StorageSystemTableFunctions::fillData(MutableColumns & res_columns) const
res_columns[0]->insert(pair.first);
}
}
}

14
dbms/src/Storages/System/StorageSystemTableFunctions.h
View File

@ -5,23 +5,25 @@
#include <ext/shared_ptr_helper.h>
namespace DB
{
class StorageSystemTableFunctions : public ext::shared_ptr_helper<StorageSystemTableFunctions>,
public IStorageSystemOneBlock<StorageSystemTableFunctions>
{
protected:
void fillData(MutableColumns & res_columns) const override;
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
public:
using IStorageSystemOneBlock::IStorageSystemOneBlock;
std::string getName() const override
{
return "SystemTableFunctions";
}
static NamesAndTypesList getNamesAndTypes()
{
return {{"name", std::make_shared<DataTypeString>()}};
}
static NamesAndTypesList getNamesAndTypes();
};
}

26
dbms/src/Storages/System/StorageSystemZooKeeper.cpp
View File

@ -1,9 +1,6 @@
#include <Columns/ColumnString.h>
#include <Columns/ColumnsNumber.h>
#include <DataTypes/DataTypeString.h>
#include <DataTypes/DataTypesNumber.h>
#include <DataTypes/DataTypeDateTime.h>
#include <DataStreams/OneBlockInputStream.h>
#include <Storages/System/StorageSystemZooKeeper.h>
#include <Parsers/ASTSelectQuery.h>
#include <Parsers/ASTIdentifier.h>
@ -19,10 +16,8 @@ namespace DB
{
StorageSystemZooKeeper::StorageSystemZooKeeper(const std::string & name_)
: name(name_)
{
setColumns(ColumnsDescription({
NamesAndTypesList StorageSystemZooKeeper::getNamesAndTypes() {
return {
{ "name", std::make_shared<DataTypeString>() },
{ "value", std::make_shared<DataTypeString>() },
{ "czxid", std::make_shared<DataTypeInt64>() },
@ -37,7 +32,7 @@ StorageSystemZooKeeper::StorageSystemZooKeeper(const std::string & name_)
{ "numChildren", std::make_shared<DataTypeInt32>() },
{ "pzxid", std::make_shared<DataTypeInt64>() },
{ "path", std::make_shared<DataTypeString>() },
}));
};
}
@ -103,17 +98,8 @@ static String extractPath(const ASTPtr & query)
}
BlockInputStreams StorageSystemZooKeeper::read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
const size_t /*max_block_size*/,
const unsigned /*num_streams*/)
void StorageSystemZooKeeper::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const
{
check(column_names);
processed_stage = QueryProcessingStage::FetchColumns;
String path = extractPath(query_info.query);
if (path.empty())
throw Exception("SELECT from system.zookeeper table must contain condition like path = 'path' in WHERE clause.");
@ -136,8 +122,6 @@ BlockInputStreams StorageSystemZooKeeper::read(
for (const String & node : nodes)
futures.push_back(zookeeper->asyncTryGet(path_part + '/' + node));
MutableColumns res_columns = getSampleBlock().cloneEmptyColumns();
for (size_t i = 0, size = nodes.size(); i < size; ++i)
{
auto res = futures[i].get();
@ -162,8 +146,6 @@ BlockInputStreams StorageSystemZooKeeper::read(
res_columns[col_num++]->insert(Int64(stat.pzxid));
res_columns[col_num++]->insert(path); /// This is the original path. In order to process the request, condition in WHERE should be triggered.
}
return BlockInputStreams(1, std::make_shared<OneBlockInputStream>(getSampleBlock().cloneWithColumns(std::move(res_columns))));
}

20
dbms/src/Storages/System/StorageSystemZooKeeper.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <ext/shared_ptr_helper.h>
#include <Storages/IStorage.h>
#include <Storages/System/IStorageSystemOneBlock.h>
namespace DB
@ -12,25 +12,17 @@ class Context;
/** Implements `zookeeper` system table, which allows you to view the data in ZooKeeper for debugging purposes.
*/
class StorageSystemZooKeeper : public ext::shared_ptr_helper<StorageSystemZooKeeper>, public IStorage
class StorageSystemZooKeeper : public ext::shared_ptr_helper<StorageSystemZooKeeper>, public IStorageSystemOneBlock<StorageSystemZooKeeper>
{
public:
std::string getName() const override { return "SystemZooKeeper"; }
std::string getTableName() const override { return name; }
BlockInputStreams read(
const Names & column_names,
const SelectQueryInfo & query_info,
const Context & context,
QueryProcessingStage::Enum & processed_stage,
size_t max_block_size,
unsigned num_streams) override;
private:
const std::string name;
static NamesAndTypesList getNamesAndTypes();
protected:
StorageSystemZooKeeper(const std::string & name_);
using IStorageSystemOneBlock::IStorageSystemOneBlock;
void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo & query_info) const override;
};
}