don't erase tagged type anymore, Nop callable/wrapper

21 files changed, 117 insertions, 77 deletions

diff --git a/ydb/core/kqp/query_compiler/kqp_query_compiler.cpp b/ydb/core/kqp/query_compiler/kqp_query_compiler.cpp
index b266ed427e9..812db4e4528 100644
--- a/ydb/core/kqp/query_compiler/kqp_query_compiler.cpp
+++ b/ydb/core/kqp/query_compiler/kqp_query_compiler.cpp
@@ -538,8 +538,7 @@ public:
 private:
     NKikimr::NMiniKQL::TType* CompileType(TProgramBuilder& pgmBuilder, const TTypeAnnotationNode& inputType) {
         TStringStream errorStream;
-        const bool withTagged = true;
-        auto type = NCommon::BuildType(inputType, pgmBuilder, errorStream, withTagged);
+        auto type = NCommon::BuildType(inputType, pgmBuilder, errorStream);
         Y_ENSURE(type, "Failed to compile type: " << errorStream.Str());
         return type;
     }
diff --git a/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp b/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp
index 53941e0cc6e..c32f51de51b 100644
--- a/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp
+++ b/ydb/library/yql/core/peephole_opt/yql_opt_peephole_physical.cpp
@@ -3767,42 +3767,6 @@ TExprNode::TPtr AutoMapGetElementhOfOptionalArray(const TExprNode::TPtr& node, T
             auto ret = ctx.ChangeChild(*node, 0U, node->Head().HeadPtr());
             return JustIf(!itemType->IsOptionalOrNull(), std::move(ret), ctx);
         }
-
-        constexpr auto typeName = TupleOrStruct ? "tuple" : "struct";
-        YQL_CLOG(DEBUG, CorePeepHole) << "Wrap " << node->Content() << " for optional " << typeName << '.';
-        return itemType->IsOptionalOrNull() ?
-            ctx.Builder(node->Pos())
-                .Callable("IfPresent")
-                    .Add(0, node->HeadPtr())
-                    .Lambda(1)
-                        .Param(typeName)
-                        .Callable(node->Content())
-                            .Arg(0, typeName)
-                            .Add(1, node->TailPtr())
-                        .Seal()
-                    .Seal()
-                    .Callable(2, "Nothing")
-                        .Add(0, ExpandType(node->Pos(), *node->GetTypeAnn(), ctx))
-                    .Seal()
-                .Seal()
-            .Build():
-            ctx.Builder(node->Pos())
-                .Callable("IfPresent")
-                    .Add(0, node->HeadPtr())
-                    .Lambda(1)
-                        .Param(typeName)
-                        .Callable("Just")
-                            .Callable(0, node->Content())
-                                .Arg(0, typeName)
-                                .Add(1, node->TailPtr())
-                            .Seal()
-                        .Seal()
-                    .Seal()
-                    .Callable(2, "Nothing")
-                        .Add(0, ExpandType(node->Pos(), *node->GetTypeAnn(), ctx))
-                    .Seal()
-                .Seal()
-            .Build();
     }
 
     return node;
diff --git a/ydb/library/yql/dq/runtime/dq_transport.cpp b/ydb/library/yql/dq/runtime/dq_transport.cpp
index 0f177986d49..5597ad4023c 100644
--- a/ydb/library/yql/dq/runtime/dq_transport.cpp
+++ b/ydb/library/yql/dq/runtime/dq_transport.cpp
@@ -374,6 +374,12 @@ ui64 EstimateSizeImpl(const NUdf::TUnboxedValuePod& value, const NKikimr::NMiniK
             }
             return 0;
         }
+
+        case TType::EKind::Tagged: {
+            auto taggedType = static_cast<const TTaggedType*>(type);
+            return EstimateSizeImpl(value, taggedType->GetBaseType(), fixed);
+        }
+
         case TType::EKind::Type:
         case TType::EKind::Stream:
         case TType::EKind::Callable:
@@ -381,7 +387,6 @@ ui64 EstimateSizeImpl(const NUdf::TUnboxedValuePod& value, const NKikimr::NMiniK
         case TType::EKind::Resource:
         case TType::EKind::Flow:
         case TType::EKind::ReservedKind:
-        case TType::EKind::Tagged:
         case TType::EKind::Block:
             THROW yexception() << "Unsupported type: " << type->GetKindAsStr();
     }
diff --git a/ydb/library/yql/minikql/comp_nodes/CMakeLists.darwin.txt b/ydb/library/yql/minikql/comp_nodes/CMakeLists.darwin.txt
index c356eb926cb..52aec2119d7 100644
--- a/ydb/library/yql/minikql/comp_nodes/CMakeLists.darwin.txt
+++ b/ydb/library/yql/minikql/comp_nodes/CMakeLists.darwin.txt
@@ -108,6 +108,7 @@ target_sources(yql-minikql-comp_nodes PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_multihopping.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_multimap.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_next_value.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_nop.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_now.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_null.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_pickle.cpp
diff --git a/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux-aarch64.txt b/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux-aarch64.txt
index fe05c2c1486..5819bbc6d33 100644
--- a/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux-aarch64.txt
+++ b/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux-aarch64.txt
@@ -109,6 +109,7 @@ target_sources(yql-minikql-comp_nodes PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_multihopping.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_multimap.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_next_value.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_nop.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_now.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_null.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_pickle.cpp
diff --git a/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux.txt b/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux.txt
index fe05c2c1486..5819bbc6d33 100644
--- a/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux.txt
+++ b/ydb/library/yql/minikql/comp_nodes/CMakeLists.linux.txt
@@ -109,6 +109,7 @@ target_sources(yql-minikql-comp_nodes PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_multihopping.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_multimap.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_next_value.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_nop.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_now.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_null.cpp
   ${CMAKE_SOURCE_DIR}/ydb/library/yql/minikql/comp_nodes/mkql_pickle.cpp
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_factory.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_factory.cpp
index d336e46810b..7b51fb5398c 100644
--- a/ydb/library/yql/minikql/comp_nodes/mkql_factory.cpp
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_factory.cpp
@@ -63,6 +63,7 @@
 #include "mkql_map_join.h"
 #include "mkql_multimap.h"
 #include "mkql_next_value.h"
+#include "mkql_nop.h"
 #include "mkql_now.h"
 #include "mkql_null.h"
 #include "mkql_pickle.h"
@@ -336,6 +337,7 @@ struct TCallableComputationNodeBuilderFuncMapFiller {
         {"RoundUp", &WrapRound},
         {"RoundDown", &WrapRound},
         {"NextValue", &WrapNextValue},
+        {"Nop", &WrapNop},
     };
 };
 
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_nop.cpp b/ydb/library/yql/minikql/comp_nodes/mkql_nop.cpp
new file mode 100644
index 00000000000..fca8350f601
--- /dev/null
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_nop.cpp
@@ -0,0 +1,14 @@
+#include "mkql_nop.h"
+
+#include <ydb/library/yql/minikql/computation/mkql_computation_node_impl.h>
+
+namespace NKikimr {
+namespace NMiniKQL {
+
+IComputationNode* WrapNop(TCallable& callable, const TComputationNodeFactoryContext& ctx) {
+    MKQL_ENSURE(callable.GetInputsCount() == 1, "Expected 1 arg");
+    return LocateNode(ctx.NodeLocator, callable, 0);
+}
+
+}
+}
diff --git a/ydb/library/yql/minikql/comp_nodes/mkql_nop.h b/ydb/library/yql/minikql/comp_nodes/mkql_nop.h
new file mode 100644
index 00000000000..b0b4cce726f
--- /dev/null
+++ b/ydb/library/yql/minikql/comp_nodes/mkql_nop.h
@@ -0,0 +1,10 @@
+#pragma once
+#include <ydb/library/yql/minikql/computation/mkql_computation_node.h>
+
+namespace NKikimr {
+namespace NMiniKQL {
+
+IComputationNode* WrapNop(TCallable& callable, const TComputationNodeFactoryContext& ctx);
+
+}
+}
diff --git a/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp b/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp
index 68d20e58f1d..47203f91f7c 100644
--- a/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp
+++ b/ydb/library/yql/minikql/computation/mkql_computation_node_pack.cpp
@@ -838,6 +838,12 @@ void TValuePacker::PackImpl(const TType* type, const NUdf::TUnboxedValuePod& val
         break;
     }
 
+    case TType::EKind::Tagged: {
+        auto taggedType = static_cast<const TTaggedType*>(type);
+        PackImpl(taggedType->GetBaseType(), value);
+        break;
+    }
+
     default:
         THROW yexception() << "Unsupported type: " << type->GetKindAsStr();
     }
diff --git a/ydb/library/yql/minikql/computation/presort.cpp b/ydb/library/yql/minikql/computation/presort.cpp
index 9f18fe8c7fd..4fd8a336a4a 100644
--- a/ydb/library/yql/minikql/computation/presort.cpp
+++ b/ydb/library/yql/minikql/computation/presort.cpp
@@ -406,13 +406,18 @@ void EncodeValue(TType* type, const NUdf::TUnboxedValue& value, TVector<ui8>& ou
         break;
     }
 
+    case TType::EKind::Tagged: {
+        auto baseType = static_cast<TTaggedType*>(type)->GetBaseType();
+        EncodeValue(baseType, value, output);
+        break;
+    }
+
     default:
         MKQL_ENSURE(false, "Unsupported type: " << type->GetKindAsStr());
     }
 }
 
 NUdf::TUnboxedValue DecodeImpl(TType* type, TStringBuf& input, const THolderFactory& factory, TVector<ui8>& buffer) {
-    Y_UNUSED(factory);
     switch (type->GetKind()) {
     case TType::EKind::Void:
         return NUdf::TUnboxedValue::Void();
@@ -489,6 +494,11 @@ NUdf::TUnboxedValue DecodeImpl(TType* type, TStringBuf& input, const THolderFact
         return factory.CreateVariantHolder(value.Release(), alt);
     }
 
+    case TType::EKind::Tagged: {
+        auto baseType = static_cast<TTaggedType*>(type)->GetBaseType();
+        return DecodeImpl(baseType, input, factory, buffer);
+    }
+
     // Struct and Dict may be encoded into a presort form only to canonize dict keys. No need to decode them.
     case TType::EKind::Struct:
     case TType::EKind::Dict:
diff --git a/ydb/library/yql/minikql/mkql_node.cpp b/ydb/library/yql/minikql/mkql_node.cpp
index 0943f72a875..ab1dd70f815 100644
--- a/ydb/library/yql/minikql/mkql_node.cpp
+++ b/ydb/library/yql/minikql/mkql_node.cpp
@@ -2383,6 +2383,9 @@ EValueRepresentation GetValueRepresentation(const TType* type) {
         case TType::EKind::Pg:
             return EValueRepresentation::Any;
 
+        case TType::EKind::Tagged:
+            return GetValueRepresentation(static_cast<const TTaggedType*>(type)->GetBaseType());
+
         default:
             Y_FAIL("Unsupported type.");
     }
diff --git a/ydb/library/yql/minikql/mkql_program_builder.cpp b/ydb/library/yql/minikql/mkql_program_builder.cpp
index 5c1e38847d0..67d8f79d9f9 100644
--- a/ydb/library/yql/minikql/mkql_program_builder.cpp
+++ b/ydb/library/yql/minikql/mkql_program_builder.cpp
@@ -3170,7 +3170,7 @@ TRuntimeNode TProgramBuilder::Nth(TRuntimeNode tuple, ui32 index) {
     MKQL_ENSURE(index < type->GetElementsCount(), "Index out of range: " << index <<
         " is not less than " << type->GetElementsCount());
     auto itemType = type->GetElementType(index);
-    if (isOptional && !itemType->IsOptional()) {
+    if (isOptional && !itemType->IsOptional() && !itemType->IsNull() && !itemType->IsPg()) {
         itemType = TOptionalType::Create(itemType, Env);
     }
 
@@ -5251,6 +5251,16 @@ TRuntimeNode TProgramBuilder::NextValue(TRuntimeNode value) {
     return TRuntimeNode(callableBuilder.Build(), false);
 }
 
+TRuntimeNode TProgramBuilder::Nop(TRuntimeNode value, TType* returnType) {
+    if constexpr (RuntimeVersion < 35U) {
+        THROW yexception() << "Runtime version (" << RuntimeVersion << ") too old for " << __func__;
+    }
+
+    TCallableBuilder callableBuilder(Env, __func__, returnType);
+    callableBuilder.Add(value);
+    return TRuntimeNode(callableBuilder.Build(), false);
+}
+
 bool TProgramBuilder::IsNull(TRuntimeNode arg) {
     return arg.GetStaticType()->IsSameType(*NewNull().GetStaticType()); // TODO ->IsNull();
 }
diff --git a/ydb/library/yql/minikql/mkql_program_builder.h b/ydb/library/yql/minikql/mkql_program_builder.h
index 643bb1e7b92..d20e1adb1cc 100644
--- a/ydb/library/yql/minikql/mkql_program_builder.h
+++ b/ydb/library/yql/minikql/mkql_program_builder.h
@@ -658,6 +658,8 @@ public:
 
     TRuntimeNode NextValue(TRuntimeNode value);
 
+    TRuntimeNode Nop(TRuntimeNode value, TType* returnType);
+
     typedef TRuntimeNode (TProgramBuilder::*UnaryFunctionMethod)(TRuntimeNode);
     typedef TRuntimeNode (TProgramBuilder::*BinaryFunctionMethod)(TRuntimeNode, TRuntimeNode);
     typedef TRuntimeNode (TProgramBuilder::*TernaryFunctionMethod)(TRuntimeNode, TRuntimeNode, TRuntimeNode);
diff --git a/ydb/library/yql/minikql/mkql_runtime_version.h b/ydb/library/yql/minikql/mkql_runtime_version.h
index e776c5577db..1baf00d2ca3 100644
--- a/ydb/library/yql/minikql/mkql_runtime_version.h
+++ b/ydb/library/yql/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 34U
+#define MKQL_RUNTIME_VERSION 35U
 #endif
 
 // History:
diff --git a/ydb/library/yql/minikql/mkql_type_builder.cpp b/ydb/library/yql/minikql/mkql_type_builder.cpp
index ae2ac5f2fd0..271e0fae050 100644
--- a/ydb/library/yql/minikql/mkql_type_builder.cpp
+++ b/ydb/library/yql/minikql/mkql_type_builder.cpp
@@ -2014,6 +2014,10 @@ NUdf::IHash::TPtr MakeHashImpl(const NMiniKQL::TType* type) {
             return new TEmptyHash();
         case NMiniKQL::TType::EKind::Pg:
             return MakePgHash((const TPgType*)type);
+        case NMiniKQL::TType::EKind::Tagged: {
+            auto taggedType = static_cast<const TTaggedType*>(type);
+            return MakeHashImpl(taggedType->GetBaseType());
+        }
         default:
             throw TTypeNotSupported() << "Data, Pg, Optional, Tuple, Struct, List, Variant or Dict is expected for hashing";
     }
@@ -2056,6 +2060,10 @@ NUdf::ICompare::TPtr MakeCompareImpl(const NMiniKQL::TType* type) {
             return new TCompare<NMiniKQL::TType::EKind::List>(type);
         case NMiniKQL::TType::EKind::Pg:
             return MakePgCompare((const TPgType*)type);
+        case NMiniKQL::TType::EKind::Tagged: {
+            auto taggedType = static_cast<const TTaggedType*>(type);
+            return MakeCompareImpl(taggedType->GetBaseType());
+        }
         default:
             throw TTypeNotSupported() << "Data, Pg, Optional, Variant over Tuple, Tuple or List is expected for comparing,"
             << "but got: " << PrintNode(type);
@@ -2102,6 +2110,10 @@ NUdf::IEquate::TPtr MakeEquateImpl(const NMiniKQL::TType* type) {
             return new TEquate<NMiniKQL::TType::EKind::Dict>(type);
         case NMiniKQL::TType::EKind::Pg:
             return MakePgEquate((const TPgType*)type);
+        case NMiniKQL::TType::EKind::Tagged: {
+            auto taggedType = static_cast<const TTaggedType*>(type);
+            return MakeEquateImpl(taggedType->GetBaseType());
+        }
         default:
             throw TTypeNotSupported() << "Data, Pg, Optional, Tuple, Struct, List, Variant or Dict is expected for equating";
     }
diff --git a/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp b/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp
index 26fb981a459..4847165b44c 100644
--- a/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp
+++ b/ydb/library/yql/providers/common/mkql/yql_provider_mkql.cpp
@@ -2177,7 +2177,13 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         return ctx.ProgramBuilder.NewNull();
     });
 
-    AddCallable({"AsTagged","Untag","WithWorld"}, [](const TExprNode& node, TMkqlBuildContext& ctx) {
+    AddCallable({ "AsTagged","Untag" }, [](const TExprNode& node, TMkqlBuildContext& ctx) {
+        auto input = MkqlBuildExpr(node.Head(), ctx);
+        auto returnType = BuildType(node, *node.GetTypeAnn(), ctx.ProgramBuilder);
+        return ctx.ProgramBuilder.Nop(input, returnType);
+    });
+
+    AddCallable({"WithWorld"}, [](const TExprNode& node, TMkqlBuildContext& ctx) {
         return MkqlBuildExpr(node.Head(), ctx);
     });
 
@@ -2246,7 +2252,7 @@ TMkqlCommonCallableCompiler::TShared::TShared() {
         YQL_ENSURE(node.ChildrenSize() == 8);
         std::string_view function = node.Head().Content();
         const auto runConfig = MkqlBuildExpr(*node.Child(1), ctx);
-        const auto userType = BuildType(*node.Child(2), *node.Child(2)->GetTypeAnn(), ctx.ProgramBuilder, true);
+        const auto userType = BuildType(*node.Child(2), *node.Child(2)->GetTypeAnn(), ctx.ProgramBuilder);
         const auto typeConfig = node.Child(3)->Content();
         const auto callableType = BuildType(node, *node.GetTypeAnn(), ctx.ProgramBuilder);
         const auto pos = ctx.ExprCtx.GetPosition(node.Pos());
diff --git a/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp b/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp
index c82ce121f36..5a2123e13fc 100644
--- a/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp
+++ b/ydb/library/yql/providers/common/mkql/yql_type_mkql.cpp
@@ -16,7 +16,7 @@
 namespace NYql {
 namespace NCommon {
 
-NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, IOutputStream& err, bool withTagged) {
+NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, IOutputStream& err) {
     switch (annotation.GetKind()) {
     case ETypeAnnotationKind::Data: {
         auto data = annotation.Cast<TDataExprType>();
@@ -42,7 +42,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
         members.reserve(structObj->GetItems().size());
 
         for (auto& item : structObj->GetItems()) {
-            auto itemType = BuildType(*item->GetItemType(), pgmBuilder, err, withTagged);
+            auto itemType = BuildType(*item->GetItemType(), pgmBuilder, err);
             if (!itemType) {
                 return nullptr;
             }
@@ -53,7 +53,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::List: {
         auto list = annotation.Cast<TListExprType>();
-        auto itemType = BuildType(*list->GetItemType(), pgmBuilder, err, withTagged);
+        auto itemType = BuildType(*list->GetItemType(), pgmBuilder, err);
         if (!itemType) {
             return nullptr;
         }
@@ -62,7 +62,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Optional: {
         auto optional = annotation.Cast<TOptionalExprType>();
-        auto itemType = BuildType(*optional->GetItemType(), pgmBuilder, err, withTagged);
+        auto itemType = BuildType(*optional->GetItemType(), pgmBuilder, err);
         if (!itemType) {
             return nullptr;
         }
@@ -74,7 +74,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
         TVector<NKikimr::NMiniKQL::TType*> elements;
         elements.reserve(tuple->GetItems().size());
         for (auto& child : tuple->GetItems()) {
-            elements.push_back(BuildType(*child, pgmBuilder, err, withTagged));
+            elements.push_back(BuildType(*child, pgmBuilder, err));
             if (!elements.back()) {
                 return nullptr;
             }
@@ -87,7 +87,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
         TVector<NKikimr::NMiniKQL::TType*> elements;
         elements.reserve(multi->GetItems().size());
         for (auto& child : multi->GetItems()) {
-            elements.push_back(BuildType(*child, pgmBuilder, err, withTagged));
+            elements.push_back(BuildType(*child, pgmBuilder, err));
             if (!elements.back()) {
                 return nullptr;
             }
@@ -97,8 +97,8 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Dict: {
         auto dictType = annotation.Cast<TDictExprType>();
-        auto keyType = BuildType(*dictType->GetKeyType(), pgmBuilder, err, withTagged);
-        auto payloadType = BuildType(*dictType->GetPayloadType(), pgmBuilder, err, withTagged);
+        auto keyType = BuildType(*dictType->GetKeyType(), pgmBuilder, err);
+        auto payloadType = BuildType(*dictType->GetPayloadType(), pgmBuilder, err);
         if (!keyType || !payloadType) {
             return nullptr;
         }
@@ -107,7 +107,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Type: {
         auto type = annotation.Cast<TTypeExprType>()->GetType();
-        return BuildType(*type, pgmBuilder, err, withTagged);
+        return BuildType(*type, pgmBuilder, err);
     }
 
     case ETypeAnnotationKind::Void: {
@@ -120,10 +120,10 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Callable: {
         auto callable = annotation.Cast<TCallableExprType>();
-        auto returnType = BuildType(*callable->GetReturnType(), pgmBuilder, err, withTagged);
+        auto returnType = BuildType(*callable->GetReturnType(), pgmBuilder, err);
         NKikimr::NMiniKQL::TCallableTypeBuilder callableTypeBuilder(pgmBuilder.GetTypeEnvironment(), "", returnType);
         for (auto& child : callable->GetArguments()) {
-            callableTypeBuilder.Add(BuildType(*child.Type, pgmBuilder, err, withTagged));
+            callableTypeBuilder.Add(BuildType(*child.Type, pgmBuilder, err));
             if (!child.Name.empty()) {
                 callableTypeBuilder.SetArgumentName(child.Name);
             }
@@ -150,17 +150,13 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Tagged: {
         auto tagged = annotation.Cast<TTaggedExprType>();
-        auto base = BuildType(*tagged->GetBaseType(), pgmBuilder, err, withTagged);
-        if (!withTagged) {
-            return base;
-        }
-
+        auto base = BuildType(*tagged->GetBaseType(), pgmBuilder, err);
         return pgmBuilder.NewTaggedType(base, tagged->GetTag());
     }
 
     case ETypeAnnotationKind::Variant: {
         auto var = annotation.Cast<TVariantExprType>();
-        auto underlyingType = BuildType(*var->GetUnderlyingType(), pgmBuilder, err, withTagged);
+        auto underlyingType = BuildType(*var->GetUnderlyingType(), pgmBuilder, err);
         if (!underlyingType) {
             return nullptr;
         }
@@ -169,7 +165,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Stream: {
         auto stream = annotation.Cast<TStreamExprType>();
-        auto itemType = BuildType(*stream->GetItemType(), pgmBuilder, err, withTagged);
+        auto itemType = BuildType(*stream->GetItemType(), pgmBuilder, err);
         if (!itemType) {
             return nullptr;
         }
@@ -178,7 +174,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Flow: {
         auto flow = annotation.Cast<TFlowExprType>();
-        auto itemType = BuildType(*flow->GetItemType(), pgmBuilder, err, withTagged);
+        auto itemType = BuildType(*flow->GetItemType(), pgmBuilder, err);
         if (!itemType) {
             return nullptr;
         }
@@ -205,7 +201,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Block: {
         auto block = annotation.Cast<TBlockExprType>();
-        auto itemType = BuildType(*block->GetItemType(), pgmBuilder, err, withTagged);
+        auto itemType = BuildType(*block->GetItemType(), pgmBuilder, err);
         if (!itemType) {
             return nullptr;
         }
@@ -214,7 +210,7 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
 
     case ETypeAnnotationKind::Scalar: {
         auto scalar = annotation.Cast<TScalarExprType>();
-        auto itemType = BuildType(*scalar->GetItemType(), pgmBuilder, err, withTagged);
+        auto itemType = BuildType(*scalar->GetItemType(), pgmBuilder, err);
         if (!itemType) {
             return nullptr;
         }
@@ -229,17 +225,17 @@ NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKiki
     }
 }
 
-NKikimr::NMiniKQL::TType* BuildType(TPositionHandle pos, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, bool withTagged) {
+NKikimr::NMiniKQL::TType* BuildType(TPositionHandle pos, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder) {
     TStringStream err;
-    auto type = BuildType(annotation, pgmBuilder, err, withTagged);
+    auto type = BuildType(annotation, pgmBuilder, err);
     if (!type) {
         ythrow TNodeException(pos) << err.Str();
     }
     return type;
 }
 
-NKikimr::NMiniKQL::TType* BuildType(const TExprNode& owner, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, bool withTagged) {
-    return BuildType(owner.Pos(), annotation, pgmBuilder, withTagged);
+NKikimr::NMiniKQL::TType* BuildType(const TExprNode& owner, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder) {
+    return BuildType(owner.Pos(), annotation, pgmBuilder);
 }
 
 const TTypeAnnotationNode* ConvertMiniKQLType(TPosition position, NKikimr::NMiniKQL::TType* type, TExprContext& ctx) {
diff --git a/ydb/library/yql/providers/common/mkql/yql_type_mkql.h b/ydb/library/yql/providers/common/mkql/yql_type_mkql.h
index 8f564c12abd..da500893f2e 100644
--- a/ydb/library/yql/providers/common/mkql/yql_type_mkql.h
+++ b/ydb/library/yql/providers/common/mkql/yql_type_mkql.h
@@ -16,9 +16,9 @@ class TProgramBuilder;
 namespace NYql {
 namespace NCommon {
 
-NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, IOutputStream& err, bool withTagged = false);
-NKikimr::NMiniKQL::TType* BuildType(TPositionHandle pos, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, bool withTagged = false);
-NKikimr::NMiniKQL::TType* BuildType(const TExprNode& owner, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, bool withTagged = false);
+NKikimr::NMiniKQL::TType* BuildType(const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder, IOutputStream& err);
+NKikimr::NMiniKQL::TType* BuildType(TPositionHandle pos, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder);
+NKikimr::NMiniKQL::TType* BuildType(const TExprNode& owner, const TTypeAnnotationNode& annotation, NKikimr::NMiniKQL::TProgramBuilder& pgmBuilder);
 
 const TTypeAnnotationNode* ConvertMiniKQLType(TPosition position, NKikimr::NMiniKQL::TType* type, TExprContext& ctx);
 
diff --git a/ydb/library/yql/providers/common/udf_resolve/yql_simple_udf_resolver.cpp b/ydb/library/yql/providers/common/udf_resolve/yql_simple_udf_resolver.cpp
index 01f235d5a72..ce190e0f41b 100644
--- a/ydb/library/yql/providers/common/udf_resolve/yql_simple_udf_resolver.cpp
+++ b/ydb/library/yql/providers/common/udf_resolve/yql_simple_udf_resolver.cpp
@@ -160,7 +160,7 @@ bool LoadFunctionsMetadata(const TVector<IUdfResolver::TFunction*>& functions,
             TType* mkqlUserType = nullptr;
             if (udf.UserType) {
                 TStringStream err;
-                mkqlUserType = BuildType(*udf.UserType, pgmBuilder, err, true);
+                mkqlUserType = BuildType(*udf.UserType, pgmBuilder, err);
                 if (!mkqlUserType) {
                     ctx.AddError(TIssue(udf.Pos, TStringBuilder() << "Invalid user type for function: "
                         << udf.Name << ", error: " << err.Str()));
diff --git a/ydb/library/yql/providers/dq/planner/execution_planner.cpp b/ydb/library/yql/providers/dq/planner/execution_planner.cpp
index f7c1ff06d18..19bb723c476 100644
--- a/ydb/library/yql/providers/dq/planner/execution_planner.cpp
+++ b/ydb/library/yql/providers/dq/planner/execution_planner.cpp
@@ -478,8 +478,7 @@ namespace NYql::NDqs {
 
             TProgramBuilder pgmBuilder(typeEnv, *FunctionRegistry);
             TStringStream errorStream;
-            const bool withTagged = true;
-            auto type = NCommon::BuildType(*exprType, pgmBuilder, errorStream, withTagged);
+            auto type = NCommon::BuildType(*exprType, pgmBuilder, errorStream);
             return SerializeNode(type, typeEnv);
         }
         return {};
@@ -811,8 +810,7 @@ THashMap<TStageId, std::tuple<TString,ui64,ui64>> TDqsExecutionPlanner::BuildAll
 
             TProgramBuilder pgmBuilder(typeEnv, *FunctionRegistry);
             TStringStream errorStream;
-            const bool withTagged = true;
-            auto type = NCommon::BuildType(*exprType, pgmBuilder, errorStream, withTagged);
+            auto type = NCommon::BuildType(*exprType, pgmBuilder, errorStream);
             return SerializeNode(type, typeEnv);
         } else {
             return GetSerializedResultType(Program);