dbt-adapters 0.1.0a1__py3-none-any.whl

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

@@ -0,0 +1,137 @@
+{% 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_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 as {{ 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 }} 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) }}
+  {% 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 }}
+
+            {% for column in add_columns %}
+               add column {{ column.name }} {{ column.data_type }}{{ ',' if not loop.last }}
+            {% endfor %}{{ ',' if add_columns and remove_columns }}
+
+            {% for column in remove_columns %}
+                drop column {{ column.name }}{{ ',' if not loop.last }}
+            {% endfor %}
+
+  {%- endset -%}
+
+  {% do run_query(sql) %}
+
+{% endmacro %}

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

@@ -0,0 +1,16 @@
+{% 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 %}

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,96 @@
+{% 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_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,79 @@
+{% 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') %}
+  {{ 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 }}
+  {%- 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,22 @@
+{% macro get_show_sql(compiled_code, sql_header, limit) -%}
+  {%- if sql_header -%}
+  {{ sql_header }}
+  {%- endif -%}
+  {%- if limit is not none -%}
+  {{ get_limit_subquery_sql(compiled_code, limit) }}
+  {%- else -%}
+  {{ compiled_code }}
+  {%- endif -%}
+{% endmacro %}
+
+{% macro get_limit_subquery_sql(sql, limit) %}
+  {{ adapter.dispatch('get_limit_subquery_sql', 'dbt')(sql, limit) }}
+{% endmacro %}
+
+{% macro default__get_limit_subquery_sql(sql, limit) %}
+    select *
+    from (
+        {{ sql }}
+    ) as model_limit_subq
+    limit {{ limit }}
+{% endmacro %}

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

@@ -0,0 +1,44 @@
+{%- macro current_timestamp() -%}
+    {{ adapter.dispatch('current_timestamp', 'dbt')() }}
+{%- endmacro -%}
+
+{% macro default__current_timestamp() -%}
+  {{ exceptions.raise_not_implemented(
+    'current_timestamp macro not implemented for adapter ' + adapter.type()) }}
+{%- endmacro %}
+
+{%- macro snapshot_get_time() -%}
+    {{ adapter.dispatch('snapshot_get_time', 'dbt')() }}
+{%- endmacro -%}
+
+{% macro default__snapshot_get_time() %}
+    {{ current_timestamp() }}
+{% endmacro %}
+
+---------------------------------------------
+
+/* {#
+    DEPRECATED: DO NOT USE IN NEW PROJECTS
+
+    This is ONLY to handle the fact that Snowflake + Postgres had functionally
+    different implementations of {{ dbt.current_timestamp }} + {{ dbt_utils.current_timestamp }}
+
+    If you had a project or package that called {{ dbt_utils.current_timestamp() }}, you should
+    continue to use this macro to guarantee identical behavior on those two databases.
+#} */
+
+{% macro current_timestamp_backcompat() %}
+    {{ return(adapter.dispatch('current_timestamp_backcompat', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__current_timestamp_backcompat() %}
+    current_timestamp::timestamp
+{% endmacro %}
+
+{% macro current_timestamp_in_utc_backcompat() %}
+    {{ return(adapter.dispatch('current_timestamp_in_utc_backcompat', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__current_timestamp_in_utc_backcompat() %}
+    {{ return(adapter.dispatch('current_timestamp_backcompat', 'dbt')()) }}
+{% endmacro %}

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

@@ -0,0 +1,10 @@
+{% macro validate_sql(sql) -%}
+  {{ return(adapter.dispatch('validate_sql', 'dbt')(sql)) }}
+{% endmacro %}
+
+{% macro default__validate_sql(sql) -%}
+  {% call statement('validate_sql') -%}
+    explain {{ sql }}
+  {% endcall %}
+  {{ return(load_result('validate_sql')) }}
+{% endmacro %}

dbt/include/global_project/macros/etc/datetime.sql

@@ -0,0 +1,62 @@
+{% macro convert_datetime(date_str, date_fmt) %}
+
+  {% set error_msg -%}
+      The provided partition date '{{ date_str }}' does not match the expected format '{{ date_fmt }}'
+  {%- endset %}
+
+  {% set res = try_or_compiler_error(error_msg, modules.datetime.datetime.strptime, date_str.strip(), date_fmt) %}
+  {{ return(res) }}
+
+{% endmacro %}
+
+
+{% macro dates_in_range(start_date_str, end_date_str=none, in_fmt="%Y%m%d", out_fmt="%Y%m%d") %}
+    {% set end_date_str = start_date_str if end_date_str is none else end_date_str %}
+
+    {% set start_date = convert_datetime(start_date_str, in_fmt) %}
+    {% set end_date = convert_datetime(end_date_str, in_fmt) %}
+
+    {% set day_count = (end_date - start_date).days %}
+    {% if day_count < 0 %}
+        {% set msg -%}
+            Partition start date is after the end date ({{ start_date }}, {{ end_date }})
+        {%- endset %}
+
+        {{ exceptions.raise_compiler_error(msg, model) }}
+    {% endif %}
+
+    {% set date_list = [] %}
+    {% for i in range(0, day_count + 1) %}
+        {% set the_date = (modules.datetime.timedelta(days=i) + start_date) %}
+        {% if not out_fmt %}
+            {% set _ = date_list.append(the_date) %}
+        {% else %}
+            {% set _ = date_list.append(the_date.strftime(out_fmt)) %}
+        {% endif %}
+    {% endfor %}
+
+    {{ return(date_list) }}
+{% endmacro %}
+
+
+{% macro partition_range(raw_partition_date, date_fmt='%Y%m%d') %}
+    {% set partition_range = (raw_partition_date | string).split(",") %}
+
+    {% if (partition_range | length) == 1 %}
+      {% set start_date = partition_range[0] %}
+      {% set end_date = none %}
+    {% elif (partition_range | length) == 2 %}
+      {% set start_date = partition_range[0] %}
+      {% set end_date = partition_range[1] %}
+    {% else %}
+      {{ exceptions.raise_compiler_error("Invalid partition time. Expected format: {Start Date}[,{End Date}]. Got: " ~ raw_partition_date) }}
+    {% endif %}
+
+    {{ return(dates_in_range(start_date, end_date, in_fmt=date_fmt)) }}
+{% endmacro %}
+
+
+{% macro py_current_timestring() %}
+    {% set dt = modules.datetime.datetime.now() %}
+    {% do return(dt.strftime("%Y%m%d%H%M%S%f")) %}
+{% endmacro %}

dbt/include/global_project/macros/etc/statement.sql

@@ -0,0 +1,52 @@
+{#--
+The macro override naming method (spark__statement) only works for macros which are called with adapter.dispatch. For macros called directly, you can just redefine them.
+--#}
+{%- macro statement(name=None, fetch_result=False, auto_begin=True, language='sql') -%}
+  {%- if execute: -%}
+    {%- set compiled_code = caller() -%}
+
+    {%- if name == 'main' -%}
+      {{ log('Writing runtime {} for node "{}"'.format(language, model['unique_id'])) }}
+      {{ write(compiled_code) }}
+    {%- endif -%}
+    {%- if language == 'sql'-%}
+      {%- set res, table = adapter.execute(compiled_code, auto_begin=auto_begin, fetch=fetch_result) -%}
+    {%- elif language == 'python' -%}
+      {%- set res = submit_python_job(model, compiled_code) -%}
+      {#-- TODO: What should table be for python models? --#}
+      {%- set table = None -%}
+    {%- else -%}
+      {% do exceptions.raise_compiler_error("statement macro didn't get supported language") %}
+    {%- endif -%}
+
+    {%- if name is not none -%}
+      {{ store_result(name, response=res, agate_table=table) }}
+    {%- endif -%}
+
+  {%- endif -%}
+{%- endmacro %}
+
+
+{% macro noop_statement(name=None, message=None, code=None, rows_affected=None, res=None) -%}
+  {%- set sql = caller() -%}
+
+  {%- if name == 'main' -%}
+    {{ log('Writing runtime SQL for node "{}"'.format(model['unique_id'])) }}
+    {{ write(sql) }}
+  {%- endif -%}
+
+  {%- if name is not none -%}
+    {{ store_raw_result(name, message=message, code=code, rows_affected=rows_affected, agate_table=res) }}
+  {%- endif -%}
+
+{%- endmacro %}
+
+
+{# a user-friendly interface into statements #}
+{% macro run_query(sql) %}
+  {% call statement("run_query_statement", fetch_result=true, auto_begin=false) %}
+    {{ sql }}
+  {% endcall %}
+
+  {% do return(load_result("run_query_statement").table) %}
+{% endmacro %}

dbt/include/global_project/macros/generic_test_sql/accepted_values.sql

@@ -0,0 +1,27 @@
+{% macro default__test_accepted_values(model, column_name, values, quote=True) %}
+
+with all_values as (
+
+    select
+        {{ column_name }} as value_field,
+        count(*) as n_records
+
+    from {{ model }}
+    group by {{ column_name }}
+
+)
+
+select *
+from all_values
+where value_field not in (
+    {% for value in values -%}
+        {% if quote -%}
+        '{{ value }}'
+        {%- else -%}
+        {{ value }}
+        {%- endif -%}
+        {%- if not loop.last -%},{%- endif %}
+    {%- endfor %}
+)
+
+{% endmacro %}

dbt/include/global_project/macros/generic_test_sql/not_null.sql

@@ -0,0 +1,9 @@
+{% macro default__test_not_null(model, column_name) %}
+
+{% set column_list = '*' if should_store_failures() else column_name %}
+
+select {{ column_list }}
+from {{ model }}
+where {{ column_name }} is null
+
+{% endmacro %}

dbt/include/global_project/macros/generic_test_sql/relationships.sql

@@ -0,0 +1,23 @@
+{% macro default__test_relationships(model, column_name, to, field) %}
+
+with child as (
+    select {{ column_name }} as from_field
+    from {{ model }}
+    where {{ column_name }} is not null
+),
+
+parent as (
+    select {{ field }} as to_field
+    from {{ to }}
+)
+
+select
+    from_field
+
+from child
+left join parent
+    on child.from_field = parent.to_field
+
+where parent.to_field is null
+
+{% endmacro %}