Index Analysis connects to the database it analyses on Azure

Lite/Controls/FinOpsTab.xaml.cs

@@ -960,11 +960,51 @@ private async void RunIndexAnalysis_Click(object sender, RoutedEventArgs e)
 
         try
         {
-            var utilityConnectionString = _credentialResolver.GetUtilityConnectionString(server);
+            var databaseNameEarly = IndexAnalysisDatabaseInput.Text?.Trim();
+            var allDatabasesEarly = IndexAnalysisAllDatabases.IsChecked == true;
+
+            /* #2407: Azure SQL Database has no cross-database execution, so the Utility DB idea — install
+               sp_IndexCleanup once and point it at any database on the server — cannot work there. The proc
+               runs INSIDE whichever database the connection opened, and @database_name asks it to read
+               another one, which Azure refuses. Reported as "set Utility DB to db1, analysing db1 works,
+               analysing db2 says no valid database" — the proc's own message, which reads like the database
+               is missing rather than unreachable.
+
+               So on Azure the connection targets the database being ANALYSED, not the utility database: the
+               proc has to be installed in each database anyway (which is what the reporter found by
+               experiment), and pointing at the target is the only shape that can work. */
+            var properties = _dataService == null
+                ? null
+                : await _dataService.GetLatestServerPropertiesAsync(GetSelectedServerId());
+            var isAzureSqlDb = properties?.EngineEdition == 5;
+
+            if (isAzureSqlDb && allDatabasesEarly)
+            {
+                /* Enumerating every database from one connection is the same cross-database read, so All
+                   Databases cannot work on Azure either — and failing per-database would half-fill the grid
+                   with whichever database the connection happened to open. */
+                IndexAnalysisStatusText.Text =
+                    "Azure SQL Database cannot analyse across databases — clear \u201CAll Databases\u201D and name one, "
+                    + "with sp_IndexCleanup installed in it.";
+                return;
+            }
+
+            var utilityConnectionString = isAzureSqlDb && !string.IsNullOrWhiteSpace(databaseNameEarly)
+                ? _credentialResolver.GetConnectionStringForDatabase(server, databaseNameEarly!)
+                : _credentialResolver.GetUtilityConnectionString(server);
 
             var exists = await LocalDataService.CheckSpIndexCleanupExistsAsync(utilityConnectionString);
             if (!exists)
             {
+                /* On Azure the proc must live in the target database, so name it — "not installed" against a
+                   server with 50 databases is not actionable without saying which one was checked. */
+                if (isAzureSqlDb && !string.IsNullOrWhiteSpace(databaseNameEarly))
+                {
+                    IndexAnalysisStatusText.Text =
+                        $"sp_IndexCleanup is not installed in [{databaseNameEarly}]. Azure SQL Database cannot run it "
+                        + "from another database, so it must be installed in each database you analyse.";
+                }
+
                 IndexAnalysisNotInstalledMessage.Visibility = Visibility.Visible;
                 IndexAnalysisNoDataMessage.Visibility = Visibility.Collapsed;
                 _indexSummaryFilterMgr!.UpdateData(new List<IndexCleanupSummaryRow>());
@@ -977,8 +1017,8 @@ private async void RunIndexAnalysis_Click(object sender, RoutedEventArgs e)
             RunIndexAnalysisButton.IsEnabled = false;
             IndexAnalysisStatusText.Text = "Running analysis...";
 
-            var databaseName = IndexAnalysisDatabaseInput.Text?.Trim();
-            var getAllDatabases = IndexAnalysisAllDatabases.IsChecked == true;
+            var databaseName = databaseNameEarly;
+            var getAllDatabases = allDatabasesEarly;
 
             var (details, summaries) = await LocalDataService.RunIndexAnalysisAsync(
                 utilityConnectionString,

Lite/Models/ServerConnection.cs

@@ -371,6 +371,33 @@ public static string ResolveUtilityConnectionString(
         return builder.ConnectionString;
     }
 
+    /// <summary>
+    /// Like <see cref="ResolveConnectionString"/> but targets an explicitly named database (#2407).
+    ///
+    /// <para>Separate from <see cref="ResolveUtilityConnectionString"/> because it answers a different
+    /// question. That one asks "where is the community proc installed" and is a per-server setting; this one
+    /// asks "which database must the connection be opened in for the read to be legal", which on Azure SQL
+    /// Database is always the database being read — it has no cross-database execution, so a proc taking a
+    /// @database_name parameter can only ever be handed its own.</para>
+    /// </summary>
+    public static string ResolveConnectionStringForDatabase(
+        ServerConnection server,
+        string databaseName,
+        CredentialService credentialService,
+        IProfileLookup? profileLookup)
+    {
+        var baseConnStr = ResolveConnectionString(server, credentialService, profileLookup);
+
+        if (string.IsNullOrWhiteSpace(databaseName))
+            return baseConnStr;
+
+        var builder = new SqlConnectionStringBuilder(baseConnStr)
+        {
+            InitialCatalog = databaseName
+        };
+        return builder.ConnectionString;
+    }
+
     /// <summary>
     /// Builds the connection string with the given credentials.
     /// Used by tests for the server-self shape; production paths go through

Lite/Services/CredentialResolver.cs

@@ -51,6 +51,14 @@ public string GetConnectionString(ServerConnection server)
     public string GetUtilityConnectionString(ServerConnection server)
         => ServerConnection.ResolveUtilityConnectionString(server, _credentialService, _profileLookup);
 
+    /// <summary>
+    /// Resolves a connection string targeting a NAMED database rather than the server's configured default
+    /// or utility database (#2407). Azure SQL Database has no cross-database execution, so a proc that reads
+    /// a database has to be run from inside it — the Utility DB indirection cannot apply there.
+    /// </summary>
+    public string GetConnectionStringForDatabase(ServerConnection server, string databaseName)
+        => ServerConnection.ResolveConnectionStringForDatabase(server, databaseName, _credentialService, _profileLookup);
+
     /// <summary>
     /// Profile-aware stored-credential check (N-1).
     /// </summary>

Lite/Windows/AddServerDialog.xaml

@@ -153,7 +153,7 @@
             <StackPanel Orientation="Horizontal" Margin="0,6,0,0">
                 <TextBlock Text="Utility DB:" Foreground="{DynamicResource ForegroundBrush}" VerticalAlignment="Center" Width="80"/>
                 <TextBox x:Name="UtilityDatabaseBox" Width="250"
-                         ToolTip="Database where community stored procedures (sp_IndexCleanup) are installed. Leave empty to use the connection database."/>
+                         ToolTip="Database where community stored procedures (sp_IndexCleanup) are installed. Leave empty to use the connection database.&#10;&#10;Ignored on Azure SQL Database (#2407): it has no cross-database execution, so a procedure can only read the database it runs in. Install sp_IndexCleanup in each database you want to analyse; Index Analysis connects to the named database directly."/>
             </StackPanel>
             <CheckBox x:Name="ReadOnlyIntentCheckBox" Content="Read-_only intent (for AG listeners and readable replicas)"
                       Foreground="{DynamicResource ForegroundBrush}" Margin="0,6,0,0"