Skip to content

Commit 1f9cb6b

Browse files
zverevgenyzverevgeny
authored
YQ-2068 extract TTypeBuilder from TProgramBuilder to get rid of dependency on IFunctionRegistry (#2224)
1 parent f2032d9 commit 1f9cb6b

File tree

13 files changed

+250
-206
lines changed

13 files changed

+250
-206
lines changed

‎ydb/library/yql/minikql/mkql_program_builder.cpp

Lines changed: 3 additions & 105 deletions
Original file line numberDiff line numberDiff line change
@@ -323,7 +323,9 @@ void EnsureDataOrOptionalOfData(TRuntimeNode node) {
323323
}
324324

325325
TProgramBuilder::TProgramBuilder(const TTypeEnvironment& env, const IFunctionRegistry& functionRegistry, bool voidWithEffects)
326-
: Env(env), FunctionRegistry(functionRegistry), VoidWithEffects(voidWithEffects)
326+
: TTypeBuilder(env)
327+
, FunctionRegistry(functionRegistry)
328+
, VoidWithEffects(voidWithEffects)
327329
{}
328330

329331
const TTypeEnvironment& TProgramBuilder::GetTypeEnvironment() const {
@@ -2325,38 +2327,6 @@ TRuntimeNode TProgramBuilder::NewEmptyStruct() {
23252327
return TRuntimeNode(Env.GetEmptyStructLazy(), true);
23262328
}
23272329

2328-
TType* TProgramBuilder::NewEmptyStructType() {
2329-
return Env.GetEmptyStructLazy()->GetGenericType();
2330-
}
2331-
2332-
TType* TProgramBuilder::NewStructType(TType* baseStructType, const std::string_view& memberName, TType* memberType) {
2333-
MKQL_ENSURE(baseStructType->IsStruct(), "Expected struct type");
2334-
2335-
const auto& detailedBaseStructType = static_cast<const TStructType&>(*baseStructType);
2336-
TStructTypeBuilder builder(Env);
2337-
builder.Reserve(detailedBaseStructType.GetMembersCount() + 1);
2338-
for (ui32 i = 0, e = detailedBaseStructType.GetMembersCount(); i < e; ++i) {
2339-
builder.Add(detailedBaseStructType.GetMemberName(i), detailedBaseStructType.GetMemberType(i));
2340-
}
2341-
2342-
builder.Add(memberName, memberType);
2343-
return builder.Build();
2344-
}
2345-
2346-
TType* TProgramBuilder::NewStructType(const TArrayRef<const std::pair<std::string_view, TType*>>& memberTypes) {
2347-
TStructTypeBuilder builder(Env);
2348-
builder.Reserve(memberTypes.size());
2349-
for (auto& x : memberTypes) {
2350-
builder.Add(x.first, x.second);
2351-
}
2352-
2353-
return builder.Build();
2354-
}
2355-
2356-
TType* TProgramBuilder::NewArrayType(const TArrayRef<const std::pair<std::string_view, TType*>>& memberTypes) {
2357-
return NewStructType(memberTypes);
2358-
}
2359-
23602330
TRuntimeNode TProgramBuilder::NewStruct(const TArrayRef<const std::pair<std::string_view, TRuntimeNode>>& members) {
23612331
if (members.empty()) {
23622332
return NewEmptyStruct();
@@ -2406,46 +2376,6 @@ TRuntimeNode TProgramBuilder::NewList(TType* itemType, const TArrayRef<const TRu
24062376
return TRuntimeNode(builder.Build(), true);
24072377
}
24082378

2409-
TType* TProgramBuilder::NewDataType(NUdf::TDataTypeId schemeType, bool optional) {
2410-
return optional ? NewOptionalType(TDataType::Create(schemeType, Env)) : TDataType::Create(schemeType, Env);
2411-
}
2412-
2413-
TType* TProgramBuilder::NewPgType(ui32 typeId) {
2414-
return TPgType::Create(typeId, Env);
2415-
}
2416-
2417-
TType* TProgramBuilder::NewDecimalType(ui8 precision, ui8 scale) {
2418-
return TDataDecimalType::Create(precision, scale, Env);
2419-
}
2420-
2421-
TType* TProgramBuilder::NewOptionalType(TType* itemType) {
2422-
return TOptionalType::Create(itemType, Env);
2423-
}
2424-
2425-
TType* TProgramBuilder::NewListType(TType* itemType) {
2426-
return TListType::Create(itemType, Env);
2427-
}
2428-
2429-
TType* TProgramBuilder::NewStreamType(TType* itemType) {
2430-
return TStreamType::Create(itemType, Env);
2431-
}
2432-
2433-
TType* TProgramBuilder::NewFlowType(TType* itemType) {
2434-
return TFlowType::Create(itemType, Env);
2435-
}
2436-
2437-
TType* TProgramBuilder::NewBlockType(TType* itemType, TBlockType::EShape shape) {
2438-
return TBlockType::Create(itemType, shape, Env);
2439-
}
2440-
2441-
TType* TProgramBuilder::NewTaggedType(TType* baseType, const std::string_view& tag) {
2442-
return TTaggedType::Create(baseType, tag, Env);
2443-
}
2444-
2445-
TType* TProgramBuilder::NewDictType(TType* keyType, TType* payloadType, bool multi) {
2446-
return TDictType::Create(keyType, multi ? NewListType(payloadType) : payloadType, Env);
2447-
}
2448-
24492379
TRuntimeNode TProgramBuilder::NewEmptyDict() {
24502380
return TRuntimeNode(Env.GetEmptyDictLazy(), true);
24512381
}
@@ -2460,17 +2390,6 @@ TRuntimeNode TProgramBuilder::NewEmptyTuple() {
24602390
return TRuntimeNode(Env.GetEmptyTupleLazy(), true);
24612391
}
24622392

2463-
TType* TProgramBuilder::NewEmptyTupleType() {
2464-
return Env.GetEmptyTupleLazy()->GetGenericType();
2465-
}
2466-
2467-
TType* TProgramBuilder::NewTupleType(const TArrayRef<TType* const>& elements) {
2468-
return TTupleType::Create(elements.size(), elements.data(), Env);
2469-
}
2470-
2471-
TType* TProgramBuilder::NewArrayType(const TArrayRef<TType* const>& elements) {
2472-
return NewTupleType(elements);
2473-
}
24742393

24752394
TRuntimeNode TProgramBuilder::NewTuple(TType* tupleType, const TArrayRef<const TRuntimeNode>& elements) {
24762395
MKQL_ENSURE(tupleType->IsTuple(), "Expected tuple type");
@@ -2488,27 +2407,6 @@ TRuntimeNode TProgramBuilder::NewTuple(const TArrayRef<const TRuntimeNode>& elem
24882407
return NewTuple(NewTupleType(types), elements);
24892408
}
24902409

2491-
TType* TProgramBuilder::NewEmptyMultiType() {
2492-
if (RuntimeVersion > 35) {
2493-
return TMultiType::Create(0, nullptr, Env);
2494-
}
2495-
return Env.GetEmptyTupleLazy()->GetGenericType();
2496-
}
2497-
2498-
TType* TProgramBuilder::NewMultiType(const TArrayRef<TType* const>& elements) {
2499-
if (RuntimeVersion > 35) {
2500-
return TMultiType::Create(elements.size(), elements.data(), Env);
2501-
}
2502-
return TTupleType::Create(elements.size(), elements.data(), Env);
2503-
}
2504-
2505-
TType* TProgramBuilder::NewResourceType(const std::string_view& tag) {
2506-
return TResourceType::Create(tag, Env);
2507-
}
2508-
2509-
TType* TProgramBuilder::NewVariantType(TType* underlyingType) {
2510-
return TVariantType::Create(underlyingType, Env);
2511-
}
25122410

25132411
TRuntimeNode TProgramBuilder::NewVariant(TRuntimeNode item, ui32 index, TType* variantType) {
25142412
const auto type = AS_TYPE(TVariantType, variantType);

‎ydb/library/yql/minikql/mkql_program_builder.h

Lines changed: 2 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
#include "defs.h"
44
#include "mkql_node.h"
55
#include "mkql_node_builder.h"
6+
#include "mkql_type_builder.h"
67
#include <ydb/library/yql/public/udf/udf_value.h>
78
#include <ydb/library/yql/core/sql_types/match_recognize.h>
89

@@ -122,7 +123,7 @@ struct TAggInfo {
122123
std::vector<ui32> ArgsColumns;
123124
};
124125

125-
class TProgramBuilder : public TMoveOnly {
126+
class TProgramBuilder : public TTypeBuilder {
126127
public:
127128
TProgramBuilder(const TTypeEnvironment& env, const IFunctionRegistry& functionRegistry, bool voidWithEffects = false);
128129

@@ -136,13 +137,7 @@ class TProgramBuilder : public TMoveOnly {
136137
TRuntimeNode NewVoid();
137138
TRuntimeNode NewNull();
138139

139-
TType* NewDataType(NUdf::TDataTypeId schemeType, bool optional = false);
140-
TType* NewDataType(NUdf::EDataSlot slot, bool optional = false) {
141-
return NewDataType(NUdf::GetDataTypeInfo(slot).TypeId, optional);
142-
}
143140

144-
TType* NewDecimalType(ui8 precision, ui8 scale);
145-
TType* NewPgType(ui32 typeId);
146141

147142
template <typename T, typename = std::enable_if_t<NUdf::TKnownDataType<T>::Result>>
148143
TRuntimeNode NewDataLiteral(T data) const {
@@ -162,47 +157,27 @@ class TProgramBuilder : public TMoveOnly {
162157

163158
TRuntimeNode NewDecimalLiteral(NYql::NDecimal::TInt128 data, ui8 precision, ui8 scale) const;
164159

165-
TType* NewOptionalType(TType* itemType);
166160
TRuntimeNode NewEmptyOptional(TType* optionalOrPgType);
167161
TRuntimeNode NewEmptyOptionalDataLiteral(NUdf::TDataTypeId schemeType);
168162
TRuntimeNode NewOptional(TRuntimeNode data);
169163
TRuntimeNode NewOptional(TType* optionalType, TRuntimeNode data);
170164

171-
TType* NewEmptyStructType();
172-
TType* NewStructType(TType* baseStructType, const std::string_view& memberName, TType* memberType);
173-
TType* NewStructType(const TArrayRef<const std::pair<std::string_view, TType*>>& memberTypes);
174-
TType* NewArrayType(const TArrayRef<const std::pair<std::string_view, TType*>>& memberTypes);
175165
TRuntimeNode NewEmptyStruct();
176166
TRuntimeNode NewStruct(const TArrayRef<const std::pair<std::string_view, TRuntimeNode>>& members);
177167
TRuntimeNode NewStruct(TType* structType, const TArrayRef<const std::pair<std::string_view, TRuntimeNode>>& members);
178168

179-
TType* NewListType(TType* itemType);
180169
TRuntimeNode NewEmptyList();
181170
TRuntimeNode NewEmptyList(TType* itemType);
182171
TRuntimeNode NewEmptyListOfVoid();
183172
TRuntimeNode NewList(TType* itemType, const TArrayRef<const TRuntimeNode>& items);
184173

185-
TType* NewDictType(TType* keyType, TType* payloadType, bool multi);
186174
TRuntimeNode NewEmptyDict();
187175
TRuntimeNode NewDict(TType* dictType, const TArrayRef<const std::pair<TRuntimeNode, TRuntimeNode>>& items);
188176

189-
TType* NewStreamType(TType* itemType);
190-
TType* NewFlowType(TType* itemType);
191-
TType* NewTaggedType(TType* baseType, const std::string_view& tag);
192-
TType* NewBlockType(TType* itemType, TBlockType::EShape shape);
193-
194-
TType* NewEmptyTupleType();
195-
TType* NewTupleType(const TArrayRef<TType* const>& elements);
196-
TType* NewArrayType(const TArrayRef<TType* const>& elements);
197177
TRuntimeNode NewEmptyTuple();
198178
TRuntimeNode NewTuple(TType* tupleType, const TArrayRef<const TRuntimeNode>& elements);
199179
TRuntimeNode NewTuple(const TArrayRef<const TRuntimeNode>& elements);
200180

201-
TType* NewEmptyMultiType();
202-
TType* NewMultiType(const TArrayRef<TType* const>& elements);
203-
204-
TType* NewResourceType(const std::string_view& tag);
205-
TType* NewVariantType(TType* underlyingType);
206181
TRuntimeNode NewVariant(TRuntimeNode item, ui32 tupleIndex, TType* variantType);
207182
TRuntimeNode NewVariant(TRuntimeNode item, const std::string_view& member, TType* variantType);
208183

@@ -831,11 +806,9 @@ class TProgramBuilder : public TMoveOnly {
831806

832807
bool IsNull(TRuntimeNode arg);
833808
protected:
834-
const TTypeEnvironment& Env;
835809
const IFunctionRegistry& FunctionRegistry;
836810
const bool VoidWithEffects;
837811
NUdf::ITypeInfoHelper::TPtr TypeInfoHelper;
838-
bool UseNullType = true;
839812
};
840813

841814
bool CanExportType(TType* type, const TTypeEnvironment& env);

‎ydb/library/yql/minikql/mkql_type_builder.cpp

Lines changed: 120 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99

1010
#include <library/cpp/containers/stack_vector/stack_vec.h>
1111
#include <ydb/library/yql/minikql/computation/mkql_computation_node_impl.h>
12+
#include <ydb/library/yql/minikql/mkql_runtime_version.h>
1213
#include <ydb/library/yql/minikql/mkql_node_printer.h>
1314
#include <ydb/library/yql/parser/pg_catalog/catalog.h>
1415
#include <ydb/library/yql/parser/pg_wrapper/interface/compare.h>
@@ -2467,5 +2468,124 @@ NUdf::IBlockItemHasher::TPtr TBlockTypeHelper::MakeHasher(NUdf::TType* type) con
24672468
return NUdf::MakeBlockReaderImpl<THasherTraits>(TTypeInfoHelper(), type, nullptr).release();
24682469
}
24692470

2471+
TType* TTypeBuilder::NewVoidType() const {
2472+
return TRuntimeNode(Env.GetVoidLazy(), true).GetStaticType();
2473+
}
2474+
2475+
TType* TTypeBuilder::NewNullType() const {
2476+
if (!UseNullType || RuntimeVersion < 11) {
2477+
TCallableBuilder callableBuilder(Env, "Null", NewOptionalType(NewVoidType()));
2478+
return TRuntimeNode(callableBuilder.Build(), false).GetStaticType();
2479+
} else {
2480+
return TRuntimeNode(Env.GetNullLazy(), true).GetStaticType();
2481+
}
2482+
}
2483+
2484+
TType* TTypeBuilder::NewEmptyStructType() const {
2485+
return Env.GetEmptyStructLazy()->GetGenericType();
2486+
}
2487+
2488+
TType* TTypeBuilder::NewStructType(TType* baseStructType, const std::string_view& memberName, TType* memberType) const {
2489+
MKQL_ENSURE(baseStructType->IsStruct(), "Expected struct type");
2490+
2491+
const auto& detailedBaseStructType = static_cast<const TStructType&>(*baseStructType);
2492+
TStructTypeBuilder builder(Env);
2493+
builder.Reserve(detailedBaseStructType.GetMembersCount() + 1);
2494+
for (ui32 i = 0, e = detailedBaseStructType.GetMembersCount(); i < e; ++i) {
2495+
builder.Add(detailedBaseStructType.GetMemberName(i), detailedBaseStructType.GetMemberType(i));
2496+
}
2497+
2498+
builder.Add(memberName, memberType);
2499+
return builder.Build();
2500+
}
2501+
2502+
TType* TTypeBuilder::NewStructType(const TArrayRef<const std::pair<std::string_view, TType*>>& memberTypes) const {
2503+
TStructTypeBuilder builder(Env);
2504+
builder.Reserve(memberTypes.size());
2505+
for (auto& x : memberTypes) {
2506+
builder.Add(x.first, x.second);
2507+
}
2508+
2509+
return builder.Build();
2510+
}
2511+
2512+
TType* TTypeBuilder::NewArrayType(const TArrayRef<const std::pair<std::string_view, TType*>>& memberTypes) const {
2513+
return NewStructType(memberTypes);
2514+
}
2515+
2516+
TType* TTypeBuilder::NewDataType(NUdf::TDataTypeId schemeType, bool optional) const {
2517+
return optional ? NewOptionalType(TDataType::Create(schemeType, Env)) : TDataType::Create(schemeType, Env);
2518+
}
2519+
2520+
TType* TTypeBuilder::NewPgType(ui32 typeId) const {
2521+
return TPgType::Create(typeId, Env);
2522+
}
2523+
2524+
TType* TTypeBuilder::NewDecimalType(ui8 precision, ui8 scale) const {
2525+
return TDataDecimalType::Create(precision, scale, Env);
2526+
}
2527+
2528+
TType* TTypeBuilder::NewOptionalType(TType* itemType) const {
2529+
return TOptionalType::Create(itemType, Env);
2530+
}
2531+
2532+
TType* TTypeBuilder::NewListType(TType* itemType) const {
2533+
return TListType::Create(itemType, Env);
2534+
}
2535+
2536+
TType* TTypeBuilder::NewStreamType(TType* itemType) const {
2537+
return TStreamType::Create(itemType, Env);
2538+
}
2539+
2540+
TType* TTypeBuilder::NewFlowType(TType* itemType) const {
2541+
return TFlowType::Create(itemType, Env);
2542+
}
2543+
2544+
TType* TTypeBuilder::NewBlockType(TType* itemType, TBlockType::EShape shape) const {
2545+
return TBlockType::Create(itemType, shape, Env);
2546+
}
2547+
2548+
TType* TTypeBuilder::NewTaggedType(TType* baseType, const std::string_view& tag) const {
2549+
return TTaggedType::Create(baseType, tag, Env);
2550+
}
2551+
2552+
TType* TTypeBuilder::NewDictType(TType* keyType, TType* payloadType, bool multi) const {
2553+
return TDictType::Create(keyType, multi ? NewListType(payloadType) : payloadType, Env);
2554+
}
2555+
2556+
TType* TTypeBuilder::NewEmptyTupleType() const {
2557+
return Env.GetEmptyTupleLazy()->GetGenericType();
2558+
}
2559+
2560+
TType* TTypeBuilder::NewTupleType(const TArrayRef<TType* const>& elements) const {
2561+
return TTupleType::Create(elements.size(), elements.data(), Env);
2562+
}
2563+
2564+
TType* TTypeBuilder::NewArrayType(const TArrayRef<TType* const>& elements) const {
2565+
return NewTupleType(elements);
2566+
}
2567+
2568+
TType* TTypeBuilder::NewEmptyMultiType() const {
2569+
if (RuntimeVersion > 35) {
2570+
return TMultiType::Create(0, nullptr, Env);
2571+
}
2572+
return Env.GetEmptyTupleLazy()->GetGenericType();
2573+
}
2574+
2575+
TType* TTypeBuilder::NewMultiType(const TArrayRef<TType* const>& elements) const {
2576+
if (RuntimeVersion > 35) {
2577+
return TMultiType::Create(elements.size(), elements.data(), Env);
2578+
}
2579+
return TTupleType::Create(elements.size(), elements.data(), Env);
2580+
}
2581+
2582+
TType* TTypeBuilder::NewResourceType(const std::string_view& tag) const {
2583+
return TResourceType::Create(tag, Env);
2584+
}
2585+
2586+
TType* TTypeBuilder::NewVariantType(TType* underlyingType) const {
2587+
return TVariantType::Create(underlyingType, Env);
2588+
}
2589+
24702590
} // namespace NMiniKQL
24712591
} // namespace Nkikimr

0 commit comments

Comments
 (0)