dbt-adapters 1.22.2__py3-none-any.whl

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

@@ -0,0 +1,167 @@
+{# ------- BOOLEAN MACROS --------- #}
+
+{#
+  -- COPY GRANTS
+  -- When a relational object (view or table) is replaced in this database,
+  -- do previous grants carry over to the new object? This may depend on:
+  --    whether we use alter-rename-swap versus CREATE OR REPLACE
+  --    user-supplied configuration (e.g. copy_grants on Snowflake)
+  -- By default, play it safe, assume TRUE: that grants ARE copied over.
+  -- This means dbt will first "show" current grants and then calculate diffs.
+  -- It may require an additional query than is strictly necessary,
+  -- but better safe than sorry.
+#}
+
+{% macro copy_grants() %}
+    {{ return(adapter.dispatch('copy_grants', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__copy_grants() %}
+    {{ return(True) }}
+{% endmacro %}
+
+
+{#
+  -- SUPPORT MULTIPLE GRANTEES PER DCL STATEMENT
+  -- Does this database support 'grant {privilege} to {grantee_1}, {grantee_2}, ...'
+  -- Or must these be separate statements:
+  --  `grant {privilege} to {grantee_1}`;
+  --  `grant {privilege} to {grantee_2}`;
+  -- By default, pick the former, because it's what we prefer when available.
+#}
+
+{% macro support_multiple_grantees_per_dcl_statement() %}
+    {{ return(adapter.dispatch('support_multiple_grantees_per_dcl_statement', 'dbt')()) }}
+{% endmacro %}
+
+{%- macro default__support_multiple_grantees_per_dcl_statement() -%}
+    {{ return(True) }}
+{%- endmacro -%}
+
+
+{% macro should_revoke(existing_relation, full_refresh_mode=True) %}
+
+    {% if not existing_relation %}
+        {#-- The table doesn't already exist, so no grants to copy over --#}
+        {{ return(False) }}
+    {% elif full_refresh_mode %}
+        {#-- The object is being REPLACED -- whether grants are copied over depends on the value of user config --#}
+        {{ return(copy_grants()) }}
+    {% else %}
+        {#-- The table is being merged/upserted/inserted -- grants will be carried over --#}
+        {{ return(True) }}
+    {% endif %}
+
+{% endmacro %}
+
+{# ------- DCL STATEMENT TEMPLATES --------- #}
+
+{% macro get_show_grant_sql(relation) %}
+    {{ return(adapter.dispatch("get_show_grant_sql", "dbt")(relation)) }}
+{% endmacro %}
+
+{% macro default__get_show_grant_sql(relation) %}
+    show grants on {{ relation.render() }}
+{% endmacro %}
+
+
+{% macro get_grant_sql(relation, privilege, grantees) %}
+    {{ return(adapter.dispatch('get_grant_sql', 'dbt')(relation, privilege, grantees)) }}
+{% endmacro %}
+
+{%- macro default__get_grant_sql(relation, privilege, grantees) -%}
+    grant {{ privilege }} on {{ relation.render() }} to {{ grantees | join(', ') }}
+{%- endmacro -%}
+
+
+{% macro get_revoke_sql(relation, privilege, grantees) %}
+    {{ return(adapter.dispatch('get_revoke_sql', 'dbt')(relation, privilege, grantees)) }}
+{% endmacro %}
+
+{%- macro default__get_revoke_sql(relation, privilege, grantees) -%}
+    revoke {{ privilege }} on {{ relation.render() }} from {{ grantees | join(', ') }}
+{%- endmacro -%}
+
+
+{# ------- RUNTIME APPLICATION --------- #}
+
+{% macro get_dcl_statement_list(relation, grant_config, get_dcl_macro) %}
+    {{ return(adapter.dispatch('get_dcl_statement_list', 'dbt')(relation, grant_config, get_dcl_macro)) }}
+{% endmacro %}
+
+{%- macro default__get_dcl_statement_list(relation, grant_config, get_dcl_macro) -%}
+    {#
+      -- Unpack grant_config into specific privileges and the set of users who need them granted/revoked.
+      -- Depending on whether this database supports multiple grantees per statement, pass in the list of
+      -- all grantees per privilege, or (if not) template one statement per privilege-grantee pair.
+      -- `get_dcl_macro` will be either `get_grant_sql` or `get_revoke_sql`
+    #}
+    {%- set dcl_statements = [] -%}
+    {%- for privilege, grantees in grant_config.items() %}
+        {%- if support_multiple_grantees_per_dcl_statement() and grantees -%}
+          {%- set dcl = get_dcl_macro(relation, privilege, grantees) -%}
+          {%- do dcl_statements.append(dcl) -%}
+        {%- else -%}
+          {%- for grantee in grantees -%}
+              {% set dcl = get_dcl_macro(relation, privilege, [grantee]) %}
+              {%- do dcl_statements.append(dcl) -%}
+          {% endfor -%}
+        {%- endif -%}
+    {%- endfor -%}
+    {{ return(dcl_statements) }}
+{%- endmacro %}
+
+
+{% macro call_dcl_statements(dcl_statement_list) %}
+    {{ return(adapter.dispatch("call_dcl_statements", "dbt")(dcl_statement_list)) }}
+{% endmacro %}
+
+{% macro default__call_dcl_statements(dcl_statement_list) %}
+    {#
+      -- By default, supply all grant + revoke statements in a single semicolon-separated block,
+      -- so that they're all processed together.
+
+      -- Some databases do not support this. Those adapters will need to override this macro
+      -- to run each statement individually.
+    #}
+    {% call statement('grants') %}
+        {% for dcl_statement in dcl_statement_list %}
+            {{ dcl_statement }};
+        {% endfor %}
+    {% endcall %}
+{% endmacro %}
+
+
+{% macro apply_grants(relation, grant_config, should_revoke) %}
+    {{ return(adapter.dispatch("apply_grants", "dbt")(relation, grant_config, should_revoke)) }}
+{% endmacro %}
+
+{% macro default__apply_grants(relation, grant_config, should_revoke=True) %}
+    {#-- If grant_config is {} or None, this is a no-op --#}
+    {% if grant_config %}
+        {% if should_revoke %}
+            {#-- We think previous grants may have carried over --#}
+            {#-- Show current grants and calculate diffs --#}
+            {% set current_grants_table = run_query(get_show_grant_sql(relation)) %}
+            {% set current_grants_dict = adapter.standardize_grants_dict(current_grants_table) %}
+            {% 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.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. --#}
+            {#-- Jump straight to granting what the user has configured. --#}
+            {% set needs_revoking = {} %}
+            {% set needs_granting = grant_config %}
+        {% endif %}
+        {% if needs_granting or needs_revoking %}
+            {% set revoke_statement_list = get_dcl_statement_list(relation, needs_revoking, get_revoke_sql) %}
+            {% set grant_statement_list = get_dcl_statement_list(relation, needs_granting, get_grant_sql) %}
+            {% set dcl_statement_list = revoke_statement_list + grant_statement_list %}
+            {% if dcl_statement_list %}
+                {{ call_dcl_statements(dcl_statement_list) }}
+            {% endif %}
+        {% endif %}
+    {% endif %}
+{% endmacro %}

dbt/include/global_project/macros/adapters/columns.sql

@@ -0,0 +1,144 @@
+{% macro get_columns_in_relation(relation) -%}
+  {{ return(adapter.dispatch('get_columns_in_relation', 'dbt')(relation)) }}
+{% endmacro %}
+
+{% macro default__get_columns_in_relation(relation) -%}
+  {{ exceptions.raise_not_implemented(
+    'get_columns_in_relation macro not implemented for adapter '+adapter.type()) }}
+{% endmacro %}
+
+{# helper for adapter-specific implementations of get_columns_in_relation #}
+{% macro sql_convert_columns_in_relation(table) -%}
+  {% set columns = [] %}
+  {% for row in table %}
+    {% do columns.append(api.Column(*row)) %}
+  {% endfor %}
+  {{ return(columns) }}
+{% endmacro %}
+
+{%- macro get_list_of_column_names(columns) -%}
+  {% set col_names = [] %}
+  {% for col in columns %}
+    {% do col_names.append(col.name) %}
+  {% endfor %}
+  {{ return(col_names) }}
+{% endmacro %}
+
+{% macro get_empty_subquery_sql(select_sql, select_sql_header=none) -%}
+  {{ return(adapter.dispatch('get_empty_subquery_sql', 'dbt')(select_sql, select_sql_header)) }}
+{% endmacro %}
+
+{#
+  Builds a query that results in the same schema as the given select_sql statement, without necessitating a data scan.
+  Useful for running a query in a 'pre-flight' context, such as model contract enforcement (assert_columns_equivalent macro).
+#}
+{% macro default__get_empty_subquery_sql(select_sql, select_sql_header=none) %}
+    {%- if select_sql_header is not none -%}
+    {{ select_sql_header }}
+    {%- endif -%}
+    select * from (
+        {{ select_sql }}
+    ) as __dbt_sbq
+    where false
+    limit 0
+{% endmacro %}
+
+{% macro get_empty_schema_sql(columns) -%}
+  {{ return(adapter.dispatch('get_empty_schema_sql', 'dbt')(columns)) }}
+{% endmacro %}
+
+{% macro default__get_empty_schema_sql(columns) %}
+    {%- set col_err = [] -%}
+    {%- set col_naked_numeric = [] -%}
+    select
+    {% for i in columns %}
+      {%- set col = columns[i] -%}
+      {%- if col['data_type'] is not defined -%}
+        {%- do col_err.append(col['name']) -%}
+      {#-- If this column's type is just 'numeric' then it is missing precision/scale, raise a warning --#}
+      {%- elif col['data_type'].strip().lower() in ('numeric', 'decimal', 'number') -%}
+        {%- do col_naked_numeric.append(col['name']) -%}
+      {%- endif -%}
+      {% set col_name = adapter.quote(col['name']) if col.get('quote') else col['name'] %}
+      {{ cast('null', col['data_type']) }} as {{ col_name }}{{ ", " if not loop.last }}
+    {%- endfor -%}
+    {%- if (col_err | length) > 0 -%}
+      {{ exceptions.column_type_missing(column_names=col_err) }}
+    {%- elif (col_naked_numeric | length) > 0 -%}
+      {{ exceptions.warn("Detected columns with numeric type and unspecified precision/scale, this can lead to unintended rounding: " ~ col_naked_numeric ~ "`") }}
+    {%- endif -%}
+{% endmacro %}
+
+{% macro get_column_schema_from_query(select_sql, select_sql_header=none) -%}
+    {% set columns = [] %}
+    {# -- Using an 'empty subquery' here to get the same schema as the given select_sql statement, without necessitating a data scan.#}
+    {% set sql = get_empty_subquery_sql(select_sql, select_sql_header) %}
+    {% set column_schema = adapter.get_column_schema_from_query(sql) %}
+    {{ return(column_schema) }}
+{% endmacro %}
+
+-- here for back compat
+{% macro get_columns_in_query(select_sql) -%}
+  {{ return(adapter.dispatch('get_columns_in_query', 'dbt')(select_sql)) }}
+{% endmacro %}
+
+{% macro default__get_columns_in_query(select_sql) %}
+    {% call statement('get_columns_in_query', fetch_result=True, auto_begin=False) -%}
+        {{ get_empty_subquery_sql(select_sql) }}
+    {% endcall %}
+    {{ return(load_result('get_columns_in_query').table.columns | map(attribute='name') | list) }}
+{% endmacro %}
+
+{% macro alter_column_type(relation, column_name, new_column_type) -%}
+  {{ return(adapter.dispatch('alter_column_type', 'dbt')(relation, column_name, new_column_type)) }}
+{% endmacro %}
+
+{% macro default__alter_column_type(relation, column_name, new_column_type) -%}
+  {#
+    1. Create a new column (w/ temp name and correct type)
+    2. Copy data over to it
+    3. Drop the existing column (cascade!)
+    4. Rename the new column to existing column
+  #}
+  {%- set tmp_column = column_name + "__dbt_alter" -%}
+
+  {% call statement('alter_column_type') %}
+    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 %}
+
+
+{% macro alter_relation_add_remove_columns(relation, add_columns = none, remove_columns = none) -%}
+  {{ return(adapter.dispatch('alter_relation_add_remove_columns', 'dbt')(relation, add_columns, remove_columns)) }}
+{% endmacro %}
+
+{% macro default__alter_relation_add_remove_columns(relation, add_columns, remove_columns) %}
+
+  {% if add_columns is none %}
+    {% set add_columns = [] %}
+  {% endif %}
+  {% if remove_columns is none %}
+    {% set remove_columns = [] %}
+  {% endif %}
+
+  {% set sql -%}
+
+     alter {{ relation.type }} {{ relation.render() }}
+
+            {% for column in add_columns %}
+               add column {{ column.quoted }} {{ column.expanded_data_type }}{{ ',' if not loop.last }}
+            {% endfor %}{{ ',' if add_columns and remove_columns }}
+
+            {% for column in remove_columns %}
+                drop column {{ column.quoted }}{{ ',' if not loop.last }}
+            {% endfor %}
+
+  {%- endset -%}
+
+  {% do run_query(sql) %}
+
+{% endmacro %}

dbt/include/global_project/macros/adapters/freshness.sql

@@ -0,0 +1,32 @@
+{% macro collect_freshness(source, loaded_at_field, filter) %}
+  {{ return(adapter.dispatch('collect_freshness', 'dbt')(source, loaded_at_field, filter))}}
+{% endmacro %}
+
+{% macro default__collect_freshness(source, loaded_at_field, filter) %}
+  {% call statement('collect_freshness', fetch_result=True, auto_begin=False) -%}
+    select
+      max({{ loaded_at_field }}) as max_loaded_at,
+      {{ current_timestamp() }} as snapshotted_at
+    from {{ source }}
+    {% if filter %}
+    where {{ filter }}
+    {% endif %}
+  {% endcall %}
+  {{ return(load_result('collect_freshness')) }}
+{% endmacro %}
+
+{% macro collect_freshness_custom_sql(source, loaded_at_query) %}
+  {{ return(adapter.dispatch('collect_freshness_custom_sql', 'dbt')(source, loaded_at_query))}}
+{% endmacro %}
+
+{% macro default__collect_freshness_custom_sql(source, loaded_at_query) %}
+  {% call statement('collect_freshness_custom_sql', fetch_result=True, auto_begin=False) -%}
+  with source_query as (
+    {{ loaded_at_query }}
+  )
+  select
+    (select * from source_query) as max_loaded_at,
+    {{ current_timestamp() }} as snapshotted_at
+  {% endcall %}
+  {{ return(load_result('collect_freshness_custom_sql')) }}
+{% endmacro %}

dbt/include/global_project/macros/adapters/indexes.sql

@@ -0,0 +1,41 @@
+{% macro get_create_index_sql(relation, index_dict) -%}
+  {{ return(adapter.dispatch('get_create_index_sql', 'dbt')(relation, index_dict)) }}
+{% endmacro %}
+
+{% macro default__get_create_index_sql(relation, index_dict) -%}
+  {% do return(None) %}
+{% endmacro %}
+
+
+{% macro create_indexes(relation) -%}
+  {{ adapter.dispatch('create_indexes', 'dbt')(relation) }}
+{%- endmacro %}
+
+{% macro default__create_indexes(relation) -%}
+  {%- set _indexes = config.get('indexes', default=[]) -%}
+
+  {% for _index_dict in _indexes %}
+    {% set create_index_sql = get_create_index_sql(relation, _index_dict) %}
+    {% if create_index_sql %}
+      {% do run_query(create_index_sql) %}
+    {% endif %}
+  {% endfor %}
+{% endmacro %}
+
+
+{% macro get_drop_index_sql(relation, index_name) -%}
+    {{ adapter.dispatch('get_drop_index_sql', 'dbt')(relation, index_name) }}
+{%- endmacro %}
+
+{% macro default__get_drop_index_sql(relation, index_name) -%}
+    {{ exceptions.raise_compiler_error("`get_drop_index_sql has not been implemented for this adapter.") }}
+{%- endmacro %}
+
+
+{% macro get_show_indexes_sql(relation) -%}
+    {{ adapter.dispatch('get_show_indexes_sql', 'dbt')(relation) }}
+{%- endmacro %}
+
+{% macro default__get_show_indexes_sql(relation) -%}
+    {{ exceptions.raise_compiler_error("`get_show_indexes_sql has not been implemented for this adapter.") }}
+{%- endmacro %}

dbt/include/global_project/macros/adapters/metadata.sql

@@ -0,0 +1,105 @@
+{% macro get_catalog_relations(information_schema, relations) -%}
+  {{ return(adapter.dispatch('get_catalog_relations', 'dbt')(information_schema, relations)) }}
+{%- endmacro %}
+
+{% macro default__get_catalog_relations(information_schema, relations) -%}
+  {% set typename = adapter.type() %}
+  {% set msg -%}
+    get_catalog_relations not implemented for {{ typename }}
+  {%- endset %}
+
+  {{ exceptions.raise_compiler_error(msg) }}
+{%- endmacro %}
+
+{% macro get_catalog(information_schema, schemas) -%}
+  {{ return(adapter.dispatch('get_catalog', 'dbt')(information_schema, schemas)) }}
+{%- endmacro %}
+
+{% macro default__get_catalog(information_schema, schemas) -%}
+
+  {% set typename = adapter.type() %}
+  {% set msg -%}
+    get_catalog not implemented for {{ typename }}
+  {%- endset %}
+
+  {{ exceptions.raise_compiler_error(msg) }}
+{% endmacro %}
+
+
+{% macro information_schema_name(database) %}
+  {{ return(adapter.dispatch('information_schema_name', 'dbt')(database)) }}
+{% endmacro %}
+
+{% macro default__information_schema_name(database) -%}
+  {%- if database -%}
+    {{ database }}.INFORMATION_SCHEMA
+  {%- else -%}
+    INFORMATION_SCHEMA
+  {%- endif -%}
+{%- endmacro %}
+
+
+{% macro list_schemas(database) -%}
+  {{ return(adapter.dispatch('list_schemas', 'dbt')(database)) }}
+{% endmacro %}
+
+{% macro default__list_schemas(database) -%}
+  {% set sql %}
+    select distinct schema_name
+    from {{ information_schema_name(database) }}.SCHEMATA
+    where catalog_name ilike '{{ database }}'
+  {% endset %}
+  {{ return(run_query(sql)) }}
+{% endmacro %}
+
+
+{% macro check_schema_exists(information_schema, schema) -%}
+  {{ return(adapter.dispatch('check_schema_exists', 'dbt')(information_schema, schema)) }}
+{% endmacro %}
+
+{% macro default__check_schema_exists(information_schema, schema) -%}
+  {% set sql -%}
+        select count(*)
+        from {{ information_schema.replace(information_schema_view='SCHEMATA') }}
+        where catalog_name='{{ information_schema.database }}'
+          and schema_name='{{ schema }}'
+  {%- endset %}
+  {{ return(run_query(sql)) }}
+{% endmacro %}
+
+
+{% macro list_relations_without_caching(schema_relation) %}
+  {{ return(adapter.dispatch('list_relations_without_caching', 'dbt')(schema_relation)) }}
+{% endmacro %}
+
+{% macro default__list_relations_without_caching(schema_relation) %}
+  {{ exceptions.raise_not_implemented(
+    'list_relations_without_caching macro not implemented for adapter '+adapter.type()) }}
+{% endmacro %}
+
+{% macro get_catalog_for_single_relation(relation) %}
+  {{ return(adapter.dispatch('get_catalog_for_single_relation', 'dbt')(relation)) }}
+{% endmacro %}
+
+{% macro default__get_catalog_for_single_relation(relation) %}
+  {{ exceptions.raise_not_implemented(
+    'get_catalog_for_single_relation macro not implemented for adapter '+adapter.type()) }}
+{% endmacro %}
+
+{% macro get_relations() %}
+  {{ return(adapter.dispatch('get_relations', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__get_relations() %}
+  {{ exceptions.raise_not_implemented(
+    'get_relations macro not implemented for adapter '+adapter.type()) }}
+{% endmacro %}
+
+{% macro get_relation_last_modified(information_schema, relations) %}
+  {{ return(adapter.dispatch('get_relation_last_modified', 'dbt')(information_schema, relations)) }}
+{% endmacro %}
+
+{% macro default__get_relation_last_modified(information_schema, relations) %}
+  {{ exceptions.raise_not_implemented(
+    'get_relation_last_modified macro not implemented for adapter ' + adapter.type()) }}
+{% endmacro %}

dbt/include/global_project/macros/adapters/persist_docs.sql

@@ -0,0 +1,33 @@
+{% macro alter_column_comment(relation, column_dict) -%}
+  {{ return(adapter.dispatch('alter_column_comment', 'dbt')(relation, column_dict)) }}
+{% endmacro %}
+
+{% macro default__alter_column_comment(relation, column_dict) -%}
+  {{ exceptions.raise_not_implemented(
+    'alter_column_comment macro not implemented for adapter '+adapter.type()) }}
+{% endmacro %}
+
+
+{% macro alter_relation_comment(relation, relation_comment) -%}
+  {{ return(adapter.dispatch('alter_relation_comment', 'dbt')(relation, relation_comment)) }}
+{% endmacro %}
+
+{% macro default__alter_relation_comment(relation, relation_comment) -%}
+  {{ exceptions.raise_not_implemented(
+    'alter_relation_comment macro not implemented for adapter '+adapter.type()) }}
+{% endmacro %}
+
+
+{% macro persist_docs(relation, model, for_relation=true, for_columns=true) -%}
+  {{ return(adapter.dispatch('persist_docs', 'dbt')(relation, model, for_relation, for_columns)) }}
+{% endmacro %}
+
+{% macro default__persist_docs(relation, model, for_relation, for_columns) -%}
+  {% if for_relation and config.persist_relation_docs() and model.description %}
+    {% do run_query(alter_relation_comment(relation, model.description)) %}
+  {% endif %}
+
+  {% if for_columns and config.persist_column_docs() and model.columns %}
+    {% do run_query(alter_column_comment(relation, model.columns)) %}
+  {% endif %}
+{% endmacro %}

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

@@ -0,0 +1,84 @@
+{% macro make_intermediate_relation(base_relation, suffix='__dbt_tmp') %}
+  {{ return(adapter.dispatch('make_intermediate_relation', 'dbt')(base_relation, suffix)) }}
+{% endmacro %}
+
+{% macro default__make_intermediate_relation(base_relation, suffix) %}
+    {{ return(default__make_temp_relation(base_relation, suffix)) }}
+{% endmacro %}
+
+{% macro make_temp_relation(base_relation, suffix='__dbt_tmp') %}
+  {#-- This ensures microbatch batches get unique temp relations to avoid clobbering --#}
+  {% if suffix == '__dbt_tmp' and model.batch %}
+    {% set suffix = suffix ~ '_' ~ model.batch.id %}
+  {% endif %}
+
+  {{ return(adapter.dispatch('make_temp_relation', 'dbt')(base_relation, suffix)) }}
+{% endmacro %}
+
+{% macro default__make_temp_relation(base_relation, suffix) %}
+    {%- set temp_identifier = base_relation.identifier ~ suffix -%}
+    {%- set temp_relation = base_relation.incorporate(
+                                path={"identifier": temp_identifier}) -%}
+
+    {{ return(temp_relation) }}
+{% endmacro %}
+
+{% macro make_backup_relation(base_relation, backup_relation_type, suffix='__dbt_backup') %}
+    {{ return(adapter.dispatch('make_backup_relation', 'dbt')(base_relation, backup_relation_type, suffix)) }}
+{% endmacro %}
+
+{% macro default__make_backup_relation(base_relation, backup_relation_type, suffix) %}
+    {%- set backup_identifier = base_relation.identifier ~ suffix -%}
+    {%- set backup_relation = base_relation.incorporate(
+                                  path={"identifier": backup_identifier},
+                                  type=backup_relation_type
+    ) -%}
+    {{ return(backup_relation) }}
+{% endmacro %}
+
+
+{% macro truncate_relation(relation) -%}
+  {{ return(adapter.dispatch('truncate_relation', 'dbt')(relation)) }}
+{% endmacro %}
+
+{% macro default__truncate_relation(relation) -%}
+  {% call statement('truncate_relation') -%}
+    truncate table {{ relation.render() }}
+  {%- endcall %}
+{% endmacro %}
+
+
+{% macro get_or_create_relation(database, schema, identifier, type) -%}
+  {{ return(adapter.dispatch('get_or_create_relation', 'dbt')(database, schema, identifier, type)) }}
+{% endmacro %}
+
+{% macro default__get_or_create_relation(database, schema, identifier, type) %}
+  {%- set target_relation = adapter.get_relation(database=database, schema=schema, identifier=identifier) %}
+
+  {% if target_relation %}
+    {% do return([true, target_relation]) %}
+  {% endif %}
+
+  {%- set new_relation = api.Relation.create(
+      database=database,
+      schema=schema,
+      identifier=identifier,
+      type=type
+  ) -%}
+  {% do return([false, new_relation]) %}
+{% endmacro %}
+
+
+-- a user-friendly interface into adapter.get_relation
+{% macro load_cached_relation(relation) %}
+  {% do return(adapter.get_relation(
+    database=relation.database,
+    schema=relation.schema,
+    identifier=relation.identifier
+  )) -%}
+{% endmacro %}
+
+-- old name for backwards compatibility
+{% macro load_relation(relation) %}
+    {{ return(load_cached_relation(relation)) }}
+{% endmacro %}

dbt/include/global_project/macros/adapters/schema.sql

@@ -0,0 +1,20 @@
+{% macro create_schema(relation) -%}
+  {{ adapter.dispatch('create_schema', 'dbt')(relation) }}
+{% endmacro %}
+
+{% macro default__create_schema(relation) -%}
+  {%- call statement('create_schema') -%}
+    create schema if not exists {{ relation.without_identifier() }}
+  {% endcall %}
+{% endmacro %}
+
+
+{% macro drop_schema(relation) -%}
+  {{ adapter.dispatch('drop_schema', 'dbt')(relation) }}
+{% endmacro %}
+
+{% macro default__drop_schema(relation) -%}
+  {%- call statement('drop_schema') -%}
+    drop schema if exists {{ relation.without_identifier() }} cascade
+  {% endcall %}
+{% endmacro %}

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) %}
+  {{ sql }}
+  {% if limit is not none %}
+  limit {{ limit }}
+  {%- endif -%}
+{% endmacro %}