Fix: Normalize before applying quotes in get_relation and list_relations methods of the runtime dbt adapter

Author: izeigerman

sqlmesh/dbt/adapter.py

@@ -245,14 +245,11 @@ def __init__(
     def get_relation(
         self, database: t.Optional[str], schema: str, identifier: str
     ) -> t.Optional[BaseRelation]:
-        return self.load_relation(
-            self.relation_type.create(
-                database=database,
-                schema=schema,
-                identifier=identifier,
-                quote_policy=self.quote_policy,
-            )
-        )
+        target_table = exp.table_(identifier, db=schema, catalog=database)
+        # Normalize before converting to a relation; otherwise, it will be too late,
+        # as quotes will have already been applied.
+        target_table = self._normalize(target_table)
+        return self.load_relation(self._table_to_relation(target_table))
 
     def load_relation(self, relation: BaseRelation) -> t.Optional[BaseRelation]:
         mapped_table = self._map_table_name(self._normalize(self._relation_to_table(relation)))
@@ -262,10 +259,15 @@ def load_relation(self, relation: BaseRelation) -> t.Optional[BaseRelation]:
         return self._table_to_relation(mapped_table)
 
     def list_relations(self, database: t.Optional[str], schema: str) -> t.List[BaseRelation]:
-        reference_relation = self.relation_type.create(
-            database=database, schema=schema, quote_policy=self.quote_policy
+        target_schema = exp.Table(
+            this=None,
+            db=exp.to_identifier(schema),
+            catalog=exp.to_identifier(database) if database else None,
         )
-        return self.list_relations_without_caching(reference_relation)
+        # Normalize before converting to a relation; otherwise, it will be too late,
+        # as quotes will have already been applied.
+        target_schema = self._normalize(target_schema)
+        return self.list_relations_without_caching(self._table_to_relation(target_schema))
 
     def list_relations_without_caching(self, schema_relation: BaseRelation) -> t.List[BaseRelation]:
         from sqlmesh.dbt.relation import RelationType

tests/dbt/test_adapter.py

@@ -379,3 +379,35 @@ def test_on_run_start_end(copy_to_temp_path):
             "CREATE OR REPLACE TABLE schema_table_sushi__dev_nested_package AS SELECT 'sushi__dev' AS schema",
         ]
     )
+
+
+def test_adapter_get_relation_normalization(
+    sushi_test_project: Project, runtime_renderer: t.Callable
+):
+    # Simulate that the quote policy is set to quote everything to make
+    # sure that we normalize correctly even if quotes are applied
+    with mock.patch.object(
+        SnowflakeConfig,
+        "quote_policy",
+        Policy(identifier=True, schema=True, database=True),
+    ):
+        context = sushi_test_project.context
+        assert context.target
+        engine_adapter = context.target.to_sqlmesh().create_engine_adapter()
+        engine_adapter._default_catalog = '"memory"'
+        renderer = runtime_renderer(context, engine_adapter=engine_adapter, dialect="snowflake")
+
+        engine_adapter.create_schema('"FOO"')
+        engine_adapter.create_table(
+            table_name='"FOO"."BAR"', columns_to_types={"baz": exp.DataType.build("int")}
+        )
+
+        assert (
+            renderer("{{ adapter.get_relation(database=None, schema='foo', identifier='bar') }}")
+            == '"memory"."FOO"."BAR"'
+        )
+
+        assert (
+            renderer("{{ adapter.list_relations(database=None, schema='foo') }}")
+            == '[<SnowflakeRelation "memory"."FOO"."BAR">]'
+        )