forked from ClickHouse/ClickHouse
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathTableFunctionTimeSeries.cpp
More file actions
128 lines (105 loc) · 4.88 KB
/
TableFunctionTimeSeries.cpp
File metadata and controls
128 lines (105 loc) · 4.88 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include <TableFunctions/TableFunctionTimeSeries.h>
#include <Interpreters/Context.h>
#include <Interpreters/DatabaseCatalog.h>
#include <Interpreters/evaluateConstantExpression.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTIdentifier.h>
#include <Storages/StorageTimeSeries.h>
#include <Storages/checkAndGetLiteralArgument.h>
#include <TableFunctions/TableFunctionFactory.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const int LOGICAL_ERROR;
extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
}
template <ViewTarget::Kind target_kind>
void TableFunctionTimeSeriesTarget<target_kind>::parseArguments(const ASTPtr & ast_function, ContextPtr context)
{
const auto & args_func = ast_function->as<ASTFunction &>();
if (!args_func.arguments)
throw Exception(ErrorCodes::LOGICAL_ERROR, "Table function '{}' must have arguments.", name);
auto & args = args_func.arguments->children;
if ((args.size() != 1) && (args.size() != 2))
throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
"Table function '{}' requires one or two arguments: {}([database, ] time_series_table)", name, name);
if (args.size() == 1)
{
/// timeSeriesMetrics( [my_db.]my_time_series_table )
if (const auto * id = args[0]->as<ASTIdentifier>())
{
if (auto table_id = id->createTable())
time_series_storage_id = table_id->getTableId();
}
}
if (time_series_storage_id.empty())
{
for (auto & arg : args)
arg = evaluateConstantExpressionOrIdentifierAsLiteral(arg, context);
if (args.size() == 1)
{
/// timeSeriesMetrics( 'my_time_series_table' )
time_series_storage_id.table_name = checkAndGetLiteralArgument<String>(args[0], "table_name");
}
else
{
/// timeSeriesMetrics( 'mydb', 'my_time_series_table' )
time_series_storage_id.database_name = checkAndGetLiteralArgument<String>(args[0], "database_name");
time_series_storage_id.table_name = checkAndGetLiteralArgument<String>(args[1], "table_name");
}
}
if (time_series_storage_id.empty())
throw Exception(ErrorCodes::BAD_ARGUMENTS, "Couldn't get a table name from the arguments of the {} table function", name);
time_series_storage_id = context->resolveStorageID(time_series_storage_id);
target_table_type_name = getTargetTable(context)->getName();
}
template <ViewTarget::Kind target_kind>
StoragePtr TableFunctionTimeSeriesTarget<target_kind>::getTargetTable(const ContextPtr & context) const
{
auto time_series_storage = storagePtrToTimeSeries(DatabaseCatalog::instance().getTable(time_series_storage_id, context));
return time_series_storage->getTargetTable(target_kind, context);
}
template <ViewTarget::Kind target_kind>
StoragePtr TableFunctionTimeSeriesTarget<target_kind>::executeImpl(
const ASTPtr & /* ast_function */,
ContextPtr context,
const String & /* table_name */,
ColumnsDescription /* cached_columns */,
bool /* is_insert_query */) const
{
return getTargetTable(context);
}
template <ViewTarget::Kind target_kind>
ColumnsDescription TableFunctionTimeSeriesTarget<target_kind>::getActualTableStructure(ContextPtr context, bool /* is_insert_query */) const
{
return getTargetTable(context)->getInMemoryMetadataPtr()->columns;
}
template <ViewTarget::Kind target_kind>
const char * TableFunctionTimeSeriesTarget<target_kind>::getStorageTypeName() const
{
return target_table_type_name.c_str();
}
void registerTableFunctionTimeSeries(TableFunctionFactory & factory)
{
factory.registerFunction<TableFunctionTimeSeriesTarget<ViewTarget::Data>>(
{.documentation = {
.description=R"(Provides direct access to the 'data' target table for a specified TimeSeries table.)",
.examples{{"timeSeriesData", "SELECT * from timeSeriesData('mydb', 'time_series_table');", ""}},
.category = FunctionDocumentation::Category::TableFunction}
});
factory.registerFunction<TableFunctionTimeSeriesTarget<ViewTarget::Tags>>(
{.documentation = {
.description=R"(Provides direct access to the 'tags' target table for a specified TimeSeries table.)",
.examples{{"timeSeriesTags", "SELECT * from timeSeriesTags('mydb', 'time_series_table');", ""}},
.category = FunctionDocumentation::Category::TableFunction}
});
factory.registerFunction<TableFunctionTimeSeriesTarget<ViewTarget::Metrics>>(
{.documentation = {
.description=R"(Provides direct access to the 'metrics' target table for a specified TimeSeries table.)",
.examples{{"timeSeriesMetrics", "SELECT * from timeSeriesMetrics('mydb', 'time_series_table');", ""}},
.category = FunctionDocumentation::Category::TableFunction}
});
}
}