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

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

@@ -0,0 +1,132 @@
+{% macro get_incremental_sql(strategy, source, target, unique_key, dest_columns, incremental_predicates) %}
+  {#
+  Retrieve appropriate SQL for whichever incremental strategy is given.
+  Args:
+    strategy: string, which incremental strategy is in to be used.
+    source: string, table from which queried results will be taken.
+    target: string, table into which results will be inserted.
+    unique_key: string, only as a placeholder for future use
+    dest_columns: List[string] of the names of the columns which data will be
+      inserted into.
+  #}
+  {%- if strategy == 'append' -%}
+    {#- Only insert new records into existing table, relying on user to manage
+       merges. -#}
+    {{ get_insert_only_sql(source, target, dest_columns) }}
+  {%- elif strategy == 'insert_overwrite' -%}
+    {#- Insert new data. If any data is duplicate, drop partition containing
+       previous data and insert new. -#}
+    {{ get_insert_overwrite_sql(source, target, dest_columns) }}
+  {%- elif strategy == 'delete+insert' -%}
+    {% do return(get_delete_insert_merge_sql(target, source, unique_key, dest_columns, incremental_predicates)) %}
+  {%- elif strategy is not none -%}
+    {% do exceptions.raise_compiler_error('Model %s has incremental strategy %s '
+                                          'specified, but that strategy is not '
+                                          'supported.' % (target, strategy)) %}
+  {% else %}
+    {{ exceptions.raise_compiler_error('No incremental strategy was specified '
+                                       'for model %s.' % (target)) }}
+  {%- endif -%}
+{% endmacro %}
+
+
+{% macro get_insert_only_sql(source, target, dest_columns) -%}
+  {%- set dest_cols_csv = get_quoted_csv(dest_columns | map(attribute="name")) %}
+
+  INSERT INTO {{ target }} ({{ dest_cols_csv }})
+  SELECT {{ dest_cols_csv }}
+  FROM {{ source }}
+{%- endmacro %}
+
+
+{% macro get_insert_overwrite_sql(source, target, dest_columns) %}
+  {#
+  Compile SQL to drop correct partitions in target and insert from source.
+  Args:
+    source: Relation from which queried results will be taken.
+    target: Relation into which results will be inserted.
+    dest_columns: list of the names of the columns which data will be
+      inserted into.
+  #}
+  {%- set partition_cols = config.get('partition_by') -%}
+  {%- set partition_vals = config.get('partitions') -%}
+  {#- Get values of partition columns for each row that will be inserted from
+     source. For each of those rows we'll drop the partition in the target. Use
+     the partition values provided in the confg block. _If_ no partition values
+     are provided, query the DB to find all partition values in the source table
+     and drop them. To match format of SQL query results, we convert each sublist
+     to a string. -#}
+  {%- if partition_vals -%}
+    {# Partition vals are set in config. #}
+    {{ drop_partitions_sql(target, partition_vals, True) }}
+  {%- else -%} {# No partition values were set in config. #}
+    {%- call statement('get_partition_cols', fetch_result=True) %}
+
+      SELECT
+      {% if partition_cols is iterable and partition_cols is not string -%}
+        DISTINCT {{ partition_cols | join(', ') }}
+      {%- else -%}
+        DISTINCT {{ partition_cols }}
+      {%- endif %}
+      FROM {{ source }}
+    {%- endcall -%}
+    {%- set partition_vals = load_result('get_partition_cols').table.rows -%}
+    {{ drop_partitions_sql(target, partition_vals, partition_cols, False) }}
+  {%- endif -%}
+  {%- set dest_columns = adapter.get_columns_in_relation(target) -%}
+  {%- set dest_cols_csv = dest_columns | map(attribute='quoted') | join(', ') -%}
+
+  {{ get_insert_only_sql(source, target, dest_columns) }}
+{% endmacro %}
+
+
+{% macro drop_partitions_sql(relation,
+                             partition_vals,
+                             part_col_names,
+                             vals_set_in_config) %}
+  {#
+  Write SQL code to drop each partition in `partition_vals`.
+  Args:
+    relation: a relation whose name will be used for `DROP PARTITION` queries.
+    partition_vals: a list of strings, each of which begins with a '['' and
+      ends with a ']', as such: '[val1, val2]', and each of which represents
+      a partition to be dropped.
+    part_col_names: a list of string, the names of the partition columns.
+    vals_set_in_config: a boolean used to determine how to treat `partition_vals`,
+      whether as a list of strings or as a list of Agate rows.
+  #}
+  {%- for vals in partition_vals -%}
+    {%- set vals -%}
+      {%- if vals is iterable and vals is not string -%}
+        {%- if vals_set_in_config -%}
+          {# `vals` is a list of strings. #}
+          {{ vals | string() | trim() | slice(1, -1) }}
+        {%- else -%}
+          {# `vals` is a list of Agate rows. #}
+          {%- if 1 == (vals | length) -%}
+            {#- There's a weird behavior where, if dbt
+                queries for only a single (text?) field `join()` removes the
+                qoutes on the resulting string. So I have to do a little bit
+                of extra work. -#}
+            '{{ vals | join(', ') }}'
+          {%- else -%}
+            '{{ vals | join("', '") }}'
+          {%- endif -%}
+        {%- endif -%}
+      {%- else -%}
+        {{ vals }}
+      {%- endif -%}
+    {%- endset -%}
+  {%- set vals = vals.strip() -%}
+  {%- if vals.startswith("'[") -%}
+    {#- If a single row is returned, but has  multiple values. -#}
+    {%- set vals = vals[2:-2] -%}
+  {%- endif -%}
+  {#- At this point, vals is a simple string of values separated by commas. -#}
+  {%- set col_types = adapter.get_columns_in_relation(relation) -%}
+  {%- set vals = adapter.annotate_date_columns_for_partitions(vals,
+                                                              part_col_names,
+                                                              col_types) %}
+  ALTER TABLE {{relation}} DROP PARTITION {{ vals.strip() }};
+  {%- endfor -%}
+{% endmacro %}

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

@@ -0,0 +1,42 @@
+{% macro firebolt__get_binding_char() %}
+  {# Override the wildcard character in prepared SQL statements. #}
+  {{ return('?') }}
+{% endmacro %}
+
+
+{% macro firebolt__create_csv_table(model, agate_table) %}
+    {%- set column_override = model['config'].get('column_types', {}) -%}
+    {%- set quote_seed_column = model['config'].get('quote_columns', None) -%}
+    {% set sql %}
+
+      CREATE DIMENSION TABLE IF NOT EXISTS {{ this.render() }} (
+          {%- for col_name in agate_table.column_names -%}
+              {%- set inferred_type = adapter.convert_type(agate_table, loop.index0) -%}
+              {%- set type = column_override.get(col_name, inferred_type) -%}
+              {%- set column_name = (col_name | string) -%}
+              {{ adapter.quote_seed_column(column_name, quote_seed_column) }} {{ type }}
+              {%- if not loop.last -%}, {%- endif -%}
+          {%- endfor -%}
+      )
+    {% endset %}
+    {% call statement('_') %}
+        {{ sql }}
+    {%- endcall %}
+    {{ return(sql) }}
+{% endmacro %}
+
+
+{# TODO: Make sure this is going to run correctly, or delete it. #}
+{% macro firebolt__reset_csv_table(model,
+                                   full_refresh,
+                                   old_relation,
+                                   agate_table) %}
+    {% set sql = "" %}
+    {% if full_refresh %}
+        {{ adapter.drop_relation(old_relation) }}
+    {% else %}
+        {{ adapter.truncate_relation(old_relation) }}
+    {% endif %}
+    {% set sql = create_csv_table(model, agate_table) %}
+    {{ return(sql) }}
+{% endmacro %}

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

@@ -0,0 +1,19 @@
+{% macro firebolt__snapshot_merge_sql(target, source, insert_cols) -%}
+    {%- set insert_cols_csv = insert_cols | join(', ') -%}
+
+    UPDATE {{ target.render() }} AS DBT_INTERNAL_DEST
+    SET dbt_valid_to = DBT_INTERNAL_SOURCE.dbt_valid_to
+    FROM {{ source }} AS DBT_INTERNAL_SOURCE
+    WHERE DBT_INTERNAL_SOURCE.dbt_scd_id = DBT_INTERNAL_DEST.dbt_scd_id
+    AND DBT_INTERNAL_DEST.dbt_valid_to IS NULL
+    AND DBT_INTERNAL_SOURCE.dbt_change_type IN ('update', 'delete');
+
+    INSERT INTO {{ target.render() }} ({{ insert_cols_csv }})
+    SELECT {{ insert_cols_csv }}
+    FROM {{ source }} AS DBT_INTERNAL_SOURCE
+    WHERE DBT_INTERNAL_SOURCE.dbt_scd_id NOT IN (
+        SELECT dbt_scd_id FROM {{ target.render() }}
+    )
+    AND DBT_INTERNAL_SOURCE.dbt_change_type = 'insert';
+
+{% endmacro %}

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

@@ -0,0 +1,40 @@
+{% materialization table, adapter='firebolt' %}
+{# Note that a nearly identical materialization appears in table.sql. #}
+  {%- set identifier = model['alias'] -%} {# alias comes from where? #}
+
+  {# Temporary workaround to issue with adapter.get_relation() until
+     the following are resolved:
+     https://github.com/firebolt-db/dbt-firebolt/issues/11
+     https://github.com/dbt-labs/dbt-core/issues/4187
+     the hack is to always drop the view/table if it already exists rather than
+     checking the db first to see if it exists.
+   #}
+  {%- set target_relation = api.Relation.create(database=database,
+                                                schema=schema,
+                                                identifier=identifier,
+                                                type='table') -%}
+  {%- set target_relation_view = api.Relation.create(database=database,
+                                                     schema=schema,
+                                                     identifier=identifier,
+                                                     type='view') -%}
+
+  {%- set grant_config = config.get('grants') -%}
+
+  {{ run_hooks(pre_hooks) }}
+
+  {% do adapter.drop_relation(target_relation) %}
+  {% do adapter.drop_relation(target_relation_view) %}
+
+  -- build model
+  {% call statement('main') -%}
+    {{ create_table_as(False, target_relation, sql) }}
+  {%- endcall %}
+  {% do create_indexes(target_relation) %}
+  {{ run_hooks(post_hooks) }}
+
+  {% set should_revoke = should_revoke(old_relation, full_refresh_mode=True) %}
+  {% do apply_grants(target_relation, grant_config, should_revoke) %}
+
+  {% do persist_docs(target_relation, model) %}
+  {{ return({'relations': [target_relation]}) }}
+{% endmaterialization %}

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

@@ -0,0 +1,15 @@
+{% macro firebolt__get_test_sql(main_sql, fail_calc, warn_if, error_if, limit) %}
+
+    SELECT
+      COALESCE(CAST({{ fail_calc }} AS INT), 0) AS failures,
+      CASE WHEN {{ fail_calc }} {{ warn_if }}
+        THEN 'true' ELSE 'false'
+      END AS should_warn,
+      CASE WHEN {{ fail_calc }} {{ error_if }}
+        THEN 'true' ELSE 'false'
+      END AS should_error
+    FROM (
+      {{ main_sql }}
+      {{ "LIMIT " ~ limit if limit is not none }}
+    ) dbt_internal_test
+{%- endmacro %}

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

@@ -0,0 +1,39 @@
+{% materialization view, adapter='firebolt' %}
+{# Note that a nearly identical materialization appears
+   in table.sql #}
+  {%- set identifier = model['alias'] -%} {# alias comes from where? #}
+
+  {# Temporary workaround to issue with adapter.get_relation() until
+     the following are resolved:
+     https://github.com/firebolt-db/dbt-firebolt/issues/11
+     https://github.com/dbt-labs/dbt-core/issues/4187
+     the hack is to always drop the view/table if it already exists rather than
+     checking the db first to see if it exists.
+   #}
+  {%- set target_relation = api.Relation.create(database=database,
+                                                schema=schema,
+                                                identifier=identifier,
+                                                type='view') -%}
+  {%- set target_relation_table = api.Relation.create(database=database,
+                                                      schema=schema,
+                                                      identifier=identifier,
+                                                      type='table') -%}
+  {%- set grant_config = config.get('grants') -%}
+
+  {{ run_hooks(pre_hooks) }}
+
+  {% do adapter.drop_relation(target_relation) %}
+  {% do adapter.drop_relation(target_relation_table) %}
+
+  -- build model
+  {% call statement('main') -%}
+    {{ create_view_as(target_relation, sql) }}
+  {%- endcall %}
+  {{ run_hooks(post_hooks) }}
+
+  {% set should_revoke = should_revoke(old_relation, full_refresh_mode=True) %}
+  {% do apply_grants(target_relation, grant_config, should_revoke) %}
+
+  {% do persist_docs(target_relation, model) %}
+  {{ return({'relations': [target_relation]}) }}
+{% endmaterialization %}

dbt/include/firebolt/macros/relations/materialized_view/alter.sql

@@ -0,0 +1,11 @@
+{% macro firebolt__get_alter_materialized_view_as_sql(
+    relation,
+    configuration_changes,
+    sql,
+    existing_relation,
+    backup_relation,
+    intermediate_relation
+) %}
+
+    {{ exceptions.raise_compiler_error("Firebolt does not support materialized views") }}
+{% endmacro %}

dbt/include/firebolt/macros/relations/materialized_view/create.sql

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

dbt/include/firebolt/macros/relations/materialized_view/describe.sql

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

dbt/include/firebolt/macros/relations/materialized_view/drop.sql

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

dbt/include/firebolt/macros/relations/materialized_view/refresh.sql

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

dbt/include/firebolt/macros/relations/table/create.sql

@@ -0,0 +1,78 @@
+{% macro firebolt__create_table_as(
+        temporary,
+        relation,
+        select_sql,
+        language = 'sql'
+    ) -%}
+      {# Create table using CTAS
+         Args:
+          temporary (bool): Unused, included so macro signature matches
+            that of dbt's default macro
+          relation (dbt relation/dict)
+          select_sql (string): The SQL query that will be used to generate
+            the internal query of the CTAS
+          language (string): sql or python models. Firebolt only supports sql.
+      #}
+    {%- if language == 'python' -%}
+        {{ exceptions.raise_compiler_error(
+            "Firebolt does not currently support " "Python models."
+        ) }}
+
+        {%- elif language not in ['python', 'sql'] -%}
+        {{ exceptions.raise_compiler_error(
+            "Unexpected language parameter supplied: %s " "Must be either 'sql' or 'python'." % (language)
+        ) }}
+    {%- endif -%}
+
+    {%- if temporary -%}
+        {%- do adapter.drop_relation(relation) -%}
+    {%- endif -%}
+
+    {%- set table_type = config.get(
+        'table_type',
+        default = 'dimension'
+    ) | upper -%}
+    {%- set primary_index = config.get('primary_index') -%}
+    {%- set incremental_strategy = config.get('incremental_strategy') -%}
+    {%- set partitions = config.get('partition_by') %}
+    CREATE {{ table_type }} TABLE IF NOT EXISTS {{ relation }}
+
+    {%- set contract_config = config.get('contract') -%}
+    {%- if contract_config.enforced -%}
+        {{ get_assert_columns_equivalent(select_sql) }}
+        {{ get_table_columns_and_constraints() }};
+    INSERT INTO
+        {{ relation }}
+        (
+            {{ adapter.dispatch(
+                'get_column_names',
+                'dbt'
+            )() }}
+        ) {%- set select_sql = get_select_subquery(select_sql) %}
+    {% endif %}
+
+    {%- if primary_index %}
+        primary INDEX {% if primary_index is iterable and primary_index is not string %}
+            "{{ primary_index | join('", "') }}"
+        {%- else -%}
+            "{{ primary_index }}"
+        {%- endif -%}
+    {%- endif -%}
+
+    {% if partitions %}
+        PARTITION BY {% if partitions is iterable and partitions is not string %}
+            {{ partitions | join(', ') }}
+        {%- else -%}
+            {{ partitions }}
+        {%- endif -%}
+    {%- endif %}
+
+    {%- if not contract_config.enforced %}
+        AS (
+    {% endif -%}
+
+    {{ select_sql }}
+
+    {% if not contract_config.enforced -%})
+    {%- endif -%}
+{% endmacro %}

dbt/include/firebolt/macros/relations/table/drop.sql

@@ -0,0 +1,3 @@
+{%- macro firebolt__drop_table(relation) -%}
+    DROP TABLE IF EXISTS {{ relation }} CASCADE
+{%- endmacro -%}

dbt/include/firebolt/macros/relations/table/rename.sql

@@ -0,0 +1,6 @@
+{% macro firebolt__get_rename_table_sql(
+        relation,
+        new_name
+    ) %}
+    {{ exceptions.raise_compiler_error("Firebolt does not support table renames") }}
+{% endmacro %}

dbt/include/firebolt/macros/relations/table/replace.sql

@@ -0,0 +1,3 @@
+{% macro firebolt__get_replace_table_sql(relation, sql) %}
+    {{ firebolt__create_table_as(False, relation, sql) }}
+{% endmacro %}

dbt/include/firebolt/macros/relations/view/create.sql

@@ -0,0 +1,16 @@
+{% macro firebolt__create_view_as(
+    relation,
+    select_sql
+  ) %}
+  CREATE
+  OR REPLACE VIEW {{ relation.identifier }}
+
+  {%- set contract_config = config.get('contract') -%}
+  {%- if contract_config.enforced -%}
+    {{ get_assert_columns_equivalent(select_sql) }}
+  {%- endif %}
+
+  AS (
+    {{ select_sql }}
+  )
+{% endmacro %}

dbt/include/firebolt/macros/relations/view/drop.sql

@@ -0,0 +1,3 @@
+{% macro firebolt__get_drop_view_sql(relation) %}
+    DROP VIEW if EXISTS {{ relation }} CASCADE
+{% endmacro %}

dbt/include/firebolt/macros/relations/view/rename.sql

@@ -0,0 +1,6 @@
+{% macro firebolt__get_rename_view_sql(
+        relation,
+        new_name
+    ) %}
+    {{ exceptions.raise_compiler_error("Firebolt does not support view renames") }}
+{% endmacro %}

dbt/include/firebolt/macros/relations/view/replace.sql

@@ -0,0 +1,3 @@
+{% macro firebolt__get_replace_view_sql(relation, sql) %}
+    {{ firebolt__create_view_as(relation, sql) }}
+{% endmacro %}

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

@@ -0,0 +1,3 @@
+{% macro firebolt__array_append(array, new_element) -%}
+    {{ array_concat(array, [new_element]) }}
+{%- endmacro %}

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

@@ -0,0 +1,3 @@
+{% macro firebolt__array_concat(array_1, array_2) -%}
+    array_concat({{ array_1 }}, {{ array_2 }})
+{%- endmacro %}

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

@@ -0,0 +1,3 @@
+{% macro firebolt__array_construct(inputs, data_type) -%}
+    [{{ inputs|join(' , ') }}]
+{%- endmacro %}

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

@@ -0,0 +1,5 @@
+{% macro firebolt__bool_or(expression) -%}
+
+    MAX({{ expression }})
+
+{%- endmacro %}

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

@@ -0,0 +1,7 @@
+{% macro firebolt__cast_bool_to_text(field) %}
+    CASE
+        WHEN {{ field }} = false THEN 'false'
+        WHEN {{ field }} = true THEN 'true'
+        ELSE NULL
+    END
+{% endmacro %}

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

@@ -0,0 +1,9 @@
+{% macro firebolt__dateadd(datepart, interval, from_date_or_timestamp) %}
+
+    DATE_ADD(
+        '{{ datepart }}',
+        {{ interval }},
+        {{ from_date_or_timestamp }}
+        )
+
+{% endmacro %}

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

@@ -0,0 +1,9 @@
+{% macro firebolt__datediff(first_date, second_date, datepart) -%}
+
+    date_diff(
+        '{{ datepart }}',
+        {{ first_date }} :: TIMESTAMP,
+        {{ second_date }} :: TIMESTAMP
+        )
+
+{%- endmacro %}

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

@@ -0,0 +1,6 @@
+{% macro firebolt__except() %}
+
+    {{ exceptions.raise_compiler_error("Firebolt does not currently support "
+                                       "EXCEPT clause.") }}
+
+{% endmacro %}

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

@@ -0,0 +1,6 @@
+{% macro firebolt__intersect() %}
+
+    {{ exceptions.raise_compiler_error("Firebolt does not currently support "
+                                       "INTERSECT clause.") }}
+
+{% endmacro %}

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

@@ -0,0 +1,27 @@
+{% macro firebolt__listagg(measure, delimiter_text, order_by_clause, limit_num) -%}
+
+    {% if order_by_clause -%}
+
+    {{ exceptions.raise_compiler_error("Firebolt does not currently support "
+                                       "ARRAY_AGG with ORDER BY clause.") }}
+
+    {%- endif %}
+
+    {% if limit_num -%}
+
+    ARRAY_JOIN(
+        SLICE(
+            ARRAY_AGG({{ measure }})
+            0,
+            {{ limit_num }}
+        ),
+        {{ delimiter_text }}
+    )
+
+    {%- else %}
+
+    ARRAY_JOIN(ARRAY_AGG({{ measure }}), {{ delimiter_text }})
+
+    {%- endif %}
+
+{%- endmacro %}

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

@@ -0,0 +1,3 @@
+{% macro firebolt__position(substring_text, string_text) %}
+    STRPOS({{ string_text }}, {{ substring_text }})
+{%- endmacro -%}

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

@@ -0,0 +1,12 @@
+{% macro firebolt__right(string_text, length_expression) %}
+
+    CASE WHEN {{ length_expression }} = 0
+        THEN ''
+    ELSE
+        SUBSTR(
+            {{ string_text }},
+            -1 * ({{ length_expression }})
+        )
+    END
+
+{%- endmacro -%}

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

@@ -0,0 +1,14 @@
+{% macro firebolt__split_part(string_text, delimiter_text, part_number) %}
+
+    {% if delimiter_text.startswith("'") and delimiter_text.endswith("'") -%}
+    SPLIT_PART(
+        {{ string_text }},
+        {{ delimiter_text }},
+        {{ part_number }}
+    )
+    {%- else %}
+    {{ exceptions.raise_compiler_error("Firebolt does not currently support "
+                                       "reading delimiter from a column.") }}
+
+    {%- endif %}
+{% endmacro %}

dbt/include/firebolt/macros/utils/timestamps.sql

@@ -0,0 +1,14 @@
+{% macro firebolt__current_timestamp() %}
+    NOW()
+{% endmacro %}
+
+
+{# TODO: Do we still need this?
+   See https://packboard.atlassian.net/browse/FIR-12156 #}
+{% macro firebolt__snapshot_string_as_time(timestamp) -%}
+  {% call statement('timestamp', fetch_result=True) %}
+
+      SELECT CAST('{{ timestamp }}' AS DATE)
+  {% endcall %}
+  {{ return(load_result('timestamp').table) }}
+{% endmacro %}

{dbt_firebolt-1.9.3.dist-info → dbt_firebolt-1.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbt_firebolt
-Version: 1.9.3
+Version: 1.9.4
 Summary: The Firebolt adapter plugin for dbt (data build tool)
 Home-page: https://github.com/firebolt-db/dbt-firebolt
 Author: Firebolt