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
|
#include "yql_opt_normalize_depends_on.h"
#include <yql/essentials/core/yql_expr_optimize.h>
#include <yql/essentials/core/yql_opt_utils.h>
#include <yql/essentials/utils/log/log.h>
#include <util/string/hex.h>
namespace NYql {
namespace {
class TNormalizeDependsOnTransformer : public TSyncTransformerBase {
public:
TNormalizeDependsOnTransformer(const TTypeAnnotationContext& types)
: Types_(types)
{}
IGraphTransformer::TStatus DoTransform(TExprNode::TPtr input, TExprNode::TPtr& output, TExprContext& ctx) override {
if (!Types_.NormalizeDependsOn) {
return IGraphTransformer::TStatus::Ok;
}
if (ctx.Step.IsDone(TExprStep::NormalizeDependsOn)) {
return IGraphTransformer::TStatus::Ok;
}
YQL_PROFILE_SCOPE(DEBUG, "TNormalizeDependsOnTransformer::DoTransform");
std::vector<TExprNode::TPtr> toNormalize;
VisitExpr(input, [&](const TExprNode::TPtr& node) {
// Only InnerDependsOn can be normalized
if (node->IsCallable("InnerDependsOn") && !IsNormalizedDependsOn(*node)) {
toNormalize.push_back(node);
return false;
}
return true;
});
if (toNormalize.empty()) {
ctx.Step.Done(TExprStep::NormalizeDependsOn);
return IGraphTransformer::TStatus::Ok;
}
TNodeOnNodeOwnedMap replaces;
for (const auto& dependsOn : toNormalize) {
TExprNode::TListType normalizedArgs;
auto hash = HexEncode(MakeCacheKey(dependsOn->Head()));
normalizedArgs.push_back(ctx.NewCallable(dependsOn->Head().Pos(), "String", { ctx.NewAtom(dependsOn->Head().Pos(), hash) }));
TNodeSet innerLambdasArgs, outerLambdasArgs;
VisitExpr(dependsOn, [&](const TExprNode::TPtr& node) {
if (node->GetDependencyScope() && node->IsComplete()) {
return false;
}
if (node->IsLambda()) {
for (const auto& arg: node->Head().Children()) {
innerLambdasArgs.insert(arg.Get());
}
} else if (node->IsArgument()) {
if (!innerLambdasArgs.contains(node.Get()) && outerLambdasArgs.insert(node.Get()).second) {
normalizedArgs.push_back(node);
}
}
return true;
}, [&](const TExprNode::TPtr& node) {
if (node->IsLambda()) {
for (const auto& arg: node->Head().Children()) {
innerLambdasArgs.erase(arg.Get());
}
}
return true;
});
if (normalizedArgs.size() == 1) {
replaces[dependsOn.Get()] = ctx.ChangeChild(*dependsOn, 0, std::move(normalizedArgs[0]));
} else {
replaces[dependsOn.Get()] = ctx.ChangeChild(*dependsOn, 0, ctx.NewList(dependsOn->Pos(), std::move(normalizedArgs)));
}
}
YQL_CLOG(INFO, Core) << "NormalizeDependsOn";
output = ctx.ReplaceNodes(std::move(input), replaces);
ctx.Step.Done(TExprStep::NormalizeDependsOn);
return TStatus(IGraphTransformer::TStatus::Repeat, true);
}
void Rewind() override {
}
private:
const TTypeAnnotationContext& Types_;
};
}
THolder<IGraphTransformer> CreateNormalizeDependsOnTransformer(const TTypeAnnotationContext& types) {
return THolder<IGraphTransformer>(new TNormalizeDependsOnTransformer(types));
}
} // namespace NYql
|
