PartOFConstraint intermediate refactoring.

3 files changed, 125 insertions, 124 deletions

diff --git a/ydb/library/yql/ast/yql_constraint.cpp b/ydb/library/yql/ast/yql_constraint.cpp
index ef604735299..96ea900acd0 100644
--- a/ydb/library/yql/ast/yql_constraint.cpp
+++ b/ydb/library/yql/ast/yql_constraint.cpp
@@ -280,18 +280,22 @@ bool TSortedConstraintNode::IsPrefixOf(const TSortedConstraintNode& node) const
     return node.Includes(*this);
 }
 
-bool TSortedConstraintNode::IsOrderBy(const TUniqueConstraintNode& unique) const {
-    NSorted::TSimpleSet<TColumnsSet> columns;
+const TSortedConstraintNode::TFullSetType TSortedConstraintNode::GetAllSets() const {
+    TFullSetType sets;
     for (const auto& key : Content_)
-        columns.insert_unique(key.first);
+        sets.insert_unique(key.first);
+    return sets;
+}
 
+bool TSortedConstraintNode::IsOrderBy(const TUniqueConstraintNode& unique) const {
+    auto columns = GetAllSets();
     const auto ordered = columns;
     for (const auto& set : unique.GetAllSets()) {
         if (std::all_of(set.cbegin(), set.cend(), [&ordered](const TPathType& path) {
-            return !path.empty() && std::any_of(ordered.cbegin(), ordered.cend(), [&path](const TColumnsSet& s) { return s.contains(path); });
+            return !path.empty() && std::any_of(ordered.cbegin(), ordered.cend(), [&path](const TSetType& s) { return s.contains(path); });
         })) {
             std::for_each(set.cbegin(), set.cend(), [&columns](const TPathType& path) {
-                if (const auto it = std::find_if(columns.cbegin(), columns.cend(), [&path](const TColumnsSet& s) { return s.contains(path); }); columns.cend() != it)
+                if (const auto it = std::find_if(columns.cbegin(), columns.cend(), [&path](const TSetType& s) { return s.contains(path); }); columns.cend() != it)
                     columns.erase(it);
             });
             if (columns.empty())
@@ -322,7 +326,7 @@ const TSortedConstraintNode* TSortedConstraintNode::MakeCommon(const std::vector
                     for (auto j = 0U; j < size; ++j) {
                         auto& one = (*content)[j];
                         auto& two = nextContent[j];
-                        TColumnsSet common;
+                        TSetType common;
                         common.reserve(std::min(one.first.size(), two.first.size()));
                         std::set_intersection(one.first.cbegin(), one.first.cend(), two.first.cbegin(), two.first.cend(), std::back_inserter(common));
                         if (common.empty() || one.second != two.second) {
@@ -357,7 +361,7 @@ const TSortedConstraintNode* TSortedConstraintNode::MakeCommon(const TSortedCons
     for (auto j = 0U; j < size; ++j) {
         auto& one = content[j];
         auto& two = Content_[j];
-        TColumnsSet common;
+        TSetType common;
         common.reserve(std::min(one.first.size(), two.first.size()));
         std::set_intersection(one.first.cbegin(), one.first.cend(), two.first.cbegin(), two.first.cend(), std::back_inserter(common));
         if (common.empty() || one.second != two.second) {
@@ -406,9 +410,29 @@ const TSortedConstraintNode* TSortedConstraintNode::CutPrefix(size_t newPrefixLe
     return ctx.MakeConstraint<TSortedConstraintNode>(std::move(content));
 }
 
+const TSortedConstraintNode* TSortedConstraintNode::RenameFields(TExprContext& ctx, const TPathReduce& reduce) const {
+    TContainerType sorted;
+    sorted.reserve(Content_.size());
+    for (const auto& item : Content_) {
+        TSetType newSet;
+        newSet.reserve(item.first.size());
+        for (const auto& path : item.first) {
+            auto newPaths = reduce(path);
+            if (!newPaths.empty())
+                newSet.insert_unique(newPaths.cbegin(), newPaths.cend());
+        }
+
+        if (newSet.empty())
+            break;
+        else
+            sorted.emplace_back(std::move(newSet), item.second);
+    }
+    return sorted.empty() ? nullptr : ctx.MakeConstraint<TSortedConstraintNode>(std::move(sorted));
+}
+
 bool TSortedConstraintNode::IsApplicableToType(const TTypeAnnotationNode& type) const {
     const auto& itemType = GetSeqItemType(type);
-    return std::all_of(Content_.cbegin(), Content_.cend(), [&itemType](const std::pair<TColumnsSet, bool>& pair) {
+    return std::all_of(Content_.cbegin(), Content_.cend(), [&itemType](const std::pair<TSetType, bool>& pair) {
         return std::all_of(pair.first.cbegin(), pair.first.cend(), std::bind(&GetSubTypeByPath, std::placeholders::_1, std::cref(itemType)));
     });
 }
@@ -629,7 +653,7 @@ bool TUniqueConstraintNode::HasEqualColumns(const std::vector<std::string_view>&
     return false;
 }
 
-const TUniqueConstraintNode* TUniqueConstraintNode::FilterFields(TExprContext& ctx, const std::function<bool(const TPathType&)>& predicate) const {
+const TUniqueConstraintNode* TUniqueConstraintNode::FilterFields(TExprContext& ctx, const TPathFilter& predicate) const {
     auto sets = Sets_;
     for (auto it = sets.cbegin(); sets.cend() != it;) {
         if (std::all_of(it->cbegin(), it->cend(), predicate))
@@ -640,7 +664,7 @@ const TUniqueConstraintNode* TUniqueConstraintNode::FilterFields(TExprContext& c
     return sets.empty() ? nullptr : ctx.MakeConstraint<TUniqueConstraintNode>(std::move(sets));
 }
 
-const TUniqueConstraintNode* TUniqueConstraintNode::RenameFields(TExprContext& ctx, const std::function<std::vector<TPathType>(const TPathType&)>& reduce) const {
+const TUniqueConstraintNode* TUniqueConstraintNode::RenameFields(TExprContext& ctx, const TPathReduce& reduce) const {
     TFullSetType sets;
     sets.reserve(Sets_.size());
     for (const auto& set : Sets_) {
@@ -784,7 +808,7 @@ TPartOfConstraintNode<TOriginalConstraintNode>::ExtractField(TExprContext& ctx,
 
 template<class TOriginalConstraintNode>
 const TPartOfConstraintNode<TOriginalConstraintNode>*
-TPartOfConstraintNode<TOriginalConstraintNode>::FilterFields(TExprContext& ctx, const std::function<bool(const TPathType& front)>& predicate) const {
+TPartOfConstraintNode<TOriginalConstraintNode>::FilterFields(TExprContext& ctx, const TPathFilter& predicate) const {
     auto mapping = Mapping_;
     for (auto part = mapping.begin(); mapping.end() != part;) {
         for (auto it = part->second.cbegin(); part->second.cend() != it;) {
@@ -803,6 +827,27 @@ TPartOfConstraintNode<TOriginalConstraintNode>::FilterFields(TExprContext& ctx,
 }
 
 template<class TOriginalConstraintNode>
+const TPartOfConstraintNode<TOriginalConstraintNode>*
+TPartOfConstraintNode<TOriginalConstraintNode>::RenameFields(TExprContext& ctx, const TPathReduce& rename) const {
+    auto mapping = Mapping_;
+    for (auto part = mapping.begin(); mapping.end() != part;) {
+        TPartType old;
+        part->second.swap(old);
+        for (auto& item : std::move(old)) {
+            for (auto& path : rename(item.first)) {
+                part->second.insert_unique(std::make_pair(std::move(path), std::move(item.second)));
+            }
+        }
+
+        if (part->second.empty())
+            part = mapping.erase(part);
+        else
+            ++part;
+    }
+    return mapping.empty() ? nullptr : ctx.MakeConstraint<TPartOfConstraintNode>(std::move(mapping));
+}
+
+template<class TOriginalConstraintNode>
 typename TPartOfConstraintNode<TOriginalConstraintNode>::TMapType
 TPartOfConstraintNode<TOriginalConstraintNode>::GetColumnMapping(const std::string_view& asField) const {
     auto mapping = Mapping_;
@@ -915,23 +960,6 @@ void TPartOfConstraintNode<TOriginalConstraintNode>::UniqueMerge(TMapType& outpu
 }
 
 template<class TOriginalConstraintNode>
-void TPartOfConstraintNode<TOriginalConstraintNode>::FilterFields(TMapType& mapping, const std::function<bool(const std::string_view& front)>& predicate) {
-    for (auto part = mapping.begin(); mapping.end() != part;) {
-        for (auto it = part->second.cbegin(); part->second.cend() != it;) {
-            if (it->first.empty() || !predicate(it->first.front()))
-                it = part->second.erase(it);
-            else
-                ++it;
-        }
-
-        if (part->second.empty())
-            part = mapping.erase(part);
-        else
-            ++part;
-    }
-}
-
-template<class TOriginalConstraintNode>
 typename TPartOfConstraintNode<TOriginalConstraintNode>::TMapType
 TPartOfConstraintNode<TOriginalConstraintNode>::ExtractField(const TMapType& mapping, const std::string_view& field) {
     TMapType parts;
diff --git a/ydb/library/yql/ast/yql_constraint.h b/ydb/library/yql/ast/yql_constraint.h
index fb3fe5ca53b..608c861cb5d 100644
--- a/ydb/library/yql/ast/yql_constraint.h
+++ b/ydb/library/yql/ast/yql_constraint.h
@@ -30,6 +30,8 @@ protected:
 public:
     using TPathType = std::deque<std::string_view>;
     using TListType = std::vector<const TConstraintNode*>;
+    using TPathFilter = std::function<bool(const TPathType&)>;
+    using TPathReduce = std::function<std::vector<TPathType>(const TPathType&)>;
 
     struct THash {
         size_t operator()(const TConstraintNode* node) const {
@@ -195,8 +197,8 @@ public:
     bool HasEqualColumns(const std::vector<std::string_view>& columns) const;
 
     static const TUniqueConstraintNode* MakeCommon(const std::vector<const TConstraintSet*>& constraints, TExprContext& ctx);
-    const TUniqueConstraintNode* FilterFields(TExprContext& ctx, const std::function<bool(const TPathType&)>& predicate) const;
-    const TUniqueConstraintNode* RenameFields(TExprContext& ctx, const std::function<std::vector<TPathType>(const TPathType&)>& reduce) const;
+    const TUniqueConstraintNode* FilterFields(TExprContext& ctx, const TPathFilter& predicate) const;
+    const TUniqueConstraintNode* RenameFields(TExprContext& ctx, const TPathReduce& reduce) const;
 
     bool IsApplicableToType(const TTypeAnnotationNode& type) const override;
 private:
@@ -205,8 +207,9 @@ private:
 
 class TSortedConstraintNode final: public TConstraintNode {
 public:
-    using TColumnsSet = NSorted::TSimpleSet<TPathType>;
-    using TContainerType = TSmallVec<std::pair<TColumnsSet, bool>>;
+    using TSetType = NSorted::TSimpleSet<TPathType>;
+    using TContainerType = TSmallVec<std::pair<TSetType, bool>>;
+    using TFullSetType = NSorted::TSimpleSet<TSetType>;
 private:
     friend struct TExprContext;
 
@@ -221,6 +224,8 @@ public:
         return Content_;
     }
 
+    const TFullSetType GetAllSets() const;
+
     bool Equals(const TConstraintNode& node) const override;
     bool Includes(const TConstraintNode& node) const override;
     void Out(IOutputStream& out) const override;
@@ -235,6 +240,8 @@ public:
     const TSortedConstraintNode* MakeCommon(const TSortedConstraintNode* other, TExprContext& ctx) const;
     static const TSortedConstraintNode* FilterByType(const TSortedConstraintNode* sorted, const TStructExprType* outItemType, TExprContext& ctx);
 
+    const TSortedConstraintNode* RenameFields(TExprContext& ctx, const TPathReduce& reduce) const;
+
     bool IsApplicableToType(const TTypeAnnotationNode& type) const override;
 protected:
     TContainerType Content_;
@@ -281,13 +288,13 @@ public:
     void ToJson(NJson::TJsonWriter& out) const override;
 
     const TPartOfConstraintNode* ExtractField(TExprContext& ctx, const std::string_view& field) const;
-    const TPartOfConstraintNode* FilterFields(TExprContext& ctx, const std::function<bool(const TPathType& front)>& predicate) const;
+    const TPartOfConstraintNode* FilterFields(TExprContext& ctx, const TPathFilter& predicate) const;
+    const TPartOfConstraintNode* RenameFields(TExprContext& ctx, const TPathReduce& reduce) const;
 
     static const TPartOfConstraintNode* MakeCommon(const std::vector<const TConstraintSet*>& constraints, TExprContext& ctx);
 
     static TMapType GetCommonMapping(const TOriginalConstraintNode* complete, const TPartOfConstraintNode* incomplete = nullptr, const std::string_view& field = {});
     static void UniqueMerge(TMapType& output, TMapType&& input);
-    static void FilterFields(TMapType& mapping, const std::function<bool(const std::string_view& front)>& predicate);
     static TMapType ExtractField(const TMapType& mapping, const std::string_view& field);
 
     static const TOriginalConstraintNode* MakeComplete(TExprContext& ctx, const TMapType& mapping, const TOriginalConstraintNode* original);
diff --git a/ydb/library/yql/core/yql_expr_constraint.cpp b/ydb/library/yql/core/yql_expr_constraint.cpp
index 63815b8c3b7..12d209fbd0a 100644
--- a/ydb/library/yql/core/yql_expr_constraint.cpp
+++ b/ydb/library/yql/core/yql_expr_constraint.cpp
@@ -80,8 +80,8 @@ public:
         : TCallableTransformerBase<TCallableConstraintTransformer>(types, instantOnly)
         , SubGraph(subGraph)
     {
-        Functions["Unordered"] = &TCallableConstraintTransformer::FromFirst<TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
-        Functions["UnorderedSubquery"] = &TCallableConstraintTransformer::FromFirst<TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions["Unordered"] = &TCallableConstraintTransformer::FromFirst<TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
+        Functions["UnorderedSubquery"] = &TCallableConstraintTransformer::FromFirst<TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TVarIndexConstraintNode, TMultiConstraintNode>;
         Functions["Sort"] = &TCallableConstraintTransformer::SortWrap;
         Functions["AssumeSorted"] = &TCallableConstraintTransformer::SortWrap;
         Functions["AssumeUnique"] = &TCallableConstraintTransformer::AssumeUniqueWrap;
@@ -105,10 +105,10 @@ public:
         Functions["ToStream"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
         Functions["ToSequence"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
         Functions["Collect"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
-        Functions["FilterNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TVarIndexConstraintNode>;
-        Functions["SkipNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TPartOfUniqueConstraintNode, TVarIndexConstraintNode>;
-        Functions["FilterNullElements"] = &TCallableConstraintTransformer::FromFirst<TPassthroughConstraintNode, TEmptyConstraintNode, TVarIndexConstraintNode>;
-        Functions["SkipNullElements"] = &TCallableConstraintTransformer::FromFirst<TPassthroughConstraintNode, TEmptyConstraintNode, TVarIndexConstraintNode>;
+        Functions["FilterNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TVarIndexConstraintNode>;
+        Functions["SkipNullMembers"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TVarIndexConstraintNode>;
+        Functions["FilterNullElements"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TVarIndexConstraintNode>;
+        Functions["SkipNullElements"] = &TCallableConstraintTransformer::FromFirst<TSortedConstraintNode, TPassthroughConstraintNode, TEmptyConstraintNode, TUniqueConstraintNode, TVarIndexConstraintNode>;
         Functions["Right!"] = &TCallableConstraintTransformer::CopyAllFrom<0>;
         Functions["Cons!"] = &TCallableConstraintTransformer::CopyAllFrom<1>;
         Functions["ExtractMembers"] = &TCallableConstraintTransformer::ExtractMembersWrap;
@@ -298,24 +298,6 @@ private:
         return TStatus::Ok;
     }
 
-    template <size_t StartFromChild>
-    TStatus AllCommonFromChildren(const TExprNode::TPtr& input, TExprNode::TPtr& output, TExprContext& ctx) const {
-        Y_UNUSED(output);
-        TVector<const TConstraintSet*> constraints;
-        for (size_t i = StartFromChild; i < input->ChildrenSize(); ++i) {
-            constraints.push_back(&input->Child(i)->GetConstraintSet());
-        }
-        TApplyCommonConstraint<TSortedConstraintNode
-            , TUniqueConstraintNode
-            , TPartOfUniqueConstraintNode
-            , TPassthroughConstraintNode
-            , TEmptyConstraintNode
-            , TVarIndexConstraintNode
-            , TMultiConstraintNode
-            >::Do(input, constraints, ctx);
-        return TStatus::Ok;
-    }
-
     TStatus FromEmpty(const TExprNode::TPtr& input, TExprNode::TPtr& /*output*/, TExprContext& ctx) const {
         input->AddConstraint(ctx.MakeConstraint<TEmptyConstraintNode>());
         return TStatus::Ok;
@@ -348,7 +330,7 @@ private:
 
             for (const auto& item : input->Tail().Children()) {
                 if (item->Tail().IsCallable("Bool"))
-                    sorted.emplace_back(std::make_pair(TSortedConstraintNode::TColumnsSet{TConstraintNode::TPathType(1U, item->Head().Content())}, FromString<bool>(item->Tail().Tail().Content())));
+                    sorted.emplace_back(std::make_pair(TSortedConstraintNode::TSetType{TConstraintNode::TPathType(1U, item->Head().Content())}, FromString<bool>(item->Tail().Tail().Content())));
                 else
                     break;
             }
@@ -407,10 +389,14 @@ private:
 
     template <bool CheckMembersType = false>
     TStatus SelectMembersWrap(const TExprNode::TPtr& input, TExprNode::TPtr& /*output*/, TExprContext& ctx) const {
-        const TTypeAnnotationNode* outItemType = input->GetTypeAnn();
+        auto outItemType = input->GetTypeAnn();
         while (outItemType->GetKind() == ETypeAnnotationKind::Optional) {
             outItemType = outItemType->Cast<TOptionalExprType>()->GetItemType();
         }
+        auto inItemType = input->Head().GetTypeAnn();
+        while (inItemType->GetKind() == ETypeAnnotationKind::Optional) {
+            inItemType = inItemType->Cast<TOptionalExprType>()->GetItemType();
+        }
         if (outItemType->GetKind() == ETypeAnnotationKind::Variant) {
             if (outItemType->Cast<TVariantExprType>()->GetUnderlyingType()->GetKind() == ETypeAnnotationKind::Tuple) {
                 const auto outSize = outItemType->Cast<TVariantExprType>()->GetUnderlyingType()->Cast<TTupleExprType>()->GetSize();
@@ -446,14 +432,10 @@ private:
         }
         else if (outItemType->GetKind() == ETypeAnnotationKind::Struct) {
             const auto outStructType = outItemType->Cast<TStructExprType>();
+            const auto inStructType = inItemType->Cast<TStructExprType>();
             if (const auto passthrough = input->Head().GetConstraint<TPassthroughConstraintNode>()) {
                 TPassthroughConstraintNode::TMapType filteredMapping;
                 if constexpr (CheckMembersType) {
-                    auto inItemType = input->Head().GetTypeAnn();
-                    while (inItemType->GetKind() == ETypeAnnotationKind::Optional) {
-                        inItemType = inItemType->Cast<TOptionalExprType>()->GetItemType();
-                    }
-                    const auto inStructType = inItemType->Cast<TStructExprType>();
                     const auto& inItems = inStructType->GetItems();
                     const auto& outItems = outStructType->GetItems();
                     for (const auto& part : passthrough->GetColumnMapping()) {
@@ -491,28 +473,22 @@ private:
                 }
             }
 
+            const auto filter = CheckMembersType ?
+                TConstraintNode::TPathFilter([inStructType, outStructType](const TConstraintNode::TPathType& path) {
+                    if (path.empty())
+                        return false;
+                    if (const auto itemType = TConstraintNode::GetSubTypeByPath(path, *outStructType))
+                        return IsSameAnnotation(*itemType, *TConstraintNode::GetSubTypeByPath(path, *inStructType));
+                    return false;
+                }):
+                TConstraintNode::TPathFilter([outStructType](const TConstraintNode::TPathType& path) {
+                    return !path.empty() && TConstraintNode::GetSubTypeByPath(path, *outStructType); }
+                );
+
             if (const auto part = input->Head().GetConstraint<TPartOfUniqueConstraintNode>()) {
-                auto mapping = part->GetColumnMapping();
-                if constexpr (CheckMembersType) {
-                    if (!mapping.empty()) {
-                        auto inItemType = input->Head().GetTypeAnn();
-                        while (inItemType->GetKind() == ETypeAnnotationKind::Optional) {
-                            inItemType = inItemType->Cast<TOptionalExprType>()->GetItemType();
-                        }
-                        const auto inStructType = inItemType->Cast<TStructExprType>();
-                        const auto& inItems = inStructType->GetItems();
-                        const auto& outItems = outStructType->GetItems();
-                        TPartOfUniqueConstraintNode::FilterFields(mapping, [&](const std::string_view& field) {
-                            const auto outItem = outStructType->FindItem(field);
-                            const auto inItem = inStructType->FindItem(field);
-                            return outItem && inItem && IsSameAnnotation(*outItems[*outItem]->GetItemType(), *inItems[*inItem]->GetItemType());
-                        });
-                    }
-                } else
-                    TPartOfUniqueConstraintNode::FilterFields(mapping, [outStructType](const std::string_view& field) { return bool(outStructType->FindItem(field)); });
-
-                if (!mapping.empty())
-                    input->AddConstraint(ctx.MakeConstraint<TPartOfUniqueConstraintNode>(std::move(mapping)));
+                if (const auto filtered = part->FilterFields(ctx, filter)) {
+                    input->AddConstraint(filtered);
+                }
             }
         }
 
@@ -544,33 +520,25 @@ private:
             }
         }
 
-        if (const auto part = input->Head().GetConstraint<TPartOfUniqueConstraintNode>()) {
-            auto mapping = part->GetColumnMapping();
-            for (auto part = mapping.begin(); mapping.end() != part;) {
-                for (auto it = part->second.begin(); part->second.end() != it;) {
-                    bool pass = false;
-                    for (const auto& p : prefixes) {
-                        const auto& prefix = p->Content();
-                        pass = !it->first.empty() && it->first.front().starts_with(prefix);
-                        if (pass) {
-                            it->first.front() = it->first.front().substr(prefix.length());
-                            break;
-                        }
-                    }
+        const auto rename = [&](const TConstraintNode::TPathType& path) -> std::vector<TConstraintNode::TPathType> {
+            if (path.empty())
+                return {};
 
-                    if (pass)
-                        ++it;
-                    else
-                        it = part->second.erase(it);
+            for (const auto& p : prefixes) {
+                if (const auto& prefix = p->Content(); path.front().starts_with(prefix)) {
+                    auto out = path;
+                    out.front() = out.front().substr(prefix.length());
+                    return {std::move(out)};
                 }
+            }
 
-                if (part->second.empty())
-                    part = mapping.erase(part);
-                else
-                    ++part;
+            return {};
+        };
+
+        if (const auto part = input->Head().GetConstraint<TPartOfUniqueConstraintNode>()) {
+            if (const auto filtered = part->RenameFields(ctx, rename)) {
+                input->AddConstraint(filtered);
             }
-            if (!mapping.empty())
-                input->AddConstraint(ctx.MakeConstraint<TPartOfUniqueConstraintNode>(std::move(mapping)));
         }
 
         return FromFirst<TVarIndexConstraintNode>(input, output, ctx);
@@ -646,10 +614,9 @@ private:
                 input->AddConstraint(sorted);
 
             if (const auto part = input->Head().GetConstraint<TPartOfUniqueConstraintNode>()) {
-                auto mapping = part->GetColumnMapping();
-                TPartOfUniqueConstraintNode::FilterFields(mapping, [outStructType](const std::string_view& field) { return bool(outStructType->FindItem(field)); });
-                if (!mapping.empty())
-                    input->AddConstraint(ctx.MakeConstraint<TPartOfUniqueConstraintNode>(std::move(mapping)));
+                if (const auto filtered = part->FilterFields(ctx, [outStructType](const TConstraintNode::TPathType& path) { return !path.empty() && outStructType->FindItem(path.front()); })) {
+                    input->AddConstraint(filtered);
+                }
             }
         }
         else if (outItemType->GetKind() == ETypeAnnotationKind::Variant) {
@@ -685,10 +652,9 @@ private:
                         constr.AddConstraint(sorted);
 
                     if (const auto part = input->Head().GetConstraint<TPartOfUniqueConstraintNode>()) {
-                        auto mapping = part->GetColumnMapping();
-                        TPartOfUniqueConstraintNode::FilterFields(mapping, [outStructType](const std::string_view& field) { return bool(outStructType->FindItem(field)); });
-                        if (!mapping.empty())
-                            constr.AddConstraint(ctx.MakeConstraint<TPartOfUniqueConstraintNode>(std::move(mapping)));
+                        if (const auto filtered = part->FilterFields(ctx, [outStructType](const TConstraintNode::TPathType& path) { return !path.empty() && outStructType->FindItem(path.front()); })) {
+                            constr.AddConstraint(filtered);
+                        }
                     }
                 }
                 input->AddConstraint(ctx.MakeConstraint<TMultiConstraintNode>(std::move(multiItems)));
@@ -1385,10 +1351,9 @@ private:
         }
 
         if (const auto part = input->Head().GetConstraint<TPartOfUniqueConstraintNode>()) {
-            auto mapping = part->GetColumnMapping();
-            TPartOfUniqueConstraintNode::FilterFields(mapping, std::bind(std::not_equal_to<std::string_view>(), std::cref(name), std::placeholders::_1));
-            if (!mapping.empty())
-                input->AddConstraint(ctx.MakeConstraint<TPartOfUniqueConstraintNode>(std::move(mapping)));
+            if (const auto filtered = part->FilterFields(ctx, [&name](const TConstraintNode::TPathType& path) { return !path.empty() && path.front() != name; })) {
+                input->AddConstraint(filtered);
+            }
         }
 
         return FromFirst<TVarIndexConstraintNode>(input, output, ctx);
@@ -1438,8 +1403,9 @@ private:
 
         TPartOfUniqueConstraintNode::TMapType uniques;
         if (const auto part = input->Head().GetConstraint<TPartOfUniqueConstraintNode>()) {
-            uniques = part->GetColumnMapping();
-            TPartOfUniqueConstraintNode::FilterFields(uniques, std::bind(std::not_equal_to<std::string_view>(), std::cref(name), std::placeholders::_1));
+            if (const auto filtered = part->FilterFields(ctx, [&name](const TConstraintNode::TPathType& path) { return !path.empty() && path.front() != name; })) {
+                uniques = filtered->GetColumnMapping();
+            }
         }
         if (const auto part = input->Tail().GetConstraint<TPartOfUniqueConstraintNode>()) {
             TPartOfUniqueConstraintNode::UniqueMerge(uniques, part->GetColumnMapping(name));
@@ -2594,7 +2560,7 @@ private:
         if (const auto& columns = ExtractSimpleSortTraits(directions, keyExtractor); !columns.empty()) {
             TSortedConstraintNode::TContainerType content(columns.size());
             std::transform(columns.cbegin(), columns.cend(), content.begin(), [](const std::pair<TConstraintNode::TPathType, bool>& item) {
-                return std::make_pair(TSortedConstraintNode::TColumnsSet{item.first}, item.second);
+                return std::make_pair(TSortedConstraintNode::TSetType{item.first}, item.second);
             });
             return ctx.MakeConstraint<TSortedConstraintNode>(std::move(content));
         }