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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
#include "Parsers/IAST_fwd.h"
#include <Interpreters/MutationsNonDeterministicHelpers.h>
#include <Parsers/ASTSelectQuery.h>
#include <Parsers/ASTFunction.h>
#include <Parsers/ASTLiteral.h>
#include <Parsers/ASTAlterQuery.h>
#include <Storages/MutationCommands.h>
#include <Interpreters/InDepthNodeVisitor.h>
#include <Interpreters/evaluateConstantExpression.h>
#include <Interpreters/ExecuteScalarSubqueriesVisitor.h>
#include <Interpreters/addTypeConversionToAST.h>
#include <Interpreters/Context.h>
#include <Functions/FunctionFactory.h>
namespace DB
{
namespace
{
/// Helps to detect situations, where non-deterministic functions may be used in mutations.
class FirstNonDeterministicFunctionMatcher
{
public:
struct Data
{
ContextPtr context;
FirstNonDeterministicFunctionResult result;
};
static bool needChildVisit(const ASTPtr & /*node*/, const ASTPtr & /*child*/)
{
return true;
}
static void visit(const ASTPtr & node, Data & data)
{
if (data.result.nondeterministic_function_name || data.result.subquery)
return;
if (node->as<ASTSelectQuery>())
{
/// We cannot determine if subquery is deterministic or not,
/// so we do not allow to use subqueries in mutation without allow_nondeterministic_mutations=1
data.result.subquery = true;
}
else if (const auto * function = typeid_cast<const ASTFunction *>(node.get()))
{
/// Property of being deterministic for lambda expression is completely determined
/// by the contents of its definition, so we just proceed to it.
if (function->name != "lambda")
{
/// NOTE It may be an aggregate function, so get(...) may throw.
/// However, an aggregate function can be used only in subquery and we do not go into subquery.
const auto func = FunctionFactory::instance().get(function->name, data.context);
if (!func->isDeterministic())
data.result.nondeterministic_function_name = func->getName();
}
}
}
};
using FirstNonDeterministicFunctionFinder = InDepthNodeVisitor<FirstNonDeterministicFunctionMatcher, true>;
using FirstNonDeterministicFunctionData = FirstNonDeterministicFunctionMatcher::Data;
/// Executes and replaces with literals
/// non-deterministic functions in query.
/// Similar to ExecuteScalarSubqueriesVisitor.
class ExecuteNonDeterministicConstFunctionsMatcher
{
public:
struct Data
{
ContextPtr context;
std::optional<size_t> max_literal_size;
};
static bool needChildVisit(const ASTPtr & ast, const ASTPtr & /*child*/)
{
/// Do not visit subqueries because they are executed separately.
return !ast->as<ASTSelectQuery>();
}
static void visit(ASTPtr & ast, const Data & data)
{
if (auto * function = ast->as<ASTFunction>())
visit(*function, ast, data);
}
static void visit(ASTFunction & function, ASTPtr & ast, const Data & data)
{
if (!FunctionFactory::instance().has(function.name))
return;
/// It makes sense to execute functions which are deterministic
/// in scope of query because they are usually constant expressions.
auto builder = FunctionFactory::instance().get(function.name, data.context);
if (builder->isDeterministic() || !builder->isDeterministicInScopeOfQuery())
return;
Field field;
DataTypePtr type;
try
{
std::tie(field, type) = evaluateConstantExpression(ast, data.context);
}
catch (...)
{
/// An exception can be thrown if the expression is not constant.
/// It's ok in that context and we just do nothing in that case.
/// It's bad pattern but it's quite hard to implement it in another way.
return;
}
auto column = type->createColumn();
column->insert(field);
Block scalar{{std::move(column), type, "_constant"}};
if (worthConvertingScalarToLiteral(scalar, data.max_literal_size))
{
auto literal = std::make_unique<ASTLiteral>(std::move(field));
ast = addTypeConversionToAST(std::move(literal), type->getName());
}
}
};
using ExecuteNonDeterministicConstFunctionsVisitor = InDepthNodeVisitor<ExecuteNonDeterministicConstFunctionsMatcher, true>;
}
FirstNonDeterministicFunctionResult findFirstNonDeterministicFunction(const MutationCommand & command, ContextPtr context)
{
FirstNonDeterministicFunctionMatcher::Data finder_data{context, {}};
switch (command.type)
{
case MutationCommand::UPDATE:
{
auto update_assignments_ast = command.ast->as<const ASTAlterCommand &>().update_assignments->clone();
FirstNonDeterministicFunctionFinder(finder_data).visit(update_assignments_ast);
if (finder_data.result.nondeterministic_function_name)
return finder_data.result;
/// Currently UPDATE and DELETE both always have predicates so we can use fallthrough
[[fallthrough]];
}
case MutationCommand::DELETE:
{
auto predicate_ast = command.predicate->clone();
FirstNonDeterministicFunctionFinder(finder_data).visit(predicate_ast);
return finder_data.result;
}
default:
break;
}
return {};
}
ASTPtr replaceNonDeterministicToScalars(const ASTAlterCommand & alter_command, ContextPtr context)
{
const auto & settings = context->getSettingsRef();
if (!settings.mutations_execute_subqueries_on_initiator
&& !settings.mutations_execute_nondeterministic_on_initiator)
return nullptr;
auto query = alter_command.clone();
auto & new_alter_command = *query->as<ASTAlterCommand>();
if (settings.mutations_execute_subqueries_on_initiator)
{
Scalars scalars;
Scalars local_scalars;
ExecuteScalarSubqueriesVisitor::Data data{
WithContext{context},
/*subquery_depth=*/ 0,
scalars,
local_scalars,
/*only_analyze=*/ false,
/*is_create_parameterized_view=*/ false,
/*replace_only_to_literals=*/ true,
settings.mutations_max_literal_size_to_replace};
ExecuteScalarSubqueriesVisitor visitor(data);
if (new_alter_command.update_assignments)
visitor.visit(new_alter_command.update_assignments);
if (new_alter_command.predicate)
visitor.visit(new_alter_command.predicate);
}
if (settings.mutations_execute_nondeterministic_on_initiator)
{
ExecuteNonDeterministicConstFunctionsVisitor::Data data{
context, settings.mutations_max_literal_size_to_replace};
ExecuteNonDeterministicConstFunctionsVisitor visitor(data);
if (new_alter_command.update_assignments)
visitor.visit(new_alter_command.update_assignments);
if (new_alter_command.predicate)
visitor.visit(new_alter_command.predicate);
}
return query;
}
}
|
