fix: use REQUIRES_SET_CATALOG + no-op set_current_catalog to handle catalog case mismatch

SINGLE_CATALOG_ONLY uses a raw == comparison (shared.py:346) between
catalog_name from the model expression and _default_catalog.  The model
expression case depends on which dialect built it: db2 dialect produces
UPPERCASE, duckdb dialect produces lowercase.  Either case can appear at
runtime and neither alone satisfies a raw == against a fixed-case string.

Switch to REQUIRES_SET_CATALOG: the decorator's alternate path (shared.py:352)
calls get_current_catalog() for the RHS of the comparison.  Both get_catalog()
(connection.py) and get_current_catalog() (db2.py) now return uppercase, so
_default_catalog and the live value are always 'TESTDB'.  When a lowercase
'testdb' arrives from a duckdb-dialect context it won't match, but that only
calls set_current_catalog() which is now a no-op — Db2 has a single catalog
and CONNECT TO cannot switch to a different database mid-session anyway.

Reverts the .lower() changes from commit ba0fe1d which broke test_janitor
by causing 'testdb vs TESTDB' errors on the SINGLE_CATALOG_ONLY path.

Author: iawanish

sqlmesh/core/config/connection.py

@@ -2650,14 +2650,17 @@ def _engine_adapter(self) -> t.Type[EngineAdapter]:
         )
 
     def get_catalog(self) -> t.Optional[str]:
-        """Normalise the catalog name to lowercase so _default_catalog is consistent
-        with get_current_catalog() and _get_current_schema(), both of which return
-        lowercase.  SQLMesh model names built through a duckdb-dialect context arrive
-        as lowercase (DuckDB's LOWERCASE normalisation strategy), and the set_catalog()
-        decorator compares catalog_name == _default_catalog with plain ==, so both sides
-        must use the same case.  SYSCAT queries apply UPPER() at point of use."""
+        """
+        Return the catalog (database) name uppercased.  Db2 stores all unquoted
+        identifiers in uppercase and CURRENT SERVER returns an uppercase string.
+        get_current_catalog() also returns uppercase, so _default_catalog and the
+        live catalog value are always in the same case.  The set_catalog() decorator's
+        REQUIRES_SET_CATALOG path compares catalog_name != get_current_catalog(); a
+        case mismatch (e.g. duckdb-dialect lowercase "testdb" vs "TESTDB") triggers
+        set_current_catalog() which is a no-op — so both cases are handled safely.
+        """
         catalog = super().get_catalog()
-        return catalog.lower() if catalog else None
+        return catalog.upper() if catalog else None
 
     @property
     def _connection_factory(self) -> t.Callable:

sqlmesh/core/engine_adapter/db2.py

@@ -85,13 +85,16 @@ class Db2EngineAdapter(
     def get_current_catalog(self) -> t.Optional[str]:
         """
         Db2 requires FROM SYSIBM.SYSDUMMY1 to read the CURRENT SERVER special register.
-        Returns lowercase — the same convention as _get_current_schema() — so that all
-        catalog/schema tokens returned to callers are consistently lowercase.
-        SYSCAT queries apply UPPER() at point of use where uppercase is required.
+        Returns the value uppercased to match the convention used by _default_catalog
+        (which comes from get_catalog() → database name as supplied in config, uppercased).
+        The set_catalog() decorator's REQUIRES_SET_CATALOG path compares
+        catalog_name != get_current_catalog() — normalising both to uppercase ensures
+        the comparison is consistent regardless of which dialect (db2 UPPERCASE vs
+        duckdb LOWERCASE) produced the catalog token in the model expression.
         """
         result = self.fetchone("SELECT CURRENT SERVER FROM SYSIBM.SYSDUMMY1")
         if result:
-            return result[0].lower() if result[0] else None
+            return result[0].upper() if result[0] else None
         return None
 
     def _build_schema_exp(
@@ -328,7 +331,19 @@ def _db2_type_to_sqlglot(self, db2_type: str, length: int, scale: int) -> exp.Da
 
     @property
     def catalog_support(self) -> CatalogSupport:
-        return CatalogSupport.SINGLE_CATALOG_ONLY
+        # REQUIRES_SET_CATALOG is used instead of SINGLE_CATALOG_ONLY because the
+        # SINGLE_CATALOG_ONLY path in set_catalog() (shared.py:346) does a raw ==
+        # comparison between catalog_name and _default_catalog.  catalog_name comes
+        # from the model expression, whose case depends on the dialect that built it:
+        # db2 dialect → UPPERCASE, duckdb dialect → lowercase.  Either case can appear
+        # at runtime and we cannot control which, so a raw == would fail for one case.
+        #
+        # The REQUIRES_SET_CATALOG path instead calls get_current_catalog() for the
+        # right-hand side.  By returning uppercase from both get_catalog() (connection.py)
+        # and get_current_catalog(), and by making set_current_catalog() a no-op (Db2 has
+        # only one catalog — CONNECT TO cannot change it meaningfully), the mismatch is
+        # tolerated: lowercase "testdb" != "TESTDB" → set_current_catalog (no-op) → proceed.
+        return CatalogSupport.REQUIRES_SET_CATALOG
 
     def table_exists(self, table_name: TableName) -> bool:
         """
@@ -836,9 +851,18 @@ def _df_to_source_queries(
         )
 
     def set_current_catalog(self, catalog: str) -> None:
-        """Switches the active catalog using Db2's CONNECT TO statement."""
-        self.execute(f"CONNECT TO {catalog}")
-        logger.debug("Switched to catalog: %s", catalog)
+        """
+        No-op for Db2 — there is only one catalog (the database name) and CONNECT TO
+        cannot switch to a different one in the middle of a session.  The set_catalog()
+        decorator calls this when catalog_name != get_current_catalog(), which happens
+        because model expressions built through a duckdb-dialect context carry lowercase
+        catalog names while get_current_catalog() returns uppercase.  The mismatch is
+        case-only and harmless, so we log it and return without executing any SQL.
+        """
+        logger.debug(
+            "set_current_catalog called with %r — no-op for Db2 (single-catalog engine)",
+            catalog,
+        )
 
     @cached_property
     def server_version(self) -> t.Tuple[int, int]: