dbt-adapters 1.3.2__tar.gz → 1.4.0__tar.gz

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/.gitignore

@@ -154,3 +154,13 @@ cython_debug/
 
 # PyCharm
 .idea/
+
+# MacOS
+.DS_Store
+
+# VSCode
+.vscode/
+.venv/
+
+# Vim
+*.swp

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-adapters
-Version: 1.3.2
+Version: 1.4.0
 Summary: The set of adapter protocols and base functionality that supports integration with dbt-core
 Project-URL: Homepage, https://github.com/dbt-labs/dbt-adapters
 Project-URL: Documentation, https://docs.getdbt.com
@@ -11,7 +11,7 @@ Author-email: dbt Labs <info@dbtlabs.com>
 Maintainer-email: dbt Labs <info@dbtlabs.com>
 License-File: LICENSE
 Keywords: adapter,adapters,database,dbt,dbt Cloud,dbt Core,dbt Labs,dbt-core,elt
-Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8.0
 Requires-Dist: agate<2.0,>=1.0
-Requires-Dist: dbt-common<2.0,>=1.3
+Requires-Dist: dbt-common<2.0,>=1.6
 Requires-Dist: mashumaro[msgpack]<4.0,>=3.0
 Requires-Dist: protobuf<5.0,>=3.0
 Requires-Dist: pytz>=2015.7

dbt_adapters-1.4.0/dbt/adapters/__about__.py

@@ -0,0 +1 @@
+version = "1.4.0"

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/adapters/base/column.py

@@ -123,9 +123,6 @@ class Column:
         else:
             return "{}({},{})".format(dtype, precision, scale)
 
-    def __repr__(self) -> str:
-        return "<Column {} ({})>".format(self.name, self.data_type)
-
     @classmethod
     def from_description(cls, name: str, raw_data_type: str) -> "Column":
         match = re.match(r"([^(]+)(\([^)]+\))?", raw_data_type)

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/adapters/base/impl.py

@@ -1602,8 +1602,13 @@ class BaseAdapter(metaclass=AdapterMeta):
             rendered_column_constraint = f"unique {constraint_expression}"
         elif constraint.type == ConstraintType.primary_key:
             rendered_column_constraint = f"primary key {constraint_expression}"
-        elif constraint.type == ConstraintType.foreign_key and constraint_expression:
-            rendered_column_constraint = f"references {constraint_expression}"
+        elif constraint.type == ConstraintType.foreign_key:
+            if constraint.to and constraint.to_columns:
+                rendered_column_constraint = (
+                    f"references {constraint.to} ({', '.join(constraint.to_columns)})"
+                )
+            elif constraint_expression:
+                rendered_column_constraint = f"references {constraint_expression}"
         elif constraint.type == ConstraintType.custom and constraint_expression:
             rendered_column_constraint = constraint_expression
 
@@ -1682,20 +1687,29 @@ class BaseAdapter(metaclass=AdapterMeta):
         rendering."""
         constraint_prefix = f"constraint {constraint.name} " if constraint.name else ""
         column_list = ", ".join(constraint.columns)
+        rendered_model_constraint = None
+
         if constraint.type == ConstraintType.check and constraint.expression:
-            return f"{constraint_prefix}check ({constraint.expression})"
+            rendered_model_constraint = f"{constraint_prefix}check ({constraint.expression})"
         elif constraint.type == ConstraintType.unique:
             constraint_expression = f" {constraint.expression}" if constraint.expression else ""
-            return f"{constraint_prefix}unique{constraint_expression} ({column_list})"
+            rendered_model_constraint = (
+                f"{constraint_prefix}unique{constraint_expression} ({column_list})"
+            )
         elif constraint.type == ConstraintType.primary_key:
             constraint_expression = f" {constraint.expression}" if constraint.expression else ""
-            return f"{constraint_prefix}primary key{constraint_expression} ({column_list})"
-        elif constraint.type == ConstraintType.foreign_key and constraint.expression:
-            return f"{constraint_prefix}foreign key ({column_list}) references {constraint.expression}"
+            rendered_model_constraint = (
+                f"{constraint_prefix}primary key{constraint_expression} ({column_list})"
+            )
+        elif constraint.type == ConstraintType.foreign_key:
+            if constraint.to and constraint.to_columns:
+                rendered_model_constraint = f"{constraint_prefix}foreign key ({column_list}) references {constraint.to} ({', '.join(constraint.to_columns)})"
+            elif constraint.expression:
+                rendered_model_constraint = f"{constraint_prefix}foreign key ({column_list}) references {constraint.expression}"
         elif constraint.type == ConstraintType.custom and constraint.expression:
-            return f"{constraint_prefix}{constraint.expression}"
-        else:
-            return None
+            rendered_model_constraint = f"{constraint_prefix}{constraint.expression}"
+
+        return rendered_model_constraint
 
     @classmethod
     def capabilities(cls) -> CapabilityDict:

dbt_adapters-1.4.0/dbt/adapters/record/__init__.py

@@ -0,0 +1,2 @@
+from dbt.adapters.record.handle import RecordReplayHandle
+from dbt.adapters.record.cursor.cursor import RecordReplayCursor

dbt_adapters-1.4.0/dbt/adapters/record/cursor/cursor.py

@@ -0,0 +1,54 @@
+from typing import Any, Optional
+
+from dbt_common.record import record_function
+
+from dbt.adapters.contracts.connection import Connection
+from dbt.adapters.record.cursor.description import CursorGetDescriptionRecord
+from dbt.adapters.record.cursor.execute import CursorExecuteRecord
+from dbt.adapters.record.cursor.fetchone import CursorFetchOneRecord
+from dbt.adapters.record.cursor.fetchmany import CursorFetchManyRecord
+from dbt.adapters.record.cursor.fetchall import CursorFetchAllRecord
+from dbt.adapters.record.cursor.rowcount import CursorGetRowCountRecord
+
+
+class RecordReplayCursor:
+    """A proxy object used to wrap native database cursors under record/replay
+    modes. In record mode, this proxy notes the parameters and return values
+    of the methods and properties it implements, which closely match the Python
+    DB API 2.0 cursor methods used by many dbt adapters to interact with the
+    database or DWH. In replay mode, it mocks out those calls using previously
+    recorded calls, so that no interaction with a database actually occurs."""
+
+    def __init__(self, native_cursor: Any, connection: Connection) -> None:
+        self.native_cursor = native_cursor
+        self.connection = connection
+
+    @record_function(CursorExecuteRecord, method=True, id_field_name="connection_name")
+    def execute(self, operation, parameters=None) -> None:
+        self.native_cursor.execute(operation, parameters)
+
+    @record_function(CursorFetchOneRecord, method=True, id_field_name="connection_name")
+    def fetchone(self) -> Any:
+        return self.native_cursor.fetchone()
+
+    @record_function(CursorFetchManyRecord, method=True, id_field_name="connection_name")
+    def fetchmany(self, size: int) -> Any:
+        return self.native_cursor.fetchmany(size)
+
+    @record_function(CursorFetchAllRecord, method=True, id_field_name="connection_name")
+    def fetchall(self) -> Any:
+        return self.native_cursor.fetchall()
+
+    @property
+    def connection_name(self) -> Optional[str]:
+        return self.connection.name
+
+    @property
+    @record_function(CursorGetRowCountRecord, method=True, id_field_name="connection_name")
+    def rowcount(self) -> int:
+        return self.native_cursor.rowcount
+
+    @property
+    @record_function(CursorGetDescriptionRecord, method=True, id_field_name="connection_name")
+    def description(self) -> str:
+        return self.native_cursor.description

dbt_adapters-1.4.0/dbt/adapters/record/cursor/description.py

@@ -0,0 +1,37 @@
+import dataclasses
+from typing import Any, Iterable, Mapping
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorGetDescriptionParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorGetDescriptionResult:
+    columns: Iterable[Any]
+
+    def _to_dict(self) -> Any:
+        column_dicts = []
+        for c in self.columns:
+            # This captures the mandatory column information, but we might need
+            # more for some adapters.
+            # See https://peps.python.org/pep-0249/#description
+            column_dicts.append((c[0], c[1]))
+
+        return {"columns": column_dicts}
+
+    @classmethod
+    def _from_dict(cls, dct: Mapping) -> "CursorGetDescriptionResult":
+        return CursorGetDescriptionResult(columns=dct["columns"])
+
+
+@Recorder.register_record_type
+class CursorGetDescriptionRecord(Record):
+    """Implements record/replay support for the cursor.description property."""
+
+    params_cls = CursorGetDescriptionParams
+    result_cls = CursorGetDescriptionResult
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/execute.py

@@ -0,0 +1,20 @@
+import dataclasses
+from typing import Any, Iterable, Union, Mapping
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorExecuteParams:
+    connection_name: str
+    operation: str
+    parameters: Union[Iterable[Any], Mapping[str, Any]]
+
+
+@Recorder.register_record_type
+class CursorExecuteRecord(Record):
+    """Implements record/replay support for the cursor.execute() method."""
+
+    params_cls = CursorExecuteParams
+    result_cls = None
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/fetchall.py

@@ -0,0 +1,66 @@
+import dataclasses
+import datetime
+from typing import Any, Dict, List, Mapping
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorFetchAllParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorFetchAllResult:
+    results: List[Any]
+
+    def _to_dict(self) -> Dict[str, Any]:
+        processed_results = []
+        for result in self.results:
+            result = tuple(map(self._process_value, result))
+            processed_results.append(result)
+
+        return {"results": processed_results}
+
+    @classmethod
+    def _from_dict(cls, dct: Mapping) -> "CursorFetchAllResult":
+        unprocessed_results = []
+        for result in dct["results"]:
+            result = tuple(map(cls._unprocess_value, result))
+            unprocessed_results.append(result)
+
+        return CursorFetchAllResult(unprocessed_results)
+
+    @classmethod
+    def _process_value(cls, value: Any) -> Any:
+        if type(value) is datetime.date:
+            return {"type": "date", "value": value.isoformat()}
+        elif type(value) is datetime.datetime:
+            return {"type": "datetime", "value": value.isoformat()}
+        else:
+            return value
+
+    @classmethod
+    def _unprocess_value(cls, value: Any) -> Any:
+        if type(value) is dict:
+            value_type = value.get("type")
+            if value_type == "date":
+                date_string = value.get("value")
+                assert isinstance(date_string, str)
+                return datetime.date.fromisoformat(date_string)
+            elif value_type == "datetime":
+                date_string = value.get("value")
+                assert isinstance(date_string, str)
+                return datetime.datetime.fromisoformat(date_string)
+            return value
+        else:
+            return value
+
+
+@Recorder.register_record_type
+class CursorFetchAllRecord(Record):
+    """Implements record/replay support for the cursor.fetchall() method."""
+
+    params_cls = CursorFetchAllParams
+    result_cls = CursorFetchAllResult
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/fetchmany.py

@@ -0,0 +1,23 @@
+import dataclasses
+from typing import Any, List
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorFetchManyParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorFetchManyResult:
+    results: List[Any]
+
+
+@Recorder.register_record_type
+class CursorFetchManyRecord(Record):
+    """Implements record/replay support for the cursor.fetchmany() method."""
+
+    params_cls = CursorFetchManyParams
+    result_cls = CursorFetchManyResult
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/fetchone.py

@@ -0,0 +1,23 @@
+import dataclasses
+from typing import Any
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorFetchOneParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorFetchOneResult:
+    result: Any
+
+
+@Recorder.register_record_type
+class CursorFetchOneRecord(Record):
+    """Implements record/replay support for the cursor.fetchone() method."""
+
+    params_cls = CursorFetchOneParams
+    result_cls = CursorFetchOneResult
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/cursor/rowcount.py

@@ -0,0 +1,23 @@
+import dataclasses
+from typing import Optional
+
+from dbt_common.record import Record, Recorder
+
+
+@dataclasses.dataclass
+class CursorGetRowCountParams:
+    connection_name: str
+
+
+@dataclasses.dataclass
+class CursorGetRowCountResult:
+    rowcount: Optional[int]
+
+
+@Recorder.register_record_type
+class CursorGetRowCountRecord(Record):
+    """Implements record/replay support for the cursor.rowcount property."""
+
+    params_cls = CursorGetRowCountParams
+    result_cls = CursorGetRowCountResult
+    group = "Database"

dbt_adapters-1.4.0/dbt/adapters/record/handle.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from dbt.adapters.contracts.connection import Connection
+
+from dbt.adapters.record.cursor.cursor import RecordReplayCursor
+
+
+class RecordReplayHandle:
+    """A proxy object used for record/replay modes. What adapters call a
+    'handle' is typically a native database connection, but should not be
+    confused with the Connection protocol, which is a dbt-adapters concept.
+
+    Currently, the only function of the handle proxy is to provide a record/replay
+    aware cursor object when cursor() is called."""
+
+    def __init__(self, native_handle: Any, connection: Connection) -> None:
+        self.native_handle = native_handle
+        self.connection = connection
+
+    def cursor(self) -> Any:
+        # The native handle could be None if we are in replay mode, because no
+        # actual database access should be performed in that mode.
+        cursor = None if self.native_handle is None else self.native_handle.cursor()
+        return RecordReplayCursor(cursor, self.connection)

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/adapters/sql/connections.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, TYPE_CH
 from dbt_common.events.contextvars import get_node_info
 from dbt_common.events.functions import fire_event
 from dbt_common.exceptions import DbtInternalError, NotImplementedError
-from dbt_common.record import record_function
 from dbt_common.utils import cast_to_str
 
 from dbt.adapters.base import BaseConnectionManager
@@ -20,7 +19,6 @@ from dbt.adapters.events.types import (
     SQLQuery,
     SQLQueryStatus,
 )
-from dbt.adapters.record import QueryRecord
 
 if TYPE_CHECKING:
     import agate
@@ -143,7 +141,6 @@ class SQLConnectionManager(BaseConnectionManager):
 
         return table_from_data_flat(data, column_names)
 
-    @record_function(QueryRecord, method=True, tuple_result=True)
     def execute(
         self,
         sql: str,

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/adapters/apply_grants.sql

@@ -61,7 +61,7 @@
 {% endmacro %}
 
 {% macro default__get_show_grant_sql(relation) %}
-    show grants on {{ relation }}
+    show grants on {{ relation.render() }}
 {% endmacro %}
 
 
@@ -70,7 +70,7 @@
 {% endmacro %}
 
 {%- macro default__get_grant_sql(relation, privilege, grantees) -%}
-    grant {{ privilege }} on {{ relation }} to {{ grantees | join(', ') }}
+    grant {{ privilege }} on {{ relation.render() }} to {{ grantees | join(', ') }}
 {%- endmacro -%}
 
 
@@ -79,7 +79,7 @@
 {% endmacro %}
 
 {%- macro default__get_revoke_sql(relation, privilege, grantees) -%}
-    revoke {{ privilege }} on {{ relation }} from {{ grantees | join(', ') }}
+    revoke {{ privilege }} on {{ relation.render() }} from {{ grantees | join(', ') }}
 {%- endmacro -%}
 
 
@@ -147,7 +147,7 @@
             {% set needs_granting = diff_of_two_dicts(grant_config, current_grants_dict) %}
             {% set needs_revoking = diff_of_two_dicts(current_grants_dict, grant_config) %}
             {% if not (needs_granting or needs_revoking) %}
-                {{ log('On ' ~ relation ~': All grants are in place, no revocation or granting needed.')}}
+                {{ log('On ' ~ relation.render() ~': All grants are in place, no revocation or granting needed.')}}
             {% endif %}
         {% else %}
             {#-- We don't think there's any chance of previous grants having carried over. --#}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/adapters/columns.sql

@@ -96,10 +96,10 @@
   {%- set tmp_column = column_name + "__dbt_alter" -%}
 
   {% call statement('alter_column_type') %}
-    alter table {{ relation }} add column {{ adapter.quote(tmp_column) }} {{ new_column_type }};
-    update {{ relation }} set {{ adapter.quote(tmp_column) }} = {{ adapter.quote(column_name) }};
-    alter table {{ relation }} drop column {{ adapter.quote(column_name) }} cascade;
-    alter table {{ relation }} rename column {{ adapter.quote(tmp_column) }} to {{ adapter.quote(column_name) }}
+    alter table {{ relation.render() }} add column {{ adapter.quote(tmp_column) }} {{ new_column_type }};
+    update {{ relation.render() }} set {{ adapter.quote(tmp_column) }} = {{ adapter.quote(column_name) }};
+    alter table {{ relation.render() }} drop column {{ adapter.quote(column_name) }} cascade;
+    alter table {{ relation.render() }} rename column {{ adapter.quote(tmp_column) }} to {{ adapter.quote(column_name) }}
   {% endcall %}
 
 {% endmacro %}
@@ -120,7 +120,7 @@
 
   {% set sql -%}
 
-     alter {{ relation.type }} {{ relation }}
+     alter {{ relation.type }} {{ relation.render() }}
 
             {% for column in add_columns %}
                add column {{ column.name }} {{ column.data_type }}{{ ',' if not loop.last }}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/adapters/relation.sql

@@ -38,7 +38,7 @@
 
 {% macro default__truncate_relation(relation) -%}
   {% call statement('truncate_relation') -%}
-    truncate table {{ relation }}
+    truncate table {{ relation.render() }}
   {%- endcall %}
 {% endmacro %}
 

dbt_adapters-1.4.0/dbt/include/global_project/macros/adapters/show.sql

@@ -0,0 +1,26 @@
+{#
+    We expect a syntax error if dbt show is invoked both with a --limit flag to show
+    and with a limit predicate embedded in its inline query. No special handling is
+    provided out-of-box.
+#}
+{% macro get_show_sql(compiled_code, sql_header, limit) -%}
+  {%- if sql_header is not none -%}
+  {{ sql_header }}
+  {%- endif %}
+  {{ get_limit_subquery_sql(compiled_code, limit) }}
+{% endmacro %}
+
+{#
+    Not necessarily a true subquery anymore. Now, merely a query subordinate
+    to the calling macro.
+#}
+{%- macro get_limit_subquery_sql(sql, limit) -%}
+  {{ adapter.dispatch('get_limit_sql', 'dbt')(sql, limit) }}
+{%- endmacro -%}
+
+{% macro default__get_limit_sql(sql, limit) %}
+  {{ compiled_code }}
+  {% if limit is not none %}
+  limit {{ limit }}
+  {%- endif -%}
+{% endmacro %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/models/clone/clone.sql

@@ -27,14 +27,14 @@
 
       {%- set target_relation = this.incorporate(type='table') -%}
       {% if existing_relation is not none and not existing_relation.is_table %}
-        {{ log("Dropping relation " ~ existing_relation ~ " because it is of type " ~ existing_relation.type) }}
+        {{ log("Dropping relation " ~ existing_relation.render() ~ " because it is of type " ~ existing_relation.type) }}
         {{ drop_relation_if_exists(existing_relation) }}
       {% endif %}
 
       -- as a general rule, data platforms that can clone tables can also do atomic 'create or replace'
       {% call statement('main') %}
           {% if target_relation and defer_relation and target_relation == defer_relation %}
-              {{ log("Target relation and defer relation are the same, skipping clone for relation: " ~ target_relation) }}
+              {{ log("Target relation and defer relation are the same, skipping clone for relation: " ~ target_relation.render()) }}
           {% else %}
               {{ create_or_replace_clone(target_relation, defer_relation) }}
           {% endif %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/models/clone/create_or_replace_clone.sql

@@ -3,5 +3,5 @@
 {% endmacro %}
 
 {% macro default__create_or_replace_clone(this_relation, defer_relation) %}
-    create or replace table {{ this_relation }} clone {{ defer_relation }}
+    create or replace table {{ this_relation.render() }} clone {{ defer_relation.render() }}
 {% endmacro %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/models/incremental/incremental.sql

@@ -39,9 +39,12 @@
       {% set need_swap = true %}
   {% else %}
     {% do run_query(get_create_table_as_sql(True, temp_relation, sql)) %}
-    {% do adapter.expand_target_column_types(
-             from_relation=temp_relation,
-             to_relation=target_relation) %}
+    {% set contract_config = config.get('contract') %}
+    {% if not contract_config or not contract_config.enforced %}
+      {% do adapter.expand_target_column_types(
+               from_relation=temp_relation,
+               to_relation=target_relation) %}
+    {% endif %}
     {#-- Process schema changes. Returns dict of changes if successful. Use source columns for upserting/merging --#}
     {% set dest_columns = process_schema_changes(on_schema_change, temp_relation, existing_relation) %}
     {% if not dest_columns %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/models/materialized_view.sql

@@ -71,9 +71,9 @@
             {% set build_sql = get_alter_materialized_view_as_sql(target_relation, configuration_changes, sql, existing_relation, backup_relation, intermediate_relation) %}
         {% elif on_configuration_change == 'continue' %}
             {% set build_sql = '' %}
-            {{ exceptions.warn("Configuration changes were identified and `on_configuration_change` was set to `continue` for `" ~ target_relation ~ "`") }}
+            {{ exceptions.warn("Configuration changes were identified and `on_configuration_change` was set to `continue` for `" ~ target_relation.render() ~ "`") }}
         {% elif on_configuration_change == 'fail' %}
-            {{ exceptions.raise_fail_fast_error("Configuration changes were identified and `on_configuration_change` was set to `fail` for `" ~ target_relation ~ "`") }}
+            {{ exceptions.raise_fail_fast_error("Configuration changes were identified and `on_configuration_change` was set to `fail` for `" ~ target_relation.render() ~ "`") }}
 
         {% else %}
             -- this only happens if the user provides a value other than `apply`, 'skip', 'fail'

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/seeds/helpers.sql

@@ -37,7 +37,7 @@
         {% set sql = create_csv_table(model, agate_table) %}
     {% else %}
         {{ adapter.truncate_relation(old_relation) }}
-        {% set sql = "truncate table " ~ old_relation %}
+        {% set sql = "truncate table " ~ old_relation.render() %}
     {% endif %}
 
     {{ return(sql) }}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/seeds/seed.sql

@@ -22,7 +22,7 @@
   -- build model
   {% set create_table_sql = "" %}
   {% if exists_as_view %}
-    {{ exceptions.raise_compiler_error("Cannot seed to '{}', it is a view".format(old_relation)) }}
+    {{ exceptions.raise_compiler_error("Cannot seed to '{}', it is a view".format(old_relation.render())) }}
   {% elif exists_as_table %}
     {% set create_table_sql = reset_csv_table(model, full_refresh_mode, old_relation, agate_table) %}
   {% else %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/snapshots/helpers.sql

@@ -8,7 +8,7 @@
 {% macro default__create_columns(relation, columns) %}
   {% for column in columns %}
     {% call statement() %}
-      alter table {{ relation }} add column "{{ column.name }}" {{ column.data_type }};
+      alter table {{ relation.render() }} add column "{{ column.name }}" {{ column.data_type }};
     {% endcall %}
   {% endfor %}
 {% endmacro %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/materializations/snapshots/snapshot_merge.sql

@@ -7,7 +7,7 @@
 {% macro default__snapshot_merge_sql(target, source, insert_cols) -%}
     {%- set insert_cols_csv = insert_cols | join(', ') -%}
 
-    merge into {{ target }} as DBT_INTERNAL_DEST
+    merge into {{ target.render() }} as DBT_INTERNAL_DEST
     using {{ source }} as DBT_INTERNAL_SOURCE
     on DBT_INTERNAL_SOURCE.dbt_scd_id = DBT_INTERNAL_DEST.dbt_scd_id
 

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/relations/drop.sql

@@ -16,7 +16,7 @@
         {{ drop_materialized_view(relation) }}
 
     {%- else -%}
-        drop {{ relation.type }} if exists {{ relation }} cascade
+        drop {{ relation.type }} if exists {{ relation.render() }} cascade
 
     {%- endif -%}
 

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/relations/materialized_view/drop.sql

@@ -10,5 +10,5 @@ actually executes the drop, and `get_drop_sql`, which returns the template.
 
 
 {% macro default__drop_materialized_view(relation) -%}
-    drop materialized view if exists {{ relation }} cascade
+    drop materialized view if exists {{ relation.render() }} cascade
 {%- endmacro %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/relations/rename.sql

@@ -30,6 +30,6 @@
 {% macro default__rename_relation(from_relation, to_relation) -%}
   {% set target_name = adapter.quote_as_configured(to_relation.identifier, 'identifier') %}
   {% call statement('rename_relation') -%}
-    alter table {{ from_relation }} rename to {{ target_name }}
+    alter table {{ from_relation.render() }} rename to {{ target_name }}
   {%- endcall %}
 {% endmacro %}

{dbt_adapters-1.3.2 → dbt_adapters-1.4.0}/dbt/include/global_project/macros/relations/table/drop.sql

@@ -10,5 +10,5 @@ actually executes the drop, and `get_drop_sql`, which returns the template.
 
 
 {% macro default__drop_table(relation) -%}
-    drop table if exists {{ relation }} cascade
+    drop table if exists {{ relation.render() }} cascade
 {%- endmacro %}