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
129
130
131
132
133
134
135
136
|
#include <Planner/PlannerContext.h>
#include <Analyzer/TableNode.h>
#include <Analyzer/ColumnNode.h>
#include <Analyzer/ConstantNode.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
const ColumnIdentifier & GlobalPlannerContext::createColumnIdentifier(const QueryTreeNodePtr & column_node)
{
const auto & column_node_typed = column_node->as<ColumnNode &>();
auto column_source_node = column_node_typed.getColumnSource();
return createColumnIdentifier(column_node_typed.getColumn(), column_source_node);
}
const ColumnIdentifier & GlobalPlannerContext::createColumnIdentifier(const NameAndTypePair & column, const QueryTreeNodePtr & /*column_source_node*/)
{
std::string column_identifier;
column_identifier += column.name;
column_identifier += '_' + std::to_string(column_identifiers.size());
auto [it, inserted] = column_identifiers.emplace(column_identifier);
assert(inserted);
return *it;
}
bool GlobalPlannerContext::hasColumnIdentifier(const ColumnIdentifier & column_identifier)
{
return column_identifiers.contains(column_identifier);
}
PlannerContext::PlannerContext(ContextMutablePtr query_context_, GlobalPlannerContextPtr global_planner_context_)
: query_context(std::move(query_context_))
, global_planner_context(std::move(global_planner_context_))
{}
TableExpressionData & PlannerContext::getOrCreateTableExpressionData(const QueryTreeNodePtr & table_expression_node)
{
auto [it, _] = table_expression_node_to_data.emplace(table_expression_node, TableExpressionData());
return it->second;
}
const TableExpressionData & PlannerContext::getTableExpressionDataOrThrow(const QueryTreeNodePtr & table_expression_node) const
{
auto table_expression_data_it = table_expression_node_to_data.find(table_expression_node);
if (table_expression_data_it == table_expression_node_to_data.end())
throw Exception(ErrorCodes::LOGICAL_ERROR,
"Table expression {} is not registered in planner context",
table_expression_node->formatASTForErrorMessage());
return table_expression_data_it->second;
}
TableExpressionData & PlannerContext::getTableExpressionDataOrThrow(const QueryTreeNodePtr & table_expression_node)
{
auto table_expression_data_it = table_expression_node_to_data.find(table_expression_node);
if (table_expression_data_it == table_expression_node_to_data.end())
throw Exception(ErrorCodes::LOGICAL_ERROR,
"Table expression {} is not registered in planner context",
table_expression_node->formatASTForErrorMessage());
return table_expression_data_it->second;
}
const TableExpressionData * PlannerContext::getTableExpressionDataOrNull(const QueryTreeNodePtr & table_expression_node) const
{
auto table_expression_data_it = table_expression_node_to_data.find(table_expression_node);
if (table_expression_data_it == table_expression_node_to_data.end())
return nullptr;
return &table_expression_data_it->second;
}
TableExpressionData * PlannerContext::getTableExpressionDataOrNull(const QueryTreeNodePtr & table_expression_node)
{
auto table_expression_data_it = table_expression_node_to_data.find(table_expression_node);
if (table_expression_data_it == table_expression_node_to_data.end())
return nullptr;
return &table_expression_data_it->second;
}
const ColumnIdentifier & PlannerContext::getColumnNodeIdentifierOrThrow(const QueryTreeNodePtr & column_node) const
{
auto & column_node_typed = column_node->as<ColumnNode &>();
const auto & column_name = column_node_typed.getColumnName();
auto column_source = column_node_typed.getColumnSource();
const auto & table_expression_data = getTableExpressionDataOrThrow(column_source);
return table_expression_data.getColumnIdentifierOrThrow(column_name);
}
const ColumnIdentifier * PlannerContext::getColumnNodeIdentifierOrNull(const QueryTreeNodePtr & column_node) const
{
auto & column_node_typed = column_node->as<ColumnNode &>();
const auto & column_name = column_node_typed.getColumnName();
auto column_source = column_node_typed.getColumnSourceOrNull();
if (!column_source)
return nullptr;
const auto * table_expression_data = getTableExpressionDataOrNull(column_source);
if (!table_expression_data)
return nullptr;
return table_expression_data->getColumnIdentifierOrNull(column_name);
}
PlannerContext::SetKey PlannerContext::createSetKey(const DataTypePtr & left_operand_type, const QueryTreeNodePtr & set_source_node)
{
const auto set_source_hash = set_source_node->getTreeHash();
if (set_source_node->as<ConstantNode>())
{
/* We need to hash the type of the left operand because we can build different sets for different types.
* (It's done for performance reasons. It's cheaper to convert a small set of values from literal to the type of the left operand.)
*
* For example in expression `(a :: Decimal(9, 1) IN (1.0, 2.5)) AND (b :: Decimal(9, 0) IN (1, 2.5))`
* we need to build two different sets:
* - `{1, 2.5} :: Set(Decimal(9, 1))` for a
* - `{1} :: Set(Decimal(9, 0))` for b (2.5 omitted because bercause it's not representable as Decimal(9, 0)).
*/
return "__set_" + left_operand_type->getName() + '_' + toString(set_source_hash);
}
/// For other cases we will cast left operand to the type of the set source, so no difference in types.
return "__set_" + toString(set_source_hash);
}
}
|
