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
|
#include "mkql_hasitems.h"
#include <yql/essentials/minikql/computation/mkql_computation_node_codegen.h> // Y_IGNORE
#include <yql/essentials/minikql/mkql_node_cast.h>
#include <yql/essentials/minikql/mkql_node_builder.h>
namespace NKikimr {
namespace NMiniKQL {
namespace {
template <bool IsDict, bool IsOptional>
class THasItemsWrapper : public TMutableCodegeneratorNode<THasItemsWrapper<IsDict, IsOptional>> {
typedef TMutableCodegeneratorNode<THasItemsWrapper<IsDict, IsOptional>> TBaseComputation;
public:
THasItemsWrapper(TComputationMutables& mutables, IComputationNode* collection)
: TBaseComputation(mutables, EValueRepresentation::Embedded)
, Collection(collection)
{}
NUdf::TUnboxedValuePod DoCalculate(TComputationContext& compCtx) const {
const auto& collection = Collection->GetValue(compCtx);
if (IsOptional && !collection) {
return NUdf::TUnboxedValuePod();
}
const bool hasItems = IsDict ? collection.HasDictItems() : collection.HasListItems();
return NUdf::TUnboxedValuePod(hasItems);
}
#ifndef MKQL_DISABLE_CODEGEN
Value* DoGenerateGetValue(const TCodegenContext& ctx, BasicBlock*& block) const {
auto& context = ctx.Codegen.GetContext();
const auto collection = GetNodeValue(Collection, ctx, block);
if constexpr (IsOptional) {
const auto good = BasicBlock::Create(context, "good", ctx.Func);
const auto done = BasicBlock::Create(context, "done", ctx.Func);
const auto result = PHINode::Create(collection->getType(), 2U, "result", done);
result->addIncoming(collection, block);
BranchInst::Create(done, good, IsEmpty(collection, block), block);
block = good;
const auto has = CallBoxedValueVirtualMethod<IsDict ? NUdf::TBoxedValueAccessor::EMethod::HasDictItems : NUdf::TBoxedValueAccessor::EMethod::HasListItems>(Type::getInt1Ty(context), collection, ctx.Codegen, block);
if (Collection->IsTemporaryValue())
CleanupBoxed(collection, ctx, block);
result->addIncoming(MakeBoolean(has, context, block), block);
BranchInst::Create(done, block);
block = done;
return result;
} else {
const auto has = CallBoxedValueVirtualMethod<IsDict ? NUdf::TBoxedValueAccessor::EMethod::HasDictItems : NUdf::TBoxedValueAccessor::EMethod::HasListItems>(Type::getInt1Ty(context), collection, ctx.Codegen, block);
if (Collection->IsTemporaryValue())
CleanupBoxed(collection, ctx, block);
return MakeBoolean(has, context, block);
}
}
#endif
private:
void RegisterDependencies() const final {
this->DependsOn(Collection);
}
IComputationNode* const Collection;
};
}
IComputationNode* WrapHasItems(TCallable& callable, const TComputationNodeFactoryContext& ctx) {
MKQL_ENSURE(callable.GetInputsCount() == 1, "Expected 1 arg");
bool isOptional;
const auto type = UnpackOptional(callable.GetInput(0).GetStaticType(), isOptional);
if (type->IsDict()) {
if (isOptional)
return new THasItemsWrapper<true, true>(ctx.Mutables, LocateNode(ctx.NodeLocator, callable, 0));
else
return new THasItemsWrapper<true, false>(ctx.Mutables, LocateNode(ctx.NodeLocator, callable, 0));
} else {
if (isOptional)
return new THasItemsWrapper<false, true>(ctx.Mutables, LocateNode(ctx.NodeLocator, callable, 0));
else
return new THasItemsWrapper<false, false>(ctx.Mutables, LocateNode(ctx.NodeLocator, callable, 0));
}
THROW yexception() << "Expected list or dict.";
}
}
}
|
