perf: fetch table indexes for a schema in one query, not one per table

`enrichColumnsWithKeyAndIndexMetadata` called `getTableIndexes` once per
table inside its loop. On a wide schema that is hundreds of serial round
trips, and it re-runs for every caller that misses the `databaseObjects`
cache.

Measured on a 567-table MySQL connection reached over an SSH tunnel,
`GET /api/connections/{id}/objects`:

    before   152.66s / 196.30s on cache miss (~270ms per table)
    after      1.09s - 1.50s on cache miss
    cached     0.03-0.48s (unchanged)

Both pre-fix requests were abandoned by the client (nginx 499). Because
there is no stampede guard, a second caller arriving during the first
sweep starts its own full sweep, so retrying made it worse.

The fix mirrors what `loadForeignKeyColumns` already does one line above:
fetch the whole schema once and group in memory. Adds
`IntrospectionProvider.getAllTableIndexes` with a default implementation
that loops the existing per-table method, so a provider that does not
override it is unchanged, plus overrides for both shipped providers:

- MySQL: one INFORMATION_SCHEMA.STATISTICS query scoped to a single
  TABLE_SCHEMA, so it stays bounded on a server hosting many databases.
- Postgres: the same joins and filters as the per-table query, with
  `t.relname = ANY(?)` in place of `t.relname = ?`. Matching bare relnames
  across schemas is deliberate — it is what the per-table path already does
  for an unqualified name.

Behaviour preserved:
- Tables with no indexes map to an empty list, so callers can distinguish
  "no indexes" from "not scanned" without a per-table fallback.
- Objects qualified with a schema other than the connection database still
  take the per-table path, since the bulk query covers a single schema.
- A failed bulk fetch logs and falls back rather than dropping index flags.

Verification. The Postgres form was diffed against the per-table form on a
live database with EXCEPT ALL in both directions: 744 rows each, zero rows
differing either way, composite index column order preserved. Both engines
were then exercised end to end with index flags still populated (MySQL: 760
columns with a single-column index and 375 composite, of 4588; Postgres: 32
and 2, of 128) and no fallback warnings logged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013dSdoA8UGq7PVyvEwWjPXM

Author: geekypunk

backend/src/main/java/com/dbaagent/provider/api/IntrospectionProvider.java

@@ -4,7 +4,10 @@
 
 import java.sql.Connection;
 import java.sql.SQLException;
+import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 /**
@@ -48,6 +51,44 @@ public interface IntrospectionProvider {
      */
     List<TableIndex> getTableIndexes(Connection connection, String database, String tableName) throws SQLException;
 
+    /**
+     * Get indexes for every table in a schema in one round trip.
+     *
+     * <p>The per-table {@link #getTableIndexes} above is a round trip each, which turns
+     * enrichment of a wide schema into hundreds of serial queries — painful on any link
+     * with real latency (an SSH tunnel to a replica, say). This mirrors what
+     * {@link #getForeignKeys} already does for constraints: fetch the whole schema once
+     * and group in memory.
+     *
+     * <p>Keys are lower-cased bare table names. A table that exists but has no indexes
+     * maps to an empty list, so callers can tell "no indexes" from "not scanned" and do
+     * not need a per-table fallback for the empty case.
+     *
+     * <p>The default implementation just loops {@link #getTableIndexes}, so a provider
+     * that does not override this behaves exactly as before.
+     *
+     * @param connection The database connection
+     * @param database The database/schema name
+     * @param tableNames Tables the caller cares about (used only by the default fallback)
+     * @return Map of lower-cased table name to that table's indexes
+     * @throws SQLException If a database error occurs
+     */
+    default Map<String, List<TableIndex>> getAllTableIndexes(
+        Connection connection, String database, Collection<String> tableNames
+    ) throws SQLException {
+        Map<String, List<TableIndex>> byTable = new HashMap<>();
+        for (String tableName : tableNames) {
+            if (tableName == null) {
+                continue;
+            }
+            byTable.put(
+                tableName.toLowerCase(Locale.ROOT),
+                getTableIndexes(connection, database, tableName)
+            );
+        }
+        return byTable;
+    }
+
     /**
      * Get table statistics (size, row count, etc.).
      * @param connection The database connection

backend/src/main/java/com/dbaagent/provider/mysql/MySQLIntrospectionProvider.java

@@ -148,6 +148,80 @@ public List<ColumnInfo> getTableColumns(Connection connection, String database,
         return columns;
     }
 
+    /**
+     * One query for the whole schema instead of one per table.
+     *
+     * <p>INFORMATION_SCHEMA.STATISTICS is not cheap on MySQL, and paying for it 567 times
+     * in a row across a tunnel is what made schema enrichment take minutes. Scoped to a
+     * single TABLE_SCHEMA so this stays bounded on servers hosting many databases.
+     */
+    @Override
+    public Map<String, List<TableIndex>> getAllTableIndexes(
+        Connection connection, String database, Collection<String> tableNames
+    ) throws SQLException {
+        String query = """
+            SELECT TABLE_NAME, INDEX_NAME, COLUMN_NAME, NON_UNIQUE, INDEX_TYPE, SEQ_IN_INDEX
+            FROM INFORMATION_SCHEMA.STATISTICS
+            WHERE TABLE_SCHEMA = ?
+            ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
+            """;
+
+        // table -> index name -> index, so multi-column indexes accumulate their columns
+        // in SEQ_IN_INDEX order the same way the per-table path builds them.
+        Map<String, Map<String, TableIndex>> byTable = new HashMap<>();
+
+        try (PreparedStatement stmt = connection.prepareStatement(query)) {
+            stmt.setString(1, database);
+            stmt.setFetchSize(fetchSize);
+            stmt.setQueryTimeout(queryTimeoutSeconds);
+
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String tableName = rs.getString("TABLE_NAME");
+                    if (tableName == null) {
+                        continue;
+                    }
+                    String indexName = rs.getString("INDEX_NAME");
+                    String columnName = rs.getString("COLUMN_NAME");
+                    boolean nonUnique = rs.getBoolean("NON_UNIQUE");
+                    String indexType = rs.getString("INDEX_TYPE");
+
+                    Map<String, TableIndex> indexMap =
+                        byTable.computeIfAbsent(tableName.toLowerCase(Locale.ROOT), k -> new LinkedHashMap<>());
+
+                    TableIndex index = indexMap.get(indexName);
+                    if (index == null) {
+                        index = new TableIndex();
+                        index.setName(indexName);
+                        index.setType(indexType);
+                        index.setUnique(!nonUnique);
+                        index.setPrimary("PRIMARY".equals(indexName));
+                        index.setColumns(new ArrayList<>());
+                        indexMap.put(indexName, index);
+                    }
+                    index.getColumns().add(columnName);
+                }
+            }
+        }
+
+        // Tables with no indexes at all must still be present, so callers can tell an
+        // unindexed table from one this scan never covered.
+        Map<String, List<TableIndex>> result = new HashMap<>();
+        for (String tableName : tableNames) {
+            if (tableName == null) {
+                continue;
+            }
+            // Callers look up by the name they passed in, but STATISTICS returns bare
+            // TABLE_NAMEs — so match on the bare name and key the result by the original.
+            String key = tableName.toLowerCase(Locale.ROOT);
+            int dot = key.lastIndexOf('.');
+            String bare = dot > 0 ? key.substring(dot + 1) : key;
+            Map<String, TableIndex> indexMap = byTable.get(bare);
+            result.put(key, indexMap == null ? new ArrayList<>() : new ArrayList<>(indexMap.values()));
+        }
+        return result;
+    }
+
     @Override
     public List<TableIndex> getTableIndexes(Connection connection, String database, String tableName) throws SQLException {
         List<TableIndex> indexes = new ArrayList<>();

backend/src/main/java/com/dbaagent/provider/postgres/PostgresIntrospectionProvider.java

@@ -211,6 +211,93 @@ LEFT JOIN (
         return columns;
     }
 
+    /**
+     * One query for every requested table instead of one per table.
+     *
+     * <p>Same joins and filters as the per-table variant below; only the predicate
+     * changes, from a single relname to an array of them. Matching on bare relname
+     * across schemas is deliberate — it is exactly what the per-table path does for an
+     * unqualified name, so this stays behaviour-preserving. Schema-qualified names are
+     * left to the per-table path by the caller.
+     */
+    @Override
+    public Map<String, List<TableIndex>> getAllTableIndexes(
+        Connection connection, String database, Collection<String> tableNames
+    ) throws SQLException {
+        String query = """
+            SELECT
+                t.relname AS table_name,
+                i.relname AS index_name,
+                a.attname AS column_name,
+                ix.indisunique AS is_unique,
+                ix.indisprimary AS is_primary,
+                am.amname AS index_type
+            FROM pg_class t
+            JOIN pg_namespace n ON n.oid = t.relnamespace
+            JOIN pg_index ix ON t.oid = ix.indrelid
+            JOIN pg_class i ON i.oid = ix.indexrelid
+            JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+            JOIN pg_am am ON i.relam = am.oid
+            WHERE t.relkind IN ('r', 'p', 'm', 'v')
+              AND t.relname = ANY(?)
+            ORDER BY t.relname, i.relname, a.attnum
+            """;
+
+        Map<String, Map<String, TableIndex>> byTable = new HashMap<>();
+        String[] names = tableNames.stream()
+            .filter(Objects::nonNull)
+            .toArray(String[]::new);
+
+        try (PreparedStatement stmt = connection.prepareStatement(query)) {
+            stmt.setArray(1, connection.createArrayOf("text", names));
+            if (fetchSize > 0) {
+                stmt.setFetchSize(fetchSize);
+            }
+            stmt.setQueryTimeout(queryTimeoutSeconds);
+
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String tableName = rs.getString("table_name");
+                    if (tableName == null) {
+                        continue;
+                    }
+                    String indexName = rs.getString("index_name");
+                    String columnName = rs.getString("column_name");
+                    boolean isUnique = rs.getBoolean("is_unique");
+                    boolean isPrimary = rs.getBoolean("is_primary");
+                    String indexType = rs.getString("index_type");
+
+                    Map<String, TableIndex> indexMap =
+                        byTable.computeIfAbsent(tableName.toLowerCase(Locale.ROOT), k -> new LinkedHashMap<>());
+
+                    TableIndex index = indexMap.get(indexName);
+                    if (index == null) {
+                        index = new TableIndex();
+                        index.setName(indexName);
+                        index.setType(indexType);
+                        index.setUnique(isUnique);
+                        index.setPrimary(isPrimary);
+                        index.setColumns(new ArrayList<>());
+                        indexMap.put(indexName, index);
+                    }
+                    index.getColumns().add(columnName);
+                }
+            }
+        }
+
+        // Every requested table gets an entry, so an unindexed table is distinguishable
+        // from one this scan did not cover.
+        Map<String, List<TableIndex>> result = new HashMap<>();
+        for (String tableName : names) {
+            String key = tableName.toLowerCase(Locale.ROOT);
+            int dot = key.lastIndexOf('.');
+            String bare = dot > 0 ? key.substring(dot + 1) : key;
+            Map<String, TableIndex> indexMap = byTable.get(bare);
+            result.put(key, indexMap == null ? new ArrayList<>() : new ArrayList<>(indexMap.values()));
+        }
+        return result;
+    }
+
     @Override
     public List<TableIndex> getTableIndexes(Connection connection, String database, String tableName) throws SQLException {
         List<TableIndex> indexes = new ArrayList<>();

backend/src/main/java/com/dbaagent/service/QueryExecutorService.java

@@ -170,6 +170,40 @@ private void enrichColumnsWithKeyAndIndexMetadata(
                 ? loadForeignKeyColumns(connection, connRequest.getDatabase(), provider, connectionId)
                 : Collections.emptySet();
 
+            // Indexes for every table up front, in one round trip. Fetching them
+            // table-by-table inside the loop below meant one query per table — on a
+            // 567-table schema behind a tunnel that was minutes, and it ran again for
+            // every caller that missed the cache.
+            //
+            // Only unqualified names, or ones qualified with this connection's own
+            // database, are covered: the bulk query is scoped to a single schema, so a
+            // `otherdb.orders` object still takes the per-table path below and keeps
+            // reading from the schema it names.
+            Map<String, List<TableIndex>> indexesByTable = Collections.emptyMap();
+            if (connection != null && provider != null) {
+                List<String> bulkTables = new ArrayList<>();
+                for (DatabaseObject obj : objects) {
+                    if (isBulkIndexable(obj, connRequest.getDatabase())) {
+                        bulkTables.add(obj.getName());
+                    }
+                }
+                if (!bulkTables.isEmpty()) {
+                    try {
+                        indexesByTable = provider.getAllTableIndexes(
+                            connection, connRequest.getDatabase(), bulkTables
+                        );
+                    } catch (Exception e) {
+                        // Fall back to the per-table path rather than losing index flags.
+                        log.warn(
+                            "Bulk index fetch failed for connection {} ({}); falling back to per-table",
+                            connectionId,
+                            e.getMessage()
+                        );
+                        indexesByTable = Collections.emptyMap();
+                    }
+                }
+            }
+
             for (DatabaseObject obj : objects) {
                 if (obj.getColumns() == null || obj.getColumns().isEmpty()) {
                     continue;
@@ -181,9 +215,13 @@ private void enrichColumnsWithKeyAndIndexMetadata(
                     && obj.getType() != null
                     && "table".equalsIgnoreCase(obj.getType())) {
                     try {
-                        List<TableIndex> indexes = provider.getTableIndexes(
-                            connection, connRequest.getDatabase(), obj.getName()
-                        );
+                        String key = obj.getName().toLowerCase(Locale.ROOT);
+                        List<TableIndex> indexes = indexesByTable.get(key);
+                        if (indexes == null) {
+                            indexes = provider.getTableIndexes(
+                                connection, connRequest.getDatabase(), obj.getName()
+                            );
+                        }
                         applyIndexFlags(obj, indexes);
                     } catch (Exception e) {
                         log.debug(
@@ -240,6 +278,22 @@ private Set<String> loadForeignKeyColumns(
         return fkColumns;
     }
 
+    /**
+     * True when the bulk (single-schema) index fetch can answer for this object.
+     * A name qualified with a different schema must not be answered from the
+     * connection database's index list.
+     */
+    private boolean isBulkIndexable(DatabaseObject obj, String database) {
+        if (obj == null || obj.getName() == null || !"table".equalsIgnoreCase(obj.getType())) {
+            return false;
+        }
+        int dot = obj.getName().lastIndexOf('.');
+        if (dot <= 0) {
+            return true;
+        }
+        return obj.getName().substring(0, dot).equalsIgnoreCase(database);
+    }
+
     private void applyIndexFlags(DatabaseObject obj, List<TableIndex> indexes) {
         if (indexes == null || indexes.isEmpty()) {
             return;