More unit tests, more cleanup (#978)

Author: benc-db

dbt/include/databricks/macros/adapters/python.sql

@@ -145,5 +145,5 @@ writer = (
 {%- endif -%}
 )
 
-writer.saveAsTable("{{ relation }}")
+writer.saveAsTable("{{ relation.render() }}")
 {% endmacro %}

dbt/include/databricks/macros/materializations/incremental/strategies.sql

@@ -37,20 +37,18 @@
 {% endmacro %}
 
 {% macro get_replace_where_sql(args_dict) -%}
-    {%- set predicates = args_dict['incremental_predicates'] -%}
-    {%- set target_relation = args_dict['target_relation'] -%}
-    {%- set temp_relation = args_dict['temp_relation'] -%}
-
-    insert into {{ target_relation }}
-    {% if predicates %}
-      {% if predicates is sequence and predicates is not string %}
-    replace where {{ predicates | join(' and ') }}
-      {% else %}
-    replace where {{ predicates }}
-      {% endif %}
-    {% endif %}
-    table {{ temp_relation }}
-
+  {%- set predicates = args_dict['incremental_predicates'] -%}
+  {%- set target_relation = args_dict['target_relation'] -%}
+  {%- set temp_relation = args_dict['temp_relation'] -%}
+INSERT INTO {{ target_relation.render() }}
+{% if predicates %}
+  {% if predicates is sequence and predicates is not string %}
+REPLACE WHERE {{ predicates | join(' and ') }}
+  {% else %}
+REPLACE WHERE {{ predicates }}
+  {% endif %}
+{% endif %}
+TABLE {{ temp_relation.render() }}
 {% endmacro %}
 
 {% macro get_insert_into_sql(source_relation, target_relation) %}

dbt/include/databricks/macros/relations/constraints.sql

@@ -28,7 +28,7 @@
 {% macro apply_alter_constraints(relation) %}
   {%- for constraint in relation.alter_constraints -%}
     {% call statement('add constraint') %}
-      ALTER TABLE {{ relation }} ADD {{ constraint.render() }}
+      ALTER TABLE {{ relation.render() }} ADD {{ constraint.render() }}
     {% endcall %}
   {%- endfor -%}
 {% endmacro %}
@@ -131,7 +131,7 @@
         {{ exceptions.raise_compiler_error("Constraint of type " ~ type ~ " with no `name` provided, and no md5 utility.") }}
       {% endif %}
     {% endif %}
-    {% set stmt = "alter table " ~ relation ~ " add constraint " ~ name ~ " check (" ~ expression ~ ");" %}
+    {% set stmt = "alter table " ~ relation.render() ~ " add constraint " ~ name ~ " check (" ~ expression ~ ");" %}
     {% do statements.append(stmt) %}
   {% elif type == 'not_null' %}
     {% set column_names = constraint.get('columns', []) %}

dbt/include/databricks/macros/relations/materialized_view/create.sql

@@ -4,7 +4,7 @@
   {%- set tblproperties = materialized_view.config["tblproperties"].tblproperties -%}
   {%- set comment = materialized_view.config["comment"].comment -%}
   {%- set refresh = materialized_view.config["refresh"] -%}
-  create materialized view {{ relation }}
+  create materialized view {{ relation.render() }}
     {{ get_create_sql_partition_by(partition_by) }}
     {{ get_create_sql_comment(comment) }}
     {{ get_create_sql_tblproperties(tblproperties) }}

dbt/include/databricks/macros/relations/optimize.sql

@@ -15,7 +15,7 @@
 {%- endmacro -%}
 
 {%- macro get_optimize_sql(relation) %}
-  optimize {{ relation }}
+  optimize {{ relation.render() }}
   {%- if config.get('zorder', False) and config.get('file_format', 'delta') == 'delta' %}
     {%- if config.get('liquid_clustered_by', False) or config.get('auto_liquid_cluster', False) %}
       {{ exceptions.warn("Both zorder and liquid_clustering are set but they are incompatible. zorder will be ignored.") }}

dbt/include/databricks/macros/relations/streaming_table/alter.sql

@@ -48,7 +48,7 @@
   {%- set partition_by = configuration_changes.changes["partition_by"].partition_by -%}
   {%- set tblproperties = configuration_changes.changes["tblproperties"].tblproperties -%}
   {%- set comment = configuration_changes.changes["comment"].comment -%}
-  CREATE OR REFRESH STREAMING TABLE {{ relation }}
+  CREATE OR REFRESH STREAMING TABLE {{ relation.render() }}
     {% if partition_by -%}
         {{ get_create_sql_partition_by(partition_by) }}
     {%- endif %}
@@ -64,7 +64,7 @@
 {% macro get_alter_st_internal(relation, configuration_changes) %}
   {%- set refresh = configuration_changes.changes["refresh"] -%}
   {%- if refresh and refresh.cron -%}
-    ALTER STREAMING TABLE {{ relation }}
+    ALTER STREAMING TABLE {{ relation.render() }}
         {{ get_alter_sql_refresh_schedule(refresh.cron, refresh.time_zone_value, False) -}}
   {%- endif -%}
 {% endmacro %}

dbt/include/databricks/macros/relations/streaming_table/create.sql

@@ -9,7 +9,7 @@
   {%- set comment = streaming_table.config["comment"].comment -%}
   {%- set refresh = streaming_table.config["refresh"] -%}
 
-  CREATE STREAMING TABLE {{ relation }}
+  CREATE STREAMING TABLE {{ relation.render() }}
     {{ get_create_sql_partition_by(partition_by) }}
     {{ get_create_sql_comment(comment) }}
     {{ get_create_sql_tblproperties(tblproperties) }}

dbt/include/databricks/macros/relations/table/create.sql

@@ -27,9 +27,9 @@
   {%- endif -%}
 
   {%- if file_format == 'delta' %}
-  create or replace table {{ target_relation }}
+  create or replace table {{ target_relation.render() }}
   {% else %}
-  create table {{ target_relation }}
+  create table {{ target_relation.render() }}
   {% endif -%}
   {{ get_column_and_constraints_sql(target_relation, columns) }}
   {{ file_format_clause() }}

dbt/include/databricks/macros/relations/table/rename.sql

@@ -1,3 +1,3 @@
 {% macro databricks__get_rename_table_sql(relation, new_name) %}
-  ALTER TABLE {{ relation }} RENAME TO `{{ new_name }}`
+  ALTER TABLE {{ relation.render() }} RENAME TO `{{ new_name }}`
 {% endmacro %}

tests/unit/macros/adapters/test_catalog_macros.py

@@ -38,7 +38,7 @@ def test_get_catalog_tables_sql(self, template_bundle):
             from `system`.`information_schema`.`tables`
         """
 
-        assert result == self.clean_sql(expected)
+        self.assert_sql_equal(result, expected)
 
     def test_get_catalog_columns_sql(self, template_bundle):
         """Test the SQL generation for catalog columns query"""
@@ -60,7 +60,7 @@ def test_get_catalog_columns_sql(self, template_bundle):
             from `system`.`information_schema`.`columns`
         """
 
-        assert result == self.clean_sql(expected)
+        self.assert_sql_equal(result, expected)
 
     def test_get_catalog_results_sql(self, template_bundle):
         """Test the SQL generation for joining tables and columns"""
@@ -73,7 +73,7 @@ def test_get_catalog_results_sql(self, template_bundle):
             order by column_index
         """
 
-        assert result == self.clean_sql(expected)
+        self.assert_sql_equal(result, expected)
 
     def test_get_catalog_schemas_where_clause_sql(self, template_bundle):
         """Test the SQL generation for schemas where clause"""
@@ -95,7 +95,7 @@ def test_get_catalog_schemas_where_clause_sql(self, template_bundle):
             )
         """
 
-        assert result == self.clean_sql(expected)
+        self.assert_sql_equal(result, expected)
 
     def test_get_catalog_relations_where_clause_sql(self, template_bundle):
         """Test the SQL generation for relations where clause"""
@@ -126,7 +126,7 @@ def test_get_catalog_relations_where_clause_sql(self, template_bundle):
             )
         """
 
-        assert result == self.clean_sql(expected)
+        self.assert_sql_equal(result, expected)
 
     def test_get_catalog(self, template_bundle, context):
         """Test the full get_catalog macro with mocked run_query"""
@@ -191,7 +191,7 @@ def test_get_catalog(self, template_bundle, context):
             order by column_index
         """
 
-        assert self.clean_sql(sql_query) == self.clean_sql(expected_sql)
+        self.assert_sql_equal(sql_query, expected_sql)
 
     def test_get_catalog_relations(self, template_bundle, context):
         """Test the get_catalog_relations macro with mocked run_query"""
@@ -265,4 +265,4 @@ def test_get_catalog_relations(self, template_bundle, context):
             order by column_index
         """
 
-        assert self.clean_sql(sql_query) == self.clean_sql(expected_sql)
+        self.assert_sql_equal(sql_query, expected_sql)

tests/unit/macros/adapters/test_columns_macros.py

@@ -14,33 +14,23 @@ def template_name(self) -> str:
     def macro_folders_to_load(self) -> list:
         return ["macros", "macros/adapters"]
 
-    @pytest.fixture
-    def mock_relation(self):
-        relation = Mock()
-        relation.database = "test_db"
-        relation.schema = "test_schema"
-        relation.identifier = "test_table"
-        relation.render = Mock(return_value="`test_db`.`test_schema`.`test_table`")
-        relation.is_delta = True
-        return relation
+    def test_get_columns_comments_sql(self, template_bundle, relation):
+        result = self.run_macro(template_bundle.template, "get_columns_comments_sql", relation)
 
-    def test_get_columns_comments_sql(self, template_bundle, mock_relation):
-        result = self.run_macro(template_bundle.template, "get_columns_comments_sql", mock_relation)
+        expected_sql = "DESCRIBE TABLE `some_database`.`some_schema`.`some_table`"
+        self.assert_sql_equal(result, expected_sql)
 
-        expected_sql = "DESCRIBE TABLE `test_db`.`test_schema`.`test_table`"
-        assert result == self.clean_sql(expected_sql)
+    def test_repair_table_sql(self, template_bundle, relation):
+        result = self.run_macro(template_bundle.template, "repair_table_sql", relation)
 
-    def test_repair_table_sql(self, template_bundle, mock_relation):
-        result = self.run_macro(template_bundle.template, "repair_table_sql", mock_relation)
+        expected_sql = "REPAIR TABLE `some_database`.`some_schema`.`some_table` SYNC METADATA"
+        self.assert_sql_equal(result, expected_sql)
 
-        expected_sql = "REPAIR TABLE `test_db`.`test_schema`.`test_table` SYNC METADATA"
-        assert result == self.clean_sql(expected_sql)
-
-    def test_get_columns_comments_via_information_schema_sql(self, template_bundle, mock_relation):
+    def test_get_columns_comments_via_information_schema_sql(self, template_bundle, relation):
         result = self.run_macro(
             template_bundle.template,
             "get_columns_comments_via_information_schema_sql",
-            mock_relation,
+            relation,
         )
 
         # Note the lowercase in the WHERE clause due to |lower filters
@@ -51,14 +41,14 @@ def test_get_columns_comments_via_information_schema_sql(self, template_bundle,
               comment
             FROM `system`.`information_schema`.`columns`
             WHERE
-              table_catalog = 'test_db' and
-              table_schema = 'test_schema' and
-              table_name = 'test_table'
+              table_catalog = 'some_database' and
+              table_schema = 'some_schema' and
+              table_name = 'some_table'
         """
 
-        assert result == self.clean_sql(expected_sql)
+        self.assert_sql_equal(result, expected_sql)
 
-    def test_drop_columns_sql(self, template_bundle, context, mock_relation):
+    def test_drop_columns_sql(self, template_bundle, context, relation):
         """Test drop_columns_sql macro"""
         # Mock Column.format_remove_column_list
         context["api"] = MagicMock()
@@ -67,25 +57,26 @@ def test_drop_columns_sql(self, template_bundle, context, mock_relation):
         remove_columns = ["col1", "col2"]
 
         result = self.run_macro(
-            template_bundle.template, "drop_columns_sql", mock_relation, remove_columns
+            template_bundle.template, "drop_columns_sql", relation, remove_columns
         )
 
-        expected_sql = "ALTER TABLE `test_db`.`test_schema`.`test_table` DROP COLUMNS (col1, col2)"
-        assert self.clean_sql(result) == self.clean_sql(expected_sql)
+        expected_sql = (
+            "ALTER TABLE `some_database`.`some_schema`.`some_table` DROP COLUMNS (col1, col2)"
+        )
+        self.assert_sql_equal(result, expected_sql)
 
-    def test_add_columns_sql(self, template_bundle, context, mock_relation):
+    def test_add_columns_sql(self, template_bundle, context, relation):
         """Test add_columns_sql macro"""
         # Mock Column.format_add_column_list
         context["api"] = MagicMock()
         context["api"].Column.format_add_column_list = Mock(return_value="col1 INT, col2 STRING")
 
         add_columns = ["col1", "col2"]
 
-        result = self.run_macro(
-            template_bundle.template, "add_columns_sql", mock_relation, add_columns
-        )
+        result = self.run_macro(template_bundle.template, "add_columns_sql", relation, add_columns)
 
         expected_sql = (
-            "ALTER TABLE `test_db`.`test_schema`.`test_table` ADD COLUMNS (col1 INT, col2 STRING)"
+            "ALTER TABLE `some_database`.`some_schema`.`some_table` "
+            "ADD COLUMNS (col1 INT, col2 STRING)"
         )
-        assert self.clean_sql(result) == self.clean_sql(expected_sql)
+        self.assert_sql_equal(result, expected_sql)