dbt-altertable 0.1.0__py3-none-any.whl

dbt/adapters/altertable/__init__.py

@@ -0,0 +1,10 @@
+from dbt.adapters.altertable.connections import AltertableCredentials
+from dbt.adapters.altertable.impl import AltertableAdapter
+from dbt.adapters.base import AdapterPlugin
+from dbt.include import altertable
+
+Plugin = AdapterPlugin(
+    adapter=AltertableAdapter,
+    credentials=AltertableCredentials,
+    include_path=altertable.PACKAGE_PATH,
+)

dbt/adapters/altertable/__version__.py

@@ -0,0 +1 @@
+version = "0.1.0"

dbt/adapters/altertable/connections.py

@@ -0,0 +1,279 @@
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, List, Mapping, Optional, Sequence, Tuple, Union
+
+import altertable_flightsql
+from dbt_common.exceptions import DbtRuntimeError
+from mashumaro.jsonschema.annotations import Maximum, Minimum
+from typing_extensions import Annotated
+
+from dbt.adapters.contracts.connection import (
+    AdapterResponse,
+    Connection,
+    ConnectionState,
+    Credentials,
+)
+from dbt.adapters.events.logging import AdapterLogger
+from dbt.adapters.sql.connections import SQLConnectionManager
+
+logger = AdapterLogger("Altertable")
+
+
+class AltertableCursor:
+    """
+    A PEP 249-compliant cursor wrapper around the altertable_flightsql Client.
+
+    This cursor provides the standard DB-API 2.0 interface that dbt expects,
+    translating calls to the altertable_flightsql client methods.
+    """
+
+    def __init__(self, client: altertable_flightsql.Client):
+        self._client = client
+        self._results: Optional[List[Tuple[Any, ...]]] = None
+        self._description: Optional[List[Tuple[str, Any, None, None, None, None, None]]] = None
+        self._rowcount: int = -1
+        self._cursor_position: int = 0
+
+    @property
+    def description(
+        self,
+    ) -> Optional[List[Tuple[str, Any, None, None, None, None, None]]]:
+        """
+        PEP 249: Sequence of 7-item sequences describing result columns.
+
+        Each sequence contains: (name, type_code, display_size, internal_size,
+        precision, scale, null_ok). We only populate name and type_code.
+        """
+        return self._description
+
+    @property
+    def rowcount(self) -> int:
+        """
+        PEP 249: Number of rows affected by last execute.
+
+        Returns -1 for SELECT statements or when count is unknown.
+        """
+        return self._rowcount
+
+    def execute(
+        self,
+        sql: str,
+        bindings: Optional[Union[Sequence[Any], Mapping[str, Any]]] = None,
+    ) -> "AltertableCursor":
+        """
+        Execute a SQL statement.
+
+        Args:
+            sql: SQL statement to execute.
+            bindings: Optional parameter bindings. Can be a sequence (positional)
+                or a mapping (named parameters).
+
+        Returns:
+            Self for method chaining.
+        """
+        # Reset state
+        self._results = None
+        self._description = None
+        self._rowcount = -1
+        self._cursor_position = 0
+
+        print("--------------------------------")
+        print(f"SQL: {sql}")
+        print(f"Bindings: {bindings}")
+        print("--------------------------------")
+        if bindings is not None:
+            # Use prepared statement for parameterized queries
+            with self._client.prepare(sql) as stmt:
+                reader = stmt.query(parameters=bindings)
+                table = reader.read_all()
+        else:
+            reader = self._client.query(sql)
+            table = reader.read_all()
+
+        self._process_arrow_table(table)
+        return self
+
+    def _process_arrow_table(self, table) -> None:
+        """Process an Arrow table into cursor results."""
+        # Build description from schema
+        self._description = [
+            (field.name, field.type, None, None, None, None, None) for field in table.schema
+        ]
+
+        # Convert Arrow table to list of tuples (row-oriented)
+        columns = list(table.to_pydict().values())
+        if columns:
+            num_rows = len(columns[0])
+            self._results = [tuple(col[i] for col in columns) for i in range(num_rows)]
+        else:
+            self._results = []
+
+        self._rowcount = len(self._results)
+
+    def fetchone(self) -> Optional[Tuple[Any, ...]]:
+        """
+        Fetch the next row of a query result.
+
+        Returns:
+            A single row as a tuple, or None if no more rows.
+        """
+        if self._results is None or self._cursor_position >= len(self._results):
+            return None
+        row = self._results[self._cursor_position]
+        self._cursor_position += 1
+        return row
+
+    def fetchmany(self, size: Optional[int] = None) -> List[Tuple[Any, ...]]:
+        """
+        Fetch the next set of rows.
+
+        Args:
+            size: Maximum number of rows to fetch.
+
+        Returns:
+            List of rows as tuples.
+        """
+        if self._results is None:
+            return []
+        if size is None:
+            size = 1  # Default arraysize per PEP 249
+        end = min(self._cursor_position + size, len(self._results))
+        rows = self._results[self._cursor_position : end]
+        self._cursor_position = end
+        return rows
+
+    def fetchall(self) -> List[Tuple[Any, ...]]:
+        """
+        Fetch all remaining rows.
+
+        Returns:
+            List of all remaining rows as tuples.
+        """
+        if self._results is None:
+            return []
+        rows = self._results[self._cursor_position :]
+        self._cursor_position = len(self._results)
+        return rows
+
+    def close(self) -> None:
+        """Close the cursor."""
+        self._results = None
+        self._description = None
+
+    def __iter__(self):
+        """Allow iteration over results."""
+        return self
+
+    def __next__(self) -> Tuple[Any, ...]:
+        row = self.fetchone()
+        if row is None:
+            raise StopIteration
+        return row
+
+
+class AltertableConnection:
+    """
+    A PEP 249-compliant connection wrapper around the altertable_flightsql Client.
+
+    This provides the connection interface that dbt expects, with a cursor() method
+    that returns AltertableCursor instances.
+    """
+
+    def __init__(self, client: altertable_flightsql.Client):
+        self._client = client
+
+    def __enter__(self) -> "AltertableConnection":
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.close()
+
+    def cursor(self) -> AltertableCursor:
+        """Create a new cursor for this connection."""
+        return AltertableCursor(self._client)
+
+    def close(self) -> None:
+        """Close the connection."""
+        self._client.close()
+
+    def commit(self) -> None:
+        """Commit current transaction (no-op for now as we use auto-commit)."""
+        pass
+
+    def rollback(self) -> None:
+        """Rollback current transaction (no-op for now as we use auto-commit)."""
+        pass
+
+
+@dataclass
+class AltertableCredentials(Credentials):
+    username: str
+    password: str
+    host: str = "flight.altertable.ai"
+    port: Annotated[int, Minimum(0), Maximum(65535)] = 443
+    tls: bool = True
+
+    @property
+    def type(self) -> str:
+        return "altertable"
+
+    @property
+    def unique_field(self) -> str:
+        return "host"
+
+    def _connection_keys(self) -> Tuple[str, ...]:
+        return (
+            "username",
+            "password",
+            "database",
+            "schema",
+            "host",
+            "port",
+            "tls",
+        )
+
+
+class AltertableConnectionManager(SQLConnectionManager):
+    TYPE = "altertable"
+
+    @contextmanager
+    def exception_handler(self, sql: str):
+        try:
+            yield
+
+        except Exception as e:
+            logger.error(f"Error executing SQL: {sql}")
+            raise DbtRuntimeError(e) from e
+
+    def cancel(self, connection: Connection) -> None:
+        logger.debug(f"Attempting to cancel connection: {connection.name}")
+
+    @classmethod
+    def open(cls, connection: Connection) -> Connection:
+        if connection.state == ConnectionState.OPEN:
+            return connection
+
+        def connect():
+            client = altertable_flightsql.Client(
+                username=connection.credentials.username,
+                password=connection.credentials.password,
+                catalog=connection.credentials.database,
+                schema=connection.credentials.schema,
+                host=connection.credentials.host,
+                port=connection.credentials.port,
+                tls=connection.credentials.tls,
+            )
+            return AltertableConnection(client)
+
+        return cls.retry_connection(
+            connection,
+            connect=connect,
+            logger=logger,
+            retry_limit=1,
+            retry_timeout=lambda attempt: attempt**2,
+            retryable_exceptions=[Exception],
+        )
+
+    @classmethod
+    def get_response(cls, cursor) -> AdapterResponse:
+        return AdapterResponse(_message="OK")

dbt/adapters/altertable/impl.py

@@ -0,0 +1,10 @@
+from dbt.adapters.altertable.connections import AltertableConnectionManager
+from dbt.adapters.sql import SQLAdapter
+
+
+class AltertableAdapter(SQLAdapter):
+    ConnectionManager = AltertableConnectionManager
+
+    @classmethod
+    def date_function(cls) -> str:
+        return "now()"

dbt/include/altertable/__init__.py

@@ -0,0 +1,3 @@
+import os
+
+PACKAGE_PATH = os.path.dirname(__file__)

dbt/include/altertable/dbt_project.yml

@@ -0,0 +1,5 @@
+name: dbt_altertable
+version: 0.1
+config-version: 1
+
+macro-paths: ["macros"]

dbt/include/altertable/macros/adapters.sql

@@ -0,0 +1,279 @@
+{% macro altertable__create_schema(relation) -%}
+  {%- call statement('create_schema') -%}
+    {% set sql %}
+        select type from duckdb_databases()
+        where lower(database_name)='{{ relation.database | lower }}'
+        and type='sqlite'
+    {% endset %}
+    {% set results = run_query(sql) %}
+    {% if results|length == 0 %}
+        create schema if not exists {{ relation.without_identifier() }}
+    {% else %}
+        {% if relation.schema!='main' %}
+            {{ exceptions.raise_compiler_error(
+                "Schema must be 'main' when writing to sqlite "
+                ~ "instead got " ~ relation.schema
+            )}}
+        {% endif %}
+    {% endif %}
+  {%- endcall -%}
+{% endmacro %}
+
+{% macro altertable__drop_schema(relation) -%}
+  {%- call statement('drop_schema') -%}
+    drop schema if exists {{ relation.without_identifier() }} cascade
+  {%- endcall -%}
+{% endmacro %}
+
+{% macro altertable__list_schemas(database) -%}
+  {% set sql %}
+    select schema_name
+    from system.information_schema.schemata
+    {% if database is not none %}
+    where lower(catalog_name) = '{{ database | lower | trim('"') }}'
+    {% endif %}
+  {% endset %}
+  {{ return(run_query(sql)) }}
+{% endmacro %}
+
+{% macro altertable__check_schema_exists(information_schema, schema) -%}
+  {% set sql -%}
+        select count(*)
+        from system.information_schema.schemata
+        where lower(schema_name) = '{{ schema | lower }}'
+        and lower(catalog_name) = '{{ information_schema.database | lower }}'
+  {%- endset %}
+  {{ return(run_query(sql)) }}
+{% endmacro %}
+
+{% macro get_column_names() %}
+  {# loop through user_provided_columns to get column names #}
+    {%- set user_provided_columns = model['columns'] -%}
+    (
+    {% for i in user_provided_columns %}
+      {% set col = user_provided_columns[i] %}
+      {{ col['name'] }} {{ "," if not loop.last }}
+    {% endfor %}
+  )
+{% endmacro %}
+
+
+{% macro altertable__create_table_as(temporary, relation, compiled_code, language='sql') -%}
+  {%- if language == 'sql' -%}
+    {% set contract_config = config.get('contract') %}
+    {% if contract_config.enforced %}
+      {{ get_assert_columns_equivalent(compiled_code) }}
+    {% endif %}
+    {%- set sql_header = config.get('sql_header', none) -%}
+
+    {{ sql_header if sql_header is not none }}
+
+    create {% if temporary: -%}temporary{%- endif %} table
+      {{ relation.include(database=(not temporary), schema=(not temporary)) }}
+  {% if contract_config.enforced and not temporary %}
+    {#-- DuckDB doesnt support constraints on temp tables --#}
+    {{ get_table_columns_and_constraints() }} ;
+    insert into {{ relation }} {{ get_column_names() }} (
+      {{ get_select_subquery(compiled_code) }}
+    );
+  {% else %}
+    as (
+      {{ compiled_code }}
+    );
+  {% endif %}
+  {%- elif language == 'python' -%}
+    {{ py_write_table(temporary=temporary, relation=relation, compiled_code=compiled_code) }}
+  {%- else -%}
+      {% do exceptions.raise_compiler_error("altertable__create_table_as macro didn't get supported language, it got %s" % language) %}
+  {%- endif -%}
+{% endmacro %}
+
+{% macro py_write_table(temporary, relation, compiled_code) -%}
+{{ compiled_code }}
+
+def materialize(df, con):
+    try:
+        import pyarrow
+        pyarrow_available = True
+    except ImportError:
+        pyarrow_available = False
+    finally:
+        if pyarrow_available and isinstance(df, pyarrow.Table):
+            # https://github.com/duckdb/duckdb/issues/6584
+            import pyarrow.dataset
+    tmp_name = '__dbt_python_model_df_' + '{{ relation.identifier }}'
+    con.register(tmp_name, df)
+    con.execute('create table {{ relation }} as select * from ' + tmp_name)
+    con.unregister(tmp_name)
+{% endmacro %}
+
+{% macro altertable__create_view_as(relation, sql) -%}
+  {% set contract_config = config.get('contract') %}
+  {% if contract_config.enforced %}
+    {{ get_assert_columns_equivalent(sql) }}
+  {%- endif %}
+  {%- set sql_header = config.get('sql_header', none) -%}
+
+  {{ sql_header if sql_header is not none }}
+  create view {{ relation }} as (
+    {{ sql }}
+  );
+{% endmacro %}
+
+{% macro altertable__get_columns_in_relation(relation) -%}
+  {% call statement('get_columns_in_relation', fetch_result=True) %}
+      select
+          column_name,
+          data_type,
+          character_maximum_length,
+          numeric_precision,
+          numeric_scale
+
+      from system.information_schema.columns
+      where table_name = '{{ relation.identifier }}'
+      {% if relation.schema %}
+      and lower(table_schema) = '{{ relation.schema | lower }}'
+      {% endif %}
+      {% if relation.database %}
+      and lower(table_catalog) = '{{ relation.database | lower }}'
+      {% endif %}
+      order by ordinal_position
+
+  {% endcall %}
+  {% set table = load_result('get_columns_in_relation').table %}
+  {{ return(sql_convert_columns_in_relation(table)) }}
+{% endmacro %}
+
+{% macro altertable__list_relations_without_caching(schema_relation) %}
+  {% call statement('list_relations_without_caching', fetch_result=True) -%}
+    select
+      '{{ schema_relation.database }}' as database,
+      table_name as name,
+      table_schema as schema,
+      CASE table_type
+        WHEN 'BASE TABLE' THEN 'table'
+        WHEN 'VIEW' THEN 'view'
+        WHEN 'LOCAL TEMPORARY' THEN 'table'
+        END as type
+    from system.information_schema.tables
+    where lower(table_schema) = '{{ schema_relation.schema | lower }}'
+    and lower(table_catalog) = '{{ schema_relation.database | lower }}'
+  {% endcall %}
+  {{ return(load_result('list_relations_without_caching').table) }}
+{% endmacro %}
+
+{% macro altertable__make_temp_relation(base_relation, suffix) %}
+    {% set tmp_identifier = base_relation.identifier ~ suffix ~ py_current_timestring() %}
+    {% do return(base_relation.incorporate(
+                                  path={
+                                    "identifier": tmp_identifier,
+                                    "schema": none,
+                                    "database": none
+                                  })) -%}
+{% endmacro %}
+
+{% macro altertable__rename_relation(from_relation, to_relation) -%}
+  {% set target_name = adapter.quote_as_configured(to_relation.identifier, 'identifier') %}
+  {% call statement('rename_relation') -%}
+    alter {{ to_relation.type }} {{ from_relation }} rename to {{ target_name }}
+  {%- endcall %}
+{% endmacro %}
+
+{% macro altertable__current_timestamp() -%}
+  now()
+{%- endmacro %}
+
+{% macro altertable__snapshot_string_as_time(timestamp) -%}
+    {%- set result = "'" ~ timestamp ~ "'::timestamp" -%}
+    {{ return(result) }}
+{%- endmacro %}
+
+{% macro altertable__snapshot_get_time() -%}
+  {{ current_timestamp() }}::timestamp
+{%- endmacro %}
+
+{% macro altertable__get_incremental_default_sql(arg_dict) %}
+  {% do return(get_incremental_delete_insert_sql(arg_dict)) %}
+{% endmacro %}
+
+{% macro location_exists(location) -%}
+  {% do return(adapter.location_exists(location)) %}
+{% endmacro %}
+
+{% macro write_to_file(relation, location, options) -%}
+  {% call statement('write_to_file') -%}
+    copy {{ relation }} to '{{ location }}' ({{ options }})
+  {%- endcall %}
+{% endmacro %}
+
+{% macro store_relation(plugin, relation, location, format, config) -%}
+  {%- set column_list = adapter.get_columns_in_relation(relation) -%}
+  {% do adapter.store_relation(plugin, relation, column_list, location, format, config) %}
+{% endmacro %}
+
+{% macro render_write_options(config) -%}
+  {% set options = config.get('options', {}) %}
+  {% if options is not mapping %}
+    {% do exceptions.raise_compiler_error("The options argument must be a dictionary") %}
+  {% endif %}
+
+  {% for k in options %}
+    {% set _ = options.update({k: render(options[k])}) %}
+  {% endfor %}
+
+  {# legacy top-level write options #}
+  {% if config.get('format') %}
+    {% set _ = options.update({'format': render(config.get('format'))}) %}
+  {% endif %}
+  {% if config.get('delimiter') %}
+    {% set _ = options.update({'delimiter': render(config.get('delimiter'))}) %}
+  {% endif %}
+
+  {% do return(options) %}
+{%- endmacro %}
+
+{% macro altertable__apply_grants(relation, grant_config, should_revoke=True) %}
+    {#-- If grant_config is {} or None, this is a no-op --#}
+    {% if grant_config %}
+      {{ adapter.warn_once('Grants for relations are not supported by DuckDB') }}
+    {% endif %}
+{% endmacro %}
+
+{% macro altertable__get_create_index_sql(relation, index_dict) -%}
+  {%- set index_config = adapter.parse_index(index_dict) -%}
+  {%- set comma_separated_columns = ", ".join(index_config.columns) -%}
+  {%- set index_name = index_config.render(relation) -%}
+
+  create {% if index_config.unique -%}
+    unique
+  {%- endif %} index
+  "{{ index_name }}"
+  on {{ relation }}
+  ({{ comma_separated_columns }});
+{%- endmacro %}
+
+{% macro drop_indexes_on_relation(relation) -%}
+  {% call statement('get_indexes_on_relation', fetch_result=True) %}
+    SELECT index_name
+    FROM duckdb_indexes()
+    WHERE schema_name = '{{ relation.schema }}'
+      AND table_name = '{{ relation.identifier }}'
+  {% endcall %}
+
+  {% set results = load_result('get_indexes_on_relation').table %}
+  {% for row in results %}
+    {% set index_name = row[0] %}
+    {% call statement('drop_index_' + loop.index|string, auto_begin=false) %}
+      DROP INDEX "{{ relation.schema }}"."{{ index_name }}"
+    {% endcall %}
+  {% endfor %}
+
+  {#-- Verify indexes were dropped --#}
+  {% call statement('verify_indexes_dropped', fetch_result=True) %}
+    SELECT COUNT(*) as remaining_indexes
+    FROM duckdb_indexes()
+    WHERE schema_name = '{{ relation.schema }}'
+      AND table_name = '{{ relation.identifier }}'
+  {% endcall %}
+  {% set verify_results = load_result('verify_indexes_dropped').table %}
+{%- endmacro %}

dbt/include/altertable/macros/catalog.sql

@@ -0,0 +1,45 @@
+
+{% macro altertable__get_catalog(information_schema, schemas) -%}
+  {%- call statement('catalog', fetch_result=True) -%}
+    with relations AS (
+      select
+        t.table_name
+        , t.database_name
+        , t.schema_name
+        , 'BASE TABLE' as table_type
+        , t.comment as table_comment
+      from duckdb_tables() t
+      WHERE t.database_name = '{{ database }}'
+      UNION ALL
+      SELECT v.view_name as table_name
+      , v.database_name
+      , v.schema_name
+      , 'VIEW' as table_type
+      , v.comment as table_comment
+      from duckdb_views() v
+      WHERE v.database_name = '{{ database }}'
+    )
+    select
+        '{{ database }}' as table_database,
+        r.schema_name as table_schema,
+        r.table_name,
+        r.table_type,
+        r.table_comment,
+        c.column_name,
+        c.column_index as column_index,
+        c.data_type as column_type,
+        c.comment as column_comment,
+        NULL as table_owner
+    FROM relations r JOIN duckdb_columns() c ON r.schema_name = c.schema_name AND r.table_name = c.table_name
+    WHERE (
+        {%- for schema in schemas -%}
+          upper(r.schema_name) = upper('{{ schema }}'){%- if not loop.last %} or {% endif -%}
+        {%- endfor -%}
+    )
+    ORDER BY
+        r.schema_name,
+        r.table_name,
+        c.column_index
+  {%- endcall -%}
+  {{ return(load_result('catalog').table) }}
+{%- endmacro %}

dbt/include/altertable/macros/columns.sql

@@ -0,0 +1,23 @@
+{% macro altertable__alter_relation_add_remove_columns(relation, add_columns, remove_columns) %}
+
+  {% if add_columns %}
+    {% for column in add_columns %}
+      {% set sql -%}
+         alter {{ relation.type }} {{ relation }} add column
+           {{ api.Relation.create(identifier=column.name) }} {{ column.data_type }}
+      {%- endset -%}
+      {% do run_query(sql) %}
+    {% endfor %}
+  {% endif %}
+
+  {% if remove_columns %}
+    {% for column in remove_columns %}
+      {% set sql -%}
+        alter {{ relation.type }} {{ relation }} drop column
+          {{ api.Relation.create(identifier=column.name) }}
+      {%- endset -%}
+      {% do run_query(sql) %}
+    {% endfor %}
+  {% endif %}
+
+{% endmacro %}

dbt/include/altertable/macros/persist_docs.sql

@@ -0,0 +1,36 @@
+
+{#
+  The logic in this file is adapted from dbt-postgres, since DuckDB matches
+  the Postgres relation/column commenting model as of 0.10.1
+#}
+
+{#
+  By using dollar-quoting like this, users can embed anything they want into their comments
+  (including nested dollar-quoting), as long as they do not use this exact dollar-quoting
+  label. It would be nice to just pick a new one but eventually you do have to give up.
+#}
+{% macro duckdb_escape_comment(comment) -%}
+  {% if comment is not string %}
+    {% do exceptions.raise_compiler_error('cannot escape a non-string: ' ~ comment) %}
+  {% endif %}
+  {%- set magic = '$dbt_comment_literal_block$' -%}
+  {%- if magic in comment -%}
+    {%- do exceptions.raise_compiler_error('The string ' ~ magic ~ ' is not allowed in comments.') -%}
+  {%- endif -%}
+  {{ magic }}{{ comment }}{{ magic }}
+{%- endmacro %}
+
+{% macro altertable__alter_relation_comment(relation, comment) %}
+  {% set escaped_comment = duckdb_escape_comment(comment) %}
+  comment on {{ relation.type }} {{ relation }} is {{ escaped_comment }};
+{% endmacro %}
+
+
+{% macro altertable__alter_column_comment(relation, column_dict) %}
+  {% set existing_columns = adapter.get_columns_in_relation(relation) | map(attribute="name") | list %}
+  {% for column_name in column_dict if (column_name in existing_columns) %}
+    {% set comment = column_dict[column_name]['description'] %}
+    {% set escaped_comment = duckdb_escape_comment(comment) %}
+    comment on column {{ relation }}.{{ adapter.quote(column_name) if column_dict[column_name]['quote'] else column_name }} is {{ escaped_comment }};
+  {% endfor %}
+{% endmacro %}

dbt/include/altertable/macros/seed.sql

@@ -0,0 +1,55 @@
+
+{% macro altertable__get_binding_char() %}
+  {{ return(adapter.get_binding_char()) }}
+{% endmacro %}
+
+{% macro altertable__get_batch_size() %}
+  {{ return(10000) }}
+{% endmacro %}
+
+{% macro altertable__load_csv_rows(model, agate_table) %}
+    {% if config.get('fast', true) %}
+        {% set seed_file_path = adapter.get_seed_file_path(model) %}
+        {% set delimiter = config.get('delimiter', ',') %}
+        {% set sql %}
+          COPY {{ this.render() }} FROM '{{ seed_file_path }}' (FORMAT CSV, HEADER TRUE, DELIMITER '{{ delimiter }}')
+        {% endset %}
+        {% do adapter.add_query(sql, abridge_sql_log=True) %}
+        {{ return(sql) }}
+    {% endif %}
+
+    {% set batch_size = get_batch_size() %}
+    {% set agate_table = adapter.convert_datetimes_to_strs(agate_table) %}
+    {% set cols_sql = get_seed_column_quoted_csv(model, agate_table.column_names) %}
+    {% set bindings = [] %}
+
+    {% set statements = [] %}
+
+    {% for chunk in agate_table.rows | batch(batch_size) %}
+        {% set bindings = [] %}
+
+        {% for row in chunk %}
+            {% do bindings.extend(row) %}
+        {% endfor %}
+
+        {% set sql %}
+            insert into {{ this.render() }} ({{ cols_sql }}) values
+            {% for row in chunk -%}
+                ({%- for column in agate_table.column_names -%}
+                    {{ get_binding_char() }}
+                    {%- if not loop.last%},{%- endif %}
+                {%- endfor -%})
+                {%- if not loop.last%},{%- endif %}
+            {%- endfor %}
+        {% endset %}
+
+        {% do adapter.add_query(sql, bindings=bindings, abridge_sql_log=True) %}
+
+        {% if loop.index0 == 0 %}
+            {% do statements.append(sql) %}
+        {% endif %}
+    {% endfor %}
+
+    {# Return SQL so we can render it out into the compiled files #}
+    {{ return(statements[0]) }}
+{% endmacro %}

dbt/include/altertable/macros/snapshot_helper.sql

@@ -0,0 +1,40 @@
+{% macro altertable__snapshot_merge_sql(target, source, insert_cols) -%}
+    {%- set insert_cols_csv = insert_cols | join(', ') -%}
+
+    {%- set columns = config.get("snapshot_table_column_names") or get_snapshot_table_column_names() -%}
+
+    update {{ target }} as DBT_INTERNAL_TARGET
+    set {{ columns.dbt_valid_to }} = DBT_INTERNAL_SOURCE.{{ columns.dbt_valid_to }}
+    from {{ source }} as DBT_INTERNAL_SOURCE
+    where DBT_INTERNAL_SOURCE.{{ columns.dbt_scd_id }}::text = DBT_INTERNAL_TARGET.{{ columns.dbt_scd_id }}::text
+      and DBT_INTERNAL_SOURCE.dbt_change_type::text in ('update'::text, 'delete'::text)
+      {% if config.get("dbt_valid_to_current") %}
+        and (DBT_INTERNAL_TARGET.{{ columns.dbt_valid_to }} = {{ config.get('dbt_valid_to_current') }} or DBT_INTERNAL_TARGET.{{ columns.dbt_valid_to }} is null);
+      {% else %}
+        and DBT_INTERNAL_TARGET.{{ columns.dbt_valid_to }} is null;
+      {% endif %}
+
+    insert into {{ target }} ({{ insert_cols_csv }})
+    select {% for column in insert_cols -%}
+        DBT_INTERNAL_SOURCE.{{ column }} {%- if not loop.last %}, {%- endif %}
+    {%- endfor %}
+    from {{ source }} as DBT_INTERNAL_SOURCE
+    where DBT_INTERNAL_SOURCE.dbt_change_type::text = 'insert'::text;
+
+{% endmacro %}
+
+{% macro build_snapshot_staging_table(strategy, sql, target_relation) %}
+    {% set temp_relation = make_temp_relation(target_relation) %}
+
+    {% set select = snapshot_staging_table(strategy, sql, target_relation) %}
+
+    {% call statement('build_snapshot_staging_relation') %}
+        {{ create_table_as(False, temp_relation, select) }}
+    {% endcall %}
+
+    {% do return(temp_relation) %}
+{% endmacro %}
+
+{% macro altertable__post_snapshot(staging_relation) %}
+    {% do return(drop_relation(staging_relation)) %}
+{% endmacro %}

dbt/include/altertable/macros/utils/any_value.sql

@@ -0,0 +1,5 @@
+{% macro altertable__any_value(expression) -%}
+
+    arbitrary({{ expression }})
+
+{%- endmacro %}

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

@@ -0,0 +1,22 @@
+{% macro altertable__dateadd(datepart, interval, from_date_or_timestamp) %}
+
+    {#
+      Support both literal and expression intervals (e.g., column references)
+      by multiplying an INTERVAL by the value. This avoids DuckDB parser issues
+      with "interval (<expr>) <unit>" and works across versions.
+
+      Also map unsupported units:
+      - quarter => 3 months
+      - week    => 7 days (DuckDB supports WEEK as a literal, but keep it explicit)
+    #}
+
+    {%- set unit = datepart | lower -%}
+    {%- if unit == 'quarter' -%}
+        ({{ from_date_or_timestamp }} + (cast({{ interval }} as bigint) * 3) * interval 1 month)
+    {%- elif unit == 'week' -%}
+        ({{ from_date_or_timestamp }} + (cast({{ interval }} as bigint) * 7) * interval 1 day)
+    {%- else -%}
+        ({{ from_date_or_timestamp }} + cast({{ interval }} as bigint) * interval 1 {{ unit }})
+    {%- endif -%}
+
+{% endmacro %}

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

@@ -0,0 +1,12 @@
+{% macro altertable__datediff(first_date, second_date, datepart) -%}
+    {% if datepart == 'week' %}
+            ({{ datediff(first_date, second_date, 'day') }} // 7 + case
+            when date_part('dow', ({{first_date}})::timestamp) <= date_part('dow', ({{second_date}})::timestamp) then
+                case when {{first_date}} <= {{second_date}} then 0 else -1 end
+            else
+                case when {{first_date}} <= {{second_date}} then 1 else 0 end
+        end)
+    {% else %}
+        (date_diff('{{ datepart }}', {{ first_date }}::timestamp, {{ second_date}}::timestamp ))
+    {% endif %}
+{%- endmacro %}

dbt/include/altertable/macros/utils/external_location.sql

@@ -0,0 +1,8 @@
+{%- macro external_location(relation, config) -%}
+  {%- if config.get('options', {}).get('partition_by') is none -%}
+    {%- set format = config.get('format', 'parquet') -%}
+    {{- adapter.external_root() }}/{{ relation.identifier }}.{{ format }}
+  {%- else -%}
+    {{- adapter.external_root() }}/{{ relation.identifier }}
+  {%- endif -%}
+{%- endmacro -%}

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

@@ -0,0 +1,5 @@
+{% macro altertable__generate_series(upper_bound) %}
+    select
+        generate_series as generated_number
+    from generate_series(1, {{ upper_bound }})
+{% endmacro %}

dbt/include/altertable/macros/utils/lastday.sql

@@ -0,0 +1,14 @@
+{% macro altertable__last_day(date, datepart) -%}
+
+    {%- if datepart == 'quarter' -%}
+    -- duckdb dateadd does not support quarter interval.
+    cast(
+        {{dbt.dateadd('day', '-1',
+        dbt.dateadd('month', '3', dbt.date_trunc(datepart, date))
+        )}}
+        as date)
+    {%- else -%}
+    {{dbt.default_last_day(date, datepart)}}
+    {%- endif -%}
+
+{%- endmacro %}

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

@@ -0,0 +1,22 @@
+{% macro altertable__listagg(measure, delimiter_text, order_by_clause, limit_num) -%}
+    {% if limit_num -%}
+    list_aggr(
+        (array_agg(
+            {{ measure }}
+            {% if order_by_clause -%}
+            {{ order_by_clause }}
+            {%- endif %}
+        ))[1:{{ limit_num }}],
+        'string_agg',
+        {{ delimiter_text }}
+        )
+    {%- else %}
+    string_agg(
+        {{ measure }},
+        {{ delimiter_text }}
+        {% if order_by_clause -%}
+        {{ order_by_clause }}
+        {%- endif %}
+        )
+    {%- endif %}
+{%- endmacro %}

dbt/include/altertable/macros/utils/splitpart.sql

@@ -0,0 +1,3 @@
+{% macro altertable__split_part(string_text, delimiter_text, part_number) %}
+    string_split({{ string_text }}, {{ delimiter_text }})[ {{ part_number }} ]
+{% endmacro %}

dbt/include/altertable/macros/utils/upstream.sql

@@ -0,0 +1,42 @@
+{%- macro register_upstream_external_models() -%}
+{% if execute %}
+{% set upstream_nodes = {} %}
+{% set upstream_schemas = {} %}
+{% for node in selected_resources %}
+  {% if node not in graph['nodes'] %}{% continue %}{% endif %}
+  {% for upstream_node in graph['nodes'][node]['depends_on']['nodes'] %}
+    {% if upstream_node not in upstream_nodes and upstream_node not in selected_resources %}
+      {% do upstream_nodes.update({upstream_node: None}) %}
+      {% set upstream = graph['nodes'].get(upstream_node) %}
+      {% if upstream
+         and upstream.resource_type in ('model', 'seed')
+         and upstream.config.materialized=='external'
+      %}
+        {%- set upstream_rel = api.Relation.create(
+          database=upstream['database'],
+          schema=upstream['schema'],
+          identifier=upstream['alias']
+        ) -%}
+        {%- set location = upstream.config.get('location', external_location(upstream_rel, upstream.config)) -%}
+        {%- set rendered_options = render_write_options(upstream.config) -%}
+        {%- set upstream_location = adapter.external_read_location(location, rendered_options) -%}
+        {% if upstream_rel.schema not in upstream_schemas %}
+          {% call statement('main', language='sql') -%}
+            create schema if not exists {{ upstream_rel.without_identifier() }}
+          {%- endcall %}
+          {% do upstream_schemas.update({upstream_rel.schema: None}) %}
+        {% endif %}
+        {% call statement('main', language='sql') -%}
+          create or replace view {{ upstream_rel }} as (
+            select * from '{{ upstream_location }}'
+          );
+        {%- endcall %}
+      {%- endif %}
+    {% endif %}
+  {% endfor %}
+{% endfor %}
+{% if upstream_nodes %}
+  {% do adapter.commit() %}
+{% endif %}
+{% endif %}
+{%- endmacro -%}

dbt_altertable-0.1.0.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: dbt-altertable
+Version: 0.1.0
+Summary: DBT adapter for Altertable
+Author-email: Altertable Team <leo@altertable.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/altertable/dbt-altertable
+Project-URL: Repository, https://github.com/altertable/dbt-altertable
+Project-URL: Documentation, https://github.com/altertable/dbt-altertable#readme
+Project-URL: Bug Tracker, https://github.com/altertable/dbt-altertable/issues
+Keywords: dbt,altertable,adapter,database,duckdb
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dbt-core>=1.5.0
+Requires-Dist: dbt-adapters>=0.1.0
+Requires-Dist: altertable-flightsql>=0.2.1
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
+Requires-Dist: ruff>=0.14; extra == "dev"
+Dynamic: license-file
+
+# dbt-altertable
+
+A dbt adapter for Altertable.
+
+## Installation
+
+Install the package using pip:
+
+```bash
+pip install dbt-altertable
+```
+
+Or install from source:
+
+```bash
+git clone <repository-url>
+cd dbt-altertable
+pip install .
+```
+
+## Configuration
+
+Add the following to your `profiles.yml`:
+
+```yaml
+your_profile_name:
+  target: dev
+  outputs:
+    dev:
+      type: altertable
+      username: your_username
+      password: your_password
+      database: your_database
+      schema: your_schema
+```
+
+### Credentials Fields
+
+- **username** (required): Your Altertable username
+- **password** (required): Your Altertable password
+- **database** (required): Target database name
+- **schema** (required): Target schema name
+
+## SQL Dialect
+
+dbt models should use **DuckDB-compatible SQL syntax**. Altertable uses DuckDB as its query engine, so you can leverage all DuckDB SQL features and functions in your models.
+
+For DuckDB SQL reference, see: https://duckdb.org/docs/sql/introduction
+
+## Credits
+
+This adapter is built upon the excellent work of the [dbt-duckdb](https://github.com/duckdb/dbt-duckdb) project.

dbt_altertable-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+dbt/adapters/altertable/__init__.py,sha256=aiDnzI0isB4uL3Egz_rug60LMBteYPcONs2D3DNg_nE,347
+dbt/adapters/altertable/__version__.py,sha256=aOHawL1zuHMfBWKXqwUkXcW96oXLNCY-CXdHDqkz4g4,18
+dbt/adapters/altertable/connections.py,sha256=y7400jr1BNgT3R1nNBGeMAsImfbuOUIeSk-0cFEN6Qk,8412
+dbt/adapters/altertable/impl.py,sha256=mRNdOKRKNCKmmqFPQWFEb_pZYl-gCq5gdyvAjngE-ps,283
+dbt/include/altertable/__init__.py,sha256=vBGWeG-dHHkimfnX8axBJ4IgAowFw8xADmo6Auzn2xc,52
+dbt/include/altertable/dbt_project.yml,sha256=7Prucdcneyyo1yyvIZo_FCc_U-IrEONnnJw1YK86bso,77
+dbt/include/altertable/macros/adapters.sql,sha256=lz2GuFHEufDU3C3wgG3-IyFg_YnAo49ldLEJn6RFJKI,9747
+dbt/include/altertable/macros/catalog.sql,sha256=KRs9iEWDIANzvGjWOr4YaiOnzAV6BC_CL4W9gAnX9N8,1396
+dbt/include/altertable/macros/columns.sql,sha256=kJKaEJWX4CEoJv-l5aOcywj2ejXXa7QMncyb0SdE-RI,711
+dbt/include/altertable/macros/persist_docs.sql,sha256=DTZrfG-5AUSiEDkBGEC-IUB_Q6aIUgMqr7UBiIxkEBU,1628
+dbt/include/altertable/macros/seed.sql,sha256=bwwSGoXMrWHRHM5d8QZ75QnZgTbvNexJa9kv5p66h68,1861
+dbt/include/altertable/macros/snapshot_helper.sql,sha256=QVezsIkYk62csDLrGdXoEoUEd5nn2RAqUuZ_01rCQfQ,1793
+dbt/include/altertable/macros/utils/any_value.sql,sha256=sRgSBSeUnXyaqOy8ZSDHDHYdCdiY6mjnl5y2_1WH83Q,97
+dbt/include/altertable/macros/utils/dateadd.sql,sha256=m7hSTbZe0Pc_92jxmF8o2Uk6pW4Pj4Qp8JLUV2DCDBg,906
+dbt/include/altertable/macros/utils/datediff.sql,sha256=TTO12Yc-7U0YYlkwM5rdA__Ksf76ihX_gJNxLWGLRGo,622
+dbt/include/altertable/macros/utils/external_location.sql,sha256=mqJ5qQbIb8pVe9EjHYJJUSHjpIY_4_rc8HnFWMigw6Q,357
+dbt/include/altertable/macros/utils/generate_series.sql,sha256=B0ZB6406uW1OZwpqAjf-qySO0CbN7BbNjhdeCqoHuv4,170
+dbt/include/altertable/macros/utils/lastday.sql,sha256=fL3CjkTH-q-U2fsJNeuQ_J0eLAMQeSmU9jJq09f4s8c,382
+dbt/include/altertable/macros/utils/listagg.sql,sha256=_1gnxr4dMhgIpFqMsbOT56_ebcavYXJ7Dud8beGGJwA,572
+dbt/include/altertable/macros/utils/splitpart.sql,sha256=q6cWKfZYmQvE_3rE-zgwFqv_74G7NdZfKWAHWAErik0,171
+dbt/include/altertable/macros/utils/upstream.sql,sha256=rzTve-UPACtc6LNcNMVaJIm8lBttTsAxXo02zTsQq80,1798
+dbt_altertable-0.1.0.dist-info/licenses/LICENSE,sha256=va_NkzryPHPb1cPczNYjG-5tPY7LoHMPB3FouVr1aFs,1072
+dbt_altertable-0.1.0.dist-info/METADATA,sha256=DfxLp0khhdXdKR3FVvRePUQ4Uuv-7Ru7---dJfMDNvY,2488
+dbt_altertable-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dbt_altertable-0.1.0.dist-info/top_level.txt,sha256=B2YH4he17ajilEWOGCKHbRcEJlCuZKwCcgFcLPntLsE,4
+dbt_altertable-0.1.0.dist-info/RECORD,,

dbt_altertable-0.1.0.dist-info/WHEEL

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

dbt_altertable-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Altertable Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dbt_altertable-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dbt