dbt-firebolt 1.9.3__py3-none-any.whl → 1.10.0__py3-none-any.whl

dbt/adapters/firebolt/__init__.py

@@ -7,7 +7,7 @@ from dbt.adapters.firebolt.connections import (
 from dbt.adapters.firebolt.impl import FireboltAdapter
 from dbt.include import firebolt
 
-__version__ = "1.9.3"
+__version__ = "1.10.0"
 
 Plugin = AdapterPlugin(
     adapter=FireboltAdapter,  # type: ignore

dbt/adapters/firebolt/connections.py

@@ -19,7 +19,12 @@ from dbt_common.exceptions import (
     NotImplementedError,
 )
 from firebolt.client import DEFAULT_API_URL
-from firebolt.client.auth import Auth, ClientCredentials, UsernamePassword
+from firebolt.client.auth import (
+    Auth,
+    ClientCredentials,
+    FireboltCore,
+    UsernamePassword,
+)
 from firebolt.db import ARRAY, DECIMAL, ExtendedType
 from firebolt.db import connect as sdk_connect
 from firebolt.db.connection import Connection as SDKConnection
@@ -41,6 +46,7 @@ class FireboltCredentials(Credentials):
     api_endpoint: Optional[str] = DEFAULT_API_URL
     engine_name: Optional[str] = None
     account_name: Optional[str] = None
+    url: Optional[str] = None
     retries: int = 1
 
     _ALIASES = {
@@ -48,26 +54,14 @@ class FireboltCredentials(Credentials):
     }
 
     def __post_init__(self) -> None:
-        # If user and password are not provided, assume client_id and client_secret
-        # are provided instead
-        if not self.user and not self.password:
-            if not self.client_id or not self.client_secret:
-                raise DbtConfigError(
-                    'Either user and password or client_id and client_secret'
-                    ' must be provided'
-                )
-        else:
-            if self.client_id or self.client_secret:
-                raise DbtConfigError(
-                    'Either user and password or client_id and client_secret'
-                    ' must be provided'
-                )
+        # Check the credentials are valid and we can determine the auth method
+        _determine_auth(self)
 
     @property
     def type(self) -> str:
         return 'firebolt'
 
-    def _connection_keys(self) -> Tuple[str, str, str, str, str, str, str]:
+    def _connection_keys(self) -> Tuple[str, str, str, str, str, str, str, str]:
         """
         Return tuple of keys (i.e. not values) to display
         in the `dbt debug` output.
@@ -80,6 +74,7 @@ class FireboltCredentials(Credentials):
             'database',
             'engine_name',
             'params',
+            'url',
         )
 
     @property
@@ -222,17 +217,50 @@ class FireboltConnectionManager(SQLConnectionManager):
 
 
 def _determine_auth(credentials: FireboltCredentials) -> Auth:
-    if credentials.client_id and credentials.client_secret:
-        return ClientCredentials(credentials.client_id, credentials.client_secret)
-    elif '@' in credentials.user:  # type: ignore # checked in the dataclass
-        # email auth can only be used with UsernamePassword
-        return UsernamePassword(
-            credentials.user,  # type: ignore[arg-type]
-            credentials.password,  # type: ignore[arg-type]
-        )
-    else:
-        # assume user provided id and secret in the user/password fields
+    """Determine the appropriate authentication method based on provided credentials."""
+
+    def _has_client_credentials() -> bool:
+        return bool(credentials.client_id and credentials.client_secret)
+
+    def _has_user_password() -> bool:
+        return bool(credentials.user and credentials.password)
+
+    def _is_email_auth() -> bool:
+        return bool(credentials.user and '@' in credentials.user)
+
+    # Handle Firebolt Core authentication (no other credentials allowed)
+    if credentials.url:
+        if _has_client_credentials() or _has_user_password():
+            raise DbtConfigError(
+                'If url is provided, do not provide user, password, '
+                'client_id, or client_secret.'
+            )
+        return FireboltCore()
+
+    # Handle client credentials authentication
+    if _has_client_credentials():
         return ClientCredentials(
-            credentials.user,  # type: ignore[arg-type]
-            credentials.password,  # type: ignore[arg-type]
+            credentials.client_id,  # type: ignore[arg-type]
+            credentials.client_secret,  # type: ignore[arg-type]
         )
+
+    # Handle username/password authentication
+    if _has_user_password():
+        if _is_email_auth():
+            return UsernamePassword(
+                credentials.user,  # type: ignore[arg-type]
+                credentials.password,  # type: ignore[arg-type]
+            )
+        else:
+            return ClientCredentials(
+                credentials.user,  # type: ignore[arg-type]
+                credentials.password,  # type: ignore[arg-type]
+            )
+
+    # If we reach here, no valid authentication method was found
+    raise DbtConfigError(
+        'No valid authentication method found. Provide either:\n'
+        '- client_id and client_secret\n'
+        '- user and password\n'
+        '- or use url for Firebolt Core connection'
+    )

dbt/adapters/firebolt/impl.py

@@ -313,7 +313,8 @@ class FireboltAdapter(SQLAdapter):
             names = sorted((self.quote(n) for n in column_names))
 
         where_expressions = [
-            f'{relation_a}.{name} = {relation_b}.{name}' for name in names
+            f'{relation_a}.{name} IS NOT DISTINCT FROM {relation_b}.{name}'
+            for name in names
         ]
         where_clause = ' AND '.join(where_expressions)
         columns_csv = ', '.join(names)

dbt/include/firebolt/macros/adapters/apply_grants.sql

@@ -0,0 +1,37 @@
+{% macro firebolt__get_show_grant_sql(relation) %}
+    {# Usually called from apply_grants. Should not be called directly. #}
+    {{ adapter.raise_grant_error() }}
+{% endmacro %}
+
+
+{%- macro firebolt__get_grant_sql(relation, privilege, grantee) -%}
+    {# Usually called from apply_grants. Should not be called directly. #}
+    {{ adapter.raise_grant_error() }}
+{%- endmacro -%}
+
+
+{%- macro firebolt__get_revoke_sql(relation, privilege, grantee) -%}
+    {# Usually called from apply_grants. Should not be called directly. #}
+    {{ adapter.raise_grant_error() }}
+{%- endmacro -%}
+
+
+{% macro firebolt__copy_grants() %}
+    {{ return(True) }}
+{% endmacro %}
+
+
+{% macro firebolt__apply_grants(relation, grant_config, should_revoke) %}
+    {% if grant_config %}
+        {{ adapter.raise_grant_error() }}
+    {% endif %}
+{% endmacro %}
+
+
+{%- macro firebolt__get_dcl_statement_list(relation, grant_config, get_dcl_macro) -%}
+    {# Firebolt does not support DCL statements yet #}
+    {% if grant_config %}
+        {{ adapter.raise_grant_error() }}
+    {% endif %}
+    {{ return([]) }}
+{%- endmacro %}

dbt/include/firebolt/macros/adapters/relation.sql

@@ -0,0 +1,49 @@
+{% macro firebolt__rename_relation(source, target) -%}
+  {# Create new relation, do CTAS to swap it, remove original relation.
+     Must check whether relation is view or table, because process is
+     different for the two. #}
+  {% set all_relations = (list_relations_without_caching(source)) %}
+  {% set tables = adapter.filter_table(all_relations, 'type', 'table') %}
+  {% set views = adapter.filter_table(all_relations, 'type', 'view') %}
+  {% if (views.rows | length) > 0 %}
+    {% call statement('view_definition', fetch_result=True) %}
+
+      SELECT view_definition FROM information_schema.views
+      WHERE table_name = '{{ source.identifier }}'
+    {%- endcall %}
+    {% if load_result('view_definition')['data'] %}
+      {# For some reason this ocassionally returns an empty set.
+         In that case do nothing. Don't even ask why I have to jump through
+         the stupid hoops to get the value out of the result in the next line. #}
+      {% set view_ddl = load_result('view_definition')['data'][0][0] %}
+      {% set view_ddl = view_ddl.replace(source.identifier,
+                                         target.identifier) %}
+      {% call statement('new_view') %}
+
+        DROP VIEW {{ source.identifier }};
+        {{ view_ddl }};
+      {% endcall %}
+    {% endif %}
+  {% elif (tables.rows | length) > 0 %}
+    {# There were no views, so retrieve table. (There must be a table.) #}
+    {% set table_type = adapter.filter_table(all_relations, 'table_type', '') %}
+    {% call statement('tables') %}
+
+      CREATE {{ table_type }} TABLE {{ target.identifier }} AS
+      SELECT * FROM {{ source.identifier }};
+      DROP TABLE {{ source.identifier }};
+    {%- endcall %}
+  {% endif %}
+{% endmacro %}
+
+
+{% macro firebolt__drop_relation(relation) -%}
+  {#-
+  Drop relation. Drop both table and view because relation doesn't always
+  have a table_type specified.
+  #}
+  {% call statement('drop') %}
+
+      DROP {{ relation.type | upper }} IF EXISTS {{ relation }} CASCADE;
+  {% endcall %}
+{% endmacro %}

dbt/include/firebolt/macros/dbt_external_tables/create_external_table.sql

@@ -0,0 +1,141 @@
+{% macro firebolt__create_external_table(source_node) %}
+    {% if source_node.external.strategy == 'copy' %}
+        {{ firebolt__create_with_copy_from(source_node) }}
+    {% else %}
+        {{ firebolt__create_with_external_table(source_node) }}
+    {% endif %}
+{% endmacro %}
+
+{% macro firebolt__create_with_external_table(source_node) %}
+    {%- set external = source_node.external -%}
+    {%- if 'partitions' in external -%}
+        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
+                                                             external.partitions) -%}
+    {%- else -%}
+        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
+                                                             []) -%}
+    {%- endif -%}
+    {%- set credentials = external.credentials -%}
+    {# Leaving out "IF NOT EXISTS" because this should only be called by
+       if no DROP IF is necessary. #}
+    CREATE EXTERNAL TABLE {{source(source_node.source_name, source_node.name)}} (
+        {%- for column in columns -%}
+          {{ column }}
+          {{- ',' if not loop.last }}
+        {% endfor -%}
+    )
+    {% if external.url %} URL = '{{external.url}}' {%- endif %}
+    {%- if credentials and credentials.internal_role_arn %}
+        CREDENTIALS = (AWS_ROLE_ARN = '{{credentials.internal_role_arn}}'
+        {%- if credentials.external_role_id %}
+                       AWS_ROLE_EXTERNAL_ID = '{{credentials.external_role_id}}'
+        {%- endif -%}
+        )
+    {% elif credentials and credentials.aws_key_id %}
+        CREDENTIALS = (AWS_KEY_ID = '{{credentials.aws_key_id}}'
+                       AWS_SECRET_KEY = '{{credentials.aws_secret_key}}')
+    {%- endif %}
+    {%- if external.object_pattern -%} OBJECT_PATTERN = '{{external.object_pattern}}' {%- endif %}
+    {% if external.object_patterns -%}
+        OBJECT_PATTERN =
+            {%- for obj in external.object_patterns -%}
+                {{ obj }}
+                {{- ',' if not loop.last }}
+            {%- endfor %}
+    {%- endif %}
+    {%- if external.compression -%} COMPRESSION = {{external.compression}} {%- endif %}
+    TYPE = {{ external.type }}
+{% endmacro %}
+
+{% macro firebolt__create_with_copy_from(source_node) %}
+    {# COPY FROM is only available in Firebolt 2.0. #}
+    {%- set external = source_node.external -%}
+    {%- set credentials = external.credentials -%}
+    {%- set where_clause = external.where -%}
+    {%- set options = external.options -%}
+    {%- set csv_options = options.csv_options -%}
+    {%- set error_file_credentials = options.error_file_credentials -%}
+
+    {# There are no partitions, but this formats the columns correctly. #}
+    {%- if 'partitions' in external -%}
+        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
+                                                             external.partitions) -%}
+    {%- else -%}
+        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
+                                                             []) -%}
+    {%- endif -%}
+    COPY INTO {{source(source_node.source_name, source_node.name)}}
+    {%- if columns and columns | length > 0 %}
+    (
+        {%- for column in columns -%}
+          {{ column.name }}
+          {%- if column.default %} DEFAULT {{ column.default }}{% endif %}
+          {%- if column.source_column_name %} {{ '$' ~ loop.index0 }}{% endif %}
+          {{- ',' if not loop.last }}
+        {%- endfor -%}
+    )
+    {%- endif %}
+    FROM '{{external.url}}'
+    {%- if options or credentials %}
+        WITH
+        {%- if options.object_pattern %}
+            PATTERN = '{{options.object_pattern}}'
+        {%- endif %}
+        {%- if options.type %}
+            TYPE = {{ options.type }}
+        {%- endif %}
+        {%- if options.auto_create %}
+            AUTO_CREATE = {{ options.auto_create | upper }}
+        {%- endif %}
+        {%- if options.allow_column_mismatch %}
+            ALLOW_COLUMN_MISMATCH = {{ options.allow_column_mismatch | upper }}
+        {%- endif %}
+        {%- if options.error_file %}
+            ERROR_FILE = '{{ options.error_file }}'
+        {%- endif %}
+        {%- if error_file_credentials %}
+            ERROR_FILE_CREDENTIALS = (AWS_KEY_ID = '{{ error_file_credentials.aws_key_id }}' AWS_SECRET_KEY = '{{ error_file_credentials.aws_secret_key }}')
+        {%- endif %}
+        {%- if options.max_errors_per_file %}
+            MAX_ERRORS_PER_FILE = {{ options.max_errors_per_file }}
+        {%- endif %}
+        {%- if csv_options %}
+            {%- if csv_options.header %}
+                HEADER = {{ csv_options.header | upper }}
+            {%- endif %}
+            {%- if csv_options.delimiter %}
+                DELIMITER = '{{ csv_options.delimiter }}'
+            {%- endif %}
+            {%- if csv_options.newline %}
+                NEWLINE = '{{ csv_options.newline }}'
+            {%- endif %}
+            {%- if csv_options.quote %}
+                QUOTE = {{ csv_options.quote }}
+            {%- endif %}
+            {%- if csv_options.escape %}
+                ESCAPE = '{{ csv_options.escape }}'
+            {%- endif %}
+            {%- if csv_options.null_string %}
+                NULL_STRING = '{{ csv_options.null_string }}'
+            {%- endif %}
+            {%- if csv_options.empty_field_as_null %}
+                EMPTY_FIELD_AS_NULL = {{ csv_options.empty_field_as_null | upper }}
+            {%- endif %}
+            {%- if csv_options.skip_blank_lines %}
+                SKIP_BLANK_LINES = {{ csv_options.skip_blank_lines | upper }}
+            {%- endif %}
+            {%- if csv_options.date_format %}
+                DATE_FORMAT = '{{ csv_options.date_format }}'
+            {%- endif %}
+            {%- if csv_options.timestamp_format %}
+                TIMESTAMP_FORMAT = '{{ csv_options.timestamp_format }}'
+            {%- endif %}
+        {%- endif %}
+        {%- if credentials %}
+            CREDENTIALS = (AWS_KEY_ID = '{{credentials.aws_key_id}}' AWS_SECRET_KEY = '{{credentials.aws_secret_key}}')
+        {%- endif %}
+    {%- endif %}
+    {%- if where_clause %}
+        WHERE {{ where_clause }}
+    {%- endif %}
+{% endmacro %}

dbt/include/firebolt/macros/dbt_external_tables/dropif.sql

@@ -0,0 +1,6 @@
+{% macro firebolt__dropif(source_node) %}
+    {% set ddl %}
+        DROP TABLE IF EXISTS {{ source_node['name'] }}
+    {% endset %}
+    {{return(ddl)}}
+{% endmacro %}

dbt/include/firebolt/macros/dbt_external_tables/get_external_build_plan.sql

@@ -0,0 +1,18 @@
+{% macro firebolt__get_external_build_plan(source_node) %}
+    {% set build_plan = [] %}
+    {% set old_relation = adapter.get_relation(
+        database = source_node.database,
+        schema = source_node.schema,
+        identifier = source_node.identifier
+    ) %}
+    {# var(variable, Boolean) defaults to Boolean value if variable isnt set.
+       Firebolt doesn't do refresh because we don't need to—external tables will always
+       pull most recent data from S3, so the default action below is to skip. #}
+    {% if old_relation is none or var('ext_full_refresh', false) %}
+        {% set build_plan = build_plan + [dropif(source_node),
+                                          create_external_table(source_node)] %}
+    {% else %}
+        {% set build_plan = dbt_external_tables.refresh_external_table(source_node) %}
+    {% endif %}
+    {% do return(build_plan) %}
+{% endmacro %}

dbt/include/firebolt/macros/materializations/clone.sql

@@ -0,0 +1,3 @@
+{% macro firebolt__can_clone_table() %}
+    {{ return(False) }}
+{% endmacro %}

dbt/include/firebolt/macros/materializations/materialized_view.sql

@@ -0,0 +1,3 @@
+{% macro firebolt__get_materialized_view_configuration_changes(existing_relation, new_config) %}
+    {{ exceptions.raise_compiler_error("Firebolt does not support materialized views") }}
+{% endmacro %}

dbt/include/firebolt/macros/materializations/models/incremental/column_helpers.sql

@@ -0,0 +1,21 @@
+{% macro intersect_columns(source_columns, target_columns) %}
+  {# Return a List[FireboltColumn] of columns that appear in both source and target.
+     Args:
+       source_columns: List[FireboltColumn]
+       target_columns: List[FireboltColumn]
+  #}
+  {% set result = [] %}
+  {# Note I'm using `column` and not `name` below, as name is a getter
+     and column is the actual field. #}
+  {% set source_names = source_columns | map(attribute = 'column') | list %}
+  {% set target_names = target_columns | map(attribute = 'column') | list %}
+  {# Check whether the name attribute exists in the target - this does
+     not perform a data type check. This is O(m•n), but cardinality
+     of columns is probably low enough that it doesn't matter. #}
+  {% for sc in source_columns %}
+    {% if sc.name in target_names %}
+       {{ result.append(sc) }}
+    {% endif %}
+  {% endfor %}
+  {{ return(result) }}
+{% endmacro %}

dbt/include/firebolt/macros/materializations/models/incremental/incremental.sql

@@ -0,0 +1,131 @@
+{% macro dbt_firebolt_get_tmp_relation_type(strategy) %}
+  {#
+    Determine whether to use a temporary view or a table based on
+    specified strategy and config. Users can override the behaviour
+    by setting tmp_replation_type. Default is to use a view (more efficient).
+
+    Arguments:
+      strategy: incremental strategy from config. e.g. "append"
+  #}
+  {%- set tmp_relation_type = config.get('tmp_relation_type') -%}
+
+  {% if tmp_relation_type == "table" %}
+    {{ return("table") }}
+  {% elif tmp_relation_type == "view" %}
+    {{ return("view") }}
+  {% elif strategy in ("default", "append", "insert_overwrite") %}
+    {{ return("view") }}
+  {% else %}
+    {{ return("table") }}
+  {% endif %}
+{% endmacro %}
+
+{% materialization incremental, adapter='firebolt' -%}
+  {#
+  Incremental implementation. Actual strategy SQL is determined
+  outside this materialization, in strategies.sql.
+
+  This function works by first creating a view, `new_records`, of type `BaseRelation`,
+  then using a CTE defined in the project model to populate `new_records` with
+  any records that ought to be inserted into the original table (views aren't currently
+  supported), `existing`, using an INSERT. This process is agnostic to the incremental
+  strategy actually used: the specific INSERT is defined in `strategies.sql`.
+
+  Note that all new relations must first be instantiated as BaseRelation objects,
+  and that those objects are used to create and query actual relations in the DB.
+  Care must be taken to correctly define each BaseRelation as either a view or
+  a table, lest subsequent operations on the relations (be the they objects or
+  the DB tables the objects abstract) fail.
+  #}
+
+  {% set unique_key = config.get('unique_key') %}
+
+  {% set grant_config = config.get('grants') %}
+
+  {%- set strategy = config.get('incremental_strategy') -%}
+  {%- if is_incremental() and strategy is none -%}
+    {{ log('Model %s is set to incremental, but no incremental strategy is set. '
+           'Defaulting to append' % this, True) }}
+    {%- set strategy = 'append' -%}
+  {%- endif -%}
+  {# In following lines:
+
+     `target` is just a dbt `BaseRelation` object, not a DB table.
+
+     We're only retrieving `existing` to check for existence; `load_relation()`
+     returns a `BaseRelation` with the dictionary values of any relations that exist
+     in dbt's cache that share the identifier of the passed relation. If none
+     exist, returns None. Note that this does *not* create a table in the DB.
+
+     `target` is a relation with all the same fields as `existing`, but guaranteed
+     to be an actual `BaseRelation` object. #}
+  {%- set target = this.incorporate(type='table') -%}
+  {%- set existing = load_relation(this) -%}
+  {%- set tmp_relation_type = dbt_firebolt_get_tmp_relation_type(strategy) -%}
+  {%- set new_records = make_temp_relation(target) -%}
+  {{ drop_relation_if_exists(new_records) }}
+  {%- set new_records = new_records.incorporate(type=tmp_relation_type) -%}
+  {%- set on_schema_change = incremental_validate_on_schema_change(
+                                config.get('on_schema_change'),
+                                default='ignore') -%}
+
+  -- `BEGIN` happens here:
+  {{ run_hooks(pre_hooks, inside_transaction=True) }}
+  {%- set partition_by = config.get('partition_by') -%}
+  {# First check whether we want to full refresh for existing view or config reasons. #}
+  {%- if strategy == 'insert_overwrite' and not partition_by -%}
+    {% do exceptions.raise_compiler_error('`insert_overwrite` is specified for model %s, '
+                                          'but `partition_by` is not. `insert_overwrite` '
+                                          'requires a partition.' % (target)) %}
+  {%- endif -%}
+  {%- set do_full_refresh = (should_full_refresh()
+                             or existing.is_view) %}
+  {% if existing is none %}
+    {%- set build_sql = create_table_as(False, target, sql) -%}
+  {%- elif do_full_refresh -%}
+    {{ drop_relation_if_exists(existing) }}
+    {%- set build_sql = create_table_as(False, target, sql) -%}
+  {%- else -%}
+    {# Actually do the incremental query here. #}
+    {# Instantiate new objects in dbt's internal list. Have to
+       run this query so dbt can query the DB to get the columns in
+       new_records. #}
+    {%- if tmp_relation_type=='view' -%}
+      {%- do run_query(create_view_as(new_records, sql)) -%}
+    {%- else -%}
+      {%- do run_query(create_table_as(True, new_records, sql)) -%}
+    {%- endif -%}
+    {# All errors involving schema changes are dealt with in `process_schema_changes`. #}
+    {%- set dest_columns = process_schema_changes(on_schema_change,
+                                                  new_records,
+                                                  existing) -%}
+    {%- set incremental_predicates = config.get('predicates', none) or config.get('incremental_predicates', none) -%}
+    {%- set build_sql = get_incremental_sql(strategy,
+                                            new_records,
+                                            target,
+                                            unique_key,
+                                            dest_columns,
+                                            incremental_predicates) -%}
+  {%- endif -%}
+  {%- call statement("main") -%}
+    {{ build_sql }}
+  {%- endcall -%}
+
+  {% set should_revoke = should_revoke(existing_relation, full_refresh_mode) %}
+  {% do apply_grants(target_relation, grant_config, should_revoke) %}
+
+  {# Todo: figure out what persist_docs and create_indexes do. #}
+  {%- do persist_docs(target, model) -%}
+  {%- if existing is none
+      or existing.is_view
+      or should_full_refresh() -%}
+  {%- do create_indexes(target) -%}
+  {%- endif %}
+
+  {{ drop_relation_if_exists(new_records) }}
+
+  {{ run_hooks(post_hooks, inside_transaction=True) }}
+
+  {{ return({'relations': [target]}) }}
+
+{%- endmaterialization %}

dbt/include/firebolt/macros/materializations/models/incremental/is_incremental.sql

@@ -0,0 +1,14 @@
+{% macro is_incremental() %}
+    {#- Return True if model is incremental, otherwise False. -#}
+    {% if not execute %}
+        {{ return(False) }}
+    {% else %}
+        {% set relation = adapter.get_relation(this.database,
+                                               this.schema,
+                                               this.table) %}
+        {{ return(relation is not none
+                  and relation.type == 'table'
+                  and model.config.materialized == 'incremental'
+                  and not should_full_refresh()) }}
+    {% endif %}
+{% endmacro %}

dbt/include/firebolt/macros/materializations/models/incremental/merge.sql

@@ -0,0 +1,38 @@
+{% macro firebolt__get_delete_insert_merge_sql(target, source, unique_key, dest_columns, incremental_predicates) -%}
+
+    {%- set dest_cols_csv = get_quoted_csv(dest_columns | map(attribute="name")) -%}
+
+    {% if unique_key %}
+        {% if unique_key is sequence and unique_key is not string %}
+            delete from {{ target }}
+            where
+                ({{ get_quoted_csv(unique_key) }}) in (
+                    select {{ get_quoted_csv(unique_key) }}
+                    from {{ source }}
+                )
+                {% if incremental_predicates %}
+                    {% for predicate in incremental_predicates %}
+                        and {{ predicate }}
+                    {% endfor %}
+                {% endif %};
+        {% else %}
+            delete from {{ target }}
+            where (
+                {{ unique_key }}) in (
+                select ({{ unique_key }})
+                from {{ source }}
+            )
+            {%- if incremental_predicates %}
+                {% for predicate in incremental_predicates %}
+                    and {{ predicate }}
+                {% endfor %}
+            {%- endif -%};
+
+        {% endif %}
+    {% endif %}
+
+    insert into {{ target }} ({{ dest_cols_csv }})
+    select {{ dest_cols_csv }}
+    from {{ source }}
+
+{%- endmacro %}