dbt-adapters 1.22.2__py3-none-any.whl

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

@@ -0,0 +1,52 @@
+{%- 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 %}
+
+{% macro get_snapshot_get_time_data_type() %}
+    {% set snapshot_time = adapter.dispatch('snapshot_get_time', 'dbt')() %}
+    {% set time_data_type_sql = 'select ' ~ snapshot_time ~ ' as dbt_snapshot_time' %}
+    {% set snapshot_time_column_schema = get_column_schema_from_query(time_data_type_sql) %}
+    {% set time_data_type = snapshot_time_column_schema[0].dtype %}
+    {{ return(time_data_type or none) }}
+{% 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 %}

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

@@ -0,0 +1,12 @@
+{% macro default__test_unique(model, column_name) %}
+
+select
+    {{ column_name }} as unique_field,
+    count(*) as n_records
+
+from {{ model }}
+where {{ column_name }} is not null
+group by {{ column_name }}
+having count(*) > 1
+
+{% endmacro %}

dbt/include/global_project/macros/get_custom_name/get_custom_alias.sql

@@ -0,0 +1,36 @@
+
+{#
+    Renders a alias name given a custom alias name. If the custom
+    alias name is none, then the resulting alias is just the filename of the
+    model. If an alias override is specified, then that is used.
+
+    This macro can be overriden in projects to define different semantics
+    for rendering a alias name.
+
+    Arguments:
+    custom_alias_name: The custom alias name specified for a model, or none
+    node: The available node that an alias is being generated for, or none
+
+#}
+
+{% macro generate_alias_name(custom_alias_name=none, node=none) -%}
+    {% do return(adapter.dispatch('generate_alias_name', 'dbt')(custom_alias_name, node)) %}
+{%- endmacro %}
+
+{% macro default__generate_alias_name(custom_alias_name=none, node=none) -%}
+
+    {%- if custom_alias_name -%}
+
+        {{ custom_alias_name | trim }}
+
+    {%- elif node.version -%}
+
+        {{ return(node.name ~ "_v" ~ (node.version | replace(".", "_"))) }}
+
+    {%- else -%}
+
+        {{ node.name }}
+
+    {%- endif -%}
+
+{%- endmacro %}

dbt/include/global_project/macros/get_custom_name/get_custom_database.sql

@@ -0,0 +1,32 @@
+{#
+    Renders a database name given a custom database name. If the custom
+    database name is none, then the resulting database is just the "database"
+    value in the specified target. If a database override is specified, then
+    the custom database name is used instead of the default "database" value.
+
+    This macro can be overriden in projects to define different semantics
+    for rendering a database name.
+
+    Arguments:
+    custom_database_name: The custom database name specified for a model, or none
+    node: The node the database is being generated for
+
+#}
+
+{% macro generate_database_name(custom_database_name=none, node=none) -%}
+    {% do return(adapter.dispatch('generate_database_name', 'dbt')(custom_database_name, node)) %}
+{%- endmacro %}
+
+{% macro default__generate_database_name(custom_database_name=none, node=none) -%}
+    {%- set default_database = target.database -%}
+    {%- if custom_database_name is none -%}
+
+        {{ default_database }}
+
+    {%- else -%}
+
+        {{ custom_database_name }}
+
+    {%- endif -%}
+
+{%- endmacro %}

dbt/include/global_project/macros/get_custom_name/get_custom_schema.sql

@@ -0,0 +1,60 @@
+
+{#
+    Renders a schema name given a custom schema name. If the custom
+    schema name is none, then the resulting schema is just the "schema"
+    value in the specified target. If a schema override is specified, then
+    the resulting schema is the default schema concatenated with the
+    custom schema.
+
+    This macro can be overriden in projects to define different semantics
+    for rendering a schema name.
+
+    Arguments:
+    custom_schema_name: The custom schema name specified for a model, or none
+    node: The node the schema is being generated for
+
+#}
+{% macro generate_schema_name(custom_schema_name=none, node=none) -%}
+    {{ return(adapter.dispatch('generate_schema_name', 'dbt')(custom_schema_name, node)) }}
+{% endmacro %}
+
+{% macro default__generate_schema_name(custom_schema_name, node) -%}
+
+    {%- set default_schema = target.schema -%}
+    {%- if custom_schema_name is none -%}
+
+        {{ default_schema }}
+
+    {%- else -%}
+
+        {{ default_schema }}_{{ custom_schema_name | trim }}
+
+    {%- endif -%}
+
+{%- endmacro %}
+
+
+{#
+    Renders a schema name given a custom schema name. In production, this macro
+    will render out the overriden schema name for a model. Otherwise, the default
+    schema specified in the active target is used.
+
+    Arguments:
+    custom_schema_name: The custom schema name specified for a model, or none
+    node: The node the schema is being generated for
+
+#}
+{% macro generate_schema_name_for_env(custom_schema_name, node) -%}
+
+    {%- set default_schema = target.schema -%}
+    {%- if target.name == 'prod' and custom_schema_name is not none -%}
+
+        {{ custom_schema_name | trim }}
+
+    {%- else -%}
+
+        {{ default_schema }}
+
+    {%- endif -%}
+
+{%- endmacro %}

dbt/include/global_project/macros/materializations/configs.sql

@@ -0,0 +1,21 @@
+{% macro set_sql_header(config) -%}
+  {{ config.set('sql_header', caller()) }}
+{%- endmacro %}
+
+
+{% macro should_full_refresh() %}
+  {% set config_full_refresh = config.get('full_refresh') %}
+  {% if config_full_refresh is none %}
+    {% set config_full_refresh = flags.FULL_REFRESH %}
+  {% endif %}
+  {% do return(config_full_refresh) %}
+{% endmacro %}
+
+
+{% macro should_store_failures() %}
+  {% set config_store_failures = config.get('store_failures') %}
+  {% if config_store_failures is none %}
+    {% set config_store_failures = flags.STORE_FAILURES %}
+  {% endif %}
+  {% do return(config_store_failures) %}
+{% endmacro %}

dbt/include/global_project/macros/materializations/functions/aggregate.sql

@@ -0,0 +1,65 @@
+--- get signature dispatch + default macro ---
+
+{% macro get_aggregate_function_create_replace_signature(target_relation) %}
+    {{ return(adapter.dispatch('get_aggregate_function_create_replace_signature', 'dbt')(target_relation)) }}
+{% endmacro %}
+
+{% macro default__get_aggregate_function_create_replace_signature(target_relation) %}
+    CREATE OR REPLACE AGGREGATE FUNCTION {{ target_relation.render() }} ({{ get_formatted_aggregate_function_args()}})
+    RETURNS {{ model.returns.data_type }}
+    {{ get_function_language_specifier() }}
+    {{ get_aggregate_function_volatility_specifier() }}
+    {% if model.get('language') == 'python' %}
+        {{ get_function_python_options() }}
+    {% endif %}
+    AS
+{% endmacro %}
+
+--- formatted args dispatch + default macro ---
+
+{% macro get_formatted_aggregate_function_args() %}
+    {{ return(adapter.dispatch('get_formatted_aggregate_function_args', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__get_formatted_aggregate_function_args() %}
+    {# conveniently we can reuse the sql scalar function args #}
+    {{ formatted_scalar_function_args_sql() }}
+{% endmacro %}
+
+--- function language specifier dispatch + default macro ---
+
+{% macro get_function_language_specifier() %}
+    {{ return(adapter.dispatch('get_function_language_specifier', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__get_function_language_specifier() %}
+    {% set language = model.get('language') %}
+    {% if language == 'sql' %}
+        {# generally you dont need to specify the language for sql functions #}
+    {% elif language == 'python' %}
+        LANGUAGE PYTHON
+    {% else %}
+        {{ 'LANGUAGE ' ~ language.upper() }}
+    {% endif %}
+{% endmacro %}
+
+--- function volatility specifier dispatch + default macro ---
+
+{% macro get_aggregate_function_volatility_specifier() %}
+    {{ return(adapter.dispatch('get_aggregate_function_volatility_specifier', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__get_aggregate_function_volatility_specifier() %}
+    {{ scalar_function_volatility_sql() }}
+{% endmacro %}
+
+--- function python options + default macro ---
+
+{% macro get_function_python_options() %}
+    {{ return(adapter.dispatch('get_function_python_options', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__get_function_python_options() %}
+    RUNTIME_VERSION = '{{ model.config.get('runtime_version') }}'
+    HANDLER = '{{ model.config.get('entry_point') }}'
+{% endmacro %}

dbt/include/global_project/macros/materializations/functions/function.sql

@@ -0,0 +1,20 @@
+{% materialization function, default, supported_languages=['sql', 'python'] %}
+    {% set existing_relation = load_cached_relation(this) %}
+    {% set target_relation = this.incorporate(type=this.Function) %}
+
+    {{ run_hooks(pre_hooks) }}
+
+    {% set function_config = this.get_function_config(model) %}
+    {% set macro_name = this.get_function_macro_name(function_config) %}
+
+    {# Doing this aliasing of adapter.dispatch is a hacky way to disable the static analysis of actually calling adapter.dispatch #}
+    {# This is necessary because the static analysis breaks being able to dynamically pass a macro_name #}
+    {% set _dispatch = adapter.dispatch %}
+
+    {% set build_sql = _dispatch(macro_name, 'dbt')(target_relation) %}
+    {{ function_execute_build_sql(build_sql, existing_relation, target_relation) }}
+    {{ run_hooks(post_hooks) }}
+
+    {{ return({'relations': [target_relation]}) }}
+
+{% endmaterialization %}

dbt/include/global_project/macros/materializations/functions/helpers.sql

@@ -0,0 +1,20 @@
+{% macro function_execute_build_sql(build_sql, existing_relation, target_relation) %}
+    {{ return(adapter.dispatch('function_execute_build_sql', 'dbt')(build_sql, existing_relation, target_relation)) }}
+{% endmacro %}
+
+{% macro default__function_execute_build_sql(build_sql, existing_relation, target_relation) %}
+
+    {% set grant_config = config.get('grants') %}
+
+    {% call statement(name="main") %}
+        {{ build_sql }}
+    {% endcall %}
+
+    {% set should_revoke = should_revoke(existing_relation, full_refresh_mode=True) %}
+    {% do apply_grants(target_relation, grant_config, should_revoke=should_revoke) %}
+
+    {% do persist_docs(target_relation, model) %}
+
+    {{ adapter.commit() }}
+
+{% endmacro %}

dbt/include/global_project/macros/materializations/functions/scalar.sql

@@ -0,0 +1,69 @@
+{% macro scalar_function_sql(target_relation) %}
+    {{ return(adapter.dispatch('scalar_function_sql', 'dbt')(target_relation)) }}
+{% endmacro %}
+
+{% macro default__scalar_function_sql(target_relation) %}
+    {{ scalar_function_create_replace_signature_sql(target_relation) }}
+    {{ scalar_function_body_sql() }};
+{% endmacro %}
+
+{% macro scalar_function_create_replace_signature_sql(target_relation) %}
+    {{ return(adapter.dispatch('scalar_function_create_replace_signature_sql', 'dbt')(target_relation)) }}
+{% endmacro %}
+
+{% macro default__scalar_function_create_replace_signature_sql(target_relation) %}
+    CREATE OR REPLACE FUNCTION {{ target_relation.render() }} ({{ formatted_scalar_function_args_sql()}})
+    RETURNS {{ model.returns.data_type }}
+    {{ scalar_function_volatility_sql() }}
+    AS
+{% endmacro %}
+
+{% macro formatted_scalar_function_args_sql() %}
+    {{ return(adapter.dispatch('formatted_scalar_function_args_sql', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__formatted_scalar_function_args_sql() %}
+    {% set args = [] %}
+    {% for arg in model.arguments -%}
+        {%- do args.append(arg.name ~ ' ' ~ arg.data_type) -%}
+    {%- endfor %}
+    {{ args | join(', ') }}
+{% endmacro %}
+
+{% macro scalar_function_body_sql() %}
+    {{ return(adapter.dispatch('scalar_function_body_sql', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__scalar_function_body_sql() %}
+    $$
+       {{ model.compiled_code }}
+    $$ LANGUAGE SQL
+{% endmacro %}
+
+{% macro scalar_function_volatility_sql() %}
+    {{ return(adapter.dispatch('scalar_function_volatility_sql', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__scalar_function_volatility_sql() %}
+    {% set volatility = model.config.get('volatility') %}
+    {% if volatility == 'deterministic' %}
+        IMMUTABLE
+    {% elif volatility == 'stable' %}
+        STABLE
+    {% elif volatility == 'non-deterministic' %}
+        VOLATILE
+    {% elif volatility != none %}
+        {# This shouldn't happen unless a new volatility is invented #}
+        {% do unsupported_volatility_warning(volatility) %}
+    {% endif %}
+    {# If no volatility is set, don't add anything and let the data warehouse default it #}
+{% endmacro %}
+
+{% macro unsupported_volatility_warning(volatility) %}
+    {{ return(adapter.dispatch('unsupported_volatility_warning', 'dbt')(volatility)) }}
+{% endmacro %}
+
+{% macro default__unsupported_volatility_warning(volatility) %}
+    {% set msg = "Found `" ~ volatility ~ "` volatility specified on function `" ~ model.name ~ "`. This volatility is not supported by " ~ adapter.type() ~ ", and will be ignored" %}
+    {% do exceptions.warn(msg) %}
+{% endmacro %}

dbt/include/global_project/macros/materializations/hooks.sql

@@ -0,0 +1,35 @@
+{% macro run_hooks(hooks, inside_transaction=True) %}
+  {% for hook in hooks | selectattr('transaction', 'equalto', inside_transaction)  %}
+    {% if not inside_transaction and loop.first %}
+      {% call statement(auto_begin=inside_transaction) %}
+        commit;
+      {% endcall %}
+    {% endif %}
+    {% set rendered = render(hook.get('sql')) | trim %}
+    {% if (rendered | length) > 0 %}
+      {% call statement(auto_begin=inside_transaction) %}
+        {{ rendered }}
+      {% endcall %}
+    {% endif %}
+  {% endfor %}
+{% endmacro %}
+
+
+{% macro make_hook_config(sql, inside_transaction) %}
+    {{ tojson({"sql": sql, "transaction": inside_transaction}) }}
+{% endmacro %}
+
+
+{% macro before_begin(sql) %}
+    {{ make_hook_config(sql, inside_transaction=False) }}
+{% endmacro %}
+
+
+{% macro in_transaction(sql) %}
+    {{ make_hook_config(sql, inside_transaction=True) }}
+{% endmacro %}
+
+
+{% macro after_commit(sql) %}
+    {{ make_hook_config(sql, inside_transaction=False) }}
+{% endmacro %}

dbt/include/global_project/macros/materializations/models/clone/can_clone_table.sql

@@ -0,0 +1,7 @@
+{% macro can_clone_table() %}
+    {{ return(adapter.dispatch('can_clone_table', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__can_clone_table() %}
+    {{ return(False) }}
+{% endmacro %}