YQL-20229: Add WideMap stream overload

commit_hash:297647045a9ca9c90137f0ec6488181f81fe2447

25 files changed, 521 insertions, 286 deletions

diff --git a/yql/essentials/core/peephole_opt/yql_opt_peephole_physical.cpp b/yql/essentials/core/peephole_opt/yql_opt_peephole_physical.cpp
index 4483106009e..ee16a1bcc39 100644
--- a/yql/essentials/core/peephole_opt/yql_opt_peephole_physical.cpp
+++ b/yql/essentials/core/peephole_opt/yql_opt_peephole_physical.cpp
@@ -421,13 +421,9 @@ TExprNode::TPtr ExpandReplicateScalars(const TExprNode::TPtr& node, TExprContext
     }
 
     return ctx.Builder(node->Pos())
-        .Callable("FromFlow")
-            .Callable(0, "WideMap")
-                .Callable(0, "ToFlow")
-                    .Add(0, node->HeadPtr())
-                .Seal()
-                .Add(1, ctx.NewLambda(node->Pos(), ctx.NewArguments(node->Pos(), std::move(args)), std::move(bodyItems)))
-            .Seal()
+        .Callable("WideMap")
+            .Add(0, node->HeadPtr())
+            .Add(1, ctx.NewLambda(node->Pos(), ctx.NewArguments(node->Pos(), std::move(args)), std::move(bodyItems)))
         .Seal()
         .Build();
 }
@@ -5451,10 +5447,7 @@ TExprNode::TPtr DropUnusedStateFromUpdate(const TExprNode& lambda, const std::ve
 }
 
 TExprNode::TPtr MakeWideMapForDropUnused(TExprNode::TPtr&& input, const std::vector<ui32>& unused, TExprContext& ctx) {
-    const bool isFlow = input->GetTypeAnn()->GetKind() == ETypeAnnotationKind::Flow;
     const auto width = GetStreamOrFlowElementsCount(input->GetTypeAnn());
-    input = isFlow ? std::move(input) : ctx.NewCallable(input->Pos(), "ToFlow", {std::move(input)});
-
     auto result = ctx.Builder(input->Pos())
         .Callable("WideMap")
             .Add(0, std::move(input))
@@ -5469,8 +5462,6 @@ TExprNode::TPtr MakeWideMapForDropUnused(TExprNode::TPtr&& input, const std::vec
                 })
             .Seal()
         .Seal().Build();
-    auto pos = result->Pos();
-    result = isFlow ? result : ctx.NewCallable(pos, "FromFlow", {std::move(result)});
     return result;
 }
 
@@ -6653,24 +6644,20 @@ TExprNode::TPtr OptimizeWideMapBlocks(const TExprNode::TPtr& node, TExprContext&
         if (auto newLambda = RebuildArgumentsOnlyLambdaForBlocks(*lambda, ctx, types)) {
             const auto& wideFromBlocks = input.Head();
             // Technically, the code below rewrites the following sequence
-            // (WideMap (ToFlow (WideFromBlocks (FromFlow (<input>)))))
-            // into (ToFlow (WideFromBlocks (FromFlow (WideMap (<input>)).
+            // (WideMap (ToFlow (WideFromBlocks (<input>))))
+            // into (ToFlow (WideFromBlocks (WideMap (<input>).
             // Hence, the logging is left intact.
             YQL_CLOG(DEBUG, CorePeepHole) << "Swap " << wideFromBlocks.Content() << " with " << node->Content();
             // If tail is FromFlow, its input is WideFlow and can be
             // used intact; Otherwise the input is WideStream, so the
             // new input should be converted to WideFlow.
             const auto tail = wideFromBlocks.HeadPtr();
-            const auto flowInput = tail->IsCallable("FromFlow") ? tail->HeadPtr()
-                                 : ctx.NewCallable(tail->Pos(), "ToFlow", { tail });
             return ctx.Builder(node->Pos())
                 .Callable("ToFlow")
                     .Callable(0, "WideFromBlocks")
-                        .Callable(0, "FromFlow")
-                            .Callable(0, "WideMap")
-                                .Add(0, flowInput)
-                                .Add(1, newLambda)
-                            .Seal()
+                        .Callable(0, "WideMap")
+                            .Add(0, tail)
+                            .Add(1, newLambda)
                         .Seal()
                     .Seal()
                 .Seal()
@@ -6682,7 +6669,7 @@ TExprNode::TPtr OptimizeWideMapBlocks(const TExprNode::TPtr& node, TExprContext&
         return node;
     }
 
-    auto multiInputType = input.GetTypeAnn()->Cast<TFlowExprType>()->GetItemType()->Cast<TMultiExprType>();
+    auto* multiInputType = GetWideFlowOrStreamComponents(*input.GetTypeAnn());
     ui32 newNodes;
     TNodeMap<size_t> rewritePositions;
     TExprNode::TPtr blockLambda;
@@ -6690,6 +6677,8 @@ TExprNode::TPtr OptimizeWideMapBlocks(const TExprNode::TPtr& node, TExprContext&
     bool keepInputColumns = false;
     if (!TBlockRewriter(ctx, types).CollectBlockRewrites(multiInputType->GetItems(), keepInputColumns, lambda, newNodes, rewritePositions, blockLambda, restLambda)) {
         return node;
+    } else {
+        MKQL_ENSURE(input.GetTypeAnn()->GetKind() == ETypeAnnotationKind::Flow, "Only flow WideMap node can be rewritten to blocks.");
     }
 
     if (!newNodes) {
@@ -6701,17 +6690,13 @@ TExprNode::TPtr OptimizeWideMapBlocks(const TExprNode::TPtr& node, TExprContext&
     auto ret = ctx.Builder(node->Pos())
         .Callable("ToFlow")
             .Callable(0, "WideFromBlocks")
-                .Callable(0, "FromFlow")
-                    .Callable(0, "WideMap")
-                        .Callable(0, "ToFlow")
-                            .Callable(0, "WideToBlocks")
-                                .Callable(0, "FromFlow")
-                                    .Add(0, node->HeadPtr())
-                                .Seal()
-                            .Seal()
+                .Callable(0, "WideMap")
+                    .Callable(0, "WideToBlocks")
+                        .Callable(0, "FromFlow")
+                            .Add(0, node->HeadPtr())
                         .Seal()
-                        .Add(1, blockLambda)
                     .Seal()
+                    .Add(1, blockLambda)
                 .Seal()
             .Seal()
         .Seal()
@@ -6745,11 +6730,9 @@ TExprNode::TPtr OptimizeWideFilterBlocks(const TExprNode::TPtr& node, TExprConte
 
     auto blockMapped = ctx.Builder(node->Pos())
         .Callable("WideMap")
-            .Callable(0, "ToFlow")
-                .Callable(0, "WideToBlocks")
-                    .Callable(0, "FromFlow")
-                        .Add(0, node->HeadPtr())
-                    .Seal()
+            .Callable(0, "WideToBlocks")
+                .Callable(0, "FromFlow")
+                    .Add(0, node->HeadPtr())
                 .Seal()
             .Seal()
             .Add(1, blockLambda)
@@ -6760,23 +6743,17 @@ TExprNode::TPtr OptimizeWideFilterBlocks(const TExprNode::TPtr& node, TExprConte
         // lambda is block-friendly
         YQL_ENSURE(it->second == multiInputType->GetSize(), "Block filter column must follow original input columns");
         auto result = ctx.Builder(node->Pos())
-            .Callable("ToFlow")
-                .Callable(0, "BlockCompress")
-                    .Callable(0, "FromFlow")
-                        .Add(0, blockMapped)
-                    .Seal()
-                    .Atom(1, it->second)
-                .Seal()
+            .Callable("BlockCompress")
+                .Add(0, blockMapped)
+                .Atom(1, it->second)
             .Seal()
             .Build();
 
         if (node->ChildrenSize() == 3) {
             result = ctx.Builder(node->Pos())
-                .Callable("ToFlow")
-                    .Callable(0, "WideTakeBlocks")
-                        .Add(0, ctx.NewCallable(node->Pos(), "FromFlow", {result}))
-                        .Add(1, node->ChildPtr(2))
-                    .Seal()
+                .Callable("WideTakeBlocks")
+                    .Add(0, result)
+                    .Add(1, node->ChildPtr(2))
                 .Seal()
                 .Build();
         }
@@ -6786,9 +6763,7 @@ TExprNode::TPtr OptimizeWideFilterBlocks(const TExprNode::TPtr& node, TExprConte
         return ctx.Builder(node->Pos())
             .Callable("ToFlow")
                 .Callable(0, "WideFromBlocks")
-                    .Callable(0, "FromFlow")
-                        .Add(0, result)
-                    .Seal()
+                    .Add(0, result)
                 .Seal()
             .Seal()
             .Build();
@@ -6801,9 +6776,7 @@ TExprNode::TPtr OptimizeWideFilterBlocks(const TExprNode::TPtr& node, TExprConte
         .Callable("WideFilter")
             .Callable(0, "ToFlow")
                 .Callable(0, "WideFromBlocks")
-                    .Callable(0, "FromFlow")
-                        .Add(0, blockMapped)
-                    .Seal()
+                    .Add(0, blockMapped)
                 .Seal()
             .Seal()
             .Add(1, restLambda)
@@ -7055,9 +7028,8 @@ TExprNode::TPtr OptimizeBlockMerge(const TExprNode::TPtr& node, TExprContext& ct
 }
 
 TExprNode::TPtr SwapReplicateScalarsWithWideMap(const TExprNode::TPtr& wideMap, TExprContext& ctx) {
-    const auto& child = wideMap->Head();
-    YQL_ENSURE(wideMap->IsCallable("WideMap") && child.IsCallable("ToFlow") && child.Head().IsCallable("ReplicateScalars"));
-    const auto& input = child.Head();
+    const auto& input = wideMap->Head();
+    YQL_ENSURE(wideMap->IsCallable("WideMap") && input.IsCallable("ReplicateScalars"));
     auto inputTypes = input.GetTypeAnn()->Cast<TStreamExprType>()->GetItemType()->Cast<TMultiExprType>()->GetItems();
     YQL_ENSURE(inputTypes.size() > 0);
 
@@ -7120,18 +7092,12 @@ TExprNode::TPtr SwapReplicateScalarsWithWideMap(const TExprNode::TPtr& wideMap,
     }
 
     return ctx.Builder(wideMap->Pos())
-        .Callable("ToFlow")
-            .Callable(0, "ReplicateScalars")
-                .Callable(0, "FromFlow")
-                    .Callable(0, "WideMap")
-                        .Callable(0, "ToFlow")
-                            .Add(0, input.HeadPtr())
-                        .Seal()
-                        .Add(1, ctx.DeepCopyLambda(lambda))
-                    .Seal()
-                .Seal()
-                .Add(1, ctx.NewList(input.Pos(), std::move(replicatedOutputIndexes)))
+        .Callable("ReplicateScalars")
+            .Callable(0, "WideMap")
+                .Add(0, input.HeadPtr())
+                .Add(1, ctx.DeepCopyLambda(lambda))
             .Seal()
+            .Add(1, ctx.NewList(input.Pos(), std::move(replicatedOutputIndexes)))
         .Seal()
         .Build();
 }
@@ -7171,6 +7137,7 @@ TExprNode::TPtr OptimizeWideMaps(const TExprNode::TPtr& node, TExprContext& ctx)
                     .Add(1, DropUnusedArgs(node->Tail(), unused, ctx))
                 .Seal().Build();
         } else if (input.IsCallable("ToFlow") && input.Head().IsCallable("BlockCompress")) {
+            // This branch is accessible for NarrowMap/ExpandMap callable optimization since they accept flow type.
             auto& blockCompress = input.Head();
             YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << blockCompress.Content() << " with " << unused.size() << " unused fields.";
             const auto index = FromString<ui32>(blockCompress.Tail().Content());
@@ -7185,7 +7152,22 @@ TExprNode::TPtr OptimizeWideMaps(const TExprNode::TPtr& node, TExprContext& ctx)
                     .Seal()
                     .Add(1, DropUnusedArgs(node->Tail(), unused, ctx))
                 .Seal().Build();
+        } else if (input.IsCallable("BlockCompress")) {
+            // This branch is accessible for WideMap callable optimization since it accepts stream type.
+            auto& blockCompress = input;
+            YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << blockCompress.Content() << " with " << unused.size() << " unused fields.";
+            const auto index = FromString<ui32>(blockCompress.Tail().Content());
+            const auto delta = std::distance(unused.cbegin(), std::find_if(unused.cbegin(), unused.cend(), std::bind(std::less<ui32>(), index, std::placeholders::_1)));
+            return ctx.Builder(node->Pos())
+                .Callable(node->Content())
+                    .Callable(0, blockCompress.Content())
+                        .Add(0, MakeWideMapForDropUnused(blockCompress.HeadPtr(), unused, ctx))
+                        .Atom(1, index - delta)
+                    .Seal()
+                    .Add(1, DropUnusedArgs(node->Tail(), unused, ctx))
+                .Seal().Build();
         } else if (input.IsCallable("ToFlow") && input.Head().IsCallable("WideToBlocks")) {
+            // This branch is accessible for NarrowMap/ExpandMap callable optimization since they accept flow type.
             auto actualUnused = unused;
             if (actualUnused.back() + 1U == node->Tail().Head().ChildrenSize())
                 actualUnused.pop_back();
@@ -7226,7 +7208,48 @@ TExprNode::TPtr OptimizeWideMaps(const TExprNode::TPtr& node, TExprContext& ctx)
                     .Seal()
                     .Build();
             }
+        } else if (input.IsCallable("WideToBlocks")) {
+            // This branch is accessible for WideMap callable optimization since it accepts stream type.
+            auto actualUnused = unused;
+            if (actualUnused.back() + 1U == node->Tail().Head().ChildrenSize())
+                actualUnused.pop_back();
+            if (!actualUnused.empty()) {
+                const auto& wideToBlocks = input;
+                YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << wideToBlocks.Content() << " with " << actualUnused.size() << " unused fields.";
+                auto tail = wideToBlocks.HeadPtr();
+                const auto width = tail->GetTypeAnn()->Cast<TStreamExprType>()->GetItemType()->Cast<TMultiExprType>()->GetSize();
+                // Note: Here we wrap WideMap with ToFlow/FromFlow
+                // since we allow stream version of WideMap only for Block types.
+                return ctx.Builder(node->Pos())
+                    .Callable(node->Content())
+                        .Callable(0, "WideToBlocks")
+                            .Callable(0, "FromFlow")
+                                .Callable(0, "WideMap")
+                                    .Callable(0, "ToFlow")
+                                        .Add(0, std::move(tail))
+                                    .Seal()
+                                    .Lambda(1)
+                                        .Params("items", width)
+                                        .Do([&](TExprNodeBuilder& parent) -> TExprNodeBuilder& {
+                                            for (auto i = 0U, j = 0U; i < width; ++i) {
+                                                if (unused.cend() == std::find(unused.cbegin(), unused.cend(), i))
+                                                    parent.Arg(j++, "items", i);
+                                            }
+                                            return parent;
+                                        })
+                                    .Seal()
+                                .Seal()
+                            .Seal()
+                        .Seal()
+                        .Add(1, DropUnusedArgs(node->Tail(), actualUnused, ctx))
+                    .Seal()
+                    .Build();
+            }
         } else if (input.IsCallable("ToFlow") && input.Head().IsCallable({"WideFromBlocks", "WideTakeBlocks", "WideSkipBlocks"})) {
+            // When Wide{Take,Skip}Blocks are optmized, the acceptable map types are NarrowMap/ExpandMap.
+            // When WideFromBlocks is optimized, the acceptable map types are NarrowMap/ExpandMap/WideMap.
+            // Using flow version of WideMap over WideFromBlocks ensures compliance with the following invariant:
+            // WideMap over stream type used <--> WideMap input types are block types.
             auto& inputHead = input.Head();
             YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << inputHead.Content() << " with " << unused.size() << " unused fields.";
             auto rewritedInputHead = ctx.ChangeChild(inputHead, 0U, MakeWideMapForDropUnused(inputHead.HeadPtr(), unused, ctx));
@@ -7238,6 +7261,16 @@ TExprNode::TPtr OptimizeWideMaps(const TExprNode::TPtr& node, TExprContext& ctx)
                     .Add(1, DropUnusedArgs(node->Tail(), unused, ctx))
                 .Seal()
                 .Build();
+        } else if (input.IsCallable({"WideTakeBlocks", "WideSkipBlocks"})) {
+            // This branch is accessible for WideMap callable optimization since it accepts stream type.
+            YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << input.Content() << " with " << unused.size() << " unused fields.";
+            auto rewritedInputHead = ctx.ChangeChild(input, 0U, MakeWideMapForDropUnused(input.HeadPtr(), unused, ctx));
+            return ctx.Builder(node->Pos())
+                .Callable(node->Content())
+                    .Add(0, rewritedInputHead)
+                    .Add(1, DropUnusedArgs(node->Tail(), unused, ctx))
+                .Seal()
+                .Build();
         } else if (input.IsCallable("WideCondense1")) {
             if (const auto& unusedState = UnusedState<2U>(*input.Child(1), input.Tail(), {&node->Tail(), input.Child(2)}); !unusedState.empty()) {
                 YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << input.Content() << " with " << unusedState.size() << " unused fields.";
@@ -7276,8 +7309,8 @@ TExprNode::TPtr OptimizeWideMaps(const TExprNode::TPtr& node, TExprContext& ctx)
                     .Add(0, ctx.ChangeChildren(input, std::move(children)))
                     .Add(1, DropUnusedArgs(node->Tail(), unused, ctx))
                 .Seal().Build();
-        } else if (node->IsCallable("WideMap") && input.IsCallable("ToFlow") && input.Head().IsCallable("ReplicateScalars")) {
-            YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << input.Head().Content();
+        } else if (node->IsCallable("WideMap") && input.IsCallable("ReplicateScalars")) {
+            YQL_CLOG(DEBUG, CorePeepHole) << node->Content() << " over " << input.Content();
             return SwapReplicateScalarsWithWideMap(node, ctx);
         }
     }
diff --git a/yql/essentials/core/type_ann/type_ann_wide.cpp b/yql/essentials/core/type_ann/type_ann_wide.cpp
index 4905e85aeef..c665606a44f 100644
--- a/yql/essentials/core/type_ann/type_ann_wide.cpp
+++ b/yql/essentials/core/type_ann/type_ann_wide.cpp
@@ -8,6 +8,20 @@ namespace NTypeAnnImpl {
 
 namespace {
 
+bool EnsureThatWideMapStreamAllowedForBlocksOnly(bool isFlow, const TMultiExprType* multiType, const TExprNode::TPtr& input, TContext& ctx) {
+    if (!isFlow && !IsWideBlockType(*multiType)) {
+        ctx.Expr.AddError(TIssue(ctx.Expr.GetPosition(input->Pos()), TStringBuilder() << "WideMap must accept stream for block types."));
+        return false;
+    }
+
+    if (isFlow && IsWideBlockType(*multiType)) {
+        ctx.Expr.AddError(TIssue(ctx.Expr.GetPosition(input->Pos()), TStringBuilder() << "WideMap must accept flow for non-block types."));
+        return false;
+    }
+
+    return true;
+}
+
 const TMultiExprType* GetWideLambdaOutputType(const TExprNode& lambda, TExprContext& ctx) {
     TTypeAnnotationNode::TListType types;
     types.reserve(lambda.ChildrenSize() - 1U);
@@ -54,11 +68,16 @@ IGraphTransformer::TStatus WideMapWrapper(const TExprNode::TPtr& input, TExprNod
         return IGraphTransformer::TStatus::Error;
     }
 
-    if (!EnsureWideFlowType(input->Head(), ctx.Expr)) {
+    if (!EnsureWideFlowOrStreamType(input->Head(), ctx.Expr)) {
         return IGraphTransformer::TStatus::Error;
     }
 
-    const auto multiType = input->Head().GetTypeAnn()->Cast<TFlowExprType>()->GetItemType()->Cast<TMultiExprType>();
+    const auto multiType = GetWideFlowOrStreamComponents(*input->Head().GetTypeAnn());
+    bool isFlow = input->Head().GetTypeAnn()->GetKind() == ETypeAnnotationKind::Flow;
+
+    if (!EnsureThatWideMapStreamAllowedForBlocksOnly(isFlow, multiType, input, ctx)) {
+        return IGraphTransformer::TStatus::Error;
+    }
 
     auto& lambda = input->TailRef();
     const auto status = ConvertToLambda(lambda, ctx.Expr, multiType->GetSize());
@@ -85,7 +104,11 @@ IGraphTransformer::TStatus WideMapWrapper(const TExprNode::TPtr& input, TExprNod
         }
     }
 
-    input->SetTypeAnn(ctx.Expr.MakeType<TFlowExprType>(GetWideLambdaOutputType(*lambda, ctx.Expr)));
+    if (isFlow) {
+        input->SetTypeAnn(ctx.Expr.MakeType<TFlowExprType>(GetWideLambdaOutputType(*lambda, ctx.Expr)));
+    } else {
+        input->SetTypeAnn(ctx.Expr.MakeType<TStreamExprType>(GetWideLambdaOutputType(*lambda, ctx.Expr)));
+    }
     return IGraphTransformer::TStatus::Ok;
 }
 
diff --git a/yql/essentials/core/yql_expr_type_annotation.cpp b/yql/essentials/core/yql_expr_type_annotation.cpp
index d92788e189a..939da55b45c 100644
--- a/yql/essentials/core/yql_expr_type_annotation.cpp
+++ b/yql/essentials/core/yql_expr_type_annotation.cpp
@@ -3158,6 +3158,46 @@ bool EnsureWideStreamType(TPositionHandle position, const TTypeAnnotationNode& t
     return true;
 }
 
+bool EnsureWideFlowOrStreamType(const TExprNode& node, TExprContext& ctx) {
+    if (HasError(node.GetTypeAnn(), ctx)) {
+        return false;
+    }
+
+    if (!node.GetTypeAnn()) {
+        YQL_ENSURE(node.Type() == TExprNode::Lambda);
+        ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder() << "Expected wide stream or flow type, but got lambda"));
+        return false;
+    }
+
+    if (!IsWideFlowOrStreamType(*node.GetTypeAnn())) {
+        ctx.AddError(TIssue(ctx.GetPosition(node.Pos()), TStringBuilder() << "Expected wide stream or flow type, but got: " << *node.GetTypeAnn()));
+        return false;
+    }
+
+    return true;
+}
+
+bool IsWideFlowOrStreamType(const TTypeAnnotationNode& type) {
+    if (type.GetKind() == ETypeAnnotationKind::Stream && type.Cast<TStreamExprType>()->GetItemType()->GetKind() == ETypeAnnotationKind::Multi) {
+        return true;
+    } else if (type.GetKind() == ETypeAnnotationKind::Flow && type.Cast<TFlowExprType>()->GetItemType()->GetKind() == ETypeAnnotationKind::Multi) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+const TMultiExprType* GetWideFlowOrStreamComponents(const TTypeAnnotationNode& type) {
+    MKQL_ENSURE(IsWideFlowOrStreamType(type), "Expected wide stream or flow type.");
+    if (type.GetKind() == ETypeAnnotationKind::Flow) {
+        return type.Cast<TFlowExprType>()->GetItemType()->Cast<TMultiExprType>();
+    } else if (type.GetKind() == ETypeAnnotationKind::Stream) {
+        return type.Cast<TStreamExprType>()->GetItemType()->Cast<TMultiExprType>();
+    } else {
+        Y_UNREACHABLE();
+    }
+}
+
 bool IsWideBlockType(const TTypeAnnotationNode& type) {
     if (type.GetKind() != ETypeAnnotationKind::Multi) {
         return false;
diff --git a/yql/essentials/core/yql_expr_type_annotation.h b/yql/essentials/core/yql_expr_type_annotation.h
index fecc24829cb..f4319c683b9 100644
--- a/yql/essentials/core/yql_expr_type_annotation.h
+++ b/yql/essentials/core/yql_expr_type_annotation.h
@@ -129,6 +129,9 @@ bool EnsureWideFlowType(const TExprNode& node, TExprContext& ctx);
 bool EnsureWideFlowType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
 bool EnsureWideStreamType(const TExprNode& node, TExprContext& ctx);
 bool EnsureWideStreamType(TPositionHandle position, const TTypeAnnotationNode& type, TExprContext& ctx);
+bool EnsureWideFlowOrStreamType(const TExprNode& node, TExprContext& ctx);
+bool IsWideFlowOrStreamType(const TTypeAnnotationNode& type);
+const TMultiExprType* GetWideFlowOrStreamComponents(const TTypeAnnotationNode& type);
 bool IsWideBlockType(const TTypeAnnotationNode& type);
 bool IsWideSequenceBlockType(const TTypeAnnotationNode& type);
 bool IsSupportedAsBlockType(TPositionHandle pos, const TTypeAnnotationNode& type, TExprContext& ctx, TTypeAnnotationContext& types, bool reportUnspported = false);
diff --git a/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp b/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp
index e970cd3f05a..f4a7e6ce34f 100644
--- a/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp
+++ b/yql/essentials/minikql/comp_nodes/mkql_wide_map.cpp
@@ -10,10 +10,10 @@ using NYql::EnsureDynamicCast;
 
 namespace {
 
-class TWideMapWrapper : public TStatelessWideFlowCodegeneratorNode<TWideMapWrapper> {
-using TBaseComputation = TStatelessWideFlowCodegeneratorNode<TWideMapWrapper>;
+class TWideMapFlowWrapper : public TStatelessWideFlowCodegeneratorNode<TWideMapFlowWrapper> {
+using TBaseComputation = TStatelessWideFlowCodegeneratorNode<TWideMapFlowWrapper>;
 public:
-    TWideMapWrapper(TComputationMutables& mutables, IComputationWideFlowNode* flow, TComputationExternalNodePtrVector&& items, TComputationNodePtrVector&& newItems)
+    TWideMapFlowWrapper(TComputationMutables& mutables, IComputationWideFlowNode* flow, TComputationExternalNodePtrVector&& items, TComputationNodePtrVector&& newItems)
         : TBaseComputation(flow)
         , Flow(flow)
         , Items(std::move(items))
@@ -89,8 +89,8 @@ public:
 private:
     void RegisterDependencies() const final {
         if (const auto flow = FlowDependsOn(Flow)) {
-            std::for_each(Items.cbegin(), Items.cend(), std::bind(&TWideMapWrapper::Own, flow, std::placeholders::_1));
-            std::for_each(NewItems.cbegin(), NewItems.cend(), std::bind(&TWideMapWrapper::DependsOn, flow, std::placeholders::_1));
+            std::for_each(Items.cbegin(), Items.cend(), std::bind(&TWideMapFlowWrapper::Own, flow, std::placeholders::_1));
+            std::for_each(NewItems.cbegin(), NewItems.cend(), std::bind(&TWideMapFlowWrapper::DependsOn, flow, std::placeholders::_1));
         }
     }
 
@@ -102,25 +102,145 @@ private:
     const ui32 WideFieldsIndex;
 };
 
+class TWideMapStreamWrapper: public TMutableComputationNode<TWideMapStreamWrapper> {
+    using TBaseComputation = TMutableComputationNode<TWideMapStreamWrapper>;
+
+public:
+    TWideMapStreamWrapper(TComputationMutables& mutables, IComputationNode* stream, TComputationExternalNodePtrVector&& items, TComputationNodePtrVector&& newItems)
+        : TBaseComputation(mutables)
+        , Stream(stream)
+        , Items(std::move(items))
+        , NewItems(std::move(newItems))
+        , PasstroughtMap(GetPasstroughtMapOneToOne(Items, NewItems))
+        , ReversePasstroughtMap(GetPasstroughtMapOneToOne(NewItems, Items))
+        , WideFieldsIndex(mutables.IncrementWideFieldsIndex(Items.size()))
+    {
+    }
+
+    NYql::NUdf::TUnboxedValuePod DoCalculate(TComputationContext& ctx) const {
+        return ctx.HolderFactory.Create<TStreamValue>(
+                    ctx,
+                     ctx.HolderFactory,
+                     Stream->GetValue(ctx),
+                     Items,
+                     NewItems,
+                     PasstroughtMap,
+                     ReversePasstroughtMap);
+    }
+
+private:
+    class TStreamValue: public TComputationValue<TStreamValue> {
+        using TBase = TComputationValue<TStreamValue>;
+
+    public:
+        TStreamValue(TMemoryUsageInfo* memInfo,
+                     TComputationContext& compCtx,
+                     const THolderFactory& holderFactory,
+                     NYql::NUdf::TUnboxedValue&& stream,
+                     const TComputationExternalNodePtrVector& items,
+                     const TComputationNodePtrVector& newItems,
+                     TPassthroughSpan passtroughtMap,
+                     TPassthroughSpan reversePasstroughtMap)
+            : TBase(memInfo)
+            , CompCtx(compCtx)
+            , HolderFactory(holderFactory)
+            , Stream(std::move(stream))
+            , Items(items)
+            , NewItems(newItems)
+            , PasstroughtMap(std::move(passtroughtMap))
+            , ReversePasstroughtMap(std::move(reversePasstroughtMap))
+        {
+            State.resize(Items.size());
+            Y_UNUSED(HolderFactory);
+        }
+
+        NUdf::EFetchStatus WideFetch(NUdf::TUnboxedValue* output, ui32 width) final {
+            Y_UNUSED(width);
+            if (const auto result = Stream.WideFetch(State.data(), State.size()); NUdf::EFetchStatus::Ok != result) {
+                return result;
+            }
+
+            for (auto i = 0U; i < Items.size(); ++i) {
+                if (const auto& map = PasstroughtMap[i]; map && !Items[i]->GetDependencesCount()) {
+                    output[*map] = State[i];
+                } else {
+                    Items[i]->RefValue(CompCtx) = State[i];
+                }
+            }
+
+            for (auto i = 0U; i < NewItems.size(); ++i) {
+                if (const auto& map = ReversePasstroughtMap[i]) {
+                    if (const auto from = *map; !Items[from]->GetDependencesCount()) {
+                        if (const auto first = *PasstroughtMap[from]; first != i) {
+                            output[i] = output[first];
+                        }
+                        continue;
+                    }
+                }
+
+                output[i] = NewItems[i]->GetValue(CompCtx);
+            }
+            return NUdf::EFetchStatus::Ok;
+        }
+
+    private:
+        TComputationContext& CompCtx;
+        const THolderFactory& HolderFactory;
+        NUdf::TUnboxedValue Stream;
+        const TComputationExternalNodePtrVector& Items;
+        const TComputationNodePtrVector& NewItems;
+
+        const TPassthroughSpan PasstroughtMap;
+        const TPassthroughSpan ReversePasstroughtMap;
+        TUnboxedValueVector State;
+    };
+
+    void RegisterDependencies() const final {
+        Stream->AddDependence(this);
+        std::for_each(Items.cbegin(), Items.cend(), std::bind(&TWideMapStreamWrapper::Own, this, std::placeholders::_1));
+        std::for_each(NewItems.cbegin(), NewItems.cend(), std::bind(&TWideMapStreamWrapper::DependsOn, this, std::placeholders::_1));
+    }
+
+    IComputationNode* const Stream;
+    const TComputationExternalNodePtrVector Items;
+    const TComputationNodePtrVector NewItems;
+    const TPasstroughtMap PasstroughtMap;
+    const TPasstroughtMap ReversePasstroughtMap;
+
+    const ui32 WideFieldsIndex;
+};
 }
 
 IComputationNode* WrapWideMap(TCallable& callable, const TComputationNodeFactoryContext& ctx) {
     MKQL_ENSURE(callable.GetInputsCount() > 0U, "Expected argument.");
-    const auto inputWidth = GetWideComponentsCount(AS_TYPE(TFlowType, callable.GetInput(0U).GetStaticType()));
-    const auto outputWidth = GetWideComponentsCount(AS_TYPE(TFlowType, callable.GetType()->GetReturnType()));
+    MKQL_ENSURE(callable.GetInput(0U).GetStaticType()->IsFlow() || callable.GetInput(0U).GetStaticType()->IsStream(),
+                "Expected stream or flow for input.");
+
+    const auto inputWidth = GetWideComponentsCount(callable.GetInput(0U).GetStaticType());
+    const auto outputWidth = GetWideComponentsCount(callable.GetType()->GetReturnType());
+
+    if (callable.GetInput(0U).GetStaticType()->IsFlow()) {
+        MKQL_ENSURE(callable.GetType()->GetReturnType()->IsFlow(), "Expected flow return type.");
+    } else {
+        MKQL_ENSURE(callable.GetType()->GetReturnType()->IsStream(), "Expected stream return type.");
+    }
+
     MKQL_ENSURE(callable.GetInputsCount() == inputWidth + outputWidth + 1U, "Wrong signature.");
 
-    const auto flow = LocateNode(ctx.NodeLocator, callable, 0U);
-    if (const auto wide = dynamic_cast<IComputationWideFlowNode*>(flow)) {
-        TComputationNodePtrVector newItems(outputWidth, nullptr);
-        ui32 index = inputWidth;
-        std::generate(newItems.begin(), newItems.end(), [&](){ return LocateNode(ctx.NodeLocator, callable, ++index); });
+    const auto flowOrStream = LocateNode(ctx.NodeLocator, callable, 0U);
+    TComputationNodePtrVector newItems(outputWidth, nullptr);
+    ui32 index = inputWidth;
+    std::generate(newItems.begin(), newItems.end(), [&]() { return LocateNode(ctx.NodeLocator, callable, ++index); });
 
-        TComputationExternalNodePtrVector args(inputWidth, nullptr);
-        index = 0U;
-        std::generate(args.begin(), args.end(), [&](){ return LocateExternalNode(ctx.NodeLocator, callable, ++index); });
+    TComputationExternalNodePtrVector args(inputWidth, nullptr);
+    index = 0U;
+    std::generate(args.begin(), args.end(), [&]() { return LocateExternalNode(ctx.NodeLocator, callable, ++index); });
 
-        return new TWideMapWrapper(ctx.Mutables, wide, std::move(args), std::move(newItems));
+    if (const auto flow = dynamic_cast<IComputationWideFlowNode*>(flowOrStream)) {
+        return new TWideMapFlowWrapper(ctx.Mutables, flow, std::move(args), std::move(newItems));
+    } else {
+        auto* stream = flowOrStream;
+        return new TWideMapStreamWrapper(ctx.Mutables, stream, std::move(args), std::move(newItems));
     }
 
     THROW yexception() << "Expected wide flow.";
diff --git a/yql/essentials/minikql/comp_nodes/ut/mkql_block_coalesce_ut.cpp b/yql/essentials/minikql/comp_nodes/ut/mkql_block_coalesce_ut.cpp
index d984e2edb96..e2bff5d5fdc 100644
--- a/yql/essentials/minikql/comp_nodes/ut/mkql_block_coalesce_ut.cpp
+++ b/yql/essentials/minikql/comp_nodes/ut/mkql_block_coalesce_ut.cpp
@@ -270,9 +270,9 @@ void BlockCoalesceGraphTest(size_t length, size_t offset) {
         };
     });
 
-    node = pb.ToFlow(pb.WideToBlocks(pb.FromFlow(node)));
+    node = pb.WideToBlocks(pb.FromFlow(node));
     if (offset > 0) {
-        node = pb.ToFlow(pb.WideSkipBlocks(pb.FromFlow(node), pb.NewDataLiteral<ui64>(offset)));
+        node = pb.WideSkipBlocks(node, pb.NewDataLiteral<ui64>(offset));
     }
     node = pb.WideMap(node, [&](TRuntimeNode::TList items) -> TRuntimeNode::TList {
         Y_ENSURE(items.size() == 3);
@@ -281,7 +281,7 @@ void BlockCoalesceGraphTest(size_t length, size_t offset) {
             items[2]};
     });
 
-    node = pb.ToFlow(pb.WideFromBlocks(pb.FromFlow(node)));
+    node = pb.ToFlow(pb.WideFromBlocks(node));
     node = pb.NarrowMap(node, [&](TRuntimeNode::TList items) -> TRuntimeNode {
         return pb.NewTuple(outputTupleType, {items[0]});
     });
diff --git a/yql/essentials/minikql/comp_nodes/ut/mkql_block_exists_ut.cpp b/yql/essentials/minikql/comp_nodes/ut/mkql_block_exists_ut.cpp
index bfbce821173..27e0ded263a 100644
--- a/yql/essentials/minikql/comp_nodes/ut/mkql_block_exists_ut.cpp
+++ b/yql/essentials/minikql/comp_nodes/ut/mkql_block_exists_ut.cpp
@@ -66,7 +66,7 @@ void DoBlockExistsOffset(size_t length, size_t offset) {
     if (offset > 0) {
         node = pb.WideSkipBlocks(node, pb.NewDataLiteral<ui64>(offset));
     }
-    node = pb.WideMap(pb.ToFlow(node), [&](TRuntimeNode::TList items) -> TRuntimeNode::TList {
+    node = pb.WideMap(node, [&](TRuntimeNode::TList items) -> TRuntimeNode::TList {
         return {
             items[0],
             pb.BlockExists(items[1]),
@@ -75,7 +75,7 @@ void DoBlockExistsOffset(size_t length, size_t offset) {
             items[4],
         };
     });
-    node = pb.ToFlow(pb.WideFromBlocks(pb.FromFlow(node)));
+    node = pb.ToFlow(pb.WideFromBlocks(node));
     node = pb.NarrowMap(node, [&](TRuntimeNode::TList items) -> TRuntimeNode {
         return pb.NewTuple(outputTupleType, {items[0], items[1], items[2], items[3]});
     });
diff --git a/yql/essentials/minikql/comp_nodes/ut/mkql_blocks_ut.cpp b/yql/essentials/minikql/comp_nodes/ut/mkql_blocks_ut.cpp
index b7e49d0a087..1c572624c67 100644
--- a/yql/essentials/minikql/comp_nodes/ut/mkql_blocks_ut.cpp
+++ b/yql/essentials/minikql/comp_nodes/ut/mkql_blocks_ut.cpp
@@ -484,11 +484,11 @@ Y_UNIT_TEST_LLVM(TestBlockFunc) {
     const auto wideFlow = pb.ExpandMap(flow, [&](TRuntimeNode item) -> TRuntimeNode::TList {
         return {pb.Nth(item, 0U), pb.Nth(item, 1U)};
     });
-    const auto wideBlocksFlow = pb.ToFlow(pb.WideToBlocks(pb.FromFlow(wideFlow)));
-    const auto sumWideFlow = pb.WideMap(wideBlocksFlow, [&](TRuntimeNode::TList items) -> TRuntimeNode::TList {
+    const auto wideBlocksStream = pb.WideToBlocks(pb.FromFlow(wideFlow));
+    const auto sumWideStream = pb.WideMap(wideBlocksStream, [&](TRuntimeNode::TList items) -> TRuntimeNode::TList {
         return {pb.BlockFunc("Add", ui64BlockType, {items[0], items[1]})};
     });
-    const auto sumNarrowFlow = pb.NarrowMap(sumWideFlow, [&](TRuntimeNode::TList items) -> TRuntimeNode {
+    const auto sumNarrowFlow = pb.NarrowMap(pb.ToFlow(sumWideStream), [&](TRuntimeNode::TList items) -> TRuntimeNode {
         return items[0];
     });
     const auto pgmReturn = pb.Collect(pb.FromBlocks(sumNarrowFlow));
@@ -541,11 +541,11 @@ Y_UNIT_TEST_LLVM(TestBlockFuncWithNullables) {
     const auto wideFlow = pb.ExpandMap(flow, [&](TRuntimeNode item) -> TRuntimeNode::TList {
         return {pb.Nth(item, 0U), pb.Nth(item, 1U)};
     });
-    const auto wideBlocksFlow = pb.ToFlow(pb.WideToBlocks(pb.FromFlow(wideFlow)));
-    const auto sumWideFlow = pb.WideMap(wideBlocksFlow, [&](TRuntimeNode::TList items) -> TRuntimeNode::TList {
+    const auto wideBlocksStream = pb.WideToBlocks(pb.FromFlow(wideFlow));
+    const auto sumWideStream = pb.WideMap(wideBlocksStream, [&](TRuntimeNode::TList items) -> TRuntimeNode::TList {
         return {pb.BlockFunc("Add", ui64OptBlockType, {items[0], items[1]})};
     });
-    const auto sumNarrowFlow = pb.NarrowMap(sumWideFlow, [&](TRuntimeNode::TList items) -> TRuntimeNode {
+    const auto sumNarrowFlow = pb.NarrowMap(pb.ToFlow(sumWideStream), [&](TRuntimeNode::TList items) -> TRuntimeNode {
         return items[0];
     });
     const auto pgmReturn = pb.Collect(pb.FromBlocks(sumNarrowFlow));
diff --git a/yql/essentials/minikql/computation/mkql_computation_node_impl.h b/yql/essentials/minikql/computation/mkql_computation_node_impl.h
index dac175b7c1f..e406df2e46d 100644
--- a/yql/essentials/minikql/computation/mkql_computation_node_impl.h
+++ b/yql/essentials/minikql/computation/mkql_computation_node_impl.h
@@ -1038,6 +1038,7 @@ IComputationNode* LocateNode(const TNodeLocator& nodeLocator, TNode& node, bool
 IComputationExternalNode* LocateExternalNode(const TNodeLocator& nodeLocator, TCallable& callable, ui32 index, bool pop = true);
 
 using TPasstroughtMap = std::vector<std::optional<size_t>>;
+using TPassthroughSpan = std::vector<std::optional<size_t>>;
 
 template<class TContainerOne, class TContainerTwo>
 TPasstroughtMap GetPasstroughtMap(const TContainerOne& from, const TContainerTwo& to);
diff --git a/yql/essentials/minikql/mkql_program_builder.cpp b/yql/essentials/minikql/mkql_program_builder.cpp
index 93c808e51db..284f2222c30 100644
--- a/yql/essentials/minikql/mkql_program_builder.cpp
+++ b/yql/essentials/minikql/mkql_program_builder.cpp
@@ -3768,9 +3768,10 @@ TRuntimeNode TProgramBuilder::ExpandMap(TRuntimeNode flow, const TExpandLambda&
     return TRuntimeNode(callableBuilder.Build(), false);
 }
 
-TRuntimeNode TProgramBuilder::WideMap(TRuntimeNode flow, const TWideLambda& handler) {
-    const auto wideComponents = GetWideComponents(AS_TYPE(TFlowType, flow.GetStaticType()));
-
+TRuntimeNode TProgramBuilder::WideMap(TRuntimeNode flowOrStream, const TWideLambda& handler) {
+    MKQL_ENSURE(flowOrStream.GetStaticType()->IsFlow() || flowOrStream.GetStaticType()->IsStream(), "Flow or stream type expected.");
+    const auto wideComponents = GetWideComponents(flowOrStream.GetStaticType());
+    bool shouldRewriteToFlow = RuntimeVersion < 67 && flowOrStream.GetStaticType()->IsStream();
     TRuntimeNode::TList itemArgs;
     itemArgs.reserve(wideComponents.size());
     auto i = 0U;
@@ -3782,11 +3783,25 @@ TRuntimeNode TProgramBuilder::WideMap(TRuntimeNode flow, const TWideLambda& hand
     tupleItems.reserve(newItems.size());
     std::transform(newItems.cbegin(), newItems.cend(), std::back_inserter(tupleItems), std::bind(&TRuntimeNode::GetStaticType, std::placeholders::_1));
 
-    TCallableBuilder callableBuilder(Env_, __func__, NewFlowType(NewMultiType(tupleItems)));
-    callableBuilder.Add(flow);
-    std::for_each(itemArgs.cbegin(), itemArgs.cend(), std::bind(&TCallableBuilder::Add, std::ref(callableBuilder), std::placeholders::_1));
-    std::for_each(newItems.cbegin(), newItems.cend(), std::bind(&TCallableBuilder::Add, std::ref(callableBuilder), std::placeholders::_1));
-    return TRuntimeNode(callableBuilder.Build(), false);
+    auto fillCallableBuilder = [&] (TCallableBuilder& builder, TRuntimeNode input) {
+        builder.Add(input);
+        std::for_each(itemArgs.cbegin(), itemArgs.cend(), std::bind(&TCallableBuilder::Add, std::ref(builder), std::placeholders::_1));
+        std::for_each(newItems.cbegin(), newItems.cend(), std::bind(&TCallableBuilder::Add, std::ref(builder), std::placeholders::_1));
+        return TRuntimeNode(builder.Build(), false);
+    };
+
+    if (shouldRewriteToFlow) {
+        TCallableBuilder callableBuilder(Env_, __func__, NewFlowType(NewMultiType(tupleItems)));
+        return FromFlow(fillCallableBuilder(callableBuilder, ToFlow(flowOrStream)));
+    } else if (flowOrStream.GetStaticType()->IsFlow()) {
+        TCallableBuilder callableBuilder(Env_, __func__, NewFlowType(NewMultiType(tupleItems)));
+        return fillCallableBuilder(callableBuilder, flowOrStream);
+    } else if (flowOrStream.GetStaticType()->IsStream()) {
+        TCallableBuilder callableBuilder(Env_, __func__, NewStreamType(NewMultiType(tupleItems)));
+        return fillCallableBuilder(callableBuilder, flowOrStream);
+    } else {
+        Y_UNREACHABLE();
+    }
 }
 
 TRuntimeNode TProgramBuilder::WideChain1Map(TRuntimeNode flow, const TWideLambda& init, const TBinaryWideLambda& update) {
diff --git a/yql/essentials/minikql/mkql_program_builder.h b/yql/essentials/minikql/mkql_program_builder.h
index 5fdc38f5249..89eed6abee0 100644
--- a/yql/essentials/minikql/mkql_program_builder.h
+++ b/yql/essentials/minikql/mkql_program_builder.h
@@ -408,7 +408,7 @@ public:
     TRuntimeNode SkipNullElements(TRuntimeNode list, const TArrayRef<const ui32>& elements);
 
     TRuntimeNode ExpandMap(TRuntimeNode flow, const TExpandLambda& handler);
-    TRuntimeNode WideMap(TRuntimeNode flow, const TWideLambda& handler);
+    TRuntimeNode WideMap(TRuntimeNode flowOrStream, const TWideLambda& handler);
     TRuntimeNode NarrowMap(TRuntimeNode flow, const TNarrowLambda& handler);
     TRuntimeNode NarrowFlatMap(TRuntimeNode flow, const TNarrowLambda& handler);
     TRuntimeNode NarrowMultiMap(TRuntimeNode flow, const TWideLambda& handler);
diff --git a/yql/essentials/minikql/mkql_runtime_version.h b/yql/essentials/minikql/mkql_runtime_version.h
index c8021c6bfa6..241dca518c5 100644
--- a/yql/essentials/minikql/mkql_runtime_version.h
+++ b/yql/essentials/minikql/mkql_runtime_version.h
@@ -24,7 +24,7 @@ namespace NMiniKQL {
 // 1. Bump this version every time incompatible runtime nodes are introduced.
 // 2. Make sure you provide runtime node generation for previous runtime versions.
 #ifndef MKQL_RUNTIME_VERSION
-#define MKQL_RUNTIME_VERSION 66U
+#define MKQL_RUNTIME_VERSION 67U
 #endif
 
 // History:
diff --git a/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp b/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp
index f983b18b2d5..e9a9ce0bfbe 100644
--- a/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp
+++ b/yql/essentials/providers/common/mkql/yql_provider_mkql.cpp
@@ -687,7 +687,7 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         const auto arg = MkqlBuildExpr(node.Head(), ctx);
         const auto lambda = [&](TRuntimeNode::TList items) { return MkqlBuildWideLambda(node.Tail(), ctx, items); };
         TRuntimeNode result = ctx.ProgramBuilder.WideMap(arg, lambda);
-        if (IsWideBlockType(*node.GetTypeAnn()->Cast<TFlowExprType>()->GetItemType())) {
+        if (IsWideBlockType(*GetWideFlowOrStreamComponents(*node.GetTypeAnn()))) {
             result = ctx.ProgramBuilder.BlockExpandChunked(result);
         }
         return result;
diff --git a/yql/essentials/tests/s-expressions/minirun/part5/canondata/result.json b/yql/essentials/tests/s-expressions/minirun/part5/canondata/result.json
index c8be00cd9ee..da99de9c8c1 100644
--- a/yql/essentials/tests/s-expressions/minirun/part5/canondata/result.json
+++ b/yql/essentials/tests/s-expressions/minirun/part5/canondata/result.json
@@ -15,9 +15,9 @@
     ],
     "test.test[Blocks-BlocksSort+ReplicateScalars-default.txt-Debug]": [
         {
-            "checksum": "8adeb84aac9d8865516a4dd8cc3b1359",
-            "size": 635,
-            "uri": "https://{canondata_backend}/1942100/7f62e1d7e5ababbffae9cdcf4da35d121501ff83/resource.tar.gz#test.test_Blocks-BlocksSort+ReplicateScalars-default.txt-Debug_/opt.yql"
+            "checksum": "0fbc5abbf96ffc7a704877af748f2330",
+            "size": 615,
+            "uri": "https://{canondata_backend}/1814674/5a45bfb47f6e8fba5018ec876fb8245554089825/resource.tar.gz#test.test_Blocks-BlocksSort+ReplicateScalars-default.txt-Debug_/opt.yql"
         }
     ],
     "test.test[Blocks-BlocksSort+ReplicateScalars-default.txt-Results]": [
diff --git a/yql/essentials/tests/s-expressions/suites/Blocks/BlocksSort+ReplicateScalars.yqls b/yql/essentials/tests/s-expressions/suites/Blocks/BlocksSort+ReplicateScalars.yqls
index a1ef286ce7a..776a8c8fcbd 100644
--- a/yql/essentials/tests/s-expressions/suites/Blocks/BlocksSort+ReplicateScalars.yqls
+++ b/yql/essentials/tests/s-expressions/suites/Blocks/BlocksSort+ReplicateScalars.yqls
@@ -12,13 +12,13 @@
 (let expandLambda (lambda '(item) (Member item '"x")))
 (let wideStream (FromFlow (ExpandMap (ToFlow list) expandLambda)))
 (let wideBlockStream (WideToBlocks wideStream))
-(let wideFlowScalar (WideMap (ToFlow wideBlockStream) (lambda '($x, $blockSize) (AsScalar (Uint64 '"123")) $blockSize)))
+(let wideBlockScalar (WideMap  wideBlockStream (lambda '($x, $blockSize) (AsScalar (Uint64 '"123")) $blockSize)))
 
 (let sortParams '('('0 (Bool 'true))))
 
 (let replicateParams '('"0"))
 
-(let nopFromBlocksToBlocks (WideFromBlocks (WideSortBlocks (ReplicateScalars (FromFlow wideFlowScalar) replicateParams) sortParams)))
+(let nopFromBlocksToBlocks (WideFromBlocks (WideSortBlocks (ReplicateScalars wideBlockScalar replicateParams) sortParams)))
 
 (let narrowLambda (lambda '(x) (AsStruct '('"x" x))))
 (let scalarList (ForwardList (NarrowMap (ToFlow nopFromBlocksToBlocks) narrowLambda)))
diff --git a/yql/essentials/tests/sql/minirun/part0/canondata/result.json b/yql/essentials/tests/sql/minirun/part0/canondata/result.json
index c5714c2009e..c865487cb98 100644
--- a/yql/essentials/tests/sql/minirun/part0/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part0/canondata/result.json
@@ -277,9 +277,9 @@
     ],
     "test.test[blocks-agg_all_mixed_distinct-default.txt-Peephole]": [
         {
-            "checksum": "68605b539309a1ecb2a83ecdfc4b310f",
-            "size": 2750,
-            "uri": "https://{canondata_backend}/1937429/79055d48a8b63ae0b5d61c80f61c844ca111e11a/resource.tar.gz#test.test_blocks-agg_all_mixed_distinct-default.txt-Peephole_/opt.yql"
+            "checksum": "3d3f816a52fd139892f572d954b4a602",
+            "size": 2698,
+            "uri": "https://{canondata_backend}/995452/9f20ece014dafd0cb81663fd73f5ce6340c1a90d/resource.tar.gz#test.test_blocks-agg_all_mixed_distinct-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_all_mixed_distinct-default.txt-Results]": [
@@ -298,9 +298,9 @@
     ],
     "test.test[blocks-agg_singular_type_key_optional-default.txt-Peephole]": [
         {
-            "checksum": "db2e4bd6530b31b6efceb77a4a184b4e",
-            "size": 6606,
-            "uri": "https://{canondata_backend}/1925842/7e03c084910acb6d9d50a1f7dc65eda3cdac3b45/resource.tar.gz#test.test_blocks-agg_singular_type_key_optional-default.txt-Peephole_/opt.yql"
+            "checksum": "efbc25fe12576d6c81863c603b354d6a",
+            "size": 6561,
+            "uri": "https://{canondata_backend}/995452/9f20ece014dafd0cb81663fd73f5ce6340c1a90d/resource.tar.gz#test.test_blocks-agg_singular_type_key_optional-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_singular_type_key_optional-default.txt-Results]": [
@@ -319,9 +319,9 @@
     ],
     "test.test[blocks-and-default.txt-Peephole]": [
         {
-            "checksum": "ebaa52929ab2ea1003a45542332d450d",
-            "size": 702,
-            "uri": "https://{canondata_backend}/1937429/79055d48a8b63ae0b5d61c80f61c844ca111e11a/resource.tar.gz#test.test_blocks-and-default.txt-Peephole_/opt.yql"
+            "checksum": "1ab31cb2ccddd24dd0a1de9a320d63c5",
+            "size": 682,
+            "uri": "https://{canondata_backend}/995452/9f20ece014dafd0cb81663fd73f5ce6340c1a90d/resource.tar.gz#test.test_blocks-and-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-and-default.txt-Results]": [
@@ -340,9 +340,9 @@
     ],
     "test.test[blocks-ifpresent_null_last_argument-default.txt-Peephole]": [
         {
-            "checksum": "7c35b55d6b2fc1e91041d98e2b354fd7",
-            "size": 868,
-            "uri": "https://{canondata_backend}/1817427/e082b12fff160def638c040519bd57f755d945c6/resource.tar.gz#test.test_blocks-ifpresent_null_last_argument-default.txt-Peephole_/opt.yql"
+            "checksum": "1d21ca1882983c7f3f1ac41825b56dad",
+            "size": 848,
+            "uri": "https://{canondata_backend}/995452/9f20ece014dafd0cb81663fd73f5ce6340c1a90d/resource.tar.gz#test.test_blocks-ifpresent_null_last_argument-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-ifpresent_null_last_argument-default.txt-Results]": [
@@ -361,9 +361,9 @@
     ],
     "test.test[blocks-pg_call-default.txt-Peephole]": [
         {
-            "checksum": "0d759dfe6d84dfb9eb76e3ad4ba99be4",
-            "size": 907,
-            "uri": "https://{canondata_backend}/1937429/79055d48a8b63ae0b5d61c80f61c844ca111e11a/resource.tar.gz#test.test_blocks-pg_call-default.txt-Peephole_/opt.yql"
+            "checksum": "a76be65a46ac094476aae3230f115879",
+            "size": 887,
+            "uri": "https://{canondata_backend}/995452/9f20ece014dafd0cb81663fd73f5ce6340c1a90d/resource.tar.gz#test.test_blocks-pg_call-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-pg_call-default.txt-Results]": [
@@ -382,9 +382,9 @@
     ],
     "test.test[blocks-xor-default.txt-Peephole]": [
         {
-            "checksum": "8c0970d313c69c4b0d13590d30b5d864",
-            "size": 702,
-            "uri": "https://{canondata_backend}/1937429/79055d48a8b63ae0b5d61c80f61c844ca111e11a/resource.tar.gz#test.test_blocks-xor-default.txt-Peephole_/opt.yql"
+            "checksum": "024642e87d62f072f2f9f3a7513c5de1",
+            "size": 682,
+            "uri": "https://{canondata_backend}/995452/9f20ece014dafd0cb81663fd73f5ce6340c1a90d/resource.tar.gz#test.test_blocks-xor-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-xor-default.txt-Results]": [
@@ -403,9 +403,9 @@
     ],
     "test.test[blocks-xor_opt_scalar-default.txt-Peephole]": [
         {
-            "checksum": "4bab98d84e3103195a7896c1955d1030",
-            "size": 1854,
-            "uri": "https://{canondata_backend}/1937429/79055d48a8b63ae0b5d61c80f61c844ca111e11a/resource.tar.gz#test.test_blocks-xor_opt_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "a1301465b0f1f74d0bbc8cc03c083231",
+            "size": 1814,
+            "uri": "https://{canondata_backend}/995452/9f20ece014dafd0cb81663fd73f5ce6340c1a90d/resource.tar.gz#test.test_blocks-xor_opt_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-xor_opt_scalar-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part1/canondata/result.json b/yql/essentials/tests/sql/minirun/part1/canondata/result.json
index 8f3e7c05927..b71a4828c62 100644
--- a/yql/essentials/tests/sql/minirun/part1/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part1/canondata/result.json
@@ -260,9 +260,9 @@
     ],
     "test.test[blocks-agg_all-default.txt-Peephole]": [
         {
-            "checksum": "15315c4bc0f3b4b589e14c0158c32e12",
-            "size": 989,
-            "uri": "https://{canondata_backend}/1917492/eba86b26b71f83d74091393c00c13c811ffb39c5/resource.tar.gz#test.test_blocks-agg_all-default.txt-Peephole_/opt.yql"
+            "checksum": "2cac52d94b0a135a77295a6d724119ab",
+            "size": 969,
+            "uri": "https://{canondata_backend}/995452/f6090e3537b6ac5af6bbff66cd67f657f1cc30b8/resource.tar.gz#test.test_blocks-agg_all-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_all-default.txt-Results]": [
@@ -281,9 +281,9 @@
     ],
     "test.test[blocks-and_opt_scalar-default.txt-Peephole]": [
         {
-            "checksum": "00d23182d06fa9428fff3a19fbb814c2",
-            "size": 1854,
-            "uri": "https://{canondata_backend}/1917492/eba86b26b71f83d74091393c00c13c811ffb39c5/resource.tar.gz#test.test_blocks-and_opt_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "0758252400d204a749d3943bc775f0bc",
+            "size": 1814,
+            "uri": "https://{canondata_backend}/995452/f6090e3537b6ac5af6bbff66cd67f657f1cc30b8/resource.tar.gz#test.test_blocks-and_opt_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-and_opt_scalar-default.txt-Results]": [
@@ -323,9 +323,9 @@
     ],
     "test.test[blocks-ifpresent_pg-default.txt-Peephole]": [
         {
-            "checksum": "45bc2fbb29ca62155156bb2cb2df2a58",
-            "size": 1066,
-            "uri": "https://{canondata_backend}/1880306/4b6e937f0d593c4503531936e3e0e9b0c708d898/resource.tar.gz#test.test_blocks-ifpresent_pg-default.txt-Peephole_/opt.yql"
+            "checksum": "3b57d3f7bf9a19de4c4e3e0fc69c9ebd",
+            "size": 1046,
+            "uri": "https://{canondata_backend}/995452/f6090e3537b6ac5af6bbff66cd67f657f1cc30b8/resource.tar.gz#test.test_blocks-ifpresent_pg-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-ifpresent_pg-default.txt-Results]": [
@@ -365,9 +365,9 @@
     ],
     "test.test[blocks-or_scalar-default.txt-Peephole]": [
         {
-            "checksum": "d0b85b427d840550afe53e884481742f",
-            "size": 1429,
-            "uri": "https://{canondata_backend}/1917492/eba86b26b71f83d74091393c00c13c811ffb39c5/resource.tar.gz#test.test_blocks-or_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "120365bdb9dd1f8a8e4a62e2d6bc7a25",
+            "size": 1389,
+            "uri": "https://{canondata_backend}/995452/f6090e3537b6ac5af6bbff66cd67f657f1cc30b8/resource.tar.gz#test.test_blocks-or_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-or_scalar-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part2/canondata/result.json b/yql/essentials/tests/sql/minirun/part2/canondata/result.json
index b1e06d95ffc..bcfbc3c1fdd 100644
--- a/yql/essentials/tests/sql/minirun/part2/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part2/canondata/result.json
@@ -260,9 +260,9 @@
     ],
     "test.test[blocks-agg_by_key_only_distinct-default.txt-Peephole]": [
         {
-            "checksum": "0ab97b60dc932f51a4cad3d5b703d98c",
-            "size": 2174,
-            "uri": "https://{canondata_backend}/1917492/6fdf85f7e05da60eed58efcacce70c29bce9a047/resource.tar.gz#test.test_blocks-agg_by_key_only_distinct-default.txt-Peephole_/opt.yql"
+            "checksum": "7d9e856c428f2381f7d3e7388ee0a354",
+            "size": 2150,
+            "uri": "https://{canondata_backend}/1871182/8bd84ab8578c2ebd4af82266ee441200daed8d95/resource.tar.gz#test.test_blocks-agg_by_key_only_distinct-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_by_key_only_distinct-default.txt-Results]": [
@@ -281,9 +281,9 @@
     ],
     "test.test[blocks-agg_singular_type_value_optional-default.txt-Peephole]": [
         {
-            "checksum": "d22ed37889eea3b41eadb6164bf6d017",
-            "size": 3113,
-            "uri": "https://{canondata_backend}/1781765/b8d92d6ccf46e436b2e5b3b70ab511bab6d820b0/resource.tar.gz#test.test_blocks-agg_singular_type_value_optional-default.txt-Peephole_/opt.yql"
+            "checksum": "de251a08bbc706c12478c04b4ebd6c43",
+            "size": 3101,
+            "uri": "https://{canondata_backend}/1871182/8bd84ab8578c2ebd4af82266ee441200daed8d95/resource.tar.gz#test.test_blocks-agg_singular_type_value_optional-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_singular_type_value_optional-default.txt-Results]": [
@@ -302,9 +302,9 @@
     ],
     "test.test[blocks-coalesce_pg_types-default.txt-Peephole]": [
         {
-            "checksum": "fe534530228d3199c1fb63621b1bdcfc",
-            "size": 742,
-            "uri": "https://{canondata_backend}/1937150/e249b7faff24c68591c4c61cf9ecf7e069660ddc/resource.tar.gz#test.test_blocks-coalesce_pg_types-default.txt-Peephole_/opt.yql"
+            "checksum": "b13866be9b49bf34530fe439d229a539",
+            "size": 722,
+            "uri": "https://{canondata_backend}/1871182/8bd84ab8578c2ebd4af82266ee441200daed8d95/resource.tar.gz#test.test_blocks-coalesce_pg_types-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-coalesce_pg_types-default.txt-Results]": [
@@ -323,9 +323,9 @@
     ],
     "test.test[blocks-exists-default.txt-Peephole]": [
         {
-            "checksum": "fe4b8e508f707b10f04202f1c79b69ba",
-            "size": 559,
-            "uri": "https://{canondata_backend}/1917492/6fdf85f7e05da60eed58efcacce70c29bce9a047/resource.tar.gz#test.test_blocks-exists-default.txt-Peephole_/opt.yql"
+            "checksum": "973ad90642a043c89bbc84310a744dfb",
+            "size": 539,
+            "uri": "https://{canondata_backend}/1871182/8bd84ab8578c2ebd4af82266ee441200daed8d95/resource.tar.gz#test.test_blocks-exists-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-exists-default.txt-Results]": [
@@ -365,9 +365,9 @@
     ],
     "test.test[blocks-sort-default.txt-Peephole]": [
         {
-            "checksum": "fc3dd8d7c0631fdd696c87d359fd7c6b",
-            "size": 905,
-            "uri": "https://{canondata_backend}/1775059/6773e6533ba4ece8ecb355472912579ca2809089/resource.tar.gz#test.test_blocks-sort-default.txt-Peephole_/opt.yql"
+            "checksum": "c2f4de66ed094d5904374bfc1e06e1b2",
+            "size": 879,
+            "uri": "https://{canondata_backend}/1871182/8bd84ab8578c2ebd4af82266ee441200daed8d95/resource.tar.gz#test.test_blocks-sort-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-sort-default.txt-Results]": [
@@ -386,9 +386,9 @@
     ],
     "test.test[blocks-take_skip-default.txt-Peephole]": [
         {
-            "checksum": "de1c6349e4441b4e48c79285a966c8cd",
-            "size": 919,
-            "uri": "https://{canondata_backend}/1942100/9b98084d4439b1dd0f8d2398da8f0a45fa957bf8/resource.tar.gz#test.test_blocks-take_skip-default.txt-Peephole_/opt.yql"
+            "checksum": "deca93e055311b6938c37c945d445427",
+            "size": 879,
+            "uri": "https://{canondata_backend}/1871182/8bd84ab8578c2ebd4af82266ee441200daed8d95/resource.tar.gz#test.test_blocks-take_skip-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-take_skip-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part3/canondata/result.json b/yql/essentials/tests/sql/minirun/part3/canondata/result.json
index 0dd7f7e99c2..a76499a5015 100644
--- a/yql/essentials/tests/sql/minirun/part3/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part3/canondata/result.json
@@ -308,9 +308,9 @@
     ],
     "test.test[blocks-agg_by_key_mixed_distinct-default.txt-Peephole]": [
         {
-            "checksum": "0c88e98d12d4cf8941c04be6c12db505",
-            "size": 2985,
-            "uri": "https://{canondata_backend}/1809005/48af937bc8ac0c97a4229075f4b2be4980c228fe/resource.tar.gz#test.test_blocks-agg_by_key_mixed_distinct-default.txt-Peephole_/opt.yql"
+            "checksum": "82cea024410c65dd53c442c0ddde9eed",
+            "size": 2955,
+            "uri": "https://{canondata_backend}/1784117/a8dd4851cb105592256543c47107a9955843d104/resource.tar.gz#test.test_blocks-agg_by_key_mixed_distinct-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_by_key_mixed_distinct-default.txt-Results]": [
@@ -329,9 +329,9 @@
     ],
     "test.test[blocks-frompg-default.txt-Peephole]": [
         {
-            "checksum": "ccf828290806a669ba391634e532dac5",
-            "size": 551,
-            "uri": "https://{canondata_backend}/1809005/48af937bc8ac0c97a4229075f4b2be4980c228fe/resource.tar.gz#test.test_blocks-frompg-default.txt-Peephole_/opt.yql"
+            "checksum": "4a1252cc2d002cd96493909944981d71",
+            "size": 531,
+            "uri": "https://{canondata_backend}/1784117/a8dd4851cb105592256543c47107a9955843d104/resource.tar.gz#test.test_blocks-frompg-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-frompg-default.txt-Results]": [
@@ -350,9 +350,9 @@
     ],
     "test.test[blocks-or_opt-default.txt-Peephole]": [
         {
-            "checksum": "5bf71c50b094eda6b1175383a07d0e5f",
-            "size": 899,
-            "uri": "https://{canondata_backend}/1809005/48af937bc8ac0c97a4229075f4b2be4980c228fe/resource.tar.gz#test.test_blocks-or_opt-default.txt-Peephole_/opt.yql"
+            "checksum": "f1c6a6d6b417fffbea3ed53396c10326",
+            "size": 879,
+            "uri": "https://{canondata_backend}/1784117/a8dd4851cb105592256543c47107a9955843d104/resource.tar.gz#test.test_blocks-or_opt-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-or_opt-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part4/canondata/result.json b/yql/essentials/tests/sql/minirun/part4/canondata/result.json
index f0688ef5932..e7500e8b041 100644
--- a/yql/essentials/tests/sql/minirun/part4/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part4/canondata/result.json
@@ -302,9 +302,9 @@
     ],
     "test.test[blocks-agg_by_key-default.txt-Peephole]": [
         {
-            "checksum": "dad5945424bc4c6ce2b36208dafca12f",
-            "size": 1400,
-            "uri": "https://{canondata_backend}/1809005/8279b674a9a28181ade233ada2f27748f8cb3017/resource.tar.gz#test.test_blocks-agg_by_key-default.txt-Peephole_/opt.yql"
+            "checksum": "19c61f050b3cd4fad9680fb98ca719ec",
+            "size": 1388,
+            "uri": "https://{canondata_backend}/995452/d35a03ad50f8708e896cf3d4b911f6537e0c7313/resource.tar.gz#test.test_blocks-agg_by_key-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_by_key-default.txt-Results]": [
@@ -323,9 +323,9 @@
     ],
     "test.test[blocks-agg_with_long_keys-default.txt-Peephole]": [
         {
-            "checksum": "c8f494b293f588852db9bb9a43439a45",
-            "size": 1738,
-            "uri": "https://{canondata_backend}/1942173/aec80438f8fc63ab8d93cee4a56261df6843c1f3/resource.tar.gz#test.test_blocks-agg_with_long_keys-default.txt-Peephole_/opt.yql"
+            "checksum": "6d98c3b9726d96ccf911b802534df4cc",
+            "size": 1726,
+            "uri": "https://{canondata_backend}/995452/d35a03ad50f8708e896cf3d4b911f6537e0c7313/resource.tar.gz#test.test_blocks-agg_with_long_keys-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_with_long_keys-default.txt-Results]": [
@@ -344,9 +344,9 @@
     ],
     "test.test[blocks-or_opt_scalar-default.txt-Peephole]": [
         {
-            "checksum": "d4f552f4259424a5c8d52d472c39ddcb",
-            "size": 1848,
-            "uri": "https://{canondata_backend}/1809005/8279b674a9a28181ade233ada2f27748f8cb3017/resource.tar.gz#test.test_blocks-or_opt_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "4c531c1f99c207fbb9dec11de905274e",
+            "size": 1808,
+            "uri": "https://{canondata_backend}/995452/d35a03ad50f8708e896cf3d4b911f6537e0c7313/resource.tar.gz#test.test_blocks-or_opt_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-or_opt_scalar-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part5/canondata/result.json b/yql/essentials/tests/sql/minirun/part5/canondata/result.json
index afde9520ca1..d5c2cdbbc7c 100644
--- a/yql/essentials/tests/sql/minirun/part5/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part5/canondata/result.json
@@ -361,9 +361,9 @@
     ],
     "test.test[blocks-and_opt-default.txt-Peephole]": [
         {
-            "checksum": "62b19601e78710a4f6a19a3ba5afeb05",
-            "size": 900,
-            "uri": "https://{canondata_backend}/1809005/02f459fce1f16d89b3444e6e8728b9747bb52b53/resource.tar.gz#test.test_blocks-and_opt-default.txt-Peephole_/opt.yql"
+            "checksum": "f6f0e5805ac3afa2da0a9b14d316f1e0",
+            "size": 880,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-and_opt-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-and_opt-default.txt-Results]": [
@@ -382,9 +382,9 @@
     ],
     "test.test[blocks-decimal_binop-default.txt-Peephole]": [
         {
-            "checksum": "543af01b436576f500908330fda5ad9d",
-            "size": 752,
-            "uri": "https://{canondata_backend}/1809005/02f459fce1f16d89b3444e6e8728b9747bb52b53/resource.tar.gz#test.test_blocks-decimal_binop-default.txt-Peephole_/opt.yql"
+            "checksum": "adcf1bb0910fa31309c04026be6fde25",
+            "size": 732,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-decimal_binop-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-decimal_binop-default.txt-Results]": [
@@ -403,9 +403,9 @@
     ],
     "test.test[blocks-extend-default.txt-Peephole]": [
         {
-            "checksum": "9d73defb3c7ec979ad15c0d105f3211e",
+            "checksum": "1ccfe5f3399031b3ec193c28e68b30ec",
             "size": 664,
-            "uri": "https://{canondata_backend}/1775059/85273762ecc854fd58fe1daec09cca032c02ccb1/resource.tar.gz#test.test_blocks-extend-default.txt-Peephole_/opt.yql"
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-extend-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-extend-default.txt-Results]": [
@@ -424,9 +424,9 @@
     ],
     "test.test[blocks-filter-default.txt-Peephole]": [
         {
-            "checksum": "82b4953e1e8b82170f7679a66695f31d",
-            "size": 750,
-            "uri": "https://{canondata_backend}/1937001/df335b76812f126c746955ac4c4352068fe0e8b7/resource.tar.gz#test.test_blocks-filter-default.txt-Peephole_/opt.yql"
+            "checksum": "2a879700f25a590a03063ce866310022",
+            "size": 710,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-filter-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-filter-default.txt-Results]": [
@@ -445,9 +445,9 @@
     ],
     "test.test[blocks-ifpresent_nested-default.txt-Peephole]": [
         {
-            "checksum": "3b0d95b0cb5aa7a5edb8d2d0f56a704a",
-            "size": 1238,
-            "uri": "https://{canondata_backend}/1784826/8b2dfe900f1a2cf05edaef0dcca8b0a30c33c35a/resource.tar.gz#test.test_blocks-ifpresent_nested-default.txt-Peephole_/opt.yql"
+            "checksum": "f638dab7cc30faed6bbdad1b7073d0f7",
+            "size": 1218,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-ifpresent_nested-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-ifpresent_nested-default.txt-Results]": [
@@ -466,9 +466,9 @@
     ],
     "test.test[blocks-ifpresent_single_arg-default.txt-Peephole]": [
         {
-            "checksum": "8230e516d8a0f99cea0fb0566d2fbd8d",
-            "size": 1038,
-            "uri": "https://{canondata_backend}/1784826/8b2dfe900f1a2cf05edaef0dcca8b0a30c33c35a/resource.tar.gz#test.test_blocks-ifpresent_single_arg-default.txt-Peephole_/opt.yql"
+            "checksum": "944c160a07d9c5d35c8ce088e06102ac",
+            "size": 1018,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-ifpresent_single_arg-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-ifpresent_single_arg-default.txt-Results]": [
@@ -487,9 +487,9 @@
     ],
     "test.test[blocks-just-default.txt-Peephole]": [
         {
-            "checksum": "c352b609f1b0e2462f1290962c13e6f6",
-            "size": 488,
-            "uri": "https://{canondata_backend}/1809005/02f459fce1f16d89b3444e6e8728b9747bb52b53/resource.tar.gz#test.test_blocks-just-default.txt-Peephole_/opt.yql"
+            "checksum": "da038d6a56d1ed78418aff5e3dc1446e",
+            "size": 468,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-just-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-just-default.txt-Results]": [
@@ -508,9 +508,9 @@
     ],
     "test.test[blocks-not-default.txt-Peephole]": [
         {
-            "checksum": "64173242c7d6f033cc1de18b88472271",
-            "size": 524,
-            "uri": "https://{canondata_backend}/1809005/02f459fce1f16d89b3444e6e8728b9747bb52b53/resource.tar.gz#test.test_blocks-not-default.txt-Peephole_/opt.yql"
+            "checksum": "a5aed61024219c5e626a025ca09516f6",
+            "size": 504,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-not-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-not-default.txt-Results]": [
@@ -529,9 +529,9 @@
     ],
     "test.test[blocks-not_opt-default.txt-Peephole]": [
         {
-            "checksum": "9ea6f61d33ac7fddb2bc2050600e327d",
-            "size": 599,
-            "uri": "https://{canondata_backend}/1809005/02f459fce1f16d89b3444e6e8728b9747bb52b53/resource.tar.gz#test.test_blocks-not_opt-default.txt-Peephole_/opt.yql"
+            "checksum": "50029d30ea3bd00a9961ae8522b52a71",
+            "size": 579,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-not_opt-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-not_opt-default.txt-Results]": [
@@ -550,9 +550,9 @@
     ],
     "test.test[blocks-xor_scalar-default.txt-Peephole]": [
         {
-            "checksum": "40b1616837226098205c07c33be898ec",
-            "size": 1433,
-            "uri": "https://{canondata_backend}/1809005/02f459fce1f16d89b3444e6e8728b9747bb52b53/resource.tar.gz#test.test_blocks-xor_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "844625b1809bb50e0dc279baac750a07",
+            "size": 1393,
+            "uri": "https://{canondata_backend}/1597364/7f48aef528fe04463995b2698aa1655ed2bcde96/resource.tar.gz#test.test_blocks-xor_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-xor_scalar-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part6/canondata/result.json b/yql/essentials/tests/sql/minirun/part6/canondata/result.json
index 96dfc176a0c..212df59182f 100644
--- a/yql/essentials/tests/sql/minirun/part6/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part6/canondata/result.json
@@ -361,9 +361,9 @@
     ],
     "test.test[blocks-agg_with_optional_string_keys-default.txt-Peephole]": [
         {
-            "checksum": "746a1d389eb41491e1275c5323df00bf",
-            "size": 1547,
-            "uri": "https://{canondata_backend}/1881367/91257b77defd2cabf8041b14bff63c8d29b9acc0/resource.tar.gz#test.test_blocks-agg_with_optional_string_keys-default.txt-Peephole_/opt.yql"
+            "checksum": "b4dc63882ea4e6f33556f8d1118a45d5",
+            "size": 1535,
+            "uri": "https://{canondata_backend}/1871182/fc89816f1ceff459a281d25f04887929779980c3/resource.tar.gz#test.test_blocks-agg_with_optional_string_keys-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_with_optional_string_keys-default.txt-Results]": [
@@ -382,9 +382,9 @@
     ],
     "test.test[blocks-coalesce_scalar-default.txt-Peephole]": [
         {
-            "checksum": "16037c7a59e90100426abd1f7461cfd3",
-            "size": 1963,
-            "uri": "https://{canondata_backend}/1917492/9722518a50ef2685c59301cc045eae38584b9f63/resource.tar.gz#test.test_blocks-coalesce_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "9575a410ae2207877e6322bee791d020",
+            "size": 1923,
+            "uri": "https://{canondata_backend}/1871182/fc89816f1ceff459a281d25f04887929779980c3/resource.tar.gz#test.test_blocks-coalesce_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-coalesce_scalar-default.txt-Results]": [
@@ -403,9 +403,9 @@
     ],
     "test.test[blocks-member-default.txt-Peephole]": [
         {
-            "checksum": "c7daf76e38a19686c4ecd83abd730695",
-            "size": 606,
-            "uri": "https://{canondata_backend}/1917492/9722518a50ef2685c59301cc045eae38584b9f63/resource.tar.gz#test.test_blocks-member-default.txt-Peephole_/opt.yql"
+            "checksum": "ebe34f0a564e591c9c79f9e352c89fc1",
+            "size": 586,
+            "uri": "https://{canondata_backend}/1871182/fc89816f1ceff459a281d25f04887929779980c3/resource.tar.gz#test.test_blocks-member-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-member-default.txt-Results]": [
@@ -424,9 +424,9 @@
     ],
     "test.test[blocks-projection_add_ints_filter-default.txt-Peephole]": [
         {
-            "checksum": "01f95e929504c5aa0b7649319635242b",
-            "size": 891,
-            "uri": "https://{canondata_backend}/1130705/45cb0500363a371da052fdfab03d172e95a23b9c/resource.tar.gz#test.test_blocks-projection_add_ints_filter-default.txt-Peephole_/opt.yql"
+            "checksum": "53337baa34109808f8c56416f1dd2def",
+            "size": 851,
+            "uri": "https://{canondata_backend}/1871182/fc89816f1ceff459a281d25f04887929779980c3/resource.tar.gz#test.test_blocks-projection_add_ints_filter-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-projection_add_ints_filter-default.txt-Results]": [
@@ -445,9 +445,9 @@
     ],
     "test.test[blocks-singular_type_scalar-default.txt-Peephole]": [
         {
-            "checksum": "48d280b750da15c737d3d82620e0bcc6",
-            "size": 2812,
-            "uri": "https://{canondata_backend}/1920236/cd7892eb0facff7eb2c6e0b30c741174c37d06f1/resource.tar.gz#test.test_blocks-singular_type_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "e73ed30cc0c2662b926e8cb253fb8d5d",
+            "size": 2712,
+            "uri": "https://{canondata_backend}/1871182/fc89816f1ceff459a281d25f04887929779980c3/resource.tar.gz#test.test_blocks-singular_type_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-singular_type_scalar-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part7/canondata/result.json b/yql/essentials/tests/sql/minirun/part7/canondata/result.json
index 9ffda18baa6..05ad9133cd0 100644
--- a/yql/essentials/tests/sql/minirun/part7/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part7/canondata/result.json
@@ -218,9 +218,9 @@
     ],
     "test.test[blocks-as_tuple-default.txt-Peephole]": [
         {
-            "checksum": "02e80809d3cbf91101d09d4ac1e87aa0",
-            "size": 623,
-            "uri": "https://{canondata_backend}/1130705/f9eb075ce8fc54a57832e4ee918669601325c133/resource.tar.gz#test.test_blocks-as_tuple-default.txt-Peephole_/opt.yql"
+            "checksum": "b4be0806fe4b6769348dfb8df43df8e2",
+            "size": 603,
+            "uri": "https://{canondata_backend}/1597364/792b13a155afc1f7be54475ccefb55a4bef4674c/resource.tar.gz#test.test_blocks-as_tuple-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-as_tuple-default.txt-Results]": [
@@ -260,9 +260,9 @@
     ],
     "test.test[blocks-ifpresent_two_args-default.txt-Peephole]": [
         {
-            "checksum": "d5ce83db55f71972d1af85f06bd78cea",
-            "size": 1271,
-            "uri": "https://{canondata_backend}/1916746/999529ac11217edcdd3b15fc5a56af6e840ec7ae/resource.tar.gz#test.test_blocks-ifpresent_two_args-default.txt-Peephole_/opt.yql"
+            "checksum": "ae6ceb0730332a85348f1e75e7694e8c",
+            "size": 1251,
+            "uri": "https://{canondata_backend}/1597364/792b13a155afc1f7be54475ccefb55a4bef4674c/resource.tar.gz#test.test_blocks-ifpresent_two_args-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-ifpresent_two_args-default.txt-Results]": [
@@ -281,9 +281,9 @@
     ],
     "test.test[blocks-or-default.txt-Peephole]": [
         {
-            "checksum": "4c4fe5d41f9b37bfaf53bc0a57d8b48b",
-            "size": 701,
-            "uri": "https://{canondata_backend}/1917492/b01930df0710eb10e4ce2d35cddca6be33ac8a9f/resource.tar.gz#test.test_blocks-or-default.txt-Peephole_/opt.yql"
+            "checksum": "d440564dc64883cdf7dd29f7e629c6ce",
+            "size": 681,
+            "uri": "https://{canondata_backend}/1597364/792b13a155afc1f7be54475ccefb55a4bef4674c/resource.tar.gz#test.test_blocks-or-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-or-default.txt-Results]": [
@@ -302,9 +302,9 @@
     ],
     "test.test[blocks-topg-default.txt-Peephole]": [
         {
-            "checksum": "237a12866d5a4f1af7a79ba95d1a6f71",
-            "size": 557,
-            "uri": "https://{canondata_backend}/1917492/b01930df0710eb10e4ce2d35cddca6be33ac8a9f/resource.tar.gz#test.test_blocks-topg-default.txt-Peephole_/opt.yql"
+            "checksum": "624b115d71c60431caa516418d0b57e2",
+            "size": 537,
+            "uri": "https://{canondata_backend}/1597364/792b13a155afc1f7be54475ccefb55a4bef4674c/resource.tar.gz#test.test_blocks-topg-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-topg-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part8/canondata/result.json b/yql/essentials/tests/sql/minirun/part8/canondata/result.json
index d6effe20bb8..599e122e7ba 100644
--- a/yql/essentials/tests/sql/minirun/part8/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part8/canondata/result.json
@@ -375,9 +375,9 @@
     ],
     "test.test[blocks-agg_singular_type_key-default.txt-Peephole]": [
         {
-            "checksum": "f77f6136a2995c5b0e0ae3ed00274d36",
-            "size": 6564,
-            "uri": "https://{canondata_backend}/1936273/07450a3416f3c728f9a8a8fdde6e5f5a0ca2d9a6/resource.tar.gz#test.test_blocks-agg_singular_type_key-default.txt-Peephole_/opt.yql"
+            "checksum": "9273da08a3b99431f11b7325005b3f50",
+            "size": 6519,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-agg_singular_type_key-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_singular_type_key-default.txt-Results]": [
@@ -396,9 +396,9 @@
     ],
     "test.test[blocks-agg_singular_type_value-default.txt-Peephole]": [
         {
-            "checksum": "b34c4e8ca42e6232ef03f2ffeb05fd83",
-            "size": 3013,
-            "uri": "https://{canondata_backend}/1130705/a25045513209436069d9f9a29831b732c13e1675/resource.tar.gz#test.test_blocks-agg_singular_type_value-default.txt-Peephole_/opt.yql"
+            "checksum": "a0a7cb4b6b6a29f03a95fc4b896a87ea",
+            "size": 3001,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-agg_singular_type_value-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_singular_type_value-default.txt-Results]": [
@@ -417,9 +417,9 @@
     ],
     "test.test[blocks-agg_with_optional_short_keys-default.txt-Peephole]": [
         {
-            "checksum": "922eb78f0602be1324327c4e1d615df7",
-            "size": 1500,
-            "uri": "https://{canondata_backend}/1937367/01b34a497b7b8ca6a58c91f8a4e3d26eac6fc1dd/resource.tar.gz#test.test_blocks-agg_with_optional_short_keys-default.txt-Peephole_/opt.yql"
+            "checksum": "b6774ec936b1318670817fde88bcd621",
+            "size": 1488,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-agg_with_optional_short_keys-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_with_optional_short_keys-default.txt-Results]": [
@@ -438,9 +438,9 @@
     ],
     "test.test[blocks-and_scalar-default.txt-Peephole]": [
         {
-            "checksum": "9ef95c0429987ba69696f349db7a3143",
-            "size": 1433,
-            "uri": "https://{canondata_backend}/1881367/2ee5d4b68dd6e9c4fef4660614522e34e2459106/resource.tar.gz#test.test_blocks-and_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "c8b693f9c682cc0c507d6acbe20569cd",
+            "size": 1393,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-and_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-and_scalar-default.txt-Results]": [
@@ -459,9 +459,9 @@
     ],
     "test.test[blocks-coalesce_multi_optional_data_type-default.txt-Peephole]": [
         {
-            "checksum": "38287310a981017fcf2fa2cf7b482d4f",
-            "size": 891,
-            "uri": "https://{canondata_backend}/1937001/26b879fa17edc79687f71103ac1dacc46f13313b/resource.tar.gz#test.test_blocks-coalesce_multi_optional_data_type-default.txt-Peephole_/opt.yql"
+            "checksum": "b23dce371a58342c2a657ffa8582e96e",
+            "size": 871,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-coalesce_multi_optional_data_type-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-coalesce_multi_optional_data_type-default.txt-Results]": [
@@ -480,9 +480,9 @@
     ],
     "test.test[blocks-if-default.txt-Peephole]": [
         {
-            "checksum": "b23952b137d3faf33b6168319047e152",
-            "size": 737,
-            "uri": "https://{canondata_backend}/1881367/2ee5d4b68dd6e9c4fef4660614522e34e2459106/resource.tar.gz#test.test_blocks-if-default.txt-Peephole_/opt.yql"
+            "checksum": "9005d5ae0471cc5bd956bff3d9e0be92",
+            "size": 717,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-if-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-if-default.txt-Results]": [
@@ -501,9 +501,9 @@
     ],
     "test.test[blocks-pg_op-default.txt-Peephole]": [
         {
-            "checksum": "570868d831a49ebc5e0c21dcadf9c81f",
-            "size": 883,
-            "uri": "https://{canondata_backend}/1881367/2ee5d4b68dd6e9c4fef4660614522e34e2459106/resource.tar.gz#test.test_blocks-pg_op-default.txt-Peephole_/opt.yql"
+            "checksum": "a43f220670457507e40a2beb9717dae9",
+            "size": 863,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-pg_op-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-pg_op-default.txt-Results]": [
@@ -522,9 +522,9 @@
     ],
     "test.test[blocks-xor_opt-default.txt-Peephole]": [
         {
-            "checksum": "2b909a2bd312a54ad8c7153247298993",
-            "size": 900,
-            "uri": "https://{canondata_backend}/1881367/2ee5d4b68dd6e9c4fef4660614522e34e2459106/resource.tar.gz#test.test_blocks-xor_opt-default.txt-Peephole_/opt.yql"
+            "checksum": "30eec4a3ed0f9d06148742141a620408",
+            "size": 880,
+            "uri": "https://{canondata_backend}/995452/36420a4a5c1f498a2f7efc13e9ff1f6b3b41fdf9/resource.tar.gz#test.test_blocks-xor_opt-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-xor_opt-default.txt-Results]": [
diff --git a/yql/essentials/tests/sql/minirun/part9/canondata/result.json b/yql/essentials/tests/sql/minirun/part9/canondata/result.json
index 005566d0129..411bc67c634 100644
--- a/yql/essentials/tests/sql/minirun/part9/canondata/result.json
+++ b/yql/essentials/tests/sql/minirun/part9/canondata/result.json
@@ -176,9 +176,9 @@
     ],
     "test.test[blocks-agg_all_only_distinct-default.txt-Peephole]": [
         {
-            "checksum": "71442e05f1ea713f163527b5ff08d065",
-            "size": 1683,
-            "uri": "https://{canondata_backend}/1917492/5cddb9dcb358e358fc244d25a12d573969df0013/resource.tar.gz#test.test_blocks-agg_all_only_distinct-default.txt-Peephole_/opt.yql"
+            "checksum": "26be680d23afbddb9d4896ab82accafa",
+            "size": 1651,
+            "uri": "https://{canondata_backend}/995452/d8b1a11634521c475d3b5cbe4d7b45ea3dd2a175/resource.tar.gz#test.test_blocks-agg_all_only_distinct-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-agg_all_only_distinct-default.txt-Results]": [
@@ -197,9 +197,9 @@
     ],
     "test.test[blocks-coalesce-default.txt-Peephole]": [
         {
-            "checksum": "9ea7c29f9825b44790014fc6a147d5cc",
-            "size": 1175,
-            "uri": "https://{canondata_backend}/1917492/5cddb9dcb358e358fc244d25a12d573969df0013/resource.tar.gz#test.test_blocks-coalesce-default.txt-Peephole_/opt.yql"
+            "checksum": "b7f66aa119dd901b7850358eec1d7716",
+            "size": 1135,
+            "uri": "https://{canondata_backend}/995452/d8b1a11634521c475d3b5cbe4d7b45ea3dd2a175/resource.tar.gz#test.test_blocks-coalesce-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-coalesce-default.txt-Results]": [
@@ -218,9 +218,9 @@
     ],
     "test.test[blocks-if_scalar-default.txt-Peephole]": [
         {
-            "checksum": "471947ddcb963e1ac303d4cd71c10242",
-            "size": 2035,
-            "uri": "https://{canondata_backend}/1917492/5cddb9dcb358e358fc244d25a12d573969df0013/resource.tar.gz#test.test_blocks-if_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "68867025e8eeca6d309903e482116c48",
+            "size": 1995,
+            "uri": "https://{canondata_backend}/995452/d8b1a11634521c475d3b5cbe4d7b45ea3dd2a175/resource.tar.gz#test.test_blocks-if_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-if_scalar-default.txt-Results]": [
@@ -239,9 +239,9 @@
     ],
     "test.test[blocks-ifpresent_explicitly_strict-default.txt-Peephole]": [
         {
-            "checksum": "e4ac8f53ae68b9ab29ec81b62b5dfd0d",
-            "size": 868,
-            "uri": "https://{canondata_backend}/1775319/8ef6bbaa9001bae80f645156017516ec623f5e72/resource.tar.gz#test.test_blocks-ifpresent_explicitly_strict-default.txt-Peephole_/opt.yql"
+            "checksum": "2167f96ee979428961e64d3d7875a9db",
+            "size": 848,
+            "uri": "https://{canondata_backend}/995452/d8b1a11634521c475d3b5cbe4d7b45ea3dd2a175/resource.tar.gz#test.test_blocks-ifpresent_explicitly_strict-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-ifpresent_explicitly_strict-default.txt-Results]": [
@@ -260,9 +260,9 @@
     ],
     "test.test[blocks-ifpresent_scalar-default.txt-Peephole]": [
         {
-            "checksum": "334b468aab11047a6f54d6e318d5e3f6",
-            "size": 869,
-            "uri": "https://{canondata_backend}/1775319/8ef6bbaa9001bae80f645156017516ec623f5e72/resource.tar.gz#test.test_blocks-ifpresent_scalar-default.txt-Peephole_/opt.yql"
+            "checksum": "c60e0e0ce8c5c13f96311afa44df259b",
+            "size": 849,
+            "uri": "https://{canondata_backend}/995452/d8b1a11634521c475d3b5cbe4d7b45ea3dd2a175/resource.tar.gz#test.test_blocks-ifpresent_scalar-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-ifpresent_scalar-default.txt-Results]": [
@@ -281,9 +281,9 @@
     ],
     "test.test[blocks-nth-default.txt-Peephole]": [
         {
-            "checksum": "66aeb49d6120f870670261bac89f6c13",
-            "size": 611,
-            "uri": "https://{canondata_backend}/1917492/5cddb9dcb358e358fc244d25a12d573969df0013/resource.tar.gz#test.test_blocks-nth-default.txt-Peephole_/opt.yql"
+            "checksum": "90023fa9be853f50d83924dd5be24b6e",
+            "size": 591,
+            "uri": "https://{canondata_backend}/995452/d8b1a11634521c475d3b5cbe4d7b45ea3dd2a175/resource.tar.gz#test.test_blocks-nth-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-nth-default.txt-Results]": [
@@ -302,9 +302,9 @@
     ],
     "test.test[blocks-projection_add_ints-default.txt-Peephole]": [
         {
-            "checksum": "40ca33def60be28702004037b2c2222c",
-            "size": 682,
-            "uri": "https://{canondata_backend}/1917492/5cddb9dcb358e358fc244d25a12d573969df0013/resource.tar.gz#test.test_blocks-projection_add_ints-default.txt-Peephole_/opt.yql"
+            "checksum": "7e49aed99a06c1e0bf7d347303017697",
+            "size": 662,
+            "uri": "https://{canondata_backend}/995452/d8b1a11634521c475d3b5cbe4d7b45ea3dd2a175/resource.tar.gz#test.test_blocks-projection_add_ints-default.txt-Peephole_/opt.yql"
         }
     ],
     "test.test[blocks-projection_add_ints-default.txt-Results]": [