dbt-adapters 0.1.0a1__py3-none-any.whl

dbt/include/global_project/macros/utils/array_append.sql

@@ -0,0 +1,8 @@
+{% macro array_append(array, new_element) -%}
+  {{ return(adapter.dispatch('array_append', 'dbt')(array, new_element)) }}
+{%- endmacro %}
+
+{# new_element must be the same data type as elements in array to match postgres functionality #}
+{% macro default__array_append(array, new_element) -%}
+    array_append({{ array }}, {{ new_element }})
+{%- endmacro %}

dbt/include/global_project/macros/utils/array_concat.sql

@@ -0,0 +1,7 @@
+{% macro array_concat(array_1, array_2) -%}
+  {{ return(adapter.dispatch('array_concat', 'dbt')(array_1, array_2)) }}
+{%- endmacro %}
+
+{% macro default__array_concat(array_1, array_2) -%}
+    array_cat({{ array_1 }}, {{ array_2 }})
+{%- endmacro %}

dbt/include/global_project/macros/utils/array_construct.sql

@@ -0,0 +1,12 @@
+{% macro array_construct(inputs=[], data_type=api.Column.translate_type('integer')) -%}
+  {{ return(adapter.dispatch('array_construct', 'dbt')(inputs, data_type)) }}
+{%- endmacro %}
+
+{# all inputs must be the same data type to match postgres functionality #}
+{% macro default__array_construct(inputs, data_type) -%}
+    {% if inputs|length > 0 %}
+    array[ {{ inputs|join(' , ') }} ]
+    {% else %}
+    array[]::{{data_type}}[]
+    {% endif %}
+{%- endmacro %}

dbt/include/global_project/macros/utils/bool_or.sql

@@ -0,0 +1,9 @@
+{% macro bool_or(expression) -%}
+    {{ return(adapter.dispatch('bool_or', 'dbt') (expression)) }}
+{% endmacro %}
+
+{% macro default__bool_or(expression) -%}
+
+    bool_or({{ expression }})
+
+{%- endmacro %}

dbt/include/global_project/macros/utils/cast_bool_to_text.sql

@@ -0,0 +1,7 @@
+{% macro cast_bool_to_text(field) %}
+  {{ adapter.dispatch('cast_bool_to_text', 'dbt') (field) }}
+{% endmacro %}
+
+{% macro default__cast_bool_to_text(field) %}
+    cast({{ field }} as {{ api.Column.translate_type('string') }})
+{% endmacro %}

dbt/include/global_project/macros/utils/concat.sql

@@ -0,0 +1,7 @@
+{% macro concat(fields) -%}
+  {{ return(adapter.dispatch('concat', 'dbt')(fields)) }}
+{%- endmacro %}
+
+{% macro default__concat(fields) -%}
+    {{ fields|join(' || ') }}
+{%- endmacro %}

dbt/include/global_project/macros/utils/data_types.sql

@@ -0,0 +1,129 @@
+{# string  -------------------------------------------------     #}
+
+{%- macro type_string() -%}
+  {{ return(adapter.dispatch('type_string', 'dbt')()) }}
+{%- endmacro -%}
+
+{% macro default__type_string() %}
+    {{ return(api.Column.translate_type("string")) }}
+{% endmacro %}
+
+-- This will return 'text' by default
+-- On Postgres + Snowflake, that's equivalent to varchar (no size)
+-- Redshift will treat that as varchar(256)
+
+
+{# timestamp  -------------------------------------------------     #}
+
+{%- macro type_timestamp() -%}
+  {{ return(adapter.dispatch('type_timestamp', 'dbt')()) }}
+{%- endmacro -%}
+
+{% macro default__type_timestamp() %}
+    {{ return(api.Column.translate_type("timestamp")) }}
+{% endmacro %}
+
+/*
+POSTGRES
+https://www.postgresql.org/docs/current/datatype-datetime.html:
+The SQL standard requires that writing just `timestamp`
+be equivalent to `timestamp without time zone`, and
+PostgreSQL honors that behavior.
+`timestamptz` is accepted as an abbreviation for `timestamp with time zone`;
+this is a PostgreSQL extension.
+
+SNOWFLAKE
+https://docs.snowflake.com/en/sql-reference/data-types-datetime.html#timestamp
+The TIMESTAMP_* variation associated with TIMESTAMP is specified by the
+TIMESTAMP_TYPE_MAPPING session parameter. The default is TIMESTAMP_NTZ.
+
+BIGQUERY
+TIMESTAMP means 'timestamp with time zone'
+DATETIME means 'timestamp without time zone'
+TODO: shouldn't this return DATETIME instead of TIMESTAMP, for consistency with other databases?
+e.g. dateadd returns a DATETIME
+
+/* Snowflake:
+https://docs.snowflake.com/en/sql-reference/data-types-datetime.html#timestamp
+The TIMESTAMP_* variation associated with TIMESTAMP is specified by the TIMESTAMP_TYPE_MAPPING session parameter. The default is TIMESTAMP_NTZ.
+*/
+
+
+{# float  -------------------------------------------------     #}
+
+{%- macro type_float() -%}
+  {{ return(adapter.dispatch('type_float', 'dbt')()) }}
+{%- endmacro -%}
+
+{% macro default__type_float() %}
+    {{ return(api.Column.translate_type("float")) }}
+{% endmacro %}
+
+{# numeric  -------------------------------------------------     #}
+
+{%- macro type_numeric() -%}
+  {{ return(adapter.dispatch('type_numeric', 'dbt')()) }}
+{%- endmacro -%}
+
+/*
+This one can't be just translate_type, since precision/scale make it a bit more complicated.
+
+On most databases, the default (precision, scale) is something like:
+  Redshift: (18, 0)
+  Snowflake: (38, 0)
+  Postgres: (<=131072, 0)
+
+https://www.postgresql.org/docs/current/datatype-numeric.html:
+Specifying NUMERIC without any precision or scale creates an “unconstrained numeric”
+column in which numeric values of any length can be stored, up to the implementation limits.
+A column of this kind will not coerce input values to any particular scale,
+whereas numeric columns with a declared scale will coerce input values to that scale.
+(The SQL standard requires a default scale of 0, i.e., coercion to integer precision.
+We find this a bit useless. If you're concerned about portability, always specify
+the precision and scale explicitly.)
+*/
+
+{% macro default__type_numeric() %}
+    {{ return(api.Column.numeric_type("numeric", 28, 6)) }}
+{% endmacro %}
+
+
+{# bigint  -------------------------------------------------     #}
+
+{%- macro type_bigint() -%}
+  {{ return(adapter.dispatch('type_bigint', 'dbt')()) }}
+{%- endmacro -%}
+
+-- We don't have a conversion type for 'bigint' in TYPE_LABELS,
+-- so this actually just returns the string 'bigint'
+
+{% macro default__type_bigint() %}
+    {{ return(api.Column.translate_type("bigint")) }}
+{% endmacro %}
+
+-- Good news: BigQuery now supports 'bigint' (and 'int') as an alias for 'int64'
+
+{# int  -------------------------------------------------     #}
+
+{%- macro type_int() -%}
+  {{ return(adapter.dispatch('type_int', 'dbt')()) }}
+{%- endmacro -%}
+
+{%- macro default__type_int() -%}
+  {{ return(api.Column.translate_type("integer")) }}
+{%- endmacro -%}
+
+-- returns 'int' everywhere, except BigQuery, where it returns 'int64'
+-- (but BigQuery also now accepts 'int' as a valid alias for 'int64')
+
+{# bool  -------------------------------------------------     #}
+
+{%- macro type_boolean() -%}
+  {{ return(adapter.dispatch('type_boolean', 'dbt')()) }}
+{%- endmacro -%}
+
+{%- macro default__type_boolean() -%}
+  {{ return(api.Column.translate_type("boolean")) }}
+{%- endmacro -%}
+
+-- returns 'boolean' everywhere. BigQuery accepts 'boolean' as a valid alias for 'bool'

dbt/include/global_project/macros/utils/date_spine.sql

@@ -0,0 +1,75 @@
+{% macro get_intervals_between(start_date, end_date, datepart) -%}
+    {{ return(adapter.dispatch('get_intervals_between', 'dbt')(start_date, end_date, datepart)) }}
+{%- endmacro %}
+
+{% macro default__get_intervals_between(start_date, end_date, datepart) -%}
+    {%- call statement('get_intervals_between', fetch_result=True) %}
+
+        select {{ dbt.datediff(start_date, end_date, datepart) }}
+
+    {%- endcall -%}
+
+    {%- set value_list = load_result('get_intervals_between') -%}
+
+    {%- if value_list and value_list['data'] -%}
+        {%- set values = value_list['data'] | map(attribute=0) | list %}
+        {{ return(values[0]) }}
+    {%- else -%}
+        {{ return(1) }}
+    {%- endif -%}
+
+{%- endmacro %}
+
+
+
+
+{% macro date_spine(datepart, start_date, end_date) %}
+    {{ return(adapter.dispatch('date_spine', 'dbt')(datepart, start_date, end_date)) }}
+{%- endmacro %}
+
+{% macro default__date_spine(datepart, start_date, end_date) %}
+
+
+    {# call as follows:
+
+    date_spine(
+        "day",
+        "to_date('01/01/2016', 'mm/dd/yyyy')",
+        "dbt.dateadd(week, 1, current_date)"
+    ) #}
+
+
+    with rawdata as (
+
+        {{dbt.generate_series(
+            dbt.get_intervals_between(start_date, end_date, datepart)
+        )}}
+
+    ),
+
+    all_periods as (
+
+        select (
+            {{
+                dbt.dateadd(
+                    datepart,
+                    "row_number() over (order by 1) - 1",
+                    start_date
+                )
+            }}
+        ) as date_{{datepart}}
+        from rawdata
+
+    ),
+
+    filtered as (
+
+        select *
+        from all_periods
+        where date_{{datepart}} <= {{ end_date }}
+
+    )
+
+    select * from filtered
+
+{% endmacro %}

dbt/include/global_project/macros/utils/date_trunc.sql

@@ -0,0 +1,7 @@
+{% macro date_trunc(datepart, date) -%}
+  {{ return(adapter.dispatch('date_trunc', 'dbt') (datepart, date)) }}
+{%- endmacro %}
+
+{% macro default__date_trunc(datepart, date) -%}
+    date_trunc('{{datepart}}', {{date}})
+{%- endmacro %}

dbt/include/global_project/macros/utils/dateadd.sql

@@ -0,0 +1,14 @@
+{% macro dateadd(datepart, interval, from_date_or_timestamp) %}
+  {{ return(adapter.dispatch('dateadd', 'dbt')(datepart, interval, from_date_or_timestamp)) }}
+{% endmacro %}
+
+
+{% macro default__dateadd(datepart, interval, from_date_or_timestamp) %}
+
+    dateadd(
+        {{ datepart }},
+        {{ interval }},
+        {{ from_date_or_timestamp }}
+        )
+
+{% endmacro %}

dbt/include/global_project/macros/utils/datediff.sql

@@ -0,0 +1,14 @@
+{% macro datediff(first_date, second_date, datepart) %}
+  {{ return(adapter.dispatch('datediff', 'dbt')(first_date, second_date, datepart)) }}
+{% endmacro %}
+
+
+{% macro default__datediff(first_date, second_date, datepart) -%}
+
+    datediff(
+        {{ datepart }},
+        {{ first_date }},
+        {{ second_date }}
+        )
+
+{%- endmacro %}

dbt/include/global_project/macros/utils/escape_single_quotes.sql

@@ -0,0 +1,8 @@
+{% macro escape_single_quotes(expression) %}
+      {{ return(adapter.dispatch('escape_single_quotes', 'dbt') (expression)) }}
+{% endmacro %}
+
+{# /*Default to replacing a single apostrophe with two apostrophes: they're -> they''re*/ #}
+{% macro default__escape_single_quotes(expression) -%}
+{{ expression | replace("'","''") }}
+{%- endmacro %}

dbt/include/global_project/macros/utils/except.sql

@@ -0,0 +1,9 @@
+{% macro except() %}
+  {{ return(adapter.dispatch('except', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__except() %}
+
+    except
+
+{% endmacro %}

dbt/include/global_project/macros/utils/generate_series.sql

@@ -0,0 +1,53 @@
+{% macro get_powers_of_two(upper_bound) %}
+    {{ return(adapter.dispatch('get_powers_of_two', 'dbt')(upper_bound)) }}
+{% endmacro %}
+
+{% macro default__get_powers_of_two(upper_bound) %}
+
+    {% if upper_bound <= 0 %}
+    {{ exceptions.raise_compiler_error("upper bound must be positive") }}
+    {% endif %}
+
+    {% for _ in range(1, 100) %}
+       {% if upper_bound <= 2 ** loop.index %}{{ return(loop.index) }}{% endif %}
+    {% endfor %}
+
+{% endmacro %}
+
+
+{% macro generate_series(upper_bound) %}
+    {{ return(adapter.dispatch('generate_series', 'dbt')(upper_bound)) }}
+{% endmacro %}
+
+{% macro default__generate_series(upper_bound) %}
+
+    {% set n = dbt.get_powers_of_two(upper_bound) %}
+
+    with p as (
+        select 0 as generated_number union all select 1
+    ), unioned as (
+
+    select
+
+    {% for i in range(n) %}
+    p{{i}}.generated_number * power(2, {{i}})
+    {% if not loop.last %} + {% endif %}
+    {% endfor %}
+    + 1
+    as generated_number
+
+    from
+
+    {% for i in range(n) %}
+    p as p{{i}}
+    {% if not loop.last %} cross join {% endif %}
+    {% endfor %}
+
+    )
+
+    select *
+    from unioned
+    where generated_number <= {{upper_bound}}
+    order by generated_number
+
+{% endmacro %}

dbt/include/global_project/macros/utils/hash.sql

@@ -0,0 +1,7 @@
+{% macro hash(field) -%}
+  {{ return(adapter.dispatch('hash', 'dbt') (field)) }}
+{%- endmacro %}
+
+{% macro default__hash(field) -%}
+    md5(cast({{ field }} as {{ api.Column.translate_type('string') }}))
+{%- endmacro %}

dbt/include/global_project/macros/utils/intersect.sql

@@ -0,0 +1,9 @@
+{% macro intersect() %}
+  {{ return(adapter.dispatch('intersect', 'dbt')()) }}
+{% endmacro %}
+
+{% macro default__intersect() %}
+
+    intersect
+
+{% endmacro %}

dbt/include/global_project/macros/utils/last_day.sql

@@ -0,0 +1,15 @@
+{% macro last_day(date, datepart) %}
+  {{ return(adapter.dispatch('last_day', 'dbt') (date, datepart)) }}
+{% endmacro %}
+
+{%- macro default_last_day(date, datepart) -%}
+    cast(
+        {{dbt.dateadd('day', '-1',
+        dbt.dateadd(datepart, '1', dbt.date_trunc(datepart, date))
+        )}}
+        as date)
+{%- endmacro -%}
+
+{% macro default__last_day(date, datepart) -%}
+    {{dbt.default_last_day(date, datepart)}}
+{%- endmacro %}

dbt/include/global_project/macros/utils/length.sql

@@ -0,0 +1,11 @@
+{% macro length(expression) -%}
+    {{ return(adapter.dispatch('length', 'dbt') (expression)) }}
+{% endmacro %}
+
+{% macro default__length(expression) %}
+
+    length(
+        {{ expression }}
+    )
+
+{%- endmacro -%}

dbt/include/global_project/macros/utils/listagg.sql

@@ -0,0 +1,30 @@
+{% macro listagg(measure, delimiter_text="','", order_by_clause=none, limit_num=none) -%}
+    {{ return(adapter.dispatch('listagg', 'dbt') (measure, delimiter_text, order_by_clause, limit_num)) }}
+{%- endmacro %}
+
+{% macro default__listagg(measure, delimiter_text, order_by_clause, limit_num) -%}
+
+    {% if limit_num -%}
+    array_to_string(
+        array_slice(
+            array_agg(
+                {{ measure }}
+            ){% if order_by_clause -%}
+            within group ({{ order_by_clause }})
+            {%- endif %}
+            ,0
+            ,{{ limit_num }}
+        ),
+        {{ delimiter_text }}
+        )
+    {%- else %}
+    listagg(
+        {{ measure }},
+        {{ delimiter_text }}
+        )
+        {% if order_by_clause -%}
+        within group ({{ order_by_clause }})
+        {%- endif %}
+    {%- endif %}
+
+{%- endmacro %}

dbt/include/global_project/macros/utils/literal.sql

@@ -0,0 +1,7 @@
+{%- macro string_literal(value) -%}
+  {{ return(adapter.dispatch('string_literal', 'dbt') (value)) }}
+{%- endmacro -%}
+
+{% macro default__string_literal(value) -%}
+    '{{ value }}'
+{%- endmacro %}

dbt/include/global_project/macros/utils/position.sql

@@ -0,0 +1,11 @@
+{% macro position(substring_text, string_text) -%}
+    {{ return(adapter.dispatch('position', 'dbt') (substring_text, string_text)) }}
+{% endmacro %}
+
+{% macro default__position(substring_text, string_text) %}
+
+    position(
+        {{ substring_text }} in {{ string_text }}
+    )
+
+{%- endmacro -%}

dbt/include/global_project/macros/utils/replace.sql

@@ -0,0 +1,14 @@
+{% macro replace(field, old_chars, new_chars) -%}
+    {{ return(adapter.dispatch('replace', 'dbt') (field, old_chars, new_chars)) }}
+{% endmacro %}
+
+{% macro default__replace(field, old_chars, new_chars) %}
+
+    replace(
+        {{ field }},
+        {{ old_chars }},
+        {{ new_chars }}
+    )
+
+
+{% endmacro %}

dbt/include/global_project/macros/utils/right.sql

@@ -0,0 +1,12 @@
+{% macro right(string_text, length_expression) -%}
+    {{ return(adapter.dispatch('right', 'dbt') (string_text, length_expression)) }}
+{% endmacro %}
+
+{% macro default__right(string_text, length_expression) %}
+
+    right(
+        {{ string_text }},
+        {{ length_expression }}
+    )
+
+{%- endmacro -%}

dbt/include/global_project/macros/utils/safe_cast.sql

@@ -0,0 +1,9 @@
+{% macro safe_cast(field, type) %}
+  {{ return(adapter.dispatch('safe_cast', 'dbt') (field, type)) }}
+{% endmacro %}
+
+{% macro default__safe_cast(field, type) %}
+    {# most databases don't support this function yet
+    so we just need to use cast #}
+    cast({{field}} as {{type}})
+{% endmacro %}

dbt/include/global_project/macros/utils/split_part.sql

@@ -0,0 +1,26 @@
+{% macro split_part(string_text, delimiter_text, part_number) %}
+  {{ return(adapter.dispatch('split_part', 'dbt') (string_text, delimiter_text, part_number)) }}
+{% endmacro %}
+
+{% macro default__split_part(string_text, delimiter_text, part_number) %}
+
+    split_part(
+        {{ string_text }},
+        {{ delimiter_text }},
+        {{ part_number }}
+        )
+
+{% endmacro %}
+
+{% macro _split_part_negative(string_text, delimiter_text, part_number) %}
+
+    split_part(
+        {{ string_text }},
+        {{ delimiter_text }},
+          length({{ string_text }})
+          - length(
+              replace({{ string_text }},  {{ delimiter_text }}, '')
+          ) + 2 + {{ part_number }}
+        )
+
+{% endmacro %}

dbt/include/global_project/tests/generic/builtin.sql

@@ -0,0 +1,30 @@
+/* {#
+  Generic tests can be defined in `macros/` or in `tests/generic`.
+  These four tests are built into the dbt-core global project.
+  To support extensibility to other adapters and SQL dialects,
+  they call 'dispatched' macros. By default, they will use
+  the SQL defined in `global_project/macros/generic_test_sql`
+#} */
+
+{% test unique(model, column_name) %}
+    {% set macro = adapter.dispatch('test_unique', 'dbt') %}
+    {{ macro(model, column_name) }}
+{% endtest %}
+
+
+{% test not_null(model, column_name) %}
+    {% set macro = adapter.dispatch('test_not_null', 'dbt') %}
+    {{ macro(model, column_name) }}
+{% endtest %}
+
+
+{% test accepted_values(model, column_name, values, quote=True) %}
+    {% set macro = adapter.dispatch('test_accepted_values', 'dbt') %}
+    {{ macro(model, column_name, values, quote) }}
+{% endtest %}
+
+
+{% test relationships(model, column_name, to, field) %}
+    {% set macro = adapter.dispatch('test_relationships', 'dbt') %}
+    {{ macro(model, column_name, to, field) }}
+{% endtest %}

dbt_adapters-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: dbt-adapters
+Version: 0.1.0a1
+Summary: The set of adapter protocols and base functionality that supports integration with dbt-core
+Project-URL: Homepage, https://github.com/dbt-labs/dbt-adapters
+Project-URL: Documentation, https://docs.getdbt.com
+Project-URL: Repository, https://github.com/dbt-labs/dbt-adapters.git
+Project-URL: Issues, https://github.com/dbt-labs/dbt-adapters/issues
+Project-URL: Changelog, https://github.com/dbt-labs/dbt-adapters/blob/main/CHANGELOG.md
+Author-email: dbt Labs <info@dbtlabs.com>
+Maintainer-email: dbt Labs <info@dbtlabs.com>
+License-File: LICENSE
+Keywords: adapter,adapters,database,dbt,dbt Cloud,dbt Core,dbt Labs,dbt-core,elt
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8.0
+Requires-Dist: agate<2.0
+Requires-Dist: dbt-common<1.0
+Requires-Dist: mashumaro[msgpack]<4.0
+Requires-Dist: protobuf<5.0
+Requires-Dist: pytz>=2015.7
+Requires-Dist: typing-extensions<5.0
+Provides-Extra: lint
+Requires-Dist: black; extra == 'lint'
+Requires-Dist: flake8; extra == 'lint'
+Requires-Dist: flake8-pyproject; extra == 'lint'
+Requires-Dist: mypy; extra == 'lint'
+Requires-Dist: types-protobuf; extra == 'lint'
+Requires-Dist: types-pytz; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-dotenv; extra == 'test'
+Requires-Dist: pytest-xdist; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Adapter
+
+This package is responsible for:
+
+- defining database connection methods
+- caching information from databases
+- determining how relations are defined
+
+There are two major adapter types: base and sql
+
+# Directories
+
+## `base`
+
+Defines the base implementation Adapters can use to build out full functionality.
+
+## `sql`
+
+Defines a sql implementation for adapters that initially inherits the base implementation
+and comes with some pre-made methods and macros that can be overwritten as needed per adapter.
+(most common type of adapter.)
+
+# Files
+
+## `cache.py`
+
+Cached information from the database.
+
+## `factory.py`
+
+Defines how we generate adapter objects
+
+## `protocol.py`
+
+Defines various interfaces for various adapter objects. Helps mypy correctly resolve methods.
+
+## `reference_keys.py`
+
+Configures naming scheme for cache elements to be universal.