fix(postgres): make a schema switch visible instead of silent

Postgres ships `search_path = "$user", public` everywhere, RDS and Aurora
included, and the "$user" entry is inert only while no schema matches the
connecting role's name. Create one — per-tenant layouts, or the per-user pattern
the Postgres docs recommend and which spread after PG15 hardened `public` — and
current_schema() silently becomes that schema.

Verified on a stock instance:

  SHOW search_path;         ->  "$user", public
  SELECT current_schema();  ->  public
  CREATE SCHEMA postgres;   -- schema named after the connecting role
  SELECT current_schema();  ->  postgres

So a connection that had been reading `public` can start reading an empty user
schema and report a healthy, empty brain — the exact failure the search_path
change was written to fix, inverted. resolveSchema()'s fallback does not catch
it, because current_schema() returned a perfectly valid schema.

Two guards, both diagnostic only:

- announceSchema() logs the schema at INFO when it is not `public`, and DEBUG
  when it is, so the unchanged historical case stays quiet while a switch is
  always on the record. Called from getDatabaseObjects and scanSchema rather
  than from resolveSchema, which runs once per table via getTableColumns — a log
  there would emit a line per table.
- warnIfEmptyWhilePublicHasTables() fires on the fingerprint of an accidental
  "$user" match: nothing found in the resolved schema while `public`, where this
  provider used to look unconditionally, still holds tables. It names the
  ALTER ROLE ... SET search_path remedy. Best-effort; a failed count never
  breaks introspection.

Default RDS/Aurora installs are unaffected either way: with no role-named schema
current_schema() is `public`, exactly as before.

Author: geekypunk

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

@@ -77,6 +77,7 @@ private List<DatabaseObject> getTablesAndViews(Connection connection) throws SQL
             """;
 
         String schema = resolveSchema(connection);
+        announceSchema(schema);
 
         try (Statement stmt = connection.createStatement();
              ResultSet rs = stmt.executeQuery(query)) {
@@ -93,6 +94,7 @@ private List<DatabaseObject> getTablesAndViews(Connection connection) throws SQL
                 objects.add(obj);
             }
         }
+        warnIfEmptyWhilePublicHasTables(connection, schema, objects.size());
         return objects;
     }
 
@@ -318,6 +320,7 @@ public SchemaMetadata scanSchema(Connection connection, String database) throws
 
         Map<String, TableMetadata> tableMap = new HashMap<>();
         String schemaName = resolveSchema(connection);
+        announceSchema(schemaName);
 
         try (Statement stmt = connection.createStatement()) {
             applyStatementSettings(stmt);
@@ -338,6 +341,8 @@ public SchemaMetadata scanSchema(Connection connection, String database) throws
             }
         }
 
+        warnIfEmptyWhilePublicHasTables(connection, schemaName, schema.getTables().size());
+
         // Batch load all columns and indexes in single queries (eliminates N+1)
         scanPostgreSQLColumnsBatch(connection, tableMap);
         scanPostgreSQLIndexesBatch(connection, tableMap);
@@ -808,6 +813,65 @@ private String resolveSchema(Connection connection) {
         return DEFAULT_SCHEMA;
     }
 
+    /**
+     * Say which schema this pass is reading, so a switch is never silent.
+     *
+     * <p>Postgres ships {@code search_path = "$user", public} everywhere, RDS and
+     * Aurora included. The {@code "$user"} entry is inert only while no schema
+     * matches the connecting role's name — create one (per-tenant layouts, or the
+     * per-user pattern the Postgres docs recommend and which spread after PG15
+     * hardened {@code public}) and {@code current_schema()} silently becomes that
+     * schema. A connection that had been reading {@code public} would then read an
+     * empty user schema and report a healthy, empty brain: the very failure this
+     * class was changed to fix, inverted.
+     *
+     * <p>Logged at INFO only when it is not {@code public}, because {@code public}
+     * is the unchanged historical case and every connection would otherwise emit a
+     * line per introspection pass.
+     *
+     * <p>Called from the two pass-level entry points rather than from
+     * {@link #resolveSchema}, which runs once per table via
+     * {@link #getTableColumns} — logging there would produce one line per table.
+     */
+    private void announceSchema(String schema) {
+        if (!DEFAULT_SCHEMA.equals(schema)) {
+            log.info("Introspecting schema '{}' (from the session search_path, not '{}')",
+                schema, DEFAULT_SCHEMA);
+        } else {
+            log.debug("Introspecting schema '{}'", schema);
+        }
+    }
+
+    /**
+     * Warn on the fingerprint of an accidental schema switch: nothing found here,
+     * while {@code public} — where this provider used to look unconditionally —
+     * still holds tables.
+     *
+     * <p>Without this the outcome is a successful-looking run over an empty schema.
+     * Best-effort: a failure to count is never allowed to break introspection.
+     */
+    private void warnIfEmptyWhilePublicHasTables(Connection connection, String schema, int found) {
+        if (found > 0 || DEFAULT_SCHEMA.equals(schema)) {
+            return;
+        }
+        try (PreparedStatement stmt = connection.prepareStatement(
+                "SELECT count(*) FROM pg_tables WHERE schemaname = ?")) {
+            stmt.setString(1, DEFAULT_SCHEMA);
+            try (ResultSet rs = stmt.executeQuery()) {
+                if (rs.next() && rs.getLong(1) > 0) {
+                    log.warn("Schema '{}' contains no tables, but '{}' has {}. The session "
+                            + "search_path resolves to '{}' — if that is not intended, check for a "
+                            + "schema named after the connecting role (search_path starts with "
+                            + "\"$user\"), or set it explicitly: "
+                            + "ALTER ROLE <user> IN DATABASE <db> SET search_path = <schema>, public;",
+                        schema, DEFAULT_SCHEMA, rs.getLong(1), schema);
+                }
+            }
+        } catch (SQLException e) {
+            log.debug("Could not compare '{}' against '{}': {}", schema, DEFAULT_SCHEMA, e.getMessage());
+        }
+    }
+
     private String quoteIdentifier(String identifier) {
         return "\"" + identifier.replace("\"", "\"\"") + "\"";
     }