dbt-firebolt 1.8.3__py3-none-any.whl → 1.9.1__py3-none-any.whl

dbt/adapters/firebolt/__init__.py

@@ -7,7 +7,7 @@ from dbt.adapters.firebolt.connections import (
 from dbt.adapters.firebolt.impl import FireboltAdapter
 from dbt.include import firebolt
 
-__version__ = "1.8.3"
+__version__ = "1.9.1"
 
 Plugin = AdapterPlugin(
     adapter=FireboltAdapter,  # type: ignore

dbt/adapters/firebolt/connections.py

@@ -20,6 +20,7 @@ from dbt_common.exceptions import (
 )
 from firebolt.client import DEFAULT_API_URL
 from firebolt.client.auth import Auth, ClientCredentials, UsernamePassword
+from firebolt.common._types import ExtendedType
 from firebolt.db import ARRAY, DECIMAL
 from firebolt.db import connect as sdk_connect
 from firebolt.db.connection import Connection as SDKConnection
@@ -191,8 +192,8 @@ class FireboltConnectionManager(SQLConnectionManager):
         raise NotImplementedError('`cancel` is not implemented for this adapter!')
 
     @classmethod
-    def data_type_code_to_name(  # type: ignore[override] # FIR-29423
-        cls, type_code: Union[type, ARRAY, DECIMAL]
+    def data_type_code_to_name(
+        cls, type_code: Union[type, ExtendedType]  # type: ignore[override] # FIR-29423
     ) -> str:
         """
         Convert a Firebolt data type code to a string representing the data type.
@@ -218,6 +219,7 @@ class FireboltConnectionManager(SQLConnectionManager):
                 return 'bytea'
             else:
                 return 'text'
+        return 'text'
 
 
 def _determine_auth(credentials: FireboltCredentials) -> Auth:

dbt/adapters/firebolt/impl.py

@@ -1,7 +1,6 @@
 import re
 import time
 from dataclasses import dataclass
-from datetime import datetime
 from typing import Any, List, Mapping, Optional, Union
 
 import agate
@@ -29,21 +28,45 @@ from dbt.adapters.firebolt.connections import FireboltConnectionManager
 from dbt.adapters.firebolt.relation import FireboltRelation
 
 
+def quote_columns(columns: Union[str, List[str]]) -> Union[str, List[str]]:
+    if isinstance(columns, str):
+        return f'"{columns}"'
+    quoted_columns = []
+    for col in columns:
+        if col.startswith('"') and col.endswith('"'):
+            quoted_columns.append(col)
+        else:
+            quoted_columns.append(f'"{col}"')
+    return quoted_columns
+
+
 @dataclass
 class FireboltIndexConfig(dbtClassMixin):
     index_type: str
+    index_name: Optional[str] = None
     join_columns: Optional[Union[str, List[str]]] = None
     key_columns: Optional[Union[str, List[str]]] = None
     dimension_column: Optional[Union[str, List[str]]] = None
     aggregation: Optional[Union[str, List[str]]] = None
 
+    def __post_init__(self) -> None:
+        # quote unquoted columns
+        if self.join_columns:
+            self.join_columns = quote_columns(self.join_columns)
+        if self.key_columns:
+            self.key_columns = quote_columns(self.key_columns)
+        if self.dimension_column:
+            self.dimension_column = quote_columns(self.dimension_column)
+
     def render_name(self, relation: FireboltRelation) -> str:
         """
         Name an index according to the following format, joined by `_`:
         index type, relation name, key/join columns, timestamp (unix & UTC)
         example index name: join_my_model_customer_id_1633504263.
         """
-        now_unix = str(int(time.mktime(datetime.utcnow().timetuple())))
+        if self.index_name:
+            return self.index_name
+        now_unix = str(int(time.time()))
         # If column_names is a list with > 1 members, join with _,
         # otherwise do not. We were getting index names like
         # join__idx__emf_customers__f_i_r_s_t___n_a_m_e__165093112.
@@ -51,14 +74,23 @@ class FireboltIndexConfig(dbtClassMixin):
         spine_col = (
             '_'.join(column_names) if isinstance(column_names, list) else column_names
         )
+        # Additional hash to ensure uniqueness after spaces are removed
+        column_hash = str(hash(spine_col))[:5]
         inputs = [
             f'{self.index_type}_idx',
             relation.identifier,
             spine_col,
+            column_hash,
             now_unix,
         ]
-        string = '__'.join([x for x in inputs if x is not None])
-        return string
+        index_name = '__'.join([x for x in inputs if x is not None])
+        if len(index_name) > 255:
+            # Firebolt index names must be <= 255 characters.
+            # If the index name is too long, hash it.
+            return f'{self.index_type}_idx_{hash(index_name)}'
+        # Remove any spaces or quotes from the index name.
+        index_name = index_name.replace(' ', '_').replace('"', '')
+        return index_name
 
     @classmethod
     def parse(cls, raw_index: Optional[Mapping]) -> Optional['FireboltIndexConfig']:
@@ -88,13 +120,12 @@ class FireboltIndexConfig(dbtClassMixin):
                     'for join indexes.'
                 )
             if index_config.index_type.upper() == 'AGGREGATING' and not (
-                index_config.key_columns and index_config.aggregation
+                index_config.aggregation
             ):
                 raise CompilationError(
                     'Invalid aggregating index definition:\n'
                     f'  Got: {index_config}.\n'
-                    '  key_columns and aggregation must be specified '
-                    'for aggregating indexes.'
+                    '  aggregation must be specified for aggregating indexes.'
                 )
             return index_config
         except ValidationError as exc:
@@ -274,7 +305,6 @@ class FireboltAdapter(SQLAdapter):
         columns: the number of rows that are different between the two
         relations and the number of mismatched rows.
         """
-        # This method only really exists for test reasons.
         names: List[str]
         if column_names is None:
             columns = self.get_columns_in_relation(relation_a)

{dbt_firebolt-1.8.3.dist-info → dbt_firebolt-1.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: dbt-firebolt
-Version: 1.8.3
+Name: dbt_firebolt
+Version: 1.9.1
 Summary: The Firebolt adapter plugin for dbt (data build tool)
 Home-page: https://github.com/firebolt-db/dbt-firebolt
 Author: Firebolt
@@ -78,7 +78,7 @@ The table below shows which dbt and Firebolt features are supported by the adapt
 | Incremental materializations - insert_overwrite | :white_check_mark: |
 | Incremental materializations - delete+insert | :white_check_mark: |
 | Incremental materializations - merge | :x: |
-| Snapshots                    | :x: |
+| Snapshots                    | :white_check_mark: |
 | Seeds                        | :white_check_mark: |
 | Tests                        | :white_check_mark: |
 | Documentation                | :white_check_mark: |

dbt_firebolt-1.9.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+dbt/adapters/firebolt/__init__.py,sha256=jTWhFz0VsnTZFi4djXBOhAHvUJaeQvrHDSiVpDTfKM4,411
+dbt/adapters/firebolt/__version__.py,sha256=zRlZGglif76ZVuWWSjsH_MMPgtVQqmj-SryYJW25FL4,69
+dbt/adapters/firebolt/column.py,sha256=COo_wjhCFgS3GFcPIPcoq7WAWgzN6DB2XqG-gk51WBc,539
+dbt/adapters/firebolt/connections.py,sha256=-R97hfke32n4j0cTUwd4A5xAwD8PqXVgnG7BPetQKcg,8010
+dbt/adapters/firebolt/impl.py,sha256=eIqnXzoMoyHq2lp1yMz7O62WJ0apM16H8IssTTwDMiw,15075
+dbt/adapters/firebolt/relation.py,sha256=Xg3Nrjw3UrF_qwnuGbPT97rSXRiDP1GlIAoBF4b7QnY,1922
+dbt/adapters/firebolt/relation_configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dbt/include/firebolt/__init__.py,sha256=vBGWeG-dHHkimfnX8axBJ4IgAowFw8xADmo6Auzn2xc,52
+dbt_firebolt-1.9.1.dist-info/LICENSE,sha256=Nn0EGvW3qmoZpBV_JVM3iPukFf3RiNCIizrWe_2oTHk,11354
+dbt_firebolt-1.9.1.dist-info/METADATA,sha256=Vay4PDqyfZmqmUUuWUA9A4ChEngOmwZ-o5e-M6DLkYk,5237
+dbt_firebolt-1.9.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+dbt_firebolt-1.9.1.dist-info/top_level.txt,sha256=B2YH4he17ajilEWOGCKHbRcEJlCuZKwCcgFcLPntLsE,4
+dbt_firebolt-1.9.1.dist-info/RECORD,,

{dbt_firebolt-1.8.3.dist-info → dbt_firebolt-1.9.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dbt/include/firebolt/dbt_project.yml

@@ -1,6 +0,0 @@
-
-name: dbt_firebolt
-version: 1.0
-config-version: 2
-
-macro-paths: ['macros']

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

@@ -1,37 +0,0 @@
-{% macro firebolt__get_show_grant_sql(relation) %}
-    {# Usually called from apply_grants. Should not be called directly. #}
-    {{ adapter.raise_grant_error() }}
-{% endmacro %}
-
-
-{%- macro firebolt__get_grant_sql(relation, privilege, grantee) -%}
-    {# Usually called from apply_grants. Should not be called directly. #}
-    {{ adapter.raise_grant_error() }}
-{%- endmacro -%}
-
-
-{%- macro firebolt__get_revoke_sql(relation, privilege, grantee) -%}
-    {# Usually called from apply_grants. Should not be called directly. #}
-    {{ adapter.raise_grant_error() }}
-{%- endmacro -%}
-
-
-{% macro firebolt__copy_grants() %}
-    {{ return(True) }}
-{% endmacro %}
-
-
-{% macro firebolt__apply_grants(relation, grant_config, should_revoke) %}
-    {% if grant_config %}
-        {{ adapter.raise_grant_error() }}
-    {% endif %}
-{% endmacro %}
-
-
-{%- macro firebolt__get_dcl_statement_list(relation, grant_config, get_dcl_macro) -%}
-    {# Firebolt does not support DCL statements yet #}
-    {% if grant_config %}
-        {{ adapter.raise_grant_error() }}
-    {% endif %}
-    {{ return([]) }}
-{%- endmacro %}

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

@@ -1,49 +0,0 @@
-{% macro firebolt__rename_relation(source, target) -%}
-  {# Create new relation, do CTAS to swap it, remove original relation.
-     Must check whether relation is view or table, because process is
-     different for the two. #}
-  {% set all_relations = (list_relations_without_caching(source)) %}
-  {% set tables = adapter.filter_table(all_relations, 'type', 'table') %}
-  {% set views = adapter.filter_table(all_relations, 'type', 'view') %}
-  {% if (views.rows | length) > 0 %}
-    {% call statement('view_definition', fetch_result=True) %}
-
-      SELECT view_definition FROM information_schema.views
-      WHERE table_name = '{{ source.identifier }}'
-    {%- endcall %}
-    {% if load_result('view_definition')['data'] %}
-      {# For some reason this ocassionally returns an empty set.
-         In that case do nothing. Don't even ask why I have to jump through
-         the stupid hoops to get the value out of the result in the next line. #}
-      {% set view_ddl = load_result('view_definition')['data'][0][0] %}
-      {% set view_ddl = view_ddl.replace(source.identifier,
-                                         target.identifier) %}
-      {% call statement('new_view') %}
-
-        DROP VIEW {{ source.identifier }};
-        {{ view_ddl }};
-      {% endcall %}
-    {% endif %}
-  {% elif (tables.rows | length) > 0 %}
-    {# There were no views, so retrieve table. (There must be a table.) #}
-    {% set table_type = adapter.filter_table(all_relations, 'table_type', '') %}
-    {% call statement('tables') %}
-
-      CREATE {{ table_type }} TABLE {{ target.identifier }} AS
-      SELECT * FROM {{ source.identifier }};
-      DROP TABLE {{ source.identifier }};
-    {%- endcall %}
-  {% endif %}
-{% endmacro %}
-
-
-{% macro firebolt__drop_relation(relation) -%}
-  {#-
-  Drop relation. Drop both table and view because relation doesn't always
-  have a table_type specified.
-  #}
-  {% call statement('drop') %}
-
-      DROP {{ relation.type | upper }} IF EXISTS {{ relation }} CASCADE;
-  {% endcall %}
-{% endmacro %}

dbt/include/firebolt/macros/adapters.sql

@@ -1,197 +0,0 @@
-{% macro firebolt__drop_schema(schema_relation) -%}
-  {# Drop tables and views for schema_relation.
-     Args:
-         schema_relation (dict): Contains values for database and schema.
-     Until schemas are supported this macro will drop all tables and views.
-  #}
-  {% set all_relations = (list_relations_without_caching(schema_relation)) %}
-
-  {% set views = adapter.filter_table(all_relations, 'type', 'view') %}
-  {% set tables = adapter.filter_table(all_relations, 'type', 'table') %}
-  {% do drop_relations_loop(views) %}
-  {% do drop_relations_loop(tables) %}
-{% endmacro %}
-
-
-{% macro drop_relations_loop(relations) %}
-  {% for row in relations %}
-    {%- set relation = api.Relation.create(database=target.database,
-                                           schema=target.schema,
-                                           identifier=row[1],
-                                           type=row[3]) -%}
-    {{ adapter.drop_relation(relation) }}
-  {%- endfor %}
-{% endmacro %}
-
-
-{% macro firebolt__list_schemas(database) %}
-  {# Return current schema. Name is a misnomer.
-     TODO: Should this actually return all schemas? #}
-  {% call statement('list_schemas', fetch_result=True, auto_begin=False) %}
-
-      SELECT 'public' AS schema
-  {% endcall %}
-  {{ return(load_result('list_schemas').table) }}
-{% endmacro %}
-
-
-{% macro firebolt__create_schema(relation) -%}
-  {# stub. Not yet supported in Firebolt. #}
-  {%- call statement('create_schema') %}
-
-      SELECT 'create_schema'
-  {% endcall %}
-{% endmacro %}
-
-
-{% macro firebolt__alter_column_type(relation, column_name, new_column_type) -%}
-  {# Stub: alter statements not currently available in Firebolt. #}
-  {% call statement('alter_column_type') %}
-
-      SELECT 'alter_column_type'
-  {% endcall %}
-{% endmacro %}
-
-
-{% macro firebolt__check_schema_exists(information_schema, schema) -%}
-  {# Stub. Will be replaced by query later. #}
-  {% call statement('check_schema_exists', fetch_result=True, auto_begin=True) %}
-
-      SELECT 'schema_exists'
-  {% endcall %}
-  {{ return(load_result('check_schema_exists').table) }}
-{% endmacro %}
-
-
-{% macro make_create_index_sql(relation,
-                               index_name,
-                               create_statement,
-                               spine_col,
-                               other_col) -%}
-  {# Create and return SQL for generating a join or aggregating index.
-     Args:
-       relation (dict):
-       index_name (str): name of the index
-       create_statement (str): either "CREATE JOIN INDEX" or
-                               "CREATE AND GENERATE AGGREGATING INDEX"
-       spine_col ([str]):
-         if agg index, key columns
-         if join index, join column
-       other_col ([str]):
-         if agg index, aggregating columns
-         if join index, dimension column
-       #}
-  {{ create_statement }} "{{ index_name }}" ON {{ relation }} (
-      {% if spine_col is iterable and spine_col is not string -%}
-          {{ spine_col | join(', ') }},
-      {% else -%}
-          {{ spine_col }},
-      {% endif -%}
-      {% if other_col is iterable and other_col is not string -%}
-          {{ other_col | join(', ') }}
-      {%- else -%}
-          {{ other_col }}
-      {%- endif -%}
-  );
-{% endmacro %}
-
-
-{% macro drop_index(index_name, index_type) -%}
-  {# Drop aggregating or join index. #}
-  {% call statement('drop_index', auto_begin=False) %}
-
-      DROP {{ index_type | upper }} INDEX "{{ index_name }}"
-  {% endcall %}
-{% endmacro %}
-
-
-{% macro firebolt__get_create_index_sql(relation, index_dict) -%}
-  {# Return aggregating or join index SQL string. #}
-  {# Parse index inputs and send parsed input to make_create_index_sql #}
-  {%- set index_config = adapter.parse_index(index_dict) -%}
-  {%- set index_name = index_config.render_name(relation) -%}
-  {%- set index_type = index_config.index_type | upper -%}
-  {%- if index_type == "JOIN" -%}
-      {{ make_create_index_sql(relation,
-                               index_name,
-                               "CREATE JOIN INDEX",
-                               index_config.join_columns,
-                               index_config.dimension_column) }}
-  {%- elif index_type == "AGGREGATING" -%}
-      {{ make_create_index_sql(relation,
-                               index_name,
-                               "CREATE AND GENERATE AGGREGATING INDEX",
-                               index_config.key_columns,
-                               index_config.aggregation) }}
-  {%- endif -%}
-{%- endmacro %}
-
-
-{% macro sql_convert_columns_in_relation_firebolt(rows) -%}
-  {% set columns = [] %}
-  {% for row in rows %}
-    {% do columns.append(api.Column(*row)) %}
-  {% endfor %}
-  {{ return(columns) }}
-{% endmacro %}
-
-
-{% macro firebolt__get_columns_in_relation(relation) -%}
-  {#-
-  Return column information for table identified by relation as
-  List[FireboltColumn].
-    Args: relation: dbt Relation
-  -#}
-  {% set sql %}
-    SELECT column_name, data_type from information_schema.columns
-    WHERE table_name = '{{ relation.identifier }}'
-  {% endset %}
-  {%- set result = run_query(sql) -%}
-  {% set columns = [] %}
-  {% for row in result %}
-    {% do columns.append(adapter.get_column_class().from_description(row['column_name'],
-                         adapter.resolve_special_columns(row['data_type']))) %}
-  {% endfor %}
-  {% do return(columns) %}
-{% endmacro %}
-
-
-{% macro firebolt__list_relations_without_caching(relation) %}
-  {# Return all views and tables as agate table.
-     Args:
-       relation (dict): Contains values for database and schema.
-
-     dbt has a relations cache. Using this macro will list all
-     the relations in the current schema using a direct DB query,
-     rather than checking the cache. So the name is a misnomer. Should
-     be list_relations_bypassing_cache or something.
-  #}
-  {% call statement('list_tables_without_caching', fetch_result=True) %}
-
-      SELECT
-          table_catalog AS "database",
-          table_name AS "name",
-          '{{ relation.schema }}' AS "schema",
-          CASE
-            WHEN table_type = 'VIEW' THEN 'view'
-            ELSE 'table'
-          END AS "type"
-      FROM
-          information_schema.tables
-  {% endcall %}
-  {% set info_table = load_result('list_tables_without_caching').table %}
-  {{ return(info_table) }}
-{% endmacro %}
-
-{% macro firebolt__truncate_relation(relation) -%}
-  {#
-  Truncate relation. Actual macro is drop_relation in ./adapters/relation.sql.
-  #}
-
-  {# Firebolt doesn't currently support TRUNCATE, so DROP CASCADE.
-     This should only be called from reset_csv_table, where it's followed by
-     `create_csv_table`, so not recreating the table here. To retrieve old code,
-     see commit f9984f6d61b8a1b877bc107b102eeb30eba54f35
-     This will be replaced by `CREATE OR REPLACE`. #}
-  {{ adapter.drop_relation(relation) }}
-{% endmacro %}

dbt/include/firebolt/macros/catalog.sql

@@ -1,103 +0,0 @@
-{# This is for building docs. Right now it's an incomplete description of
-the columns (for instance, `is_nullable` is missing) but more could be added later. #}
-
-{% macro firebolt__get_catalog(information_schema, schemas) -%}
-
-    {% set query %}
-        with tables as (
-            {{ firebolt__get_catalog_tables_sql(information_schema) }}
-            {{ firebolt__get_catalog_schemas_where_clause_sql(schemas) }}
-        ),
-        columns as (
-            {{ firebolt__get_catalog_columns_sql(information_schema) }}
-            {{ firebolt__get_catalog_schemas_where_clause_sql(schemas) }}
-        )
-        {{ firebolt__get_catalog_results_sql() }}
-    {%- endset -%}
-
-    {{ return(run_query(query)) }}
-
-{%- endmacro %}
-
-{% macro firebolt__get_catalog_relations(information_schema, relations) -%}
-
-    {% set query %}
-        with tables as (
-            {{ firebolt__get_catalog_tables_sql(information_schema) }}
-            {{ firebolt__get_catalog_relations_where_clause_sql(relations) }}
-        ),
-        columns as (
-            {{ firebolt__get_catalog_columns_sql(information_schema) }}
-            {{ firebolt__get_catalog_relations_where_clause_sql(relations) }}
-        )
-        {{ firebolt__get_catalog_results_sql() }}
-    {%- endset -%}
-
-    {{ return(run_query(query)) }}
-
-{%- endmacro %}
-
-
-{% macro firebolt__get_catalog_tables_sql(information_schema) -%}
-    SELECT
-      tbls.table_catalog AS table_database,
-      tbls.table_schema as table_schema,
-      table_type,
-      tbls.table_name as table_name,
-      CASE
-        WHEN table_type = 'VIEW' THEN 'VIEW'
-        ELSE 'TABLE'
-      END AS relation_type
-    FROM
-      information_schema.tables tbls
-{%- endmacro %}
-
-
-{% macro firebolt__get_catalog_columns_sql(information_schema) -%}
-    select
-        table_catalog as "table_database",
-        table_schema as "table_schema",
-        table_name as "table_name",
-        column_name as "column_name",
-        ordinal_position as "column_index",
-        data_type as "column_type"
-    from information_schema.columns
-{%- endmacro %}
-
-{% macro firebolt__get_catalog_results_sql() -%}
-    SELECT *
-    FROM tables
-    JOIN columns USING ("table_database", "table_schema", "table_name")
-    ORDER BY "column_index"
-{%- endmacro %}
-
-
-{% macro firebolt__get_catalog_schemas_where_clause_sql(schemas) -%}
-    WHERE ({%- for schema in schemas -%}
-        UPPER("table_schema") = UPPER('{{ schema }}'){%- if not loop.last %} OR {% endif -%}
-    {%- endfor -%})
-{%- endmacro %}
-
-
-{% macro firebolt__get_catalog_relations_where_clause_sql(relations) -%}
-    WHERE (
-        {%- for relation in relations -%}
-            {% if relation.schema and relation.identifier %}
-                (
-                    UPPER("table_schema") = UPPER('{{ relation.schema }}')
-                    AND UPPER("table_name") = UPPER('{{ relation.identifier }}')
-                )
-            {% elif relation.schema %}
-                (
-                    UPPER("table_schema") = UPPER('{{ relation.schema }}')
-                )
-            {% else %}
-                {% do exceptions.raise_compiler_error(
-                    '`get_catalog_relations` requires a list of relations, each with a schema'
-                ) %}
-            {% endif %}
-
-            {%- if not loop.last %} OR {% endif -%}
-        {%- endfor -%}
-    )
-{%- endmacro %}