YQ-2068 make IsPresortSupported const (#3657)

2 files changed, 45 insertions, 123 deletions

diff --git a/ydb/library/yql/minikql/mkql_node.cpp b/ydb/library/yql/minikql/mkql_node.cpp
index 81a26aca3a2..f165774a125 100644
--- a/ydb/library/yql/minikql/mkql_node.cpp
+++ b/ydb/library/yql/minikql/mkql_node.cpp
@@ -510,12 +510,9 @@ void TTypeType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TTypeType::CalculatePresortSupport() {
-    return false;
-}
 
 TDataType::TDataType(NUdf::TDataTypeId schemeType, const TTypeEnvironment& env)
-    : TType(EKind::Data, env.GetTypeOfTypeLazy())
+    : TType(EKind::Data, env.GetTypeOfTypeLazy(), true)
     , SchemeType(schemeType)
     , DataSlot(NUdf::FindDataSlot(schemeType))
 {
@@ -563,10 +560,6 @@ void TDataType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TDataType::CalculatePresortSupport() {
-    return true;
-}
-
 TDataDecimalType::TDataDecimalType(ui8 precision, ui8 scale, const TTypeEnvironment& env)
     : TDataType(NUdf::TDataType<NUdf::TDecimal>::Id, env), Precision(precision), Scale(scale)
 {
@@ -651,9 +644,21 @@ bool TDataLiteral::Equals(const TDataLiteral& nodeToCompare) const {
         default: return self.AsStringRef() == that.AsStringRef();
     }
 }
+static const THashSet<TStringBuf> PG_SUPPORTED_PRESORT = {
+    "bool",
+    "int2",
+    "int4",
+    "int8",
+    "float4",
+    "float8",
+    "bytea",
+    "varchar",
+    "text",
+    "cstring"
+};
 
 TPgType::TPgType(ui32 typeId, const TTypeEnvironment& env)
-    : TType(EKind::Pg, env.GetTypeOfTypeLazy())
+    : TType(EKind::Pg, env.GetTypeOfTypeLazy(), PG_SUPPORTED_PRESORT.contains(NYql::NPg::LookupType(typeId).Name))
     , TypeId(typeId)
 {
 }
@@ -689,30 +694,13 @@ void TPgType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-static THashSet<TStringBuf> PG_SUPPORTED_PRESORT = {
-    "bool",
-    "int2",
-    "int4",
-    "int8",
-    "float4",
-    "float8",
-    "bytea",
-    "varchar",
-    "text",
-    "cstring"
-};
-
-bool TPgType::CalculatePresortSupport() {
-    return PG_SUPPORTED_PRESORT.contains(GetName());
-}
-
 const TString& TPgType::GetName() const {
     return NYql::NPg::LookupType(TypeId).Name;
 }
 
 TStructType::TStructType(ui32 membersCount, std::pair<TInternName, TType*>* members, const TTypeEnvironment& env,
     bool validate)
-    : TType(EKind::Struct, env.GetTypeOfTypeLazy())
+    : TType(EKind::Struct, env.GetTypeOfTypeLazy(), CalculatePresortSupport(membersCount, members))
     , MembersCount(membersCount)
     , Members(members)
 {
@@ -843,9 +831,9 @@ void TStructType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TStructType::CalculatePresortSupport() {
-    for (ui32 i = 0; i < MembersCount; ++i) {
-        if (!Members[i].second->IsPresortSupported()) {
+bool TStructType::CalculatePresortSupport(ui32 membersCount, std::pair<TInternName, TType*>* members) {
+    for (ui32 i = 0; i < membersCount; ++i) {
+        if (!members[i].second->IsPresortSupported()) {
             return false;
         }
     }
@@ -986,7 +974,7 @@ bool TStructLiteral::Equals(const TStructLiteral& nodeToCompare) const {
 }
 
 TListType::TListType(TType* itemType, const TTypeEnvironment& env, bool validate)
-    : TType(EKind::List, env.GetTypeOfTypeLazy())
+    : TType(EKind::List, env.GetTypeOfTypeLazy(), itemType->IsPresortSupported())
     , Data(itemType)
     , IndexDictKey(env.GetUi64Lazy())
 {
@@ -1030,10 +1018,6 @@ void TListType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TListType::CalculatePresortSupport() {
-    return GetItemType()->IsPresortSupported();
-}
-
 TListLiteral::TListLiteral(TRuntimeNode* items, ui32 count, TListType* type, const TTypeEnvironment& env, bool validate)
     : TNode(type)
     , Items(items)
@@ -1166,7 +1150,7 @@ bool TListLiteral::Equals(const TListLiteral& nodeToCompare) const {
 }
 
 TStreamType::TStreamType(TType* itemType, const TTypeEnvironment& env, bool validate)
-    : TType(EKind::Stream, env.GetTypeOfTypeLazy())
+    : TType(EKind::Stream, env.GetTypeOfTypeLazy(), false)
     , Data(itemType)
 {
     Y_UNUSED(validate);
@@ -1209,12 +1193,8 @@ void TStreamType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TStreamType::CalculatePresortSupport() {
-    return false;
-}
-
 TFlowType::TFlowType(TType* itemType, const TTypeEnvironment& env, bool validate)
-    : TType(EKind::Flow, env.GetTypeOfTypeLazy())
+    : TType(EKind::Flow, env.GetTypeOfTypeLazy(), false)
     , Data(itemType)
 {
     Y_UNUSED(validate);
@@ -1257,12 +1237,8 @@ void TFlowType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TFlowType::CalculatePresortSupport() {
-    return false;
-}
-
 TOptionalType::TOptionalType(TType* itemType, const TTypeEnvironment& env, bool validate)
-    : TType(EKind::Optional, env.GetTypeOfTypeLazy())
+    : TType(EKind::Optional, env.GetTypeOfTypeLazy(), itemType->IsPresortSupported())
     , Data(itemType)
 {
     Y_UNUSED(validate);
@@ -1305,12 +1281,8 @@ void TOptionalType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TOptionalType::CalculatePresortSupport() {
-    return GetItemType()->IsPresortSupported();
-}
-
 TTaggedType::TTaggedType(TType* baseType, TInternName tag, const TTypeEnvironment& env)
-    : TType(EKind::Tagged, env.GetTypeOfTypeLazy())
+    : TType(EKind::Tagged, env.GetTypeOfTypeLazy(), baseType->IsPresortSupported())
     , BaseType(baseType)
     , Tag(tag)
 {
@@ -1353,10 +1325,6 @@ void TTaggedType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TTaggedType::CalculatePresortSupport() {
-    return GetBaseType()->IsPresortSupported();
-}
-
 TOptionalLiteral::TOptionalLiteral(TOptionalType* type, bool validate)
     : TNode(type)
 {
@@ -1486,12 +1454,9 @@ void TDictType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TDictType::CalculatePresortSupport() {
-    return KeyType->IsPresortSupported() && PayloadType->IsPresortSupported();
-}
 
 TDictType::TDictType(TType* keyType, TType* payloadType, const TTypeEnvironment& env, bool validate)
-    : TType(EKind::Dict, env.GetTypeOfTypeLazy())
+    : TType(EKind::Dict, env.GetTypeOfTypeLazy(), keyType->IsPresortSupported() && payloadType->IsPresortSupported())
     , KeyType(keyType)
     , PayloadType(payloadType)
 {
@@ -1635,7 +1600,7 @@ bool TDictLiteral::Equals(const TDictLiteral& nodeToCompare) const {
 
 TCallableType::TCallableType(const TInternName &name, TType* returnType, ui32 argumentsCount,
         TType **arguments, TNode* payload, const TTypeEnvironment& env)
-    : TType(EKind::Callable, env.GetTypeOfTypeLazy())
+    : TType(EKind::Callable, env.GetTypeOfTypeLazy(), false)
     , IsMergeDisabled0(false)
     , ArgumentsCount(argumentsCount)
     , Name(name)
@@ -1841,10 +1806,6 @@ void TCallableType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TCallableType::CalculatePresortSupport() {
-    return false;
-}
-
 TCallable::TCallable(ui32 inputsCount, TRuntimeNode* inputs, TCallableType* type, bool validate)
     : TNode(type)
     , InputsCount(inputsCount)
@@ -2109,10 +2070,6 @@ void TAnyType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TAnyType::CalculatePresortSupport() {
-    return false;
-}
-
 TAnyType* TAnyType::Create(TTypeType* type, const TTypeEnvironment& env) {
     return ::new(env.Allocate<TAnyType>()) TAnyType(type);
 }
@@ -2303,10 +2260,6 @@ void TResourceType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TResourceType::CalculatePresortSupport() {
-    return false;
-}
-
 TResourceType* TResourceType::Create(const TStringBuf& tag, const TTypeEnvironment& env) {
     return ::new(env.Allocate<TResourceType>()) TResourceType(env.GetTypeOfTypeLazy(), env.InternName(tag));
 }
@@ -2328,7 +2281,7 @@ bool TVariantType::IsConvertableTo(const TVariantType& typeToCompare, bool ignor
 }
 
 TVariantType::TVariantType(TType* underlyingType, const TTypeEnvironment& env, bool validate)
-    : TType(EKind::Variant, env.GetTypeOfTypeLazy())
+    : TType(EKind::Variant, env.GetTypeOfTypeLazy(), underlyingType->IsPresortSupported())
     , Data(underlyingType)
 {
     if (validate) {
@@ -2365,10 +2318,6 @@ void TVariantType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TVariantType::CalculatePresortSupport() {
-    return GetUnderlyingType()->IsPresortSupported();
-}
-
 TVariantLiteral* TVariantLiteral::Create(TRuntimeNode item, ui32 index, TVariantType* type, const TTypeEnvironment& env) {
     return ::new(env.Allocate<TVariantLiteral>()) TVariantLiteral(item, index, type);
 }
@@ -2436,7 +2385,7 @@ void TVariantLiteral::DoFreeze(const TTypeEnvironment& env) {
 }
 
 TBlockType::TBlockType(TType* itemType, EShape shape, const TTypeEnvironment& env)
-    : TType(EKind::Block, env.GetTypeOfTypeLazy())
+    : TType(EKind::Block, env.GetTypeOfTypeLazy(), false)
     , ItemType(itemType)
     , Shape(shape)
 {
@@ -2481,10 +2430,6 @@ void TBlockType::DoFreeze(const TTypeEnvironment& env) {
     Y_UNUSED(env);
 }
 
-bool TBlockType::CalculatePresortSupport() {
-    return false;
-}
-
 bool IsNumericType(NUdf::TDataTypeId typeId) {
     auto slot = NUdf::FindDataSlot(typeId);
     return slot && NUdf::GetDataTypeInfo(*slot).Features & NUdf::NumericType;
diff --git a/ydb/library/yql/minikql/mkql_node.h b/ydb/library/yql/minikql/mkql_node.h
index 8e83bf3ce52..83a61ff9684 100644
--- a/ydb/library/yql/minikql/mkql_node.h
+++ b/ydb/library/yql/minikql/mkql_node.h
@@ -168,31 +168,31 @@ public:
     TTypeBase(const TTypeBase& other)
         : TNode(other.Type)
         , Kind(other.Kind)
+        , SupportsPresort(other.SupportsPresort)
     {}
 
 protected:
-    TTypeBase(EKind kind, TTypeType* type);
+    TTypeBase(EKind kind, TTypeType* type, bool supportsPresort);
     TTypeBase()
         : TNode(nullptr)
         , Kind(EKind::Type)
+        , SupportsPresort(false)
     {}
 
     const EKind Kind;
-    TMaybe<bool> SupportsPresort; // transient
+    const bool SupportsPresort;
 };
 
 class TType: public TTypeBase {
 protected:
-    TType(EKind kind, TTypeType* type)
-      : TTypeBase(kind, type)
+    TType(EKind kind, TTypeType* type, bool supportsPresort)
+      : TTypeBase(kind, type, supportsPresort)
     {}
 
     TType()
       : TTypeBase()
     {}
 
-    virtual bool CalculatePresortSupport() = 0;
-
 public:
     static TStringBuf KindAsStr(EKind kind);
     TStringBuf GetKindAsStr() const;
@@ -211,12 +211,8 @@ public:
     void UpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* CloneOnCallableWrite(const TTypeEnvironment& env) const;
     void Freeze(const TTypeEnvironment& env);
-    bool IsPresortSupported() {
-        if (!SupportsPresort) {
-            SupportsPresort = CalculatePresortSupport();
-        }
-
-        return *SupportsPresort;
+    bool IsPresortSupported() const {
+        return SupportsPresort;
     }
 };
 
@@ -240,7 +236,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
     static TTypeType* Create(const TTypeEnvironment& env);
 };
@@ -259,13 +254,12 @@ public:
 
 private:
     TSingularType(TTypeType* type)
-        : TType(SingularKind, type)
+        : TType(SingularKind, type, true)
     {}
 
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
     static TSingularType<SingularKind>* Create(TTypeType* type, const TTypeEnvironment& env);
 };
@@ -532,7 +526,6 @@ protected:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     const NUdf::TDataTypeId SchemeType;
@@ -604,7 +597,6 @@ protected:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     const ui32 TypeId;
@@ -674,7 +666,7 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
+    static bool CalculatePresortSupport(ui32 membersCount, std::pair<TInternName, TType*>* members);
 
 private:
     ui32 MembersCount;
@@ -739,7 +731,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* Data;
@@ -799,7 +790,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* Data;
@@ -827,7 +817,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* Data;
@@ -855,7 +844,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* Data;
@@ -922,7 +910,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* KeyType;
@@ -1019,7 +1006,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     bool IsMergeDisabled0;
@@ -1106,9 +1092,10 @@ private:
     TRuntimeNode Result;
 };
 
-inline TTypeBase::TTypeBase(EKind kind, TTypeType* type)
+inline TTypeBase::TTypeBase(EKind kind, TTypeType* type, bool supportsPresort)
     : TNode(type)
     , Kind(kind)
+    , SupportsPresort(supportsPresort)
 {
     Y_DEBUG_ABORT_UNLESS(kind != EKind::Type);
 }
@@ -1138,7 +1125,7 @@ public:
 
 private:
     TAnyType(TTypeType* type)
-        : TType(EKind::Any, type)
+        : TType(EKind::Any, type, false)
     {}
 
     static TAnyType* Create(TTypeType* type, const TTypeEnvironment& env);
@@ -1146,7 +1133,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 };
 
 class TAny : public TNode {
@@ -1260,7 +1246,7 @@ public:
 
   protected:
     TTupleLikeType(ui32 elementsCount, TType** elements, const TTypeEnvironment& env)
-        : TType(DerivedKind, env.GetTypeOfTypeLazy())
+        : TType(DerivedKind, env.GetTypeOfTypeLazy(), CalculatePresortSupport(elementsCount, elements))
         , ElementsCount(elementsCount)
         , Elements(elements)
     {
@@ -1311,9 +1297,9 @@ private:
             Y_UNUSED(env);
     }
 
-    bool CalculatePresortSupport() override {
-        for (ui32 i = 0; i < ElementsCount; ++i) {
-            if (!Elements[i]->IsPresortSupported()) {
+    static bool CalculatePresortSupport(ui32 elementsCount, TType** elements) {
+        for (ui32 i = 0; i < elementsCount; ++i) {
+            if (!elements[i]->IsPresortSupported()) {
                 return false;
             }
         }
@@ -1405,14 +1391,13 @@ public:
 
 private:
     TResourceType(TTypeType* type, TInternName tag)
-        : TType(EKind::Resource, type)
+        : TType(EKind::Resource, type, false)
         , Tag(tag)
     {}
 
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TInternName const Tag;
@@ -1448,7 +1433,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* BaseType;
@@ -1494,7 +1478,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* Data;
@@ -1564,7 +1547,6 @@ private:
     void DoUpdateLinks(const THashMap<TNode*, TNode*>& links);
     TNode* DoCloneOnCallableWrite(const TTypeEnvironment& env) const;
     void DoFreeze(const TTypeEnvironment& env);
-    bool CalculatePresortSupport() override;
 
 private:
     TType* ItemType;
@@ -1645,11 +1627,6 @@ void TSingularType<SingularKind>::DoFreeze(const TTypeEnvironment& env) {
 }
 
 template <TType::EKind SingularKind>
-bool TSingularType<SingularKind>::CalculatePresortSupport() {
-    return true;
-}
-
-template <TType::EKind SingularKind>
 TSingular<SingularKind>* TSingular<SingularKind>::Create(const TTypeEnvironment& env) {
     return ::new(env.Allocate<TSingular<SingularKind>>()) TSingular<SingularKind>(env);
 }