fix: trim the generated normalized_match to match Java's normalizeForMatching

Found in hands-on QA of the previous commit, not by reading it.

SlowQueryAnalyticsService.normalizeForMatching ends with .trim(); the SQL
expression behind the generated column did not. A lineage row stored with
leading whitespace therefore normalized to " select ..." in the column and
"select ..." on the Java side, so the prefix LIKE never matched and
recoverFullText silently returned the truncated sample instead of the full
SQL. Verified against the local install: inserting '   SELECT x FROM t
WHERE y = 1   ' produced "[ select x from t where y = 1 ]" where Java
produces "[select x from t where y = 1]"; 4 of 1,174 real rows carried such
whitespace.

The flaw was equally present in the inline expression this column replaced,
so it is pre-existing rather than a regression — but it is silent either
way, which is why it survived.

Two parts to the fix:

* btrim(...) added to the expression in both the initializer and V118.

* The initializer now detects a stale column and rebuilds it. A generated
  column's expression cannot be altered in place and ADD COLUMN IF NOT
  EXISTS silently keeps whatever is already there, so an install that ran
  the earlier build would have kept the untrimmed expression forever. It
  compares pg_get_expr against the expected shape and only drops/re-adds
  when they differ, so a normal restart does not rewrite the table.

Verified on the running stack: restart logged "Rebuilding
query_lineage.normalized_match: stored expression is out of date", the
stored expression now carries btrim, the index survived the rebuild, and
rows-with-untrimmed-normalization went from 4 to 0.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: notSumit25

backend/src/main/java/com/dbaagent/config/QueryLineageMatchIndexInitializer.java

@@ -60,14 +60,21 @@ public class QueryLineageMatchIndexInitializer {
     private static final String INDEX = "idx_query_lineage_norm_match";
 
     /**
-     * Must match {@code SlowQueryAnalyticsService.normalizeForMatching} exactly, and the
-     * expression already inlined in the repository query. If one changes, all three do.
+     * Must match {@code SlowQueryAnalyticsService.normalizeForMatching} exactly. If one
+     * changes, both do.
+     *
+     * <p>The {@code btrim} is load-bearing and was missing from the expression this
+     * replaces: Java's {@code normalizeForMatching} ends with {@code .trim()}, so a
+     * lineage row stored with leading whitespace normalized to {@code " select ..."} on
+     * the SQL side and {@code "select ..."} on the Java side. The prefix {@code LIKE}
+     * then never matched and recovery silently returned the truncated sample. 4 of 1,174
+     * rows on the local install carry such whitespace.
      */
     private static final String NORMALIZE_EXPR =
-        "lower(regexp_replace(regexp_replace("
+        "btrim(lower(regexp_replace(regexp_replace("
             + "replace(query_text, '`', ''), "
             + "'\\s*([.,();])\\s*', '\\1', 'g'), "
-            + "'\\s+', ' ', 'g'))";
+            + "'\\s+', ' ', 'g')))";
 
     @Bean("queryLineageMatchIndexBootstrap")
     @DependsOn("entityManagerFactory")
@@ -78,6 +85,20 @@ public Object queryLineageMatchIndexBootstrap(DataSource dataSource) {
             return new Object();
         }
 
+        // A generated column's expression cannot be altered in place, and ADD COLUMN IF
+        // NOT EXISTS silently keeps whatever definition is already there. An install that
+        // ran an earlier build of this initializer therefore keeps the untrimmed
+        // expression forever unless the column is dropped first. Only drop when the
+        // definition actually differs, so a normal restart does not rewrite the table.
+        if (columnDefinitionDiffers(jdbc)) {
+            log.info("Rebuilding {}.{}: stored expression is out of date", TABLE, COLUMN);
+            try {
+                jdbc.execute("ALTER TABLE " + TABLE + " DROP COLUMN " + COLUMN);
+            } catch (RuntimeException e) {
+                log.warn("Could not drop stale {}.{}: {}", TABLE, COLUMN, e.getMessage());
+            }
+        }
+
         try {
             jdbc.execute("ALTER TABLE " + TABLE + " ADD COLUMN IF NOT EXISTS " + COLUMN
                 + " text GENERATED ALWAYS AS (" + NORMALIZE_EXPR + ") STORED");
@@ -101,6 +122,35 @@ public Object queryLineageMatchIndexBootstrap(DataSource dataSource) {
         return new Object();
     }
 
+    /**
+     * True when {@code normalized_match} exists but was generated by a different
+     * expression than {@link #NORMALIZE_EXPR}. Compared on the normalized form Postgres
+     * stores in {@code pg_get_expr}, with whitespace collapsed, since the server rewrites
+     * the text it was given (adds casts, reorders parens) and a literal comparison would
+     * report a difference on every start and rewrite the table each time.
+     */
+    private static boolean columnDefinitionDiffers(JdbcTemplate jdbc) {
+        try {
+            String stored = jdbc.query(
+                "SELECT pg_get_expr(d.adbin, d.adrelid) "
+                    + "FROM pg_attrdef d "
+                    + "JOIN pg_attribute a ON a.attrelid = d.adrelid AND a.attnum = d.adnum "
+                    + "WHERE d.adrelid = ?::regclass AND a.attname = ?",
+                rs -> rs.next() ? rs.getString(1) : null, TABLE, COLUMN);
+            if (stored == null) {
+                return false; // column not present yet — nothing stale to drop
+            }
+            return !squash(stored).contains("btrim");
+        } catch (RuntimeException e) {
+            log.warn("Could not inspect {}.{} definition: {}", TABLE, COLUMN, e.getMessage());
+            return false;
+        }
+    }
+
+    private static String squash(String s) {
+        return s.replaceAll("\\s+", "").toLowerCase();
+    }
+
     private static boolean tableExists(JdbcTemplate jdbc, String table) {
         try {
             Integer found = jdbc.queryForObject(

backend/src/main/resources/db/migration/V118__add_query_lineage_norm_match.sql

@@ -17,16 +17,21 @@
 -- at write time. On the same 34,976-row table, with the ~120-character prefix the caller
 -- actually sends: Index Scan, 0.428 ms.
 --
+-- The btrim matches Java's normalizeForMatching, which ends with .trim(). Without it a
+-- row stored with leading whitespace normalizes to " select ..." here but "select ..." in
+-- Java, so the prefix LIKE never matches and recovery silently returns the truncated
+-- sample. That flaw was present in the inline expression this replaces.
+--
 -- NOTE: this repo has no Flyway runtime (see CLAUDE.md). QueryLineageMatchIndexInitializer
 -- is what actually applies these statements at startup; this file is the changelog record.
 
 ALTER TABLE query_lineage
     ADD COLUMN IF NOT EXISTS normalized_match text
     GENERATED ALWAYS AS (
-        lower(regexp_replace(regexp_replace(
+        btrim(lower(regexp_replace(regexp_replace(
             replace(query_text, '`', ''),
             '\s*([.,();])\s*', '\1', 'g'),
-            '\s+', ' ', 'g'))
+            '\s+', ' ', 'g')))
     ) STORED;
 
 -- text_pattern_ops so LIKE 'prefix%' can use the index under any collation; the default