Batch-mode subtree elapsed sums when computing parent self-time (#215 D1)

src/PlanViewer.App/PlanViewer.App.csproj

@@ -6,7 +6,7 @@
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <ApplicationIcon>EDD.ico</ApplicationIcon>
     <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-    <Version>1.7.7</Version>
+    <Version>1.7.8</Version>
     <Authors>Erik Darling</Authors>
     <Company>Darling Data LLC</Company>
     <Product>Performance Studio</Product>

src/PlanViewer.Core/Services/PlanAnalyzer.cs

@@ -403,7 +403,7 @@
 
             if (unsnifffedParams.Count > 0)
             {
                 var hasRecompile = stmt.StatementText.Contains("RECOMPILE", StringComparison.OrdinalIgnoreCase);
                 if (!hasRecompile)
                 {
                     var names = string.Join(", ", unsnifffedParams.Select(p => p.Name));
@@ -1269,7 +1269,7 @@
         // Rule 28: Row Count Spool — NOT IN with nullable column
         // Pattern: Row Count Spool with high rewinds, child scan has IS NULL predicate,
         // and statement text contains NOT IN
         if (!cfg.IsRuleDisabled(28) && node.PhysicalOp.Contains("Row Count Spool"))
         {
             var rewinds = node.HasActualStats ? (double)node.ActualRewinds : node.EstimateRewinds;
             if (rewinds > 10000 && HasNotInPattern(node, stmt))
@@ -1731,6 +1731,14 @@
         if (child.PhysicalOp == "Parallelism" && child.Children.Count > 0)
             return child.Children.Max(GetEffectiveChildElapsedMs);
 
+        // Batch mode pipelines — each operator's elapsed stands alone rather than
+        // rolling up its descendants the way row-mode does. For a parent computing
+        // self-time above a batch-mode subtree, subtract the whole pipeline's time
+        // (Joe #215 D1: Parallelism gather-streams above three batch operators).
+        var mode = child.ActualExecutionMode ?? child.ExecutionMode;
+        if (mode == "Batch" && child.HasActualStats)
+            return SumBatchSubtreeElapsedMs(child);
+
         // Child has its own stats: use them
         if (child.ActualElapsedMs > 0)
             return child.ActualElapsedMs;
@@ -1745,6 +1753,30 @@
         return sum;
     }
 
+    /// <summary>
+    /// Sums ActualElapsedMs across a contiguous batch-mode subtree (stops at
+    /// Parallelism exchange zone boundaries). Batch operators pipeline — elapsed
+    /// times are standalone, not cumulative — so summing gives the total work the
+    /// zone did, which is what a row-mode parent above the zone should subtract
+    /// to get its own self-time.
+    /// </summary>
+    private static long SumBatchSubtreeElapsedMs(PlanNode node)
+    {
+        long sum = node.ActualElapsedMs;
+        foreach (var child in node.Children)
+        {
+            // Zone boundary — stop summing
+            if (child.PhysicalOp == "Parallelism") continue;
+
+            var childMode = child.ActualExecutionMode ?? child.ExecutionMode;
+            if (childMode == "Batch" && child.HasActualStats)
+                sum += SumBatchSubtreeElapsedMs(child);
+            else
+                sum += GetEffectiveChildElapsedMs(child);
+        }
+        return sum;
+    }
+
     /// <summary>
     /// Calculates a Parallelism (exchange) operator's own elapsed time.
     /// Exchange times are unreliable — they accumulate wait time caused by