2015-09-24 03:50:09 +00:00
|
|
|
#include <DB/Storages/System/StorageSystemMerges.h>
|
2014-09-10 11:34:26 +00:00
|
|
|
#include <DB/DataTypes/DataTypeString.h>
|
|
|
|
#include <DB/DataTypes/DataTypesNumberFixed.h>
|
|
|
|
#include <DB/Columns/ColumnString.h>
|
|
|
|
#include <DB/DataStreams/OneBlockInputStream.h>
|
|
|
|
#include <DB/Interpreters/Context.h>
|
2015-04-16 06:12:35 +00:00
|
|
|
#include <DB/Storages/MergeTree/MergeList.h>
|
|
|
|
|
2014-09-10 11:34:26 +00:00
|
|
|
|
|
|
|
namespace DB
|
|
|
|
{
|
|
|
|
|
2015-01-21 03:56:28 +00:00
|
|
|
StorageSystemMerges::StorageSystemMerges(const std::string & name)
|
|
|
|
: name{name}
|
2014-09-10 11:34:26 +00:00
|
|
|
, columns{
|
2016-05-28 07:48:40 +00:00
|
|
|
{ "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>() },
|
|
|
|
{ "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>() },
|
2016-11-03 12:00:44 +00:00
|
|
|
{ "rows_written", std::make_shared<DataTypeUInt64>() },
|
2016-12-06 20:55:13 +00:00
|
|
|
{ "columns_written", std::make_shared<DataTypeUInt64>() }
|
2014-09-10 11:34:26 +00:00
|
|
|
}
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2015-01-21 03:56:28 +00:00
|
|
|
StoragePtr StorageSystemMerges::create(const std::string & name)
|
2014-09-10 11:34:26 +00:00
|
|
|
{
|
2016-08-26 21:25:05 +00:00
|
|
|
return make_shared(name);
|
2014-09-10 11:34:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BlockInputStreams StorageSystemMerges::read(
|
2014-12-17 11:53:17 +00:00
|
|
|
const Names & column_names,
|
|
|
|
ASTPtr query,
|
|
|
|
const Context & context,
|
|
|
|
const Settings & settings,
|
|
|
|
QueryProcessingStage::Enum & processed_stage,
|
|
|
|
const size_t max_block_size,
|
|
|
|
const unsigned)
|
2014-09-10 11:34:26 +00:00
|
|
|
{
|
|
|
|
check(column_names);
|
|
|
|
processed_stage = QueryProcessingStage::FetchColumns;
|
|
|
|
|
2016-05-28 07:48:40 +00:00
|
|
|
ColumnWithTypeAndName col_database{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "database"};
|
|
|
|
ColumnWithTypeAndName col_table{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "table"};
|
|
|
|
ColumnWithTypeAndName col_elapsed{std::make_shared<ColumnFloat64>(), std::make_shared<DataTypeFloat64>(), "elapsed"};
|
|
|
|
ColumnWithTypeAndName col_progress{std::make_shared<ColumnFloat64>(), std::make_shared<DataTypeFloat64>(), "progress"};
|
|
|
|
ColumnWithTypeAndName col_num_parts{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "num_parts"};
|
|
|
|
ColumnWithTypeAndName col_result_part_name{std::make_shared<ColumnString>(), std::make_shared<DataTypeString>(), "result_part_name"};
|
|
|
|
ColumnWithTypeAndName col_total_size_bytes_compressed{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "total_size_bytes_compressed"};
|
|
|
|
ColumnWithTypeAndName col_total_size_marks{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "total_size_marks"};
|
|
|
|
ColumnWithTypeAndName col_bytes_read_uncompressed{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "bytes_read_uncompressed"};
|
|
|
|
ColumnWithTypeAndName col_rows_read{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "rows_read"};
|
|
|
|
ColumnWithTypeAndName col_bytes_written_uncompressed{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "bytes_written_uncompressed"};
|
|
|
|
ColumnWithTypeAndName col_rows_written{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "rows_written"};
|
2016-11-03 12:00:44 +00:00
|
|
|
ColumnWithTypeAndName col_columns_written{std::make_shared<ColumnUInt64>(), std::make_shared<DataTypeUInt64>(), "columns_written"};
|
2014-09-10 11:34:26 +00:00
|
|
|
|
|
|
|
for (const auto & merge : context.getMergeList().get())
|
|
|
|
{
|
|
|
|
col_database.column->insert(merge.database);
|
|
|
|
col_table.column->insert(merge.table);
|
2014-09-18 10:23:12 +00:00
|
|
|
col_elapsed.column->insert(merge.watch.elapsedSeconds());
|
2016-11-03 12:00:44 +00:00
|
|
|
col_progress.column->insert(std::min(1., merge.progress)); /// little cheat
|
2014-09-10 11:34:26 +00:00
|
|
|
col_num_parts.column->insert(merge.num_parts);
|
|
|
|
col_result_part_name.column->insert(merge.result_part_name);
|
2014-09-12 16:05:29 +00:00
|
|
|
col_total_size_bytes_compressed.column->insert(merge.total_size_bytes_compressed);
|
2014-09-10 11:34:26 +00:00
|
|
|
col_total_size_marks.column->insert(merge.total_size_marks);
|
2016-07-31 03:53:16 +00:00
|
|
|
col_bytes_read_uncompressed.column->insert(merge.bytes_read_uncompressed.load(std::memory_order_relaxed));
|
|
|
|
col_rows_read.column->insert(merge.rows_read.load(std::memory_order_relaxed));
|
|
|
|
col_bytes_written_uncompressed.column->insert(merge.bytes_written_uncompressed.load(std::memory_order_relaxed));
|
|
|
|
col_rows_written.column->insert(merge.rows_written.load(std::memory_order_relaxed));
|
2016-11-03 12:00:44 +00:00
|
|
|
col_columns_written.column->insert(merge.columns_written.load(std::memory_order_relaxed));
|
2014-09-10 11:34:26 +00:00
|
|
|
}
|
|
|
|
|
2014-09-12 16:05:29 +00:00
|
|
|
Block block{
|
|
|
|
col_database,
|
|
|
|
col_table,
|
2014-09-18 10:23:12 +00:00
|
|
|
col_elapsed,
|
|
|
|
col_progress,
|
|
|
|
col_num_parts,
|
2014-09-12 16:05:29 +00:00
|
|
|
col_result_part_name,
|
2014-09-18 10:23:12 +00:00
|
|
|
col_total_size_bytes_compressed,
|
2014-09-12 16:05:29 +00:00
|
|
|
col_total_size_marks,
|
2014-09-18 10:23:12 +00:00
|
|
|
col_bytes_read_uncompressed,
|
2014-09-12 16:05:29 +00:00
|
|
|
col_rows_read,
|
2014-09-18 10:23:12 +00:00
|
|
|
col_bytes_written_uncompressed,
|
2016-11-03 12:00:44 +00:00
|
|
|
col_rows_written,
|
2016-12-06 20:55:13 +00:00
|
|
|
col_columns_written
|
2014-09-12 16:05:29 +00:00
|
|
|
};
|
2014-09-10 11:34:26 +00:00
|
|
|
|
2016-05-28 12:22:22 +00:00
|
|
|
return BlockInputStreams{1, std::make_shared<OneBlockInputStream>(block)};
|
2014-09-10 11:34:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|