A little fix.

Tony-Romanov · Tony-Romanov · commit 72fb137ab80b · 2023-12-20T09:37:32.000+01:00
diff --git a/ydb/library/yql/core/yql_expr_constraint.cpp b/ydb/library/yql/core/yql_expr_constraint.cpp
@@ -964,7 +964,7 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable
     }
 
     template<class TConstraint, bool OrderedMap, class TInput>
-    static void GetFromMapLambda(const TInput& input, const TConstraintSet& handler, TConstraintSet& output, bool isSimpleMap, TExprContext& ctx) {
+    static void GetFromMapLambda(const TInput& input, const TConstraintSet& handler, TConstraintSet& output, bool isSingleItem, TExprContext& ctx) {
         constexpr bool isOrderConstraint = std::is_same<typename TConstraint::TMainConstraint, TSortedConstraintNode>() || std::is_same<typename TConstraint::TMainConstraint, TChoppedConstraintNode>();
         if (const auto lambda = handler.GetConstraint<TConstraint>()) {
             const auto original = input.template GetConstraint<typename TConstraint::TMainConstraint>();
@@ -986,15 +986,15 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable
                 if (!mapping.empty()) {
                     output.AddConstraint(ctx.MakeConstraint<TConstraint>(std::move(mapping)));
                 }
-            } else if (isOrderConstraint || isSimpleMap) {
+            } else if (isOrderConstraint || isSingleItem) {
                 if (const auto filtered = lambda->RemoveOriginal(ctx, original))
                     output.AddConstraint(filtered);
             }
         }
     }
 
     template<class TConstraint, bool OrderedMap, bool WideOutput>
-    static void GetFromMapLambda(const TExprNode::TPtr& input, bool isSimpleMap, TExprContext& ctx) {
+    static void GetFromMapLambda(const TExprNode::TPtr& input, bool isSingleItem, TExprContext& ctx) {
         constexpr bool isOrderConstraint = std::is_same<typename TConstraint::TMainConstraint, TSortedConstraintNode>() || std::is_same<typename TConstraint::TMainConstraint, TChoppedConstraintNode>();
         if (const auto lambda = GetConstraintFromLambda<TConstraint, WideOutput>(input->Tail(), ctx)) {
             const auto original = GetDetailed(input->Head().GetConstraint<typename TConstraint::TMainConstraint>(), *input->Head().GetTypeAnn(), ctx);
@@ -1016,7 +1016,7 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable
                 if (!mapping.empty()) {
                     input->AddConstraint(ctx.MakeConstraint<TConstraint>(std::move(mapping)));
                 }
-            } else if (isOrderConstraint || isSimpleMap) {
+            } else if (isOrderConstraint || isSingleItem) {
                 if (const auto filtered = lambda->RemoveOriginal(ctx, original))
                     input->AddConstraint(filtered);
             }
@@ -1051,11 +1051,11 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable
             }
         }
 
-        const bool isSimple = !Flat || ETypeAnnotationKind::Optional == input->Tail().Tail().GetTypeAnn()->GetKind();
-        GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);
-        GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);
-        GetFromMapLambda<TPartOfSortedConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);
-        GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);
+        const bool singleItem = ETypeAnnotationKind::Optional == input->GetTypeAnn()->GetKind();
+        GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);
+        GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);
+        GetFromMapLambda<TPartOfSortedConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);
+        GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);
 
         const auto lambdaVarIndex = GetConstraintFromLambda<TVarIndexConstraintNode, WideOutput>(input->Tail(), ctx);
         const auto lambdaMulti = GetConstraintFromLambda<TMultiConstraintNode, WideOutput>(input->Tail(), ctx);
@@ -1102,10 +1102,10 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable
                             }
                         }
                     }
-                    GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);
-                    GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);
-                    GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);
-                    GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);
+                    GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);
+                    GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);
+                    GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);
+                    GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);
 
                     if (const auto empty = item.second.template GetConstraint<TEmptyConstraintNode>()) {
                         remappedItems.pop_back();
@@ -1128,10 +1128,10 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable
                                     }
                                 }
                             }
-                            GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);
-                            GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);
-                            GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);
-                            GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);
+                            GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);
+                            GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);
+                            GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);
+                            GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);
 
                             if (const auto empty = item.second.template GetConstraint<TEmptyConstraintNode>()) {
                                 remappedItems.pop_back();

Original file line number	Diff line number	Diff line change
`@@ -964,7 +964,7 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable`
`964`	`964`	`}`
`965`	`965`
`966`	`966`	`template<class TConstraint, bool OrderedMap, class TInput>`
`967`		`- static void GetFromMapLambda(const TInput& input, const TConstraintSet& handler, TConstraintSet& output, bool isSimpleMap, TExprContext& ctx) {`
	`967`	`+ static void GetFromMapLambda(const TInput& input, const TConstraintSet& handler, TConstraintSet& output, bool isSingleItem, TExprContext& ctx) {`
`968`	`968`	`constexpr bool isOrderConstraint = std::is_same<typename TConstraint::TMainConstraint, TSortedConstraintNode>() \|\| std::is_same<typename TConstraint::TMainConstraint, TChoppedConstraintNode>();`
`969`	`969`	`if (const auto lambda = handler.GetConstraint<TConstraint>()) {`
`970`	`970`	`const auto original = input.template GetConstraint<typename TConstraint::TMainConstraint>();`
`@@ -986,15 +986,15 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable`
`986`	`986`	`if (!mapping.empty()) {`
`987`	`987`	`output.AddConstraint(ctx.MakeConstraint<TConstraint>(std::move(mapping)));`
`988`	`988`	`}`
`989`		`- } else if (isOrderConstraint \|\| isSimpleMap) {`
	`989`	`+ } else if (isOrderConstraint \|\| isSingleItem) {`
`990`	`990`	`if (const auto filtered = lambda->RemoveOriginal(ctx, original))`
`991`	`991`	`output.AddConstraint(filtered);`
`992`	`992`	`}`
`993`	`993`	`}`
`994`	`994`	`}`
`995`	`995`
`996`	`996`	`template<class TConstraint, bool OrderedMap, bool WideOutput>`
`997`		`- static void GetFromMapLambda(const TExprNode::TPtr& input, bool isSimpleMap, TExprContext& ctx) {`
	`997`	`+ static void GetFromMapLambda(const TExprNode::TPtr& input, bool isSingleItem, TExprContext& ctx) {`
`998`	`998`	`constexpr bool isOrderConstraint = std::is_same<typename TConstraint::TMainConstraint, TSortedConstraintNode>() \|\| std::is_same<typename TConstraint::TMainConstraint, TChoppedConstraintNode>();`
`999`	`999`	`if (const auto lambda = GetConstraintFromLambda<TConstraint, WideOutput>(input->Tail(), ctx)) {`
`1000`	`1000`	`const auto original = GetDetailed(input->Head().GetConstraint<typename TConstraint::TMainConstraint>(), *input->Head().GetTypeAnn(), ctx);`
`@@ -1016,7 +1016,7 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable`
`1016`	`1016`	`if (!mapping.empty()) {`
`1017`	`1017`	`input->AddConstraint(ctx.MakeConstraint<TConstraint>(std::move(mapping)));`
`1018`	`1018`	`}`
`1019`		`- } else if (isOrderConstraint \|\| isSimpleMap) {`
	`1019`	`+ } else if (isOrderConstraint \|\| isSingleItem) {`
`1020`	`1020`	`if (const auto filtered = lambda->RemoveOriginal(ctx, original))`
`1021`	`1021`	`input->AddConstraint(filtered);`
`1022`	`1022`	`}`
`@@ -1051,11 +1051,11 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable`
`1051`	`1051`	`}`
`1052`	`1052`	`}`
`1053`	`1053`
`1054`		`- const bool isSimple = !Flat \|\| ETypeAnnotationKind::Optional == input->Tail().Tail().GetTypeAnn()->GetKind();`
`1055`		`- GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);`
`1056`		`- GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);`
`1057`		`- GetFromMapLambda<TPartOfSortedConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);`
`1058`		`- GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered, WideOutput>(input, isSimple, ctx);`
	`1054`	`+ const bool singleItem = ETypeAnnotationKind::Optional == input->GetTypeAnn()->GetKind();`
	`1055`	`+ GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);`
	`1056`	`+ GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);`
	`1057`	`+ GetFromMapLambda<TPartOfSortedConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);`
	`1058`	`+ GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered, WideOutput>(input, singleItem, ctx);`
`1059`	`1059`
`1060`	`1060`	`const auto lambdaVarIndex = GetConstraintFromLambda<TVarIndexConstraintNode, WideOutput>(input->Tail(), ctx);`
`1061`	`1061`	`const auto lambdaMulti = GetConstraintFromLambda<TMultiConstraintNode, WideOutput>(input->Tail(), ctx);`
`@@ -1102,10 +1102,10 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable`
`1102`	`1102`	`}`
`1103`	`1103`	`}`
`1104`	`1104`	`}`
`1105`		`- GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);`
`1106`		`- GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);`
`1107`		`- GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);`
`1108`		`- GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, isSimple, ctx);`
	`1105`	`+ GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);`
	`1106`	`+ GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);`
	`1107`	`+ GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);`
	`1108`	`+ GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(input->Head(), item.second, remappedItems.back().second, singleItem, ctx);`
`1109`	`1109`
`1110`	`1110`	`if (const auto empty = item.second.template GetConstraint<TEmptyConstraintNode>()) {`
`1111`	`1111`	`remappedItems.pop_back();`
`@@ -1128,10 +1128,10 @@ class TCallableConstraintTransformer : public TCallableTransformerBase<TCallable`
`1128`	`1128`	`}`
`1129`	`1129`	`}`
`1130`	`1130`	`}`
`1131`		`- GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);`
`1132`		`- GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);`
`1133`		`- GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);`
`1134`		`- GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, isSimple, ctx);`
	`1131`	`+ GetFromMapLambda<TPartOfUniqueConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);`
	`1132`	`+ GetFromMapLambda<TPartOfDistinctConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);`
	`1133`	`+ GetFromMapLambda<TPartOfSortedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);`
	`1134`	`+ GetFromMapLambda<TPartOfChoppedConstraintNode, Ordered>(*origConstr, item.second, remappedItems.back().second, singleItem, ctx);`
`1135`	`1135`
`1136`	`1136`	`if (const auto empty = item.second.template GetConstraint<TEmptyConstraintNode>()) {`
`1137`	`1137`	`remappedItems.pop_back();`