From da6a2453ae25993dcb5355065d8cafeb2e289f83 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Sun, 3 May 2026 10:37:46 +0200
Subject: [PATCH 1/8] switch the default grid GroupBy from "None" to "Query
 Hash" and don't open the first line by default

---
 .../Controls/QueryStoreGridControl.axaml               |  4 ++--
 .../Controls/QueryStoreGridControl.axaml.cs            | 10 +++-------
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
index 3a9f670..6161d5b 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml
@@ -70,7 +70,7 @@
                 <StackPanel Spacing="4">
                     <TextBlock Text="Group by" Foreground="{DynamicResource ForegroundBrush}" FontSize="11"/>
                     <ComboBox x:Name="GroupByBox" Width="130" Height="36" FontSize="13"
-                              SelectedIndex="0" SelectionChanged="GroupBy_SelectionChanged">
+                              SelectedIndex="1" SelectionChanged="GroupBy_SelectionChanged">
                         <ComboBoxItem Content="None" Tag="none"/>
                         <ComboBoxItem Content="Query Hash" Tag="query-hash"/>
                         <ComboBoxItem Content="Module" Tag="module"/>
@@ -150,7 +150,7 @@
                 </ContextMenu>
             </DataGrid.ContextMenu>
             <DataGrid.Columns>
-                <DataGridTemplateColumn Header="" Width="220" IsVisible="False">
+                <DataGridTemplateColumn Header="" Width="220" IsVisible="True">
                     <DataGridTemplateColumn.CellTemplate>
                         <DataTemplate x:DataType="local:QueryStoreRow">
                             <StackPanel Orientation="Horizontal" Margin="{Binding IndentMargin}"
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index c7261a9..9911142 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -44,7 +44,7 @@ public partial class QueryStoreGridControl : UserControl
     private bool _waitStatsSupported;  // false until version + capture mode confirmed
     private bool _waitStatsEnabled = true;
     private bool _waitPercentMode;
-    private QueryStoreGroupBy _groupByMode = QueryStoreGroupBy.None;
+    private QueryStoreGroupBy _groupByMode = QueryStoreGroupBy.QueryHash;
     private List<QueryStoreRow> _groupedRootRows = new(); // top-level rows for grouped mode
 
     public event EventHandler<List<QueryStorePlan>>? PlansSelected;
@@ -89,6 +89,7 @@ public QueryStoreGridControl(ServerConnection serverConnection, ICredentialServi
         // Auto-fetch with default settings on connect
         Avalonia.Threading.Dispatcher.UIThread.Post(() =>
         {
+            ReorderColumnsForGroupBy();
             Fetch_Click(null, new RoutedEventArgs());
             _initialOrderByLoaded = true;
         }, Avalonia.Threading.DispatcherPriority.Loaded);
@@ -311,12 +312,7 @@ private async System.Threading.Tasks.Task FetchGroupedPlansAsync(
         LoadButton.IsEnabled = true;
         SelectToggleButton.Content = "Select All";
 
-        // Auto-expand the first root row to the deepest level
-        if (rootRows.Count > 0)
-        {
-            var first = rootRows[0];
-            ExpandRowRecursive(first);
-        }
+
 
         UpdateStatusText();
         UpdateBarRatios();

From 454be5df9c1409cd96bee69e76ab588f80622240 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 5 May 2026 01:31:20 +0200
Subject: [PATCH 2/8] =?UTF-8?q?The=20Query=20Stores=20Overview=20feature?=
 =?UTF-8?q?=20has=20been=20implemented.=20Here's=20a=20summary=20of=20what?=
 =?UTF-8?q?=20was=20created:=20New=20Files:=201.=20QueryStoreOverviewModel?=
 =?UTF-8?q?s.cs=20=E2=80=94=20Models=20for:=20=E2=80=A2=20QueryStoreState?=
 =?UTF-8?q?=20enum=20(Off,=20ReadOnly,=20ReadWrite)=20=E2=80=A2=20Database?=
 =?UTF-8?q?QueryStoreState=20=E2=80=94=20state=20per=20database=20?=
 =?UTF-8?q?=E2=80=A2=20DatabaseMetrics=20=E2=80=94=20aggregated=20metrics?=
 =?UTF-8?q?=20(total=20+=20avg)=20per=20database=20=E2=80=A2=20DatabaseTim?=
 =?UTF-8?q?eSlice=20=E2=80=94=20time=20slice=20data=20tagged=20by=20databa?=
 =?UTF-8?q?se=20=E2=80=A2=20DatabaseWaitCategoryTimeSlice=20=E2=80=94=20wa?=
 =?UTF-8?q?it=20stats=20tagged=20by=20database=202.=20QueryStoreOverviewSe?=
 =?UTF-8?q?rvice.cs=20=E2=80=94=20Parallel=20data=20fetching=20with:=20?=
 =?UTF-8?q?=E2=80=A2=20SemaphoreSlim=20throttling=20(default=20DOP=3D8)=20?=
 =?UTF-8?q?=E2=80=A2=20ConcurrentBag<T>=20for=20thread-safe=20result=20col?=
 =?UTF-8?q?lection=20=E2=80=A2=20Methods:=20FetchAllStatesAsync(string,=20?=
 =?UTF-8?q?int,=20CancellationToken),=20FetchAllMetricsAsync(string,=20Lis?=
 =?UTF-8?q?t<string>,=20DateTime,=20DateTime,=20int,=20CancellationToken),?=
 =?UTF-8?q?=20FetchAllTimeSlicesAsync(string,=20List<string>,=20int,=20int?=
 =?UTF-8?q?,=20CancellationToken),=20FetchAllWaitStatsAsync(string,=20List?=
 =?UTF-8?q?<string>,=20DateTime,=20DateTime,=20int,=20CancellationToken)?=
 =?UTF-8?q?=203.=20QueryStoreOverviewControl.axaml=20=E2=80=94=20Layout=20?=
 =?UTF-8?q?with=203=20rows:=20=E2=80=A2=20Row=201:=20Donut=20chart=20+=20c?=
 =?UTF-8?q?onsolidated=20time=20slicer=20+=20consolidated=20wait=20stats?=
 =?UTF-8?q?=20ribbon=20=E2=80=A2=20Row=202:=207=20bar=20chart=20cards=20(T?=
 =?UTF-8?q?otal=20metrics)=20=E2=80=A2=20Row=203:=207=20bar=20chart=20card?=
 =?UTF-8?q?s=20(Avg=20metrics)=204.=20QueryStoreOverviewControl.axaml.cs?=
 =?UTF-8?q?=20=E2=80=94=20Code-behind=20with:=20=E2=80=A2=20Donut=20chart?=
 =?UTF-8?q?=20(RW=3Dlight=20blue,=20RO=3Ddark=20blue,=20OFF=3Dgrey,=20cent?=
 =?UTF-8?q?er=20shows=20active/total)=20=E2=80=A2=20Consolidated=20time=20?=
 =?UTF-8?q?slicer=20(30-day,=2024h=20default=20selection)=20=E2=80=A2=20Co?=
 =?UTF-8?q?nsolidated=20wait=20stats=20ribbon=20(sum=20across=20databases)?=
 =?UTF-8?q?=20=E2=80=A2=20Top-N=20bar=20cards=20with=20consistent=20databa?=
 =?UTF-8?q?se=20colors,=20adaptive=20font=20color,=20tooltips,=20and=20rig?=
 =?UTF-8?q?ht-click=20"Drill=20Down=20to=20DB=20Query=20Store"=20context?=
 =?UTF-8?q?=20menu=20Modified=20Files:=205.=20QuerySessionControl.axaml=20?=
 =?UTF-8?q?=E2=80=94=20Added=20"QS=20Overview"=20button=206.=20QuerySessio?=
 =?UTF-8?q?nControl.axaml.cs=20=E2=80=94=20Added=20QueryStoreOverview=5FCl?=
 =?UTF-8?q?ick(object=3F,=20RoutedEventArgs)=20handler=20that=20opens=20th?=
 =?UTF-8?q?e=20overview=20tab=20and=20wires=20drill-down=20to=20open=20sin?=
 =?UTF-8?q?gle-DB=20Query=20Store=20tabs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Controls/QuerySessionControl.axaml        |   5 +
 .../Controls/QuerySessionControl.axaml.cs     |  70 +++
 .../Controls/QueryStoreOverviewControl.axaml  |  44 ++
 .../QueryStoreOverviewControl.axaml.cs        | 555 ++++++++++++++++++
 .../Models/QueryStoreOverviewModels.cs        |  73 +++
 .../Services/QueryStoreOverviewService.cs     | 336 +++++++++++
 6 files changed, 1083 insertions(+)
 create mode 100644 src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
 create mode 100644 src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
 create mode 100644 src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
 create mode 100644 src/PlanViewer.Core/Services/QueryStoreOverviewService.cs

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
index 99ca2c0..a6830a2 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml
@@ -57,6 +57,11 @@
                             Height="28" Padding="8,0" FontSize="12"
                             Theme="{StaticResource AppButton}"
                             ToolTip.Tip="Analyze top queries from Query Store"/>
+                    <Button x:Name="QueryStoreOverviewButton" Content="&#x1F4CA; QS Overview"
+                            Click="QueryStoreOverview_Click"
+                            Height="28" Padding="8,0" FontSize="12"
+                            Theme="{StaticResource AppButton}"
+                            ToolTip.Tip="Query Stores Overview across all databases"/>
                     <TextBlock Text="|" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="2,0"/>
                     <Button x:Name="CopyReproButton" Content="&#x1F4CB; Copy Repro"
diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index 38623ea..a8aa889 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -1389,6 +1389,76 @@ private bool HasQueryStoreTab()
 
     public void TriggerQueryStore() => QueryStore_Click(null, new RoutedEventArgs());
 
+    private async void QueryStoreOverview_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_serverConnection == null || _connectionString == null)
+        {
+            await ShowConnectionDialogAsync();
+            if (_serverConnection == null || _connectionString == null)
+                return;
+        }
+
+        SetStatus("Loading Query Store Overview...");
+
+        var overview = new QueryStoreOverviewControl(_serverConnection, _credentialService);
+        overview.DrillDownRequested += (_, db) =>
+        {
+            // Open a single-database Query Store tab
+            _selectedDatabase = db;
+            _connectionString = _serverConnection!.GetConnectionString(_credentialService, db);
+            QueryStore_Click(null, new RoutedEventArgs());
+        };
+
+        var headerText = new TextBlock
+        {
+            Text = "QS Overview",
+            VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
+            FontSize = 12
+        };
+
+        var closeBtn = new Button
+        {
+            Content = "\u2715",
+            MinWidth = 22, MinHeight = 22, Width = 22, Height = 22,
+            Padding = new Avalonia.Thickness(0),
+            FontSize = 11,
+            Margin = new Avalonia.Thickness(6, 0, 0, 0),
+            Background = Brushes.Transparent,
+            BorderThickness = new Avalonia.Thickness(0),
+            Foreground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
+            HorizontalContentAlignment = HorizontalAlignment.Center,
+            VerticalContentAlignment = VerticalAlignment.Center
+        };
+
+        var header = new StackPanel
+        {
+            Orientation = Avalonia.Layout.Orientation.Horizontal,
+            Children = { headerText, closeBtn }
+        };
+
+        var tab = new TabItem { Header = header, Content = overview };
+        closeBtn.Tag = tab;
+        closeBtn.Click += (s, _) =>
+        {
+            if (s is Button btn && btn.Tag is TabItem t)
+                SubTabControl.Items.Remove(t);
+        };
+
+        SubTabControl.Items.Add(tab);
+        SubTabControl.SelectedItem = tab;
+
+        try
+        {
+            await overview.LoadAsync();
+            SetStatus("");
+        }
+        catch (Exception ex)
+        {
+            SetStatus(ex.Message.Length > 80 ? ex.Message[..80] + "..." : ex.Message, autoClear: false);
+        }
+    }
+
     private async void QueryStore_Click(object? sender, RoutedEventArgs e)
     {
         // If a QS tab already exists, always show connection dialog for a fresh tab
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
new file mode 100644
index 0000000..98aeb25
--- /dev/null
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -0,0 +1,44 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="PlanViewer.App.Controls.QueryStoreOverviewControl">
+    <Grid x:Name="RootGrid" Background="{DynamicResource BackgroundBrush}">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+
+        <!-- Row 0: Donut + TimeSlicer + WaitStats -->
+        <Grid Grid.Row="0" Margin="10">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="2*"/>
+                <ColumnDefinition Width="2*"/>
+            </Grid.ColumnDefinitions>
+
+            <!-- Donut chart area -->
+            <Border Grid.Column="0" Background="{DynamicResource BackgroundLightBrush}"
+                    CornerRadius="4" Margin="0,0,5,0" ClipToBounds="True">
+                <Canvas x:Name="DonutCanvas"/>
+            </Border>
+
+            <!-- Time slicer (consolidated) -->
+            <Border Grid.Column="1" Background="{DynamicResource BackgroundLightBrush}"
+                    CornerRadius="4" Margin="5,0,5,0" ClipToBounds="True">
+                <Canvas x:Name="SlicerCanvas"/>
+            </Border>
+
+            <!-- Wait stats ribbon (consolidated) -->
+            <Border Grid.Column="2" Background="{DynamicResource BackgroundLightBrush}"
+                    CornerRadius="4" Margin="5,0,0,0" ClipToBounds="True">
+                <Canvas x:Name="WaitStatsCanvas"/>
+            </Border>
+        </Grid>
+
+        <!-- Row 1: Total metrics bar cards -->
+        <Grid x:Name="TotalMetricsGrid" Grid.Row="1" Margin="10"/>
+
+        <!-- Row 2: Avg metrics bar cards -->
+        <Grid x:Name="AvgMetricsGrid" Grid.Row="2" Margin="10"/>
+    </Grid>
+</UserControl>
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
new file mode 100644
index 0000000..1d38e67
--- /dev/null
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -0,0 +1,555 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using Avalonia.Threading;
+using PlanViewer.Core.Interfaces;
+using PlanViewer.Core.Models;
+using PlanViewer.Core.Services;
+
+namespace PlanViewer.App.Controls;
+
+public partial class QueryStoreOverviewControl : UserControl
+{
+    private readonly ServerConnection _serverConnection;
+    private readonly ICredentialService _credentialService;
+    private readonly string _masterConnectionString;
+    private readonly int _maxDop;
+    private readonly int _topN;
+    private CancellationTokenSource? _cts;
+
+    private List<DatabaseQueryStoreState> _states = new();
+    private List<DatabaseMetrics> _metrics = new();
+    private List<DatabaseTimeSlice> _timeSlices = new();
+    private List<DatabaseWaitCategoryTimeSlice> _waitSlices = new();
+
+    private DateTime _slicerStartUtc;
+    private DateTime _slicerEndUtc;
+    private int _daysBack = 30;
+
+    // Color palette for databases (minimizes color dispersion)
+    private static readonly Color[] Palette = new[]
+    {
+        Color.Parse("#2EAEF1"), // blue
+        Color.Parse("#F2994A"), // orange
+        Color.Parse("#27AE60"), // green
+        Color.Parse("#9B51E0"), // purple
+        Color.Parse("#EB5757"), // red
+        Color.Parse("#F2C94C"), // yellow
+        Color.Parse("#56CCF2"), // light blue
+        Color.Parse("#BB6BD9"), // violet
+    };
+
+    private static readonly Color OthersColor = Color.Parse("#555555");
+
+    // Donut colors
+    private static readonly Color ReadWriteColor = Color.Parse("#2EAEF1");  // light blue
+    private static readonly Color ReadOnlyColor = Color.Parse("#1A5276");   // dark blue
+    private static readonly Color OffColor = Color.Parse("#666666");        // grey
+
+    public event EventHandler<string>? DrillDownRequested;
+
+    public QueryStoreOverviewControl(ServerConnection serverConnection,
+        ICredentialService credentialService, int maxDop = 8, int topN = 2)
+    {
+        _serverConnection = serverConnection;
+        _credentialService = credentialService;
+        _masterConnectionString = serverConnection.GetConnectionString(credentialService, "master");
+        _maxDop = maxDop;
+        _topN = topN;
+        _slicerEndUtc = DateTime.UtcNow;
+        _slicerStartUtc = _slicerEndUtc.AddHours(-24);
+
+        InitializeComponent();
+
+        this.SizeChanged += (_, _) =>
+        {
+            DrawDonut();
+            DrawSlicer();
+            DrawWaitStats();
+        };
+    }
+
+    public async Task LoadAsync()
+    {
+        _cts?.Cancel();
+        _cts = new CancellationTokenSource();
+        var ct = _cts.Token;
+
+        // Phase 1: Get states
+        _states = await QueryStoreOverviewService.FetchAllStatesAsync(
+            _masterConnectionString, _maxDop, ct);
+
+        await Dispatcher.UIThread.InvokeAsync(DrawDonut);
+
+        // Phase 2: Get time slices for active databases
+        var activeDbs = _states
+            .Where(s => s.State != QueryStoreState.Off)
+            .Select(s => s.DatabaseName).ToList();
+
+        if (activeDbs.Count == 0) return;
+
+        _timeSlices = await QueryStoreOverviewService.FetchAllTimeSlicesAsync(
+            _masterConnectionString, activeDbs, _daysBack, _maxDop, ct);
+
+        await Dispatcher.UIThread.InvokeAsync(DrawSlicer);
+
+        // Phase 3: Metrics and wait stats for selected time range
+        await RefreshMetricsAndWaitStatsAsync(ct);
+    }
+
+    private async Task RefreshMetricsAndWaitStatsAsync(CancellationToken ct)
+    {
+        var activeDbs = _states
+            .Where(s => s.State != QueryStoreState.Off)
+            .Select(s => s.DatabaseName).ToList();
+
+        if (activeDbs.Count == 0) return;
+
+        _metrics = await QueryStoreOverviewService.FetchAllMetricsAsync(
+            _masterConnectionString, activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
+
+        _waitSlices = await QueryStoreOverviewService.FetchAllWaitStatsAsync(
+            _masterConnectionString, activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
+
+        await Dispatcher.UIThread.InvokeAsync(() =>
+        {
+            DrawWaitStats();
+            DrawBarCards();
+        });
+    }
+
+    // ── Donut Chart ──────────────────────────────────────────────────────────
+
+    private void DrawDonut()
+    {
+        DonutCanvas.Children.Clear();
+        if (_states.Count == 0) return;
+
+        var w = DonutCanvas.Bounds.Width;
+        var h = DonutCanvas.Bounds.Height;
+        if (w < 10 || h < 10) return;
+
+        var cx = w / 2;
+        var cy = h / 2;
+        var radius = Math.Min(w, h) / 2 - 10;
+        var innerRadius = radius * 0.6;
+
+        int rwCount = _states.Count(s => s.State == QueryStoreState.ReadWrite);
+        int roCount = _states.Count(s => s.State == QueryStoreState.ReadOnly);
+        int offCount = _states.Count(s => s.State == QueryStoreState.Off);
+        int total = _states.Count;
+        int activeCount = rwCount + roCount;
+
+        var segments = new List<(double fraction, Color color)>();
+        if (rwCount > 0) segments.Add(((double)rwCount / total, ReadWriteColor));
+        if (roCount > 0) segments.Add(((double)roCount / total, ReadOnlyColor));
+        if (offCount > 0) segments.Add(((double)offCount / total, OffColor));
+
+        double startAngle = -Math.PI / 2;
+        foreach (var (fraction, color) in segments)
+        {
+            var sweepAngle = fraction * 2 * Math.PI;
+            var path = CreateArcPath(cx, cy, radius, innerRadius, startAngle, startAngle + sweepAngle, color);
+            DonutCanvas.Children.Add(path);
+            startAngle += sweepAngle;
+        }
+
+        // Center text
+        var centerText = new TextBlock
+        {
+            Text = $"{activeCount}/{total}",
+            FontSize = 16,
+            FontWeight = FontWeight.Bold,
+            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center,
+            VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
+        };
+        centerText.Measure(Size.Infinity);
+        Canvas.SetLeft(centerText, cx - centerText.DesiredSize.Width / 2);
+        Canvas.SetTop(centerText, cy - centerText.DesiredSize.Height / 2);
+        DonutCanvas.Children.Add(centerText);
+
+        // Legend below
+        var legendY = cy + radius + 5;
+        DrawLegendItem(DonutCanvas, 4, legendY, ReadWriteColor, $"RW: {rwCount}");
+        DrawLegendItem(DonutCanvas, 4, legendY + 16, ReadOnlyColor, $"RO: {roCount}");
+        DrawLegendItem(DonutCanvas, 4, legendY + 32, OffColor, $"OFF: {offCount}");
+    }
+
+    private void DrawLegendItem(Canvas canvas, double x, double y, Color color, string text)
+    {
+        if (y + 14 > canvas.Bounds.Height) return;
+        var rect = new Rectangle { Width = 10, Height = 10, Fill = new SolidColorBrush(color) };
+        Canvas.SetLeft(rect, x);
+        Canvas.SetTop(rect, y);
+        canvas.Children.Add(rect);
+
+        var tb = new TextBlock
+        {
+            Text = text,
+            FontSize = 11,
+            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
+        };
+        Canvas.SetLeft(tb, x + 14);
+        Canvas.SetTop(tb, y - 1);
+        canvas.Children.Add(tb);
+    }
+
+    private Path CreateArcPath(double cx, double cy, double outerR, double innerR,
+        double startAngle, double endAngle, Color fill)
+    {
+        var largeArc = (endAngle - startAngle) > Math.PI;
+        var outerStart = new Point(cx + outerR * Math.Cos(startAngle), cy + outerR * Math.Sin(startAngle));
+        var outerEnd = new Point(cx + outerR * Math.Cos(endAngle), cy + outerR * Math.Sin(endAngle));
+        var innerStart = new Point(cx + innerR * Math.Cos(endAngle), cy + innerR * Math.Sin(endAngle));
+        var innerEnd = new Point(cx + innerR * Math.Cos(startAngle), cy + innerR * Math.Sin(startAngle));
+
+        var fig = new PathFigure { StartPoint = outerStart, IsClosed = true };
+        fig.Segments!.Add(new ArcSegment
+        {
+            Point = outerEnd,
+            Size = new Size(outerR, outerR),
+            IsLargeArc = largeArc,
+            SweepDirection = SweepDirection.Clockwise
+        });
+        fig.Segments.Add(new LineSegment { Point = innerStart });
+        fig.Segments.Add(new ArcSegment
+        {
+            Point = innerEnd,
+            Size = new Size(innerR, innerR),
+            IsLargeArc = largeArc,
+            SweepDirection = SweepDirection.CounterClockwise
+        });
+
+        var geo = new PathGeometry();
+        geo.Figures!.Add(fig);
+        return new Path { Data = geo, Fill = new SolidColorBrush(fill) };
+    }
+
+    // ── Time Slicer (consolidated) ──────────────────────────────────────────
+
+    private void DrawSlicer()
+    {
+        SlicerCanvas.Children.Clear();
+        if (_timeSlices.Count == 0) return;
+
+        var w = SlicerCanvas.Bounds.Width;
+        var h = SlicerCanvas.Bounds.Height;
+        if (w < 10 || h < 10) return;
+
+        // Consolidate across databases by hour
+        var consolidated = _timeSlices
+            .GroupBy(s => s.IntervalStartUtc)
+            .Select(g => new { Hour = g.Key, Total = g.Sum(x => x.TotalCpu) })
+            .OrderBy(x => x.Hour)
+            .ToList();
+
+        if (consolidated.Count == 0) return;
+
+        var maxVal = consolidated.Max(c => c.Total);
+        if (maxVal <= 0) maxVal = 1;
+
+        var barW = w / consolidated.Count;
+        var chartBrush = new SolidColorBrush(Color.Parse("#332EAEF1"));
+        var lineBrush = new SolidColorBrush(Color.Parse("#2EAEF1"));
+
+        for (int i = 0; i < consolidated.Count; i++)
+        {
+            var barH = (consolidated[i].Total / maxVal) * (h - 20);
+            var rect = new Rectangle
+            {
+                Width = Math.Max(1, barW - 1),
+                Height = barH,
+                Fill = chartBrush,
+            };
+            Canvas.SetLeft(rect, i * barW);
+            Canvas.SetTop(rect, h - barH - 10);
+            SlicerCanvas.Children.Add(rect);
+        }
+
+        // Selection overlay for the current time range
+        if (consolidated.Count > 0)
+        {
+            var minTime = consolidated.First().Hour;
+            var maxTime = consolidated.Last().Hour;
+            var totalSpan = (maxTime - minTime).TotalHours;
+            if (totalSpan > 0)
+            {
+                var startNorm = Math.Max(0, (_slicerStartUtc - minTime).TotalHours / totalSpan);
+                var endNorm = Math.Min(1, (_slicerEndUtc - minTime).TotalHours / totalSpan);
+                var selRect = new Rectangle
+                {
+                    Width = (endNorm - startNorm) * w,
+                    Height = h,
+                    Fill = new SolidColorBrush(Color.Parse("#442EAEF1")),
+                };
+                Canvas.SetLeft(selRect, startNorm * w);
+                Canvas.SetTop(selRect, 0);
+                SlicerCanvas.Children.Add(selRect);
+            }
+        }
+
+        // Label
+        var label = new TextBlock
+        {
+            Text = "Consolidated CPU (all DBs)",
+            FontSize = 10,
+            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
+        };
+        Canvas.SetLeft(label, 4);
+        Canvas.SetTop(label, 2);
+        SlicerCanvas.Children.Add(label);
+    }
+
+    // ── Wait Stats (consolidated) ───────────────────────────────────────────
+
+    private void DrawWaitStats()
+    {
+        WaitStatsCanvas.Children.Clear();
+        if (_waitSlices.Count == 0) return;
+
+        var w = WaitStatsCanvas.Bounds.Width;
+        var h = WaitStatsCanvas.Bounds.Height;
+        if (w < 10 || h < 10) return;
+
+        // Consolidate: sum wait ratios across databases by hour+category
+        var consolidated = _waitSlices
+            .GroupBy(s => new { s.IntervalStartUtc, s.WaitCategoryDesc })
+            .Select(g => new WaitCategoryTimeSlice
+            {
+                IntervalStartUtc = g.Key.IntervalStartUtc,
+                WaitCategoryDesc = g.Key.WaitCategoryDesc,
+                WaitCategory = g.First().WaitCategory,
+                WaitRatio = g.Sum(x => x.WaitRatio)
+            })
+            .OrderBy(x => x.IntervalStartUtc)
+            .ToList();
+
+        // Use the existing ribbon painting logic (simplified)
+        var hours = consolidated.Select(x => x.IntervalStartUtc).Distinct().OrderBy(x => x).ToList();
+        var categories = consolidated.GroupBy(x => x.WaitCategoryDesc)
+            .OrderByDescending(g => g.Sum(x => x.WaitRatio))
+            .Select(g => g.Key).Take(5).ToList();
+
+        if (hours.Count == 0) return;
+
+        var maxPerHour = hours.Select(hr =>
+            consolidated.Where(c => c.IntervalStartUtc == hr).Sum(c => c.WaitRatio)).Max();
+        if (maxPerHour <= 0) maxPerHour = 1;
+
+        var barW = w / hours.Count;
+        var waitColors = new[] { "#EB5757", "#F2994A", "#F2C94C", "#27AE60", "#2EAEF1" };
+
+        for (int hi = 0; hi < hours.Count; hi++)
+        {
+            double yOffset = 0;
+            var hourData = consolidated.Where(c => c.IntervalStartUtc == hours[hi]).ToList();
+            for (int ci = 0; ci < categories.Count && ci < waitColors.Length; ci++)
+            {
+                var val = hourData.FirstOrDefault(c => c.WaitCategoryDesc == categories[ci])?.WaitRatio ?? 0;
+                var barH = (val / maxPerHour) * (h - 20);
+                var rect = new Rectangle
+                {
+                    Width = Math.Max(1, barW - 1),
+                    Height = barH,
+                    Fill = new SolidColorBrush(Color.Parse(waitColors[ci]))
+                };
+                Canvas.SetLeft(rect, hi * barW);
+                Canvas.SetTop(rect, h - 10 - yOffset - barH);
+                WaitStatsCanvas.Children.Add(rect);
+                yOffset += barH;
+            }
+        }
+
+        var label = new TextBlock
+        {
+            Text = "Wait Stats (all DBs)",
+            FontSize = 10,
+            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
+        };
+        Canvas.SetLeft(label, 4);
+        Canvas.SetTop(label, 2);
+        WaitStatsCanvas.Children.Add(label);
+    }
+
+    // ── Bar Chart Cards ─────────────────────────────────────────────────────
+
+    private void DrawBarCards()
+    {
+        DrawMetricRow(TotalMetricsGrid, isTotal: true);
+        DrawMetricRow(AvgMetricsGrid, isTotal: false);
+    }
+
+    private void DrawMetricRow(Grid grid, bool isTotal)
+    {
+        grid.Children.Clear();
+        grid.ColumnDefinitions.Clear();
+
+        var metricNames = isTotal
+            ? new[] { "Total CPU", "Total Duration", "Executions", "Total Reads", "Total Writes", "Total Physical Reads", "Total Memory" }
+            : new[] { "Avg CPU", "Avg Duration", "Executions", "Avg Reads", "Avg Writes", "Avg Physical Reads", "Avg Memory" };
+
+        for (int i = 0; i < metricNames.Length; i++)
+            grid.ColumnDefinitions.Add(new ColumnDefinition(1, GridUnitType.Star));
+
+        // Get top N databases + others
+        var ranked = GetRankedDatabases(isTotal);
+        var topDbs = ranked.Take(_topN).Select(r => r.db).ToList();
+        var dbColors = new Dictionary<string, Color>();
+        for (int i = 0; i < topDbs.Count && i < Palette.Length; i++)
+            dbColors[topDbs[i]] = Palette[i];
+
+        for (int mi = 0; mi < metricNames.Length; mi++)
+        {
+            var card = CreateBarCard(metricNames[mi], mi, isTotal, topDbs, dbColors);
+            Grid.SetColumn(card, mi);
+            card.Margin = new Thickness(mi == 0 ? 0 : 5, 0, mi == metricNames.Length - 1 ? 0 : 5, 0);
+            grid.Children.Add(card);
+        }
+    }
+
+    private List<(string db, double total)> GetRankedDatabases(bool isTotal)
+    {
+        if (_metrics.Count == 0) return new();
+        // Rank by total CPU
+        return _metrics
+            .Select(m => (m.DatabaseName, isTotal ? m.TotalCpu : m.AvgCpu))
+            .OrderByDescending(x => x.Item2)
+            .ToList();
+    }
+
+    private Border CreateBarCard(string title, int metricIndex, bool isTotal,
+        List<string> topDbs, Dictionary<string, Color> dbColors)
+    {
+        var border = new Border
+        {
+            Background = this.FindResource("BackgroundLightBrush") as IBrush ?? new SolidColorBrush(Color.Parse("#22252D")),
+            CornerRadius = new CornerRadius(4),
+            Padding = new Thickness(6),
+            ClipToBounds = true
+        };
+
+        var stack = new StackPanel { Spacing = 4 };
+
+        // Title
+        stack.Children.Add(new TextBlock
+        {
+            Text = title,
+            FontSize = 11,
+            FontWeight = FontWeight.SemiBold,
+            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center
+        });
+
+        // Build bar data
+        var bars = new List<(string db, double value, Color color)>();
+        double othersValue = 0;
+
+        foreach (var m in _metrics)
+        {
+            var val = GetMetricValue(m, metricIndex, isTotal);
+            if (topDbs.Contains(m.DatabaseName))
+                bars.Add((m.DatabaseName, val, dbColors.GetValueOrDefault(m.DatabaseName, OthersColor)));
+            else
+                othersValue += val;
+        }
+
+        if (othersValue > 0)
+            bars.Add(("Others", othersValue, OthersColor));
+
+        var maxVal = bars.Count > 0 ? bars.Max(b => b.value) : 1;
+        if (maxVal <= 0) maxVal = 1;
+
+        foreach (var (db, value, color) in bars.OrderByDescending(b => b.value))
+        {
+            var barContainer = new Border
+            {
+                Height = 22,
+                CornerRadius = new CornerRadius(3),
+                Background = new SolidColorBrush(color),
+                ClipToBounds = true,
+                HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Stretch,
+                Width = double.NaN,
+                Margin = new Thickness(0, 1)
+            };
+
+            // Determine font color based on luminance
+            var luminance = 0.299 * color.R + 0.587 * color.G + 0.114 * color.B;
+            var fontColor = luminance > 128 ? Colors.Black : Colors.White;
+
+            var barText = new TextBlock
+            {
+                Text = db.Length > 15 ? db[..12] + "..." : db,
+                FontSize = 10,
+                Foreground = new SolidColorBrush(fontColor),
+                VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
+                Margin = new Thickness(4, 0),
+                TextTrimming = TextTrimming.CharacterEllipsis
+            };
+
+            barContainer.Child = barText;
+            ToolTip.SetTip(barContainer, $"{db}: {value:N0}");
+
+            // Context menu for drill-down
+            if (db != "Others")
+            {
+                var menu = new ContextMenu();
+                var menuItem = new MenuItem { Header = "Drill Down to DB Query Store" };
+                var dbName = db;
+                menuItem.Click += (_, _) => DrillDownRequested?.Invoke(this, dbName);
+                menu.Items.Add(menuItem);
+                barContainer.ContextMenu = menu;
+            }
+
+            // Scale width by ratio via a wrapping grid
+            var barGrid = new Grid();
+            barGrid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(value / maxVal, GridUnitType.Star)));
+            barGrid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(1 - value / maxVal, GridUnitType.Star)));
+            Grid.SetColumn(barContainer, 0);
+            barGrid.Children.Add(barContainer);
+
+            stack.Children.Add(barGrid);
+        }
+
+        border.Child = stack;
+        return border;
+    }
+
+    private static double GetMetricValue(DatabaseMetrics m, int metricIndex, bool isTotal)
+    {
+        if (isTotal)
+        {
+            return metricIndex switch
+            {
+                0 => m.TotalCpu,
+                1 => m.TotalDuration,
+                2 => m.TotalExecutions,
+                3 => m.TotalReads,
+                4 => m.TotalWrites,
+                5 => m.TotalPhysicalReads,
+                6 => m.TotalMemory,
+                _ => 0
+            };
+        }
+        return metricIndex switch
+        {
+            0 => m.AvgCpu,
+            1 => m.AvgDuration,
+            2 => m.TotalExecutions, // Executions is the same
+            3 => m.AvgReads,
+            4 => m.AvgWrites,
+            5 => m.AvgPhysicalReads,
+            6 => m.AvgMemory,
+            _ => 0
+        };
+    }
+}
diff --git a/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs b/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
new file mode 100644
index 0000000..d87c57b
--- /dev/null
+++ b/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+
+namespace PlanViewer.Core.Models;
+
+/// <summary>
+/// Query Store state for a single database.
+/// </summary>
+public enum QueryStoreState
+{
+    Off,
+    ReadOnly,
+    ReadWrite
+}
+
+/// <summary>
+/// Query Store state info for a single database.
+/// </summary>
+public class DatabaseQueryStoreState
+{
+    public string DatabaseName { get; set; } = "";
+    public QueryStoreState State { get; set; }
+}
+
+/// <summary>
+/// Aggregated metrics for a single database over a time range.
+/// </summary>
+public class DatabaseMetrics
+{
+    public string DatabaseName { get; set; } = "";
+    public double TotalCpu { get; set; }
+    public double TotalDuration { get; set; }
+    public long TotalExecutions { get; set; }
+    public double TotalReads { get; set; }
+    public double TotalWrites { get; set; }
+    public double TotalPhysicalReads { get; set; }
+    public double TotalMemory { get; set; }
+
+    public double AvgCpu => TotalExecutions > 0 ? TotalCpu / TotalExecutions : 0;
+    public double AvgDuration => TotalExecutions > 0 ? TotalDuration / TotalExecutions : 0;
+    public double AvgReads => TotalExecutions > 0 ? TotalReads / TotalExecutions : 0;
+    public double AvgWrites => TotalExecutions > 0 ? TotalWrites / TotalExecutions : 0;
+    public double AvgPhysicalReads => TotalExecutions > 0 ? TotalPhysicalReads / TotalExecutions : 0;
+    public double AvgMemory => TotalExecutions > 0 ? TotalMemory / TotalExecutions : 0;
+}
+
+/// <summary>
+/// Time slice data tagged with the source database name.
+/// </summary>
+public class DatabaseTimeSlice
+{
+    public string DatabaseName { get; set; } = "";
+    public DateTime IntervalStartUtc { get; set; }
+    public double TotalCpu { get; set; }
+    public double TotalDuration { get; set; }
+    public double TotalReads { get; set; }
+    public double TotalWrites { get; set; }
+    public double TotalPhysicalReads { get; set; }
+    public double TotalMemory { get; set; }
+    public long TotalExecutions { get; set; }
+}
+
+/// <summary>
+/// Wait stats time slice tagged with the source database name.
+/// </summary>
+public class DatabaseWaitCategoryTimeSlice
+{
+    public string DatabaseName { get; set; } = "";
+    public DateTime IntervalStartUtc { get; set; }
+    public int WaitCategory { get; set; }
+    public string WaitCategoryDesc { get; set; } = "";
+    public double WaitRatio { get; set; }
+}
diff --git a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
new file mode 100644
index 0000000..3c236a6
--- /dev/null
+++ b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
@@ -0,0 +1,336 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Data.SqlClient;
+using PlanViewer.Core.Models;
+
+namespace PlanViewer.Core.Services;
+
+/// <summary>
+/// Service for fetching Query Store overview data across multiple databases in parallel.
+/// </summary>
+public static class QueryStoreOverviewService
+{
+    /// <summary>
+    /// Fetches Query Store state for all user databases in parallel.
+    /// </summary>
+    public static async Task<List<DatabaseQueryStoreState>> FetchAllStatesAsync(
+        string masterConnectionString,
+        int maxDegreeOfParallelism = 8,
+        CancellationToken ct = default)
+    {
+        var databases = await GetUserDatabasesAsync(masterConnectionString, ct);
+        var results = new ConcurrentBag<DatabaseQueryStoreState>();
+        var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+        var tasks = databases.Select(async db =>
+        {
+            await semaphore.WaitAsync(ct);
+            try
+            {
+                var state = await GetQueryStoreStateAsync(masterConnectionString, db, ct);
+                results.Add(new DatabaseQueryStoreState { DatabaseName = db, State = state });
+            }
+            catch
+            {
+                results.Add(new DatabaseQueryStoreState { DatabaseName = db, State = QueryStoreState.Off });
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+        return results.OrderBy(r => r.DatabaseName).ToList();
+    }
+
+    /// <summary>
+    /// Fetches aggregated metrics for active Query Store databases in parallel.
+    /// </summary>
+    public static async Task<List<DatabaseMetrics>> FetchAllMetricsAsync(
+        string masterConnectionString,
+        List<string> activeDatabases,
+        DateTime startUtc,
+        DateTime endUtc,
+        int maxDegreeOfParallelism = 8,
+        CancellationToken ct = default)
+    {
+        var results = new ConcurrentBag<DatabaseMetrics>();
+        var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+        var tasks = activeDatabases.Select(async db =>
+        {
+            await semaphore.WaitAsync(ct);
+            try
+            {
+                var metrics = await FetchDatabaseMetricsAsync(masterConnectionString, db, startUtc, endUtc, ct);
+                results.Add(metrics);
+            }
+            catch
+            {
+                results.Add(new DatabaseMetrics { DatabaseName = db });
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+        return results.OrderBy(r => r.DatabaseName).ToList();
+    }
+
+    /// <summary>
+    /// Fetches time slice data for active Query Store databases in parallel.
+    /// </summary>
+    public static async Task<List<DatabaseTimeSlice>> FetchAllTimeSlicesAsync(
+        string masterConnectionString,
+        List<string> activeDatabases,
+        int daysBack = 30,
+        int maxDegreeOfParallelism = 8,
+        CancellationToken ct = default)
+    {
+        var results = new ConcurrentBag<DatabaseTimeSlice>();
+        var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+        var tasks = activeDatabases.Select(async db =>
+        {
+            await semaphore.WaitAsync(ct);
+            try
+            {
+                var slices = await FetchDatabaseTimeSlicesAsync(masterConnectionString, db, daysBack, ct);
+                foreach (var s in slices)
+                    results.Add(s);
+            }
+            catch { /* skip database on error */ }
+            finally
+            {
+                semaphore.Release();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+        return results.OrderBy(r => r.IntervalStartUtc).ToList();
+    }
+
+    /// <summary>
+    /// Fetches wait stats ribbon data for active databases in parallel.
+    /// </summary>
+    public static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchAllWaitStatsAsync(
+        string masterConnectionString,
+        List<string> activeDatabases,
+        DateTime startUtc,
+        DateTime endUtc,
+        int maxDegreeOfParallelism = 8,
+        CancellationToken ct = default)
+    {
+        var results = new ConcurrentBag<DatabaseWaitCategoryTimeSlice>();
+        var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+        var tasks = activeDatabases.Select(async db =>
+        {
+            await semaphore.WaitAsync(ct);
+            try
+            {
+                var slices = await FetchDatabaseWaitStatsAsync(masterConnectionString, db, startUtc, endUtc, ct);
+                foreach (var s in slices)
+                    results.Add(s);
+            }
+            catch { /* skip database on error */ }
+            finally
+            {
+                semaphore.Release();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+        return results.OrderBy(r => r.IntervalStartUtc).ToList();
+    }
+
+    // ── Private helpers ──────────────────────────────────────────────────────
+
+    private static async Task<List<string>> GetUserDatabasesAsync(
+        string connectionString, CancellationToken ct)
+    {
+        const string sql = @"
+SELECT name FROM sys.databases
+WHERE database_id > 4
+  AND state_desc = 'ONLINE'
+  AND is_read_only = 0
+ORDER BY name;";
+
+        var databases = new List<string>();
+        await using var conn = new SqlConnection(connectionString);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 30 };
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+            databases.Add(reader.GetString(0));
+        return databases;
+    }
+
+    private static string BuildDbConnectionString(string masterConnectionString, string database)
+    {
+        var builder = new SqlConnectionStringBuilder(masterConnectionString)
+        {
+            InitialCatalog = database
+        };
+        return builder.ConnectionString;
+    }
+
+    private static async Task<QueryStoreState> GetQueryStoreStateAsync(
+        string masterConnectionString, string database, CancellationToken ct)
+    {
+        var connStr = BuildDbConnectionString(masterConnectionString, database);
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT actual_state_desc FROM sys.database_query_store_options;";
+
+        await using var conn = new SqlConnection(connStr);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 10 };
+        var state = (string?)await cmd.ExecuteScalarAsync(ct);
+
+        return state switch
+        {
+            "READ_WRITE" => QueryStoreState.ReadWrite,
+            "READ_ONLY" => QueryStoreState.ReadOnly,
+            _ => QueryStoreState.Off
+        };
+    }
+
+    private static async Task<DatabaseMetrics> FetchDatabaseMetricsAsync(
+        string masterConnectionString, string database,
+        DateTime startUtc, DateTime endUtc, CancellationToken ct)
+    {
+        var connStr = BuildDbConnectionString(masterConnectionString, database);
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT
+    SUM(rs.avg_cpu_time * rs.count_executions) / 1000.0,
+    SUM(rs.avg_duration * rs.count_executions) / 1000.0,
+    SUM(rs.count_executions),
+    SUM(rs.avg_logical_io_reads * rs.count_executions),
+    SUM(rs.avg_logical_io_writes * rs.count_executions),
+    SUM(rs.avg_physical_io_reads * rs.count_executions),
+    SUM(rs.avg_query_max_used_memory * rs.count_executions) * 8.0 / 1024.0
+FROM sys.query_store_runtime_stats rs
+JOIN sys.query_store_runtime_stats_interval rsi
+    ON rs.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+WHERE rsi.start_time >= @start AND rsi.start_time < @end;";
+
+        await using var conn = new SqlConnection(connStr);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        cmd.Parameters.Add(new SqlParameter("@start", startUtc));
+        cmd.Parameters.Add(new SqlParameter("@end", endUtc));
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+        var metrics = new DatabaseMetrics { DatabaseName = database };
+        if (await reader.ReadAsync(ct) && !reader.IsDBNull(0))
+        {
+            metrics.TotalCpu = reader.GetDouble(0);
+            metrics.TotalDuration = reader.GetDouble(1);
+            metrics.TotalExecutions = reader.GetInt64(2);
+            metrics.TotalReads = reader.GetDouble(3);
+            metrics.TotalWrites = reader.GetDouble(4);
+            metrics.TotalPhysicalReads = reader.GetDouble(5);
+            metrics.TotalMemory = reader.GetDouble(6);
+        }
+        return metrics;
+    }
+
+    private static async Task<List<DatabaseTimeSlice>> FetchDatabaseTimeSlicesAsync(
+        string masterConnectionString, string database, int daysBack, CancellationToken ct)
+    {
+        var connStr = BuildDbConnectionString(masterConnectionString, database);
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT
+    DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
+    SUM(rs.avg_cpu_time * rs.count_executions) / 1000.0,
+    SUM(rs.avg_duration * rs.count_executions) / 1000.0,
+    SUM(rs.avg_logical_io_reads * rs.count_executions),
+    SUM(rs.avg_logical_io_writes * rs.count_executions),
+    SUM(rs.avg_physical_io_reads * rs.count_executions),
+    SUM(rs.avg_query_max_used_memory * rs.count_executions) * 8.0 / 1024.0,
+    SUM(rs.count_executions)
+FROM sys.query_store_runtime_stats rs
+JOIN sys.query_store_runtime_stats_interval rsi
+    ON rs.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+WHERE rsi.start_time >= DATEADD(DAY, -@daysBack, GETUTCDATE())
+GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0)
+ORDER BY bucket_hour;";
+
+        var rows = new List<DatabaseTimeSlice>();
+        await using var conn = new SqlConnection(connStr);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        cmd.Parameters.Add(new SqlParameter("@daysBack", daysBack));
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+        while (await reader.ReadAsync(ct))
+        {
+            rows.Add(new DatabaseTimeSlice
+            {
+                DatabaseName = database,
+                IntervalStartUtc = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc),
+                TotalCpu = reader.GetDouble(1),
+                TotalDuration = reader.GetDouble(2),
+                TotalReads = reader.GetDouble(3),
+                TotalWrites = reader.GetDouble(4),
+                TotalPhysicalReads = reader.GetDouble(5),
+                TotalMemory = reader.GetDouble(6),
+                TotalExecutions = reader.GetInt64(7),
+            });
+        }
+        return rows;
+    }
+
+    private static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchDatabaseWaitStatsAsync(
+        string masterConnectionString, string database,
+        DateTime startUtc, DateTime endUtc, CancellationToken ct)
+    {
+        var connStr = BuildDbConnectionString(masterConnectionString, database);
+        const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT
+    DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
+    ws.wait_category,
+    ws.wait_category_desc,
+    1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS wait_ratio
+FROM sys.query_store_wait_stats ws
+JOIN sys.query_store_runtime_stats_interval rsi
+    ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+WHERE rsi.start_time >= @start AND rsi.start_time < @end
+AND   ws.execution_type = 0
+GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0),
+         ws.wait_category, ws.wait_category_desc
+ORDER BY bucket_hour, wait_ratio DESC;";
+
+        var rows = new List<DatabaseWaitCategoryTimeSlice>();
+        await using var conn = new SqlConnection(connStr);
+        await conn.OpenAsync(ct);
+        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+        cmd.Parameters.Add(new SqlParameter("@start", startUtc));
+        cmd.Parameters.Add(new SqlParameter("@end", endUtc));
+        await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+        while (await reader.ReadAsync(ct))
+        {
+            rows.Add(new DatabaseWaitCategoryTimeSlice
+            {
+                DatabaseName = database,
+                IntervalStartUtc = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc),
+                WaitCategory = reader.GetInt16(1),
+                WaitCategoryDesc = reader.GetString(2),
+                WaitRatio = reader.GetDouble(3),
+            });
+        }
+        return rows;
+    }
+}

From 8615e58871f106e3249f628d5c8e1c33082a1b16 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 5 May 2026 02:26:00 +0200
Subject: [PATCH 3/8] 1. Drill-down with time range: DrillDownRequested now
 passes a DrillDownEventArgs containing Database, StartUtc, and EndUtc. The
 session control calls grid.SetInitialTimeRange() before the grid
 auto-fetches, so the drilled-down Query Store tab starts with the same time
 range selected in the overview. 2.  Progress bar: Added an indeterminate
 ProgressBar at the top of the overview. It shows during LoadAsync() (all 3
 phases) and during RefreshMetricsAndWaitStatsAsync(CancellationToken) (when
 the slicer range changes), and hides when complete via try/finally.

---
 .../Controls/QuerySessionControl.axaml.cs     |  97 +++-
 .../Controls/QueryStoreGridControl.axaml.cs   |  10 +
 .../Controls/QueryStoreOverviewControl.axaml  |  50 +-
 .../QueryStoreOverviewControl.axaml.cs        | 497 ++++++++++++------
 4 files changed, 467 insertions(+), 187 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
index a8aa889..b95806c 100644
--- a/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QuerySessionControl.axaml.cs
@@ -1400,13 +1400,15 @@ private async void QueryStoreOverview_Click(object? sender, RoutedEventArgs e)
 
         SetStatus("Loading Query Store Overview...");
 
-        var overview = new QueryStoreOverviewControl(_serverConnection, _credentialService);
-        overview.DrillDownRequested += (_, db) =>
+        var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
+        var overview = new QueryStoreOverviewControl(_serverConnection, _credentialService,
+            supportsWaitStats: supportsWaitStats);
+        overview.DrillDownRequested += async (_, args) =>
         {
-            // Open a single-database Query Store tab
-            _selectedDatabase = db;
-            _connectionString = _serverConnection!.GetConnectionString(_credentialService, db);
-            QueryStore_Click(null, new RoutedEventArgs());
+            // Open a single-database Query Store tab directly (no connection dialog)
+            _selectedDatabase = args.Database;
+            _connectionString = _serverConnection!.GetConnectionString(_credentialService, args.Database);
+            await OpenQueryStoreForDatabaseAsync(args.Database, args.StartUtc, args.EndUtc);
         };
 
         var headerText = new TextBlock
@@ -1459,6 +1461,89 @@ private async void QueryStoreOverview_Click(object? sender, RoutedEventArgs e)
         }
     }
 
+    private async Task OpenQueryStoreForDatabaseAsync(string database, DateTime? initialStartUtc = null, DateTime? initialEndUtc = null)
+    {
+        var connStr = _serverConnection!.GetConnectionString(_credentialService, database);
+
+        // Check if Query Store is enabled
+        SetStatus($"Checking Query Store on {database}...");
+        try
+        {
+            var (enabled, state) = await QueryStoreService.CheckEnabledAsync(connStr);
+            if (!enabled)
+            {
+                SetStatus($"Query Store not enabled on {database} ({state ?? "unknown"})");
+                return;
+            }
+        }
+        catch (Exception ex)
+        {
+            SetStatus(ex.Message.Length > 80 ? ex.Message[..80] + "..." : ex.Message, autoClear: false);
+            return;
+        }
+
+        SetStatus("");
+
+        // Check if wait stats are supported
+        var supportsWaitStats = _serverMetadata?.SupportsQueryStoreWaitStats ?? false;
+        if (supportsWaitStats)
+        {
+            try
+            {
+                supportsWaitStats = await QueryStoreService.IsWaitStatsCaptureEnabledAsync(connStr);
+            }
+            catch { supportsWaitStats = false; }
+        }
+
+        var databases = DatabaseBox.Items.OfType<string>().ToList();
+
+        var grid = new QueryStoreGridControl(_serverConnection!, _credentialService,
+            database, databases, supportsWaitStats);
+        if (initialStartUtc.HasValue && initialEndUtc.HasValue)
+            grid.SetInitialTimeRange(initialStartUtc.Value, initialEndUtc.Value);
+        grid.PlansSelected += OnQueryStorePlansSelected;
+
+        var headerText = new TextBlock
+        {
+            Text = $"Query Store — {database}",
+            VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
+            FontSize = 12
+        };
+        grid.DatabaseChanged += (_, db) => headerText.Text = $"Query Store — {db}";
+
+        var closeBtn = new Button
+        {
+            Content = "\u2715",
+            MinWidth = 22, MinHeight = 22, Width = 22, Height = 22,
+            Padding = new Avalonia.Thickness(0),
+            FontSize = 11,
+            Margin = new Avalonia.Thickness(6, 0, 0, 0),
+            Background = Brushes.Transparent,
+            BorderThickness = new Avalonia.Thickness(0),
+            Foreground = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB)),
+            VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center,
+            HorizontalContentAlignment = HorizontalAlignment.Center,
+            VerticalContentAlignment = VerticalAlignment.Center
+        };
+
+        var header = new StackPanel
+        {
+            Orientation = Avalonia.Layout.Orientation.Horizontal,
+            Children = { headerText, closeBtn }
+        };
+
+        var tab = new TabItem { Header = header, Content = grid };
+        closeBtn.Tag = tab;
+        closeBtn.Click += (s, _) =>
+        {
+            if (s is Button btn && btn.Tag is TabItem t)
+                SubTabControl.Items.Remove(t);
+        };
+
+        SubTabControl.Items.Add(tab);
+        SubTabControl.SelectedItem = tab;
+    }
+
     private async void QueryStore_Click(object? sender, RoutedEventArgs e)
     {
         // If a QS tab already exists, always show connection dialog for a fresh tab
diff --git a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
index 9911142..7ffc323 100644
--- a/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreGridControl.axaml.cs
@@ -95,6 +95,16 @@ public QueryStoreGridControl(ServerConnection serverConnection, ICredentialServi
         }, Avalonia.Threading.DispatcherPriority.Loaded);
     }
 
+    /// <summary>
+    /// Sets the initial slicer time range (e.g. from overview drill-down).
+    /// Must be called before the control is loaded to take effect on the first fetch.
+    /// </summary>
+    public void SetInitialTimeRange(DateTime startUtc, DateTime endUtc)
+    {
+        _slicerStartUtc = startUtc;
+        _slicerEndUtc = endUtc;
+    }
+
     private void PopulateDatabaseBox(List<string> databases, string selectedDatabase)
     {
         QsDatabaseBox.ItemsSource = databases;
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index 98aeb25..5c1eceb 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -1,17 +1,24 @@
 <UserControl xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:controls="using:PlanViewer.App.Controls"
              x:Class="PlanViewer.App.Controls.QueryStoreOverviewControl">
     <Grid x:Name="RootGrid" Background="{DynamicResource BackgroundBrush}">
         <Grid.RowDefinitions>
-            <RowDefinition Height="*"/>
-            <RowDefinition Height="*"/>
-            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="1*"/>
+            <RowDefinition Height="2*"/>
+            <RowDefinition Height="2*"/>
         </Grid.RowDefinitions>
 
-        <!-- Row 0: Donut + TimeSlicer + WaitStats -->
-        <Grid Grid.Row="0" Margin="10">
+        <!-- Row 0: Progress bar -->
+        <ProgressBar x:Name="LoadingBar" Grid.Row="0" IsIndeterminate="True"
+                     Height="3" Margin="0" IsVisible="False"
+                     Foreground="{DynamicResource AccentBrush}"/>
+
+        <!-- Row 1: Donut + TimeSlicer + WaitStats -->
+        <Grid Grid.Row="1" Margin="10">
             <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="0.6*"/>
                 <ColumnDefinition Width="2*"/>
                 <ColumnDefinition Width="2*"/>
             </Grid.ColumnDefinitions>
@@ -19,26 +26,37 @@
             <!-- Donut chart area -->
             <Border Grid.Column="0" Background="{DynamicResource BackgroundLightBrush}"
                     CornerRadius="4" Margin="0,0,5,0" ClipToBounds="True">
-                <Canvas x:Name="DonutCanvas"/>
+                <Grid RowDefinitions="Auto,*">
+                    <TextBlock Grid.Row="0" Text="QS States" FontSize="11" FontWeight="SemiBold"
+                               Foreground="{DynamicResource ForegroundBrush}"
+                               HorizontalAlignment="Center" Margin="0,4,0,0"/>
+                    <Canvas x:Name="DonutCanvas" Grid.Row="1"/>
+                </Grid>
             </Border>
 
-            <!-- Time slicer (consolidated) -->
-            <Border Grid.Column="1" Background="{DynamicResource BackgroundLightBrush}"
-                    CornerRadius="4" Margin="5,0,5,0" ClipToBounds="True">
-                <Canvas x:Name="SlicerCanvas"/>
-            </Border>
+            <!-- Time slicer (consolidated) - reuses the full TimeRangeSlicerControl -->
+            <controls:TimeRangeSlicerControl x:Name="OverviewTimeSlicer"
+                                              Grid.Column="1" Margin="5,0,5,0"
+                                              VerticalAlignment="Stretch"/>
 
-            <!-- Wait stats ribbon (consolidated) -->
+            <!-- Wait stats ribbon (consolidated by database) -->
             <Border Grid.Column="2" Background="{DynamicResource BackgroundLightBrush}"
                     CornerRadius="4" Margin="5,0,0,0" ClipToBounds="True">
-                <Canvas x:Name="WaitStatsCanvas"/>
+                <Grid RowDefinitions="Auto,*">
+                    <TextBlock Grid.Row="0" Text="Wait Stats by Database" FontSize="11" FontWeight="SemiBold"
+                               Foreground="{DynamicResource ForegroundBrush}"
+                               HorizontalAlignment="Center" Margin="0,4,0,0"/>
+                    <Border x:Name="WaitStatsBorder" Grid.Row="1" ClipToBounds="True">
+                        <Canvas x:Name="WaitStatsCanvas" Background="Transparent"/>
+                    </Border>
+                </Grid>
             </Border>
         </Grid>
 
         <!-- Row 1: Total metrics bar cards -->
-        <Grid x:Name="TotalMetricsGrid" Grid.Row="1" Margin="10"/>
+        <Grid x:Name="TotalMetricsGrid" Grid.Row="2" Margin="10"/>
 
         <!-- Row 2: Avg metrics bar cards -->
-        <Grid x:Name="AvgMetricsGrid" Grid.Row="2" Margin="10"/>
+        <Grid x:Name="AvgMetricsGrid" Grid.Row="3" Margin="10"/>
     </Grid>
 </UserControl>
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 1d38e67..7671a7f 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -6,6 +6,7 @@
 using System.Threading.Tasks;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Shapes;
 using Avalonia.Input;
 using Avalonia.Interactivity;
@@ -24,6 +25,7 @@ public partial class QueryStoreOverviewControl : UserControl
     private readonly string _masterConnectionString;
     private readonly int _maxDop;
     private readonly int _topN;
+    private readonly bool _supportsWaitStats;
     private CancellationTokenSource? _cts;
 
     private List<DatabaseQueryStoreState> _states = new();
@@ -55,16 +57,24 @@ public partial class QueryStoreOverviewControl : UserControl
     private static readonly Color ReadOnlyColor = Color.Parse("#1A5276");   // dark blue
     private static readonly Color OffColor = Color.Parse("#666666");        // grey
 
-    public event EventHandler<string>? DrillDownRequested;
+    public class DrillDownEventArgs(string database, DateTime startUtc, DateTime endUtc) : EventArgs
+    {
+        public string Database { get; } = database;
+        public DateTime StartUtc { get; } = startUtc;
+        public DateTime EndUtc { get; } = endUtc;
+    }
+
+    public event EventHandler<DrillDownEventArgs>? DrillDownRequested;
 
     public QueryStoreOverviewControl(ServerConnection serverConnection,
-        ICredentialService credentialService, int maxDop = 8, int topN = 2)
+        ICredentialService credentialService, int maxDop = 8, int topN = 4, bool supportsWaitStats = true)
     {
         _serverConnection = serverConnection;
         _credentialService = credentialService;
         _masterConnectionString = serverConnection.GetConnectionString(credentialService, "master");
         _maxDop = maxDop;
         _topN = topN;
+        _supportsWaitStats = supportsWaitStats;
         _slicerEndUtc = DateTime.UtcNow;
         _slicerStartUtc = _slicerEndUtc.AddHours(-24);
 
@@ -73,9 +83,10 @@ public QueryStoreOverviewControl(ServerConnection serverConnection,
         this.SizeChanged += (_, _) =>
         {
             DrawDonut();
-            DrawSlicer();
-            DrawWaitStats();
+            DrawWaitStatsChart();
         };
+
+        OverviewTimeSlicer.RangeChanged += OnSlicerRangeChanged;
     }
 
     public async Task LoadAsync()
@@ -84,26 +95,53 @@ public async Task LoadAsync()
         _cts = new CancellationTokenSource();
         var ct = _cts.Token;
 
-        // Phase 1: Get states
-        _states = await QueryStoreOverviewService.FetchAllStatesAsync(
-            _masterConnectionString, _maxDop, ct);
+        await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = true);
 
-        await Dispatcher.UIThread.InvokeAsync(DrawDonut);
+        try
+        {
+            // Phase 1: Get states
+            _states = await QueryStoreOverviewService.FetchAllStatesAsync(
+                _masterConnectionString, _maxDop, ct);
 
-        // Phase 2: Get time slices for active databases
-        var activeDbs = _states
-            .Where(s => s.State != QueryStoreState.Off)
-            .Select(s => s.DatabaseName).ToList();
+            await Dispatcher.UIThread.InvokeAsync(DrawDonut);
 
-        if (activeDbs.Count == 0) return;
+            // Phase 2: Get time slices for active databases
+            var activeDbs = _states
+                .Where(s => s.State != QueryStoreState.Off)
+                .Select(s => s.DatabaseName).ToList();
 
-        _timeSlices = await QueryStoreOverviewService.FetchAllTimeSlicesAsync(
-            _masterConnectionString, activeDbs, _daysBack, _maxDop, ct);
+            if (activeDbs.Count == 0) return;
 
-        await Dispatcher.UIThread.InvokeAsync(DrawSlicer);
+            _timeSlices = await QueryStoreOverviewService.FetchAllTimeSlicesAsync(
+                _masterConnectionString, activeDbs, _daysBack, _maxDop, ct);
 
-        // Phase 3: Metrics and wait stats for selected time range
-        await RefreshMetricsAndWaitStatsAsync(ct);
+            // Consolidate time slices across databases into QueryStoreTimeSlice for the slicer
+            var consolidated = _timeSlices
+                .GroupBy(s => s.IntervalStartUtc)
+                .Select(g => new QueryStoreTimeSlice
+                {
+                    IntervalStartUtc = g.Key,
+                    TotalCpu = g.Sum(x => x.TotalCpu),
+                    TotalDuration = g.Sum(x => x.TotalDuration),
+                    TotalReads = g.Sum(x => x.TotalReads),
+                    TotalWrites = g.Sum(x => x.TotalWrites),
+                    TotalPhysicalReads = g.Sum(x => x.TotalPhysicalReads),
+                    TotalMemory = g.Sum(x => x.TotalMemory),
+                    TotalExecutions = g.Sum(x => x.TotalExecutions),
+                })
+                .OrderBy(x => x.IntervalStartUtc)
+                .ToList();
+
+            await Dispatcher.UIThread.InvokeAsync(() =>
+                OverviewTimeSlicer.LoadData(consolidated, "cpu"));
+
+            // Phase 3: Metrics and wait stats for selected time range
+            await RefreshMetricsAndWaitStatsAsync(ct);
+        }
+        finally
+        {
+            await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = false);
+        }
     }
 
     private async Task RefreshMetricsAndWaitStatsAsync(CancellationToken ct)
@@ -114,17 +152,32 @@ private async Task RefreshMetricsAndWaitStatsAsync(CancellationToken ct)
 
         if (activeDbs.Count == 0) return;
 
-        _metrics = await QueryStoreOverviewService.FetchAllMetricsAsync(
+        await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = true);
+        try
+        {
+            _metrics = await QueryStoreOverviewService.FetchAllMetricsAsync(
             _masterConnectionString, activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
 
-        _waitSlices = await QueryStoreOverviewService.FetchAllWaitStatsAsync(
-            _masterConnectionString, activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
+            if (_supportsWaitStats)
+            {
+                _waitSlices = await QueryStoreOverviewService.FetchAllWaitStatsAsync(
+                    _masterConnectionString, activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
+            }
+            else
+            {
+                _waitSlices.Clear();
+            }
 
-        await Dispatcher.UIThread.InvokeAsync(() =>
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                DrawBarCards();
+                DrawWaitStatsChart();
+            });
+        }
+        finally
         {
-            DrawWaitStats();
-            DrawBarCards();
-        });
+            await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = false);
+        }
     }
 
     // ── Donut Chart ──────────────────────────────────────────────────────────
@@ -149,17 +202,55 @@ private void DrawDonut()
         int total = _states.Count;
         int activeCount = rwCount + roCount;
 
-        var segments = new List<(double fraction, Color color)>();
-        if (rwCount > 0) segments.Add(((double)rwCount / total, ReadWriteColor));
-        if (roCount > 0) segments.Add(((double)roCount / total, ReadOnlyColor));
-        if (offCount > 0) segments.Add(((double)offCount / total, OffColor));
+        var segmentInfos = new List<(int count, string label, QueryStoreState state, Color color)>();
+        if (rwCount > 0) segmentInfos.Add((rwCount, "Read Write", QueryStoreState.ReadWrite, ReadWriteColor));
+        if (roCount > 0) segmentInfos.Add((roCount, "Read Only", QueryStoreState.ReadOnly, ReadOnlyColor));
+        if (offCount > 0) segmentInfos.Add((offCount, "OFF", QueryStoreState.Off, OffColor));
 
         double startAngle = -Math.PI / 2;
-        foreach (var (fraction, color) in segments)
+        foreach (var (count, label, state, color) in segmentInfos)
         {
+            var fraction = (double)count / total;
             var sweepAngle = fraction * 2 * Math.PI;
             var path = CreateArcPath(cx, cy, radius, innerRadius, startAngle, startAngle + sweepAngle, color);
+
+            // Tooltip with details
+            var pct = fraction * 100;
+            var tipText = $"{label}: {count} database{(count != 1 ? "s" : "")} ({pct:F0}%)";
+            ToolTip.SetTip(path, tipText);
+            ToolTip.SetShowDelay(path, 200);
+
+            // Click → popup with database list
+            var capturedState = state;
+            path.Cursor = new Cursor(StandardCursorType.Hand);
+            path.PointerPressed += (_, e) =>
+            {
+                e.Handled = true;
+                ShowDonutPopup(capturedState);
+            };
+
             DonutCanvas.Children.Add(path);
+
+            // Percentage label on the arc midpoint
+            if (fraction > 0.05) // only show label if segment is large enough
+            {
+                var midAngle = startAngle + sweepAngle / 2;
+                var labelR = (radius + innerRadius) / 2;
+                var lx = cx + labelR * Math.Cos(midAngle);
+                var ly = cy + labelR * Math.Sin(midAngle);
+                var pctLabel = new TextBlock
+                {
+                    Text = $"{pct:F0}%",
+                    FontSize = 10,
+                    FontWeight = FontWeight.SemiBold,
+                    Foreground = Brushes.White,
+                };
+                pctLabel.Measure(Size.Infinity);
+                Canvas.SetLeft(pctLabel, lx - pctLabel.DesiredSize.Width / 2);
+                Canvas.SetTop(pctLabel, ly - pctLabel.DesiredSize.Height / 2);
+                DonutCanvas.Children.Add(pctLabel);
+            }
+
             startAngle += sweepAngle;
         }
 
@@ -185,6 +276,63 @@ private void DrawDonut()
         DrawLegendItem(DonutCanvas, 4, legendY + 32, OffColor, $"OFF: {offCount}");
     }
 
+    private void ShowDonutPopup(QueryStoreState state)
+    {
+        var dbs = _states.Where(s => s.State == state).OrderBy(s => s.DatabaseName).ToList();
+        var stateLabel = state switch
+        {
+            QueryStoreState.ReadWrite => "Read Write",
+            QueryStoreState.ReadOnly => "Read Only",
+            _ => "OFF"
+        };
+
+        var stack = new StackPanel { Spacing = 2, Margin = new Thickness(4) };
+        stack.Children.Add(new TextBlock
+        {
+            Text = $"{stateLabel} ({dbs.Count})",
+            FontSize = 12,
+            FontWeight = FontWeight.Bold,
+            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            Margin = new Thickness(0, 0, 0, 4)
+        });
+
+        foreach (var db in dbs)
+        {
+            stack.Children.Add(new TextBlock
+            {
+                Text = db.DatabaseName,
+                FontSize = 11,
+                Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+            });
+        }
+
+        var popup = new Popup
+        {
+            PlacementTarget = DonutCanvas,
+            Placement = PlacementMode.Pointer,
+            IsLightDismissEnabled = true,
+            Child = new Border
+            {
+                Background = this.FindResource("BackgroundLightBrush") as IBrush ?? new SolidColorBrush(Color.Parse("#22252D")),
+                BorderBrush = this.FindResource("BorderBrush") as IBrush ?? new SolidColorBrush(Color.Parse("#3A3D45")),
+                BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(6),
+                Padding = new Thickness(10),
+                MinWidth = 180,
+                MaxHeight = 300,
+                Child = new ScrollViewer { Content = stack }
+            }
+        };
+
+        // Add popup to the visual tree temporarily
+        if (DonutCanvas.Parent is Panel parentPanel)
+        {
+            parentPanel.Children.Add(popup);
+            popup.IsOpen = true;
+            popup.Closed += (_, _) => parentPanel.Children.Remove(popup);
+        }
+    }
+
     private void DrawLegendItem(Canvas canvas, double x, double y, Color color, string text)
     {
         if (y + 14 > canvas.Bounds.Height) return;
@@ -235,161 +383,197 @@ private Path CreateArcPath(double cx, double cy, double outerR, double innerR,
         return new Path { Data = geo, Fill = new SolidColorBrush(fill) };
     }
 
-    // ── Time Slicer (consolidated) ──────────────────────────────────────────
+    // ── Time Slicer (delegates to TimeRangeSlicerControl) ──────────────────
+
+    private async void OnSlicerRangeChanged(object? sender, TimeRangeChangedEventArgs e)
+    {
+        _slicerStartUtc = e.StartUtc;
+        _slicerEndUtc = e.EndUtc;
+
+        _cts?.Cancel();
+        _cts = new CancellationTokenSource();
+        try
+        {
+            await RefreshMetricsAndWaitStatsAsync(_cts.Token);
+        }
+        catch (OperationCanceledException) { }
+        catch { /* swallow errors from refresh */ }
+    }
+
+    // ── Wait Stats Chart (stacked by database) ──────────────────────────────
 
-    private void DrawSlicer()
+    private void DrawWaitStatsChart()
     {
-        SlicerCanvas.Children.Clear();
-        if (_timeSlices.Count == 0) return;
+        WaitStatsCanvas.Children.Clear();
+        if (_waitSlices.Count == 0)
+        {
+            var msg = new TextBlock
+            {
+                Text = _supportsWaitStats ? "No wait stats data" : "Wait stats not supported (SQL 2017+ required)",
+                FontSize = 10,
+                Foreground = new SolidColorBrush(Color.Parse("#888888")),
+                TextWrapping = Avalonia.Media.TextWrapping.Wrap,
+            };
+            Canvas.SetLeft(msg, 10);
+            Canvas.SetTop(msg, 20);
+            WaitStatsCanvas.Children.Add(msg);
+            return;
+        }
 
-        var w = SlicerCanvas.Bounds.Width;
-        var h = SlicerCanvas.Bounds.Height;
+        var w = WaitStatsBorder.Bounds.Width;
+        var h = WaitStatsBorder.Bounds.Height;
         if (w < 10 || h < 10) return;
 
-        // Consolidate across databases by hour
-        var consolidated = _timeSlices
-            .GroupBy(s => s.IntervalStartUtc)
-            .Select(g => new { Hour = g.Key, Total = g.Sum(x => x.TotalCpu) })
-            .OrderBy(x => x.Hour)
+        const double paddingTop = 4;
+        const double paddingBottom = 16;
+        var chartH = h - paddingTop - paddingBottom;
+        if (chartH <= 0) return;
+
+        // Consolidate: sum ALL wait ratios per database per hour (ignore wait category)
+        var dbHourData = _waitSlices
+            .GroupBy(s => new { s.DatabaseName, s.IntervalStartUtc })
+            .Select(g => (Db: g.Key.DatabaseName, Hour: g.Key.IntervalStartUtc, Total: g.Sum(x => x.WaitRatio)))
             .ToList();
 
-        if (consolidated.Count == 0) return;
+        if (dbHourData.Count == 0) return;
 
-        var maxVal = consolidated.Max(c => c.Total);
-        if (maxVal <= 0) maxVal = 1;
+        // Build complete hourly timeline
+        var allHours = dbHourData.Select(x => x.Hour).Distinct().OrderBy(x => x).ToList();
+        var n = allHours.Count;
+        if (n == 0) return;
 
-        var barW = w / consolidated.Count;
-        var chartBrush = new SolidColorBrush(Color.Parse("#332EAEF1"));
-        var lineBrush = new SolidColorBrush(Color.Parse("#2EAEF1"));
+        // Use the same top-N databases + Others as the bar cards
+        var topDbs = _dbColorMap.Keys.ToList();
 
-        for (int i = 0; i < consolidated.Count; i++)
-        {
-            var barH = (consolidated[i].Total / maxVal) * (h - 20);
-            var rect = new Rectangle
-            {
-                Width = Math.Max(1, barW - 1),
-                Height = barH,
-                Fill = chartBrush,
-            };
-            Canvas.SetLeft(rect, i * barW);
-            Canvas.SetTop(rect, h - barH - 10);
-            SlicerCanvas.Children.Add(rect);
-        }
+        // Compute per-hour totals for each database group
+        var hourLookup = dbHourData
+            .GroupBy(x => x.Hour)
+            .ToDictionary(g => g.Key, g => g.ToList());
 
-        // Selection overlay for the current time range
-        if (consolidated.Count > 0)
+        // Find max stacked total for Y scaling
+        double maxTotal = 0;
+        foreach (var hour in allHours)
         {
-            var minTime = consolidated.First().Hour;
-            var maxTime = consolidated.Last().Hour;
-            var totalSpan = (maxTime - minTime).TotalHours;
-            if (totalSpan > 0)
-            {
-                var startNorm = Math.Max(0, (_slicerStartUtc - minTime).TotalHours / totalSpan);
-                var endNorm = Math.Min(1, (_slicerEndUtc - minTime).TotalHours / totalSpan);
-                var selRect = new Rectangle
-                {
-                    Width = (endNorm - startNorm) * w,
-                    Height = h,
-                    Fill = new SolidColorBrush(Color.Parse("#442EAEF1")),
-                };
-                Canvas.SetLeft(selRect, startNorm * w);
-                Canvas.SetTop(selRect, 0);
-                SlicerCanvas.Children.Add(selRect);
-            }
+            if (!hourLookup.TryGetValue(hour, out var items)) continue;
+            var total = items.Sum(x => x.Total);
+            if (total > maxTotal) maxTotal = total;
         }
+        if (maxTotal <= 0) maxTotal = 1;
 
-        // Label
-        var label = new TextBlock
-        {
-            Text = "Consolidated CPU (all DBs)",
-            FontSize = 10,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
-        };
-        Canvas.SetLeft(label, 4);
-        Canvas.SetTop(label, 2);
-        SlicerCanvas.Children.Add(label);
-    }
-
-    // ── Wait Stats (consolidated) ───────────────────────────────────────────
-
-    private void DrawWaitStats()
-    {
-        WaitStatsCanvas.Children.Clear();
-        if (_waitSlices.Count == 0) return;
+        var stepX = w / n;
+        var barGap = Math.Min(2.0, Math.Max(0.5, stepX * 0.1));
 
-        var w = WaitStatsCanvas.Bounds.Width;
-        var h = WaitStatsCanvas.Bounds.Height;
-        if (w < 10 || h < 10) return;
+        for (int i = 0; i < n; i++)
+        {
+            var hour = allHours[i];
+            if (!hourLookup.TryGetValue(hour, out var items)) continue;
 
-        // Consolidate: sum wait ratios across databases by hour+category
-        var consolidated = _waitSlices
-            .GroupBy(s => new { s.IntervalStartUtc, s.WaitCategoryDesc })
-            .Select(g => new WaitCategoryTimeSlice
+            // Aggregate per database
+            var dbTotals = new Dictionary<string, double>();
+            double othersTotal = 0;
+            foreach (var item in items)
             {
-                IntervalStartUtc = g.Key.IntervalStartUtc,
-                WaitCategoryDesc = g.Key.WaitCategoryDesc,
-                WaitCategory = g.First().WaitCategory,
-                WaitRatio = g.Sum(x => x.WaitRatio)
-            })
-            .OrderBy(x => x.IntervalStartUtc)
-            .ToList();
+                if (topDbs.Contains(item.Db))
+                    dbTotals[item.Db] = dbTotals.GetValueOrDefault(item.Db) + item.Total;
+                else
+                    othersTotal += item.Total;
+            }
 
-        // Use the existing ribbon painting logic (simplified)
-        var hours = consolidated.Select(x => x.IntervalStartUtc).Distinct().OrderBy(x => x).ToList();
-        var categories = consolidated.GroupBy(x => x.WaitCategoryDesc)
-            .OrderByDescending(g => g.Sum(x => x.WaitRatio))
-            .Select(g => g.Key).Take(5).ToList();
+            double y = paddingTop + chartH; // bottom
+            var x = i * stepX;
 
-        if (hours.Count == 0) return;
+            // Draw stacked bars: top databases first, then others
+            foreach (var db in topDbs)
+            {
+                var val = dbTotals.GetValueOrDefault(db);
+                if (val <= 0) continue;
+                var segH = (val / maxTotal) * chartH;
+                y -= segH;
 
-        var maxPerHour = hours.Select(hr =>
-            consolidated.Where(c => c.IntervalStartUtc == hr).Sum(c => c.WaitRatio)).Max();
-        if (maxPerHour <= 0) maxPerHour = 1;
+                var color = _dbColorMap.GetValueOrDefault(db, OthersColor);
+                var rect = new Rectangle
+                {
+                    Width = Math.Max(1, stepX - barGap),
+                    Height = Math.Max(0.5, segH),
+                    Fill = new SolidColorBrush(color),
+                };
+                Canvas.SetLeft(rect, x);
+                Canvas.SetTop(rect, y);
+                WaitStatsCanvas.Children.Add(rect);
 
-        var barW = w / hours.Count;
-        var waitColors = new[] { "#EB5757", "#F2994A", "#F2C94C", "#27AE60", "#2EAEF1" };
+                ToolTip.SetTip(rect, $"{db}: {WaitRatioFormatter.Format(val)}");
+                ToolTip.SetShowDelay(rect, 200);
+            }
 
-        for (int hi = 0; hi < hours.Count; hi++)
-        {
-            double yOffset = 0;
-            var hourData = consolidated.Where(c => c.IntervalStartUtc == hours[hi]).ToList();
-            for (int ci = 0; ci < categories.Count && ci < waitColors.Length; ci++)
+            if (othersTotal > 0)
             {
-                var val = hourData.FirstOrDefault(c => c.WaitCategoryDesc == categories[ci])?.WaitRatio ?? 0;
-                var barH = (val / maxPerHour) * (h - 20);
+                var segH = (othersTotal / maxTotal) * chartH;
+                y -= segH;
                 var rect = new Rectangle
                 {
-                    Width = Math.Max(1, barW - 1),
-                    Height = barH,
-                    Fill = new SolidColorBrush(Color.Parse(waitColors[ci]))
+                    Width = Math.Max(1, stepX - barGap),
+                    Height = Math.Max(0.5, segH),
+                    Fill = new SolidColorBrush(OthersColor),
                 };
-                Canvas.SetLeft(rect, hi * barW);
-                Canvas.SetTop(rect, h - 10 - yOffset - barH);
+                Canvas.SetLeft(rect, x);
+                Canvas.SetTop(rect, y);
                 WaitStatsCanvas.Children.Add(rect);
-                yOffset += barH;
+                ToolTip.SetTip(rect, $"Others: {WaitRatioFormatter.Format(othersTotal)}");
+                ToolTip.SetShowDelay(rect, 200);
             }
         }
 
-        var label = new TextBlock
+        // X-axis labels at day boundaries
+        var labelBrush = new SolidColorBrush(Color.Parse("#E4E6EB"));
+        for (int i = 0; i < n; i++)
         {
-            Text = "Wait Stats (all DBs)",
-            FontSize = 10,
-            Foreground = new SolidColorBrush(Color.Parse("#E4E6EB"))
-        };
-        Canvas.SetLeft(label, 4);
-        Canvas.SetTop(label, 2);
-        WaitStatsCanvas.Children.Add(label);
+            if (allHours[i].Hour == 0)
+            {
+                var xDay = i * stepX;
+                WaitStatsCanvas.Children.Add(new Line
+                {
+                    StartPoint = new Point(xDay, paddingTop),
+                    EndPoint = new Point(xDay, paddingTop + chartH),
+                    Stroke = labelBrush,
+                    StrokeThickness = 1,
+                    StrokeDashArray = [4, 4],
+                    Opacity = 0.3,
+                });
+                var tb = new TextBlock
+                {
+                    Text = TimeDisplayHelper.FormatForDisplay(allHours[i], "MM/dd"),
+                    FontSize = 8,
+                    Foreground = labelBrush,
+                };
+                Canvas.SetLeft(tb, xDay + 2);
+                Canvas.SetTop(tb, h - paddingBottom + 1);
+                WaitStatsCanvas.Children.Add(tb);
+            }
+        }
     }
 
     // ── Bar Chart Cards ─────────────────────────────────────────────────────
 
+    /// <summary>Unified color map: same database → same color across all cards.</summary>
+    private Dictionary<string, Color> _dbColorMap = new();
+
     private void DrawBarCards()
     {
-        DrawMetricRow(TotalMetricsGrid, isTotal: true);
-        DrawMetricRow(AvgMetricsGrid, isTotal: false);
+        // Build a single color map based on top-N by total CPU (union across all databases)
+        _dbColorMap.Clear();
+        var ranked = _metrics
+            .OrderByDescending(m => m.TotalCpu)
+            .Select(m => m.DatabaseName)
+            .ToList();
+        var topDbs = ranked.Take(_topN).ToList();
+        for (int i = 0; i < topDbs.Count && i < Palette.Length; i++)
+            _dbColorMap[topDbs[i]] = Palette[i];
+
+        DrawMetricRow(TotalMetricsGrid, isTotal: true, topDbs);
+        DrawMetricRow(AvgMetricsGrid, isTotal: false, topDbs);
     }
 
-    private void DrawMetricRow(Grid grid, bool isTotal)
+    private void DrawMetricRow(Grid grid, bool isTotal, List<string> topDbs)
     {
         grid.Children.Clear();
         grid.ColumnDefinitions.Clear();
@@ -401,32 +585,15 @@ private void DrawMetricRow(Grid grid, bool isTotal)
         for (int i = 0; i < metricNames.Length; i++)
             grid.ColumnDefinitions.Add(new ColumnDefinition(1, GridUnitType.Star));
 
-        // Get top N databases + others
-        var ranked = GetRankedDatabases(isTotal);
-        var topDbs = ranked.Take(_topN).Select(r => r.db).ToList();
-        var dbColors = new Dictionary<string, Color>();
-        for (int i = 0; i < topDbs.Count && i < Palette.Length; i++)
-            dbColors[topDbs[i]] = Palette[i];
-
         for (int mi = 0; mi < metricNames.Length; mi++)
         {
-            var card = CreateBarCard(metricNames[mi], mi, isTotal, topDbs, dbColors);
+            var card = CreateBarCard(metricNames[mi], mi, isTotal, topDbs, _dbColorMap);
             Grid.SetColumn(card, mi);
             card.Margin = new Thickness(mi == 0 ? 0 : 5, 0, mi == metricNames.Length - 1 ? 0 : 5, 0);
             grid.Children.Add(card);
         }
     }
 
-    private List<(string db, double total)> GetRankedDatabases(bool isTotal)
-    {
-        if (_metrics.Count == 0) return new();
-        // Rank by total CPU
-        return _metrics
-            .Select(m => (m.DatabaseName, isTotal ? m.TotalCpu : m.AvgCpu))
-            .OrderByDescending(x => x.Item2)
-            .ToList();
-    }
-
     private Border CreateBarCard(string title, int metricIndex, bool isTotal,
         List<string> topDbs, Dictionary<string, Color> dbColors)
     {
@@ -505,7 +672,7 @@ private Border CreateBarCard(string title, int metricIndex, bool isTotal,
                 var menu = new ContextMenu();
                 var menuItem = new MenuItem { Header = "Drill Down to DB Query Store" };
                 var dbName = db;
-                menuItem.Click += (_, _) => DrillDownRequested?.Invoke(this, dbName);
+                menuItem.Click += (_, _) => DrillDownRequested?.Invoke(this, new DrillDownEventArgs(dbName, _slicerStartUtc, _slicerEndUtc));
                 menu.Items.Add(menuItem);
                 barContainer.ContextMenu = menu;
             }

From af1f8b8c36002cd8d6ac12ed2c979441abd8fbe5 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 5 May 2026 03:00:57 +0200
Subject: [PATCH 4/8] improve the dashboard

---
 .../Controls/QueryStoreOverviewControl.axaml  |  6 +-
 .../QueryStoreOverviewControl.axaml.cs        | 65 +++++++++++----
 .../Models/QueryStoreOverviewModels.cs        | 13 +++
 .../Services/QueryStoreOverviewService.cs     | 82 ++++++++++++++++++-
 4 files changed, 143 insertions(+), 23 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
index 5c1eceb..deeaafb 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml
@@ -10,9 +10,9 @@
             <RowDefinition Height="2*"/>
         </Grid.RowDefinitions>
 
-        <!-- Row 0: Progress bar -->
-        <ProgressBar x:Name="LoadingBar" Grid.Row="0" IsIndeterminate="True"
-                     Height="3" Margin="0" IsVisible="False"
+        <!-- Row 0: Progress bar (always visible to reserve space, toggle IsIndeterminate) -->
+        <ProgressBar x:Name="LoadingBar" Grid.Row="0" IsIndeterminate="False"
+                     Height="3" Margin="0"
                      Foreground="{DynamicResource AccentBrush}"/>
 
         <!-- Row 1: Donut + TimeSlicer + WaitStats -->
diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 7671a7f..2f8c088 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -31,7 +31,8 @@ public partial class QueryStoreOverviewControl : UserControl
     private List<DatabaseQueryStoreState> _states = new();
     private List<DatabaseMetrics> _metrics = new();
     private List<DatabaseTimeSlice> _timeSlices = new();
-    private List<DatabaseWaitCategoryTimeSlice> _waitSlices = new();
+    private List<DatabaseWaitAmountTimeSlice> _waitSlices = new();
+    private List<string> _activeDbs = new();
 
     private DateTime _slicerStartUtc;
     private DateTime _slicerEndUtc;
@@ -95,7 +96,7 @@ public async Task LoadAsync()
         _cts = new CancellationTokenSource();
         var ct = _cts.Token;
 
-        await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = true);
+        await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsIndeterminate = true);
 
         try
         {
@@ -105,15 +106,15 @@ public async Task LoadAsync()
 
             await Dispatcher.UIThread.InvokeAsync(DrawDonut);
 
-            // Phase 2: Get time slices for active databases
-            var activeDbs = _states
+            // Phase 2: Get time slices for active databases (cache the list)
+            _activeDbs = _states
                 .Where(s => s.State != QueryStoreState.Off)
                 .Select(s => s.DatabaseName).ToList();
 
-            if (activeDbs.Count == 0) return;
+            if (_activeDbs.Count == 0) return;
 
             _timeSlices = await QueryStoreOverviewService.FetchAllTimeSlicesAsync(
-                _masterConnectionString, activeDbs, _daysBack, _maxDop, ct);
+                _masterConnectionString, _activeDbs, _daysBack, _maxDop, ct);
 
             // Consolidate time slices across databases into QueryStoreTimeSlice for the slicer
             var consolidated = _timeSlices
@@ -140,28 +141,31 @@ await Dispatcher.UIThread.InvokeAsync(() =>
         }
         finally
         {
-            await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = false);
+            await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsIndeterminate = false);
         }
     }
 
     private async Task RefreshMetricsAndWaitStatsAsync(CancellationToken ct)
     {
-        var activeDbs = _states
-            .Where(s => s.State != QueryStoreState.Off)
-            .Select(s => s.DatabaseName).ToList();
+        if (_activeDbs.Count == 0) return;
 
-        if (activeDbs.Count == 0) return;
-
-        await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = true);
+        await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsIndeterminate = true);
         try
         {
             _metrics = await QueryStoreOverviewService.FetchAllMetricsAsync(
-            _masterConnectionString, activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
+                _masterConnectionString, _activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
 
             if (_supportsWaitStats)
             {
-                _waitSlices = await QueryStoreOverviewService.FetchAllWaitStatsAsync(
-                    _masterConnectionString, activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
+                var (slices, errors) = await QueryStoreOverviewService.FetchAllWaitStatsWithErrorsAsync(
+                    _masterConnectionString, _activeDbs, _slicerStartUtc, _slicerEndUtc, _maxDop, ct);
+                _waitSlices = slices;
+
+                if (errors.Count > 0)
+                {
+                    await Dispatcher.UIThread.InvokeAsync(() =>
+                        ShowWaitStatsErrors(errors));
+                }
             }
             else
             {
@@ -176,10 +180,37 @@ await Dispatcher.UIThread.InvokeAsync(() =>
         }
         finally
         {
-            await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsVisible = false);
+            await Dispatcher.UIThread.InvokeAsync(() => LoadingBar.IsIndeterminate = false);
         }
     }
 
+    private void ShowWaitStatsErrors(List<(string Database, string Error)> errors)
+    {
+        var msg = string.Join("\n", errors.Select(e => $"[{e.Database}] {e.Error}"));
+        var window = new Avalonia.Controls.Window
+        {
+            Title = "Wait Stats Errors",
+            Width = 600,
+            Height = 300,
+            Content = new ScrollViewer
+            {
+                Content = new TextBlock
+                {
+                    Text = msg,
+                    TextWrapping = Avalonia.Media.TextWrapping.Wrap,
+                    Margin = new Thickness(10),
+                    Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+                    FontSize = 12,
+                }
+            }
+        };
+        var topLevel = TopLevel.GetTopLevel(this);
+        if (topLevel is Avalonia.Controls.Window owner)
+            window.ShowDialog(owner);
+        else
+            window.Show();
+    }
+
     // ── Donut Chart ──────────────────────────────────────────────────────────
 
     private void DrawDonut()
diff --git a/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs b/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
index d87c57b..d32e837 100644
--- a/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
+++ b/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
@@ -71,3 +71,16 @@ public class DatabaseWaitCategoryTimeSlice
     public string WaitCategoryDesc { get; set; } = "";
     public double WaitRatio { get; set; }
 }
+
+/// <summary>
+/// Wait alount time slice tagged with the source database name.
+/// </summary>
+public class DatabaseWaitAmountTimeSlice
+{
+    public string DatabaseName { get; set; } = "";
+    public DateTime IntervalStartUtc { get; set; }
+	public double WaitRatio { get; set; }
+}
+
+
+
diff --git a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
index 3c236a6..0a02d64 100644
--- a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
@@ -120,7 +120,7 @@ public static async Task<List<DatabaseTimeSlice>> FetchAllTimeSlicesAsync(
     /// <summary>
     /// Fetches wait stats ribbon data for active databases in parallel.
     /// </summary>
-    public static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchAllWaitStatsAsync(
+    public static async Task<List<DatabaseWaitAmountTimeSlice>> FetchAllWaitStatsAsync(
         string masterConnectionString,
         List<string> activeDatabases,
         DateTime startUtc,
@@ -128,7 +128,7 @@ public static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchAllWaitStatsA
         int maxDegreeOfParallelism = 8,
         CancellationToken ct = default)
     {
-        var results = new ConcurrentBag<DatabaseWaitCategoryTimeSlice>();
+        var results = new ConcurrentBag<DatabaseWaitAmountTimeSlice>();
         var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
 
         var tasks = activeDatabases.Select(async db =>
@@ -136,7 +136,7 @@ public static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchAllWaitStatsA
             await semaphore.WaitAsync(ct);
             try
             {
-                var slices = await FetchDatabaseWaitStatsAsync(masterConnectionString, db, startUtc, endUtc, ct);
+                var slices = await FetchDatabaseWaitAmountAsync(masterConnectionString, db, startUtc, endUtc, ct);
                 foreach (var s in slices)
                     results.Add(s);
             }
@@ -151,6 +151,44 @@ public static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchAllWaitStatsA
         return results.OrderBy(r => r.IntervalStartUtc).ToList();
     }
 
+    /// <summary>
+    /// Fetches wait stats with error reporting per database.
+    /// </summary>
+    public static async Task<(List<DatabaseWaitAmountTimeSlice> Slices, List<(string Database, string Error)> Errors)> FetchAllWaitStatsWithErrorsAsync(
+        string masterConnectionString,
+        List<string> activeDatabases,
+        DateTime startUtc,
+        DateTime endUtc,
+        int maxDegreeOfParallelism = 8,
+        CancellationToken ct = default)
+    {
+        var results = new ConcurrentBag<DatabaseWaitAmountTimeSlice>();
+        var errors = new ConcurrentBag<(string Database, string Error)>();
+        var semaphore = new SemaphoreSlim(maxDegreeOfParallelism);
+
+        var tasks = activeDatabases.Select(async db =>
+        {
+            await semaphore.WaitAsync(ct);
+            try
+            {
+                var slices = await FetchDatabaseWaitAmountAsync(masterConnectionString, db, startUtc, endUtc, ct);
+                foreach (var s in slices)
+                    results.Add(s);
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
+            {
+                errors.Add((db, ex.Message));
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+        return (results.OrderBy(r => r.IntervalStartUtc).ToList(), errors.ToList());
+    }
+
     // ── Private helpers ──────────────────────────────────────────────────────
 
     private static async Task<List<string>> GetUserDatabasesAsync(
@@ -333,4 +371,42 @@ GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0),
         }
         return rows;
     }
+
+	private static async Task<List<DatabaseWaitAmountTimeSlice>> FetchDatabaseWaitAmountAsync(
+		string masterConnectionString, string database,
+		DateTime startUtc, DateTime endUtc, CancellationToken ct)
+	{
+		var connStr = BuildDbConnectionString(masterConnectionString, database);
+		const string sql = @"
+SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
+SELECT
+    DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
+    1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS wait_ratio
+FROM sys.query_store_wait_stats ws
+JOIN sys.query_store_runtime_stats_interval rsi
+    ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
+WHERE rsi.start_time >= @start AND rsi.start_time < @end
+AND   ws.execution_type = 0
+GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0)
+ORDER BY bucket_hour, wait_ratio;";
+
+		var rows = new List<DatabaseWaitAmountTimeSlice>();
+		await using var conn = new SqlConnection(connStr);
+		await conn.OpenAsync(ct);
+		await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
+		cmd.Parameters.Add(new SqlParameter("@start", startUtc));
+		cmd.Parameters.Add(new SqlParameter("@end", endUtc));
+		await using var reader = await cmd.ExecuteReaderAsync(ct);
+
+		while (await reader.ReadAsync(ct))
+		{
+			rows.Add(new DatabaseWaitAmountTimeSlice
+			{
+				DatabaseName = database,
+				IntervalStartUtc = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc),
+				WaitRatio = reader.GetDouble(3),
+			});
+		}
+		return rows;
+	}
 }

From 35fb7b716ee3a2a1ae3ff656f44451499f5fd17c Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 5 May 2026 03:08:16 +0200
Subject: [PATCH 5/8] fix issue about waits stats on the QS overview

---
 src/PlanViewer.Core/Services/QueryStoreOverviewService.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
index 0a02d64..e1658d9 100644
--- a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
@@ -340,7 +340,7 @@ private static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchDatabaseWait
     DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
     ws.wait_category,
     ws.wait_category_desc,
-    1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS wait_ratio
+    cast(1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS float) AS wait_ratio
 FROM sys.query_store_wait_stats ws
 JOIN sys.query_store_runtime_stats_interval rsi
     ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
@@ -381,7 +381,7 @@ private static async Task<List<DatabaseWaitAmountTimeSlice>> FetchDatabaseWaitAm
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 SELECT
     DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
-    1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS wait_ratio
+    cast(1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS float) AS wait_ratio
 FROM sys.query_store_wait_stats ws
 JOIN sys.query_store_runtime_stats_interval rsi
     ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
@@ -404,7 +404,7 @@ GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0)
 			{
 				DatabaseName = database,
 				IntervalStartUtc = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc),
-				WaitRatio = reader.GetDouble(3),
+				WaitRatio = reader.GetDouble(1),
 			});
 		}
 		return rows;

From 40298011f97d86bc8d9af383121134320cbfcfd5 Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 5 May 2026 08:40:08 +0200
Subject: [PATCH 6/8] fix null on WTR in sql

---
 src/PlanViewer.Core/Services/QueryStoreOverviewService.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
index e1658d9..bd952aa 100644
--- a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
@@ -381,7 +381,7 @@ private static async Task<List<DatabaseWaitAmountTimeSlice>> FetchDatabaseWaitAm
 SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
 SELECT
     DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
-    cast(1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS float) AS wait_ratio
+    cast(COALESCE(1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0),0.0) AS float) AS wait_ratio
 FROM sys.query_store_wait_stats ws
 JOIN sys.query_store_runtime_stats_interval rsi
     ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id

From 353acdb8275b76b6aa8b5ea5621e69e488e95d6a Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 5 May 2026 08:48:20 +0200
Subject: [PATCH 7/8] add evg ref line in waitstats chart

---
 .../QueryStoreOverviewControl.axaml.cs        | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 2f8c088..0fcfcb7 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -483,11 +483,15 @@ private void DrawWaitStatsChart()
 
         // Find max stacked total for Y scaling
         double maxTotal = 0;
+        double totalWaitSum = 0;
+        int bucketsWithData = 0;
         foreach (var hour in allHours)
         {
             if (!hourLookup.TryGetValue(hour, out var items)) continue;
             var total = items.Sum(x => x.Total);
             if (total > maxTotal) maxTotal = total;
+            totalWaitSum += total;
+            bucketsWithData++;
         }
         if (maxTotal <= 0) maxTotal = 1;
 
@@ -581,6 +585,43 @@ private void DrawWaitStatsChart()
                 WaitStatsCanvas.Children.Add(tb);
             }
         }
+
+        // ── Horizontal dashed average line ─────────────────────────────────
+        if (bucketsWithData > 0)
+        {
+            var avgWait = totalWaitSum / bucketsWithData;
+            if (avgWait > 0 && avgWait <= maxTotal)
+            {
+                var avgY = paddingTop + chartH - (avgWait / maxTotal) * chartH;
+                var dashBrush = new SolidColorBrush(Color.Parse("#E4E6EB"));
+                var avgLine = new Line
+                {
+                    StartPoint = new Point(0, avgY),
+                    EndPoint = new Point(w, avgY),
+                    Stroke = dashBrush,
+                    StrokeThickness = 1,
+                    StrokeDashArray = [6, 3],
+                    Opacity = 0.7,
+                };
+                WaitStatsCanvas.Children.Add(avgLine);
+
+                var avgLabel = new Border
+                {
+                    Background = new SolidColorBrush(Color.Parse("#B0D0D0D0")),
+                    CornerRadius = new CornerRadius(3),
+                    Padding = new Thickness(4, 1),
+                    Child = new TextBlock
+                    {
+                        Text = $"avg:{WaitRatioFormatter.Format(avgWait)}",
+                        FontSize = 10,
+                        Foreground = Brushes.Black,
+                    },
+                };
+                Canvas.SetLeft(avgLabel, 2);
+                Canvas.SetTop(avgLabel, Math.Max(0, avgY - 16));
+                WaitStatsCanvas.Children.Add(avgLabel);
+            }
+        }
     }
 
     // ── Bar Chart Cards ─────────────────────────────────────────────────────

From a21a0b10219a8baff33faf1d6422dfe3009d67de Mon Sep 17 00:00:00 2001
From: rferraton <16419423+rferraton@users.noreply.github.com>
Date: Tue, 5 May 2026 14:19:48 +0200
Subject: [PATCH 8/8] =?UTF-8?q?1.=20Dead=20code=20removed=20=E2=80=94=20De?=
 =?UTF-8?q?leted=20FetchDatabaseWaitStatsAsync=20and=20DatabaseWaitCategor?=
 =?UTF-8?q?yTimeSlice=20(no=20callers).=202.=20Bare=20catch=20blocks=20fix?=
 =?UTF-8?q?ed=20=E2=80=94=20All=204=20parallel=20fetch=20methods=20now=20u?=
 =?UTF-8?q?se=20when=20(ex=20is=20not=20OperationCanceledException)=20or?=
 =?UTF-8?q?=20when=20(!ct.IsCancellationRequested)=20so=20cancellation=20p?=
 =?UTF-8?q?ropagates=20correctly.=203.=20Permission=20errors=20surfaced=20?=
 =?UTF-8?q?=E2=80=94=20Added=20QueryStoreState.Error=20enum=20value=20and?=
 =?UTF-8?q?=20ErrorMessage=20property=20to=20DatabaseQueryStoreState.=20Th?=
 =?UTF-8?q?e=20donut=20now=20shows=20a=20red=20"Error"=20segment,=20and=20?=
 =?UTF-8?q?clicking=20it=20lists=20databases=20with=20their=20error=20mess?=
 =?UTF-8?q?ages.=204.=20=5Fcts=20leak=20fixed=20=E2=80=94=20Added=20=5Fcts?=
 =?UTF-8?q?=3F.Dispose()=20before=20every=20reassignment=20in=20LoadAsync(?=
 =?UTF-8?q?)=20and=20OnSlicerRangeChanged(object=3F,=20TimeRangeChangedEve?=
 =?UTF-8?q?ntArgs),=20plus=20a=20DetachedFromVisualTree=20handler=20that?=
 =?UTF-8?q?=20cancels=20and=20disposes=20on=20control=20teardown.=205.=20S?=
 =?UTF-8?q?izeChanged=20race=20fixed=20=E2=80=94=20DrawWaitStatsChart()=20?=
 =?UTF-8?q?now=20returns=20early=20if=20=5FdbColorMap=20is=20empty,=20prev?=
 =?UTF-8?q?enting=20all=20bars=20from=20being=20bucketed=20into=20"Others"?=
 =?UTF-8?q?=20when=20a=20resize=20fires=20before=20DrawBarCards()=20has=20?=
 =?UTF-8?q?run.=206.=20Misnamed=20field=20renamed=20=E2=80=94=20WaitRatio?=
 =?UTF-8?q?=20=E2=86=92=20WaitAmountHours=20on=20DatabaseWaitAmountTimeSli?=
 =?UTF-8?q?ce=20and=20all=20references=20in=20the=20service=20and=20contro?=
 =?UTF-8?q?l.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../QueryStoreOverviewControl.axaml.cs        | 26 ++++++++-
 .../Models/QueryStoreOverviewModels.cs        | 20 ++-----
 .../Services/QueryStoreOverviewService.cs     | 55 ++-----------------
 3 files changed, 34 insertions(+), 67 deletions(-)

diff --git a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
index 0fcfcb7..e355c20 100644
--- a/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
+++ b/src/PlanViewer.App/Controls/QueryStoreOverviewControl.axaml.cs
@@ -57,6 +57,7 @@ public partial class QueryStoreOverviewControl : UserControl
     private static readonly Color ReadWriteColor = Color.Parse("#2EAEF1");  // light blue
     private static readonly Color ReadOnlyColor = Color.Parse("#1A5276");   // dark blue
     private static readonly Color OffColor = Color.Parse("#666666");        // grey
+    private static readonly Color ErrorColor = Color.Parse("#E74C3C");      // red
 
     public class DrillDownEventArgs(string database, DateTime startUtc, DateTime endUtc) : EventArgs
     {
@@ -88,11 +89,19 @@ public QueryStoreOverviewControl(ServerConnection serverConnection,
         };
 
         OverviewTimeSlicer.RangeChanged += OnSlicerRangeChanged;
+
+        this.DetachedFromVisualTree += (_, _) =>
+        {
+            _cts?.Cancel();
+            _cts?.Dispose();
+            _cts = null;
+        };
     }
 
     public async Task LoadAsync()
     {
         _cts?.Cancel();
+        _cts?.Dispose();
         _cts = new CancellationTokenSource();
         var ct = _cts.Token;
 
@@ -108,7 +117,7 @@ public async Task LoadAsync()
 
             // Phase 2: Get time slices for active databases (cache the list)
             _activeDbs = _states
-                .Where(s => s.State != QueryStoreState.Off)
+                .Where(s => s.State == QueryStoreState.ReadWrite || s.State == QueryStoreState.ReadOnly)
                 .Select(s => s.DatabaseName).ToList();
 
             if (_activeDbs.Count == 0) return;
@@ -230,6 +239,7 @@ private void DrawDonut()
         int rwCount = _states.Count(s => s.State == QueryStoreState.ReadWrite);
         int roCount = _states.Count(s => s.State == QueryStoreState.ReadOnly);
         int offCount = _states.Count(s => s.State == QueryStoreState.Off);
+        int errCount = _states.Count(s => s.State == QueryStoreState.Error);
         int total = _states.Count;
         int activeCount = rwCount + roCount;
 
@@ -237,6 +247,7 @@ private void DrawDonut()
         if (rwCount > 0) segmentInfos.Add((rwCount, "Read Write", QueryStoreState.ReadWrite, ReadWriteColor));
         if (roCount > 0) segmentInfos.Add((roCount, "Read Only", QueryStoreState.ReadOnly, ReadOnlyColor));
         if (offCount > 0) segmentInfos.Add((offCount, "OFF", QueryStoreState.Off, OffColor));
+        if (errCount > 0) segmentInfos.Add((errCount, "Error", QueryStoreState.Error, ErrorColor));
 
         double startAngle = -Math.PI / 2;
         foreach (var (count, label, state, color) in segmentInfos)
@@ -305,6 +316,7 @@ private void DrawDonut()
         DrawLegendItem(DonutCanvas, 4, legendY, ReadWriteColor, $"RW: {rwCount}");
         DrawLegendItem(DonutCanvas, 4, legendY + 16, ReadOnlyColor, $"RO: {roCount}");
         DrawLegendItem(DonutCanvas, 4, legendY + 32, OffColor, $"OFF: {offCount}");
+        if (errCount > 0) DrawLegendItem(DonutCanvas, 4, legendY + 48, ErrorColor, $"Err: {errCount}");
     }
 
     private void ShowDonutPopup(QueryStoreState state)
@@ -314,6 +326,7 @@ private void ShowDonutPopup(QueryStoreState state)
         {
             QueryStoreState.ReadWrite => "Read Write",
             QueryStoreState.ReadOnly => "Read Only",
+            QueryStoreState.Error => "Error",
             _ => "OFF"
         };
 
@@ -329,11 +342,15 @@ private void ShowDonutPopup(QueryStoreState state)
 
         foreach (var db in dbs)
         {
+            var text = db.DatabaseName;
+            if (db.State == QueryStoreState.Error && !string.IsNullOrEmpty(db.ErrorMessage))
+                text += $" — {db.ErrorMessage}";
             stack.Children.Add(new TextBlock
             {
-                Text = db.DatabaseName,
+                Text = text,
                 FontSize = 11,
                 Foreground = new SolidColorBrush(Color.Parse("#E4E6EB")),
+                TextWrapping = Avalonia.Media.TextWrapping.Wrap,
             });
         }
 
@@ -422,6 +439,7 @@ private async void OnSlicerRangeChanged(object? sender, TimeRangeChangedEventArg
         _slicerEndUtc = e.EndUtc;
 
         _cts?.Cancel();
+        _cts?.Dispose();
         _cts = new CancellationTokenSource();
         try
         {
@@ -451,6 +469,8 @@ private void DrawWaitStatsChart()
             return;
         }
 
+        if (_dbColorMap.Count == 0) return; // not yet initialized by DrawBarCards
+
         var w = WaitStatsBorder.Bounds.Width;
         var h = WaitStatsBorder.Bounds.Height;
         if (w < 10 || h < 10) return;
@@ -463,7 +483,7 @@ private void DrawWaitStatsChart()
         // Consolidate: sum ALL wait ratios per database per hour (ignore wait category)
         var dbHourData = _waitSlices
             .GroupBy(s => new { s.DatabaseName, s.IntervalStartUtc })
-            .Select(g => (Db: g.Key.DatabaseName, Hour: g.Key.IntervalStartUtc, Total: g.Sum(x => x.WaitRatio)))
+            .Select(g => (Db: g.Key.DatabaseName, Hour: g.Key.IntervalStartUtc, Total: g.Sum(x => x.WaitAmountHours)))
             .ToList();
 
         if (dbHourData.Count == 0) return;
diff --git a/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs b/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
index d32e837..0b588f2 100644
--- a/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
+++ b/src/PlanViewer.Core/Models/QueryStoreOverviewModels.cs
@@ -10,7 +10,8 @@ public enum QueryStoreState
 {
     Off,
     ReadOnly,
-    ReadWrite
+    ReadWrite,
+    Error
 }
 
 /// <summary>
@@ -20,6 +21,7 @@ public class DatabaseQueryStoreState
 {
     public string DatabaseName { get; set; } = "";
     public QueryStoreState State { get; set; }
+    public string? ErrorMessage { get; set; }
 }
 
 /// <summary>
@@ -61,25 +63,13 @@ public class DatabaseTimeSlice
 }
 
 /// <summary>
-/// Wait stats time slice tagged with the source database name.
-/// </summary>
-public class DatabaseWaitCategoryTimeSlice
-{
-    public string DatabaseName { get; set; } = "";
-    public DateTime IntervalStartUtc { get; set; }
-    public int WaitCategory { get; set; }
-    public string WaitCategoryDesc { get; set; } = "";
-    public double WaitRatio { get; set; }
-}
-
-/// <summary>
-/// Wait alount time slice tagged with the source database name.
+/// Wait amount time slice tagged with the source database name.
 /// </summary>
 public class DatabaseWaitAmountTimeSlice
 {
     public string DatabaseName { get; set; } = "";
     public DateTime IntervalStartUtc { get; set; }
-	public double WaitRatio { get; set; }
+	public double WaitAmountHours { get; set; }
 }
 
 
diff --git a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
index bd952aa..dedf2cf 100644
--- a/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
+++ b/src/PlanViewer.Core/Services/QueryStoreOverviewService.cs
@@ -34,9 +34,9 @@ public static async Task<List<DatabaseQueryStoreState>> FetchAllStatesAsync(
                 var state = await GetQueryStoreStateAsync(masterConnectionString, db, ct);
                 results.Add(new DatabaseQueryStoreState { DatabaseName = db, State = state });
             }
-            catch
+            catch (Exception ex) when (ex is not OperationCanceledException)
             {
-                results.Add(new DatabaseQueryStoreState { DatabaseName = db, State = QueryStoreState.Off });
+                results.Add(new DatabaseQueryStoreState { DatabaseName = db, State = QueryStoreState.Error, ErrorMessage = ex.Message });
             }
             finally
             {
@@ -70,7 +70,7 @@ public static async Task<List<DatabaseMetrics>> FetchAllMetricsAsync(
                 var metrics = await FetchDatabaseMetricsAsync(masterConnectionString, db, startUtc, endUtc, ct);
                 results.Add(metrics);
             }
-            catch
+            catch (Exception ex) when (ex is not OperationCanceledException)
             {
                 results.Add(new DatabaseMetrics { DatabaseName = db });
             }
@@ -106,7 +106,7 @@ public static async Task<List<DatabaseTimeSlice>> FetchAllTimeSlicesAsync(
                 foreach (var s in slices)
                     results.Add(s);
             }
-            catch { /* skip database on error */ }
+            catch (Exception) when (!ct.IsCancellationRequested) { /* skip database on error */ }
             finally
             {
                 semaphore.Release();
@@ -140,7 +140,7 @@ public static async Task<List<DatabaseWaitAmountTimeSlice>> FetchAllWaitStatsAsy
                 foreach (var s in slices)
                     results.Add(s);
             }
-            catch { /* skip database on error */ }
+            catch (Exception) when (!ct.IsCancellationRequested) { /* skip database on error */ }
             finally
             {
                 semaphore.Release();
@@ -329,49 +329,6 @@ GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0)
         return rows;
     }
 
-    private static async Task<List<DatabaseWaitCategoryTimeSlice>> FetchDatabaseWaitStatsAsync(
-        string masterConnectionString, string database,
-        DateTime startUtc, DateTime endUtc, CancellationToken ct)
-    {
-        var connStr = BuildDbConnectionString(masterConnectionString, database);
-        const string sql = @"
-SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
-SELECT
-    DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0) AS bucket_hour,
-    ws.wait_category,
-    ws.wait_category_desc,
-    cast(1.0 * SUM(ws.total_query_wait_time_ms) / (3600.0 * 1000.0) AS float) AS wait_ratio
-FROM sys.query_store_wait_stats ws
-JOIN sys.query_store_runtime_stats_interval rsi
-    ON ws.runtime_stats_interval_id = rsi.runtime_stats_interval_id
-WHERE rsi.start_time >= @start AND rsi.start_time < @end
-AND   ws.execution_type = 0
-GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0),
-         ws.wait_category, ws.wait_category_desc
-ORDER BY bucket_hour, wait_ratio DESC;";
-
-        var rows = new List<DatabaseWaitCategoryTimeSlice>();
-        await using var conn = new SqlConnection(connStr);
-        await conn.OpenAsync(ct);
-        await using var cmd = new SqlCommand(sql, conn) { CommandTimeout = 120 };
-        cmd.Parameters.Add(new SqlParameter("@start", startUtc));
-        cmd.Parameters.Add(new SqlParameter("@end", endUtc));
-        await using var reader = await cmd.ExecuteReaderAsync(ct);
-
-        while (await reader.ReadAsync(ct))
-        {
-            rows.Add(new DatabaseWaitCategoryTimeSlice
-            {
-                DatabaseName = database,
-                IntervalStartUtc = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc),
-                WaitCategory = reader.GetInt16(1),
-                WaitCategoryDesc = reader.GetString(2),
-                WaitRatio = reader.GetDouble(3),
-            });
-        }
-        return rows;
-    }
-
 	private static async Task<List<DatabaseWaitAmountTimeSlice>> FetchDatabaseWaitAmountAsync(
 		string masterConnectionString, string database,
 		DateTime startUtc, DateTime endUtc, CancellationToken ct)
@@ -404,7 +361,7 @@ GROUP BY DATEADD(HOUR, DATEDIFF(HOUR, 0, rsi.start_time), 0)
 			{
 				DatabaseName = database,
 				IntervalStartUtc = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc),
-				WaitRatio = reader.GetDouble(1),
+				WaitAmountHours = reader.GetDouble(1),
 			});
 		}
 		return rows;