dbt-firebolt 1.9.0__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.9.0"
+__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

@@ -120,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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: dbt-firebolt
-Version: 1.9.0
+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

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.9.0.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 %}

dbt/include/firebolt/macros/dbt_external_tables/create_external_table.sql

@@ -1,137 +0,0 @@
-{% macro firebolt__create_external_table(source_node) %}
-    {% if source_node.external.strategy == 'copy' %}
-        {{ firebolt__create_with_copy_from(source_node) }}
-    {% else %}
-        {{ firebolt__create_with_external_table(source_node) }}
-    {% endif %}
-{% endmacro %}
-
-{% macro firebolt__create_with_external_table(source_node) %}
-    {%- set external = source_node.external -%}
-    {%- if 'partitions' in external -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             external.partitions) -%}
-    {%- else -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             []) -%}
-    {%- endif -%}
-    {%- set credentials = external.credentials -%}
-    {# Leaving out "IF NOT EXISTS" because this should only be called by
-       if no DROP IF is necessary. #}
-    CREATE EXTERNAL TABLE {{source(source_node.source_name, source_node.name)}} (
-        {%- for column in columns -%}
-          {{ column }}
-          {{- ',' if not loop.last }}
-        {% endfor -%}
-    )
-    {% if external.url %} URL = '{{external.url}}' {%- endif %}
-    {%- if credentials and credentials.internal_role_arn %}
-        CREDENTIALS = (AWS_ROLE_ARN = '{{credentials.internal_role_arn}}'
-        {%- if credentials.external_role_id %}
-                       AWS_ROLE_EXTERNAL_ID = '{{credentials.external_role_id}}'
-        {%- endif -%}
-        )
-    {% elif credentials and credentials.aws_key_id %}
-        CREDENTIALS = (AWS_KEY_ID = '{{credentials.aws_key_id}}'
-                       AWS_SECRET_KEY = '{{credentials.aws_secret_key}}')
-    {%- endif %}
-    {%- if external.object_pattern -%} OBJECT_PATTERN = '{{external.object_pattern}}' {%- endif %}
-    {% if external.object_patterns -%}
-        OBJECT_PATTERN =
-            {%- for obj in external.object_patterns -%}
-                {{ obj }}
-                {{- ',' if not loop.last }}
-            {%- endfor %}
-    {%- endif %}
-    {%- if external.compression -%} COMPRESSION = {{external.compression}} {%- endif %}
-    TYPE = {{ external.type }}
-{% endmacro %}
-
-{% macro firebolt__create_with_copy_from(source_node) %}
-    {# COPY FROM is only available in Firebolt 2.0. #}
-    {%- set external = source_node.external -%}
-    {%- set credentials = external.credentials -%}
-    {%- set options = external.options -%}
-    {%- set csv_options = options.csv_options -%}
-    {%- set error_file_credentials = options.error_file_credentials -%}
-
-    {# There are no partitions, but this formats the columns correctly. #}
-    {%- if 'partitions' in external -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             external.partitions) -%}
-    {%- else -%}
-        {%- set columns = adapter.make_field_partition_pairs(source_node.columns.values(),
-                                                             []) -%}
-    {%- endif -%}
-    COPY INTO {{source(source_node.source_name, source_node.name)}}
-    {%- if columns and columns | length > 0 %}
-    (
-        {%- for column in columns -%}
-          {{ column.name }}
-          {%- if column.default %} DEFAULT {{ column.default }}{% endif %}
-          {%- if column.source_column_name %} {{ '$' ~ loop.index0 }}{% endif %}
-          {{- ',' if not loop.last }}
-        {%- endfor -%}
-    )
-    {%- endif %}
-    FROM '{{external.url}}'
-    {%- if options %}
-        WITH
-        {%- if options.object_pattern %}
-            PATTERN = '{{options.object_pattern}}'
-        {%- endif %}
-        {%- if options.type %}
-            TYPE = {{ options.type }}
-        {%- endif %}
-        {%- if options.auto_create %}
-            AUTO_CREATE = {{ options.auto_create | upper }}
-        {%- endif %}
-        {%- if options.allow_column_mismatch %}
-            ALLOW_COLUMN_MISMATCH = {{ options.allow_column_mismatch | upper }}
-        {%- endif %}
-        {%- if options.error_file %}
-            ERROR_FILE = '{{ options.error_file }}'
-        {%- endif %}
-        {%- if error_file_credentials %}
-            ERROR_FILE_CREDENTIALS = (AWS_KEY_ID = '{{ error_file_credentials.aws_key_id }}' AWS_SECRET_KEY = '{{ error_file_credentials.aws_secret_key }}')
-        {%- endif %}
-        {%- if options.max_errors_per_file %}
-            MAX_ERRORS_PER_FILE = {{ options.max_errors_per_file }}
-        {%- endif %}
-        {%- if csv_options %}
-            {%- if csv_options.header %}
-                HEADER = {{ csv_options.header | upper }}
-            {%- endif %}
-            {%- if csv_options.delimiter %}
-                DELIMITER = '{{ csv_options.delimiter }}'
-            {%- endif %}
-            {%- if csv_options.newline %}
-                NEWLINE = '{{ csv_options.newline }}'
-            {%- endif %}
-            {%- if csv_options.quote %}
-                QUOTE = {{ csv_options.quote }}
-            {%- endif %}
-            {%- if csv_options.escape %}
-                ESCAPE = '{{ csv_options.escape }}'
-            {%- endif %}
-            {%- if csv_options.null_string %}
-                NULL_STRING = '{{ csv_options.null_string }}'
-            {%- endif %}
-            {%- if csv_options.empty_field_as_null %}
-                EMPTY_FIELD_AS_NULL = {{ csv_options.empty_field_as_null | upper }}
-            {%- endif %}
-            {%- if csv_options.skip_blank_lines %}
-                SKIP_BLANK_LINES = {{ csv_options.skip_blank_lines | upper }}
-            {%- endif %}
-            {%- if csv_options.date_format %}
-                DATE_FORMAT = '{{ csv_options.date_format }}'
-            {%- endif %}
-            {%- if csv_options.timestamp_format %}
-                TIMESTAMP_FORMAT = '{{ csv_options.timestamp_format }}'
-            {%- endif %}
-        {%- endif %}
-    {%- endif %}
-    {%- if credentials %}
-    CREDENTIALS = (AWS_KEY_ID = '{{credentials.aws_key_id}}' AWS_SECRET_KEY = '{{credentials.aws_secret_key}}')
-    {%- endif %}
-{% endmacro %}

dbt/include/firebolt/macros/dbt_external_tables/dropif.sql

@@ -1,6 +0,0 @@
-{% macro firebolt__dropif(source_node) %}
-    {% set ddl %}
-        DROP TABLE IF EXISTS {{ source_node['name'] }}
-    {% endset %}
-    {{return(ddl)}}
-{% endmacro %}

dbt/include/firebolt/macros/dbt_external_tables/get_external_build_plan.sql

@@ -1,18 +0,0 @@
-{% macro firebolt__get_external_build_plan(source_node) %}
-    {% set build_plan = [] %}
-    {% set old_relation = adapter.get_relation(
-        database = source_node.database,
-        schema = source_node.schema,
-        identifier = source_node.identifier
-    ) %}
-    {# var(variable, Boolean) defaults to Boolean value if variable isnt set.
-       Firebolt doesn't do refresh because we don't need to—external tables will always
-       pull most recent data from S3, so the default action below is to skip. #}
-    {% if old_relation is none or var('ext_full_refresh', false) %}
-        {% set build_plan = build_plan + [dropif(source_node),
-                                          create_external_table(source_node)] %}
-    {% else %}
-        {% set build_plan = dbt_external_tables.refresh_external_table(source_node) %}
-    {% endif %}
-    {% do return(build_plan) %}
-{% endmacro %}

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

@@ -1,3 +0,0 @@
-{% macro firebolt__can_clone_table() %}
-    {{ return(False) }}
-{% endmacro %}

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

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

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

@@ -1,21 +0,0 @@
-{% macro intersect_columns(source_columns, target_columns) %}
-  {# Return a List[FireboltColumn] of columns that appear in both source and target.
-     Args:
-       source_columns: List[FireboltColumn]
-       target_columns: List[FireboltColumn]
-  #}
-  {% set result = [] %}
-  {# Note I'm using `column` and not `name` below, as name is a getter
-     and column is the actual field. #}
-  {% set source_names = source_columns | map(attribute = 'column') | list %}
-  {% set target_names = target_columns | map(attribute = 'column') | list %}
-  {# Check whether the name attribute exists in the target - this does
-     not perform a data type check. This is O(m•n), but cardinality
-     of columns is probably low enough that it doesn't matter. #}
-  {% for sc in source_columns %}
-    {% if sc.name in target_names %}
-       {{ result.append(sc) }}
-    {% endif %}
-  {% endfor %}
-  {{ return(result) }}
-{% endmacro %}