fix(db2): normalize_identifiers before quoting to fix CTE alias case mismatch (SQL0204N)

_fetch_native_df forced quote_identifiers=True to preserve case-sensitive column
lookups. However quote_identifiers wraps unquoted identifiers with their original
(pre-normalisation) case, so a CTE alias 'c' (unquoted) became '"c"' while the
UPPERCASE normalisation strategy causes the SELECT reference to be '"C"' — a
case-sensitive mismatch on Db2 causing SQL0204N.

Fix: apply normalize_identifiers(dialect='db2') before the quote step so unquoted
identifiers are uppercased first (c → C → "C"), matching the SELECT reference.
Quoted identifiers are intentionally unchanged by normalize_identifiers.

Also update test_dialects expected_columns to include db2 in the uppercase branch:
Db2 returns column names in uppercase (W, X, Y, Z) for both quoted and unquoted
column aliases, same as Snowflake.

Author: iawanish

sqlmesh/core/engine_adapter/db2.py

@@ -6,6 +6,7 @@
 from functools import cached_property
 
 from sqlglot import exp
+from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 
 from sqlmesh.core.engine_adapter.base import EngineAdapter, _get_data_object_cache_key
 from sqlmesh.core.engine_adapter.mixins import PandasNativeFetchDFSupportMixin
@@ -776,9 +777,19 @@ def _fetch_native_df(
 
         Forcing quote_identifiers=True here ensures every SELECT issued by
         SQLMesh (evaluator, fetchdf, fetchall via execute) wraps identifiers in
-        double-quotes so Db2 matches them exactly as stored.  This mirrors the
-        same pattern used by Snowflake, BigQuery, and Athena.
+        double-quotes so Db2 matches them exactly as stored.
+
+        normalize_identifiers is applied first so that unquoted identifiers are
+        uppercased before quoting (e.g. unquoted `c` → `C` → `"C"`).  Quoted
+        identifiers (e.g. `"a"`, `"B"`) are intentionally left unchanged by
+        normalize_identifiers — they remain case-sensitive as the caller intended.
+        This prevents the mismatch where a CTE alias defined as unquoted `c` would
+        otherwise be emitted as `"c"` (lowercase) while a SELECT reference derived
+        from Db2's UPPERCASE normalisation strategy uses `"C"` (SQL0204N).
         """
+        if isinstance(query, exp.Expression):
+            query = query.copy()
+            normalize_identifiers(query, dialect=self.dialect)
         return super()._fetch_native_df(query, quote_identifiers=True)
 
     def _df_to_source_queries(

tests/core/engine_adapter/integration/test_integration.py

@@ -2636,7 +2636,10 @@ def test_dialects(ctx: TestContext):
     """
     )
     df = ctx.engine_adapter.fetchdf(q)
-    expected_columns = ["W", "X", "Y", "Z"] if ctx.dialect == "snowflake" else ["w", "x", "y", "z"]
+    # Db2 (UPPERCASE strategy) returns uppercase column names regardless of alias case
+    expected_columns = (
+        ["W", "X", "Y", "Z"] if ctx.dialect in ("snowflake", "db2") else ["w", "x", "y", "z"]
+    )
     pd.testing.assert_frame_equal(
         df, pd.DataFrame([[1, 1, 1, 1]], columns=expected_columns), check_dtype=False
     )