duckdb-sqlalchemy 1.5.4__tar.gz → 1.5.4.2__tar.gz

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/.gitignore

@@ -240,3 +240,4 @@ __marimo__/
 
 # Local Codex sandbox rules (machine-specific)
 .codex/rules/
+notes/

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/CHANGELOG.md

@@ -6,7 +6,29 @@ preserved from the upstream project for historical context.
 
 ## Maintained in this fork
 
-## Unreleased
+## [1.5.4.2](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.4.1...v1.5.4.2) (2026-07-03)
+
+### Features
+
+- expose MotherDuck Dive status metadata columns on `md_list_dives()`, `md_create_dive()`, `md_get_dive()`, and other summary-returning Dive helpers
+
+### Bug Fixes
+
+- reject `copy_from_rows(..., include_header=True)` for sequence rows without explicit `columns` instead of letting DuckDB treat the first data row as the header
+
+### Maintenance
+
+- centralize reflection result default handling for multi-reflection methods without changing public behavior
+
+### Tooling
+
+- refresh the locked development dependency set to the latest non-breaking transitive releases within existing version caps
+
+## [1.5.4.1](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.4...v1.5.4.1) (2026-07-01)
+
+### Bug Fixes
+
+- render autoincrement integer primary keys with an implicit DuckDB sequence (`DEFAULT nextval(...)`) instead of PostgreSQL's unsupported `SERIAL`, so `Column(Integer, primary_key=True)` works without an explicit `Sequence` ([#128](https://github.com/leonardovida/duckdb-sqlalchemy/issues/128))
 
 ## [1.5.4](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.3...v1.5.4) (2026-06-26)
 

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckdb-sqlalchemy
-Version: 1.5.4
+Version: 1.5.4.2
 Summary: DuckDB SQLAlchemy dialect for DuckDB and MotherDuck
 Project-URL: Bug Tracker, https://github.com/leonardovida/duckdb-sqlalchemy/issues
 Project-URL: Changelog, https://github.com/leonardovida/duckdb-sqlalchemy/releases

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/docs/olap.md

@@ -103,7 +103,13 @@ user_stmt = select(
 )
 
 dives = md_list_dives()
-dives_stmt = select(dives.c.id, dives.c.title, dives.c.required_resources)
+dives_stmt = select(
+    dives.c.id,
+    dives.c.title,
+    dives.c.status,
+    dives.c.status_applies_to_version,
+    dives.c.required_resources,
+)
 
 tokens = md_access_tokens()
 tokens_stmt = select(tokens.c.token_name, tokens.c.token_type, tokens.c.expire_at)
@@ -132,7 +138,7 @@ created = md_create_dive(
 create_stmt = select(created.c.id, created.c.version_id)
 
 dive = md_get_dive(id="00000000-0000-0000-0000-000000000000")
-dive_stmt = select(dive.c.title, dive.c.content)
+dive_stmt = select(dive.c.title, dive.c.status, dive.c.content)
 
 updated = md_update_dive_content(
     id="00000000-0000-0000-0000-000000000000",

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/duckdb_sqlalchemy/__init__.py

@@ -15,6 +15,7 @@ from typing import (
     Dict,
     Iterable,
     List,
+    Mapping,
     Optional,
     Sequence,
     Tuple,
@@ -24,10 +25,12 @@ from typing import (
 import duckdb
 import sqlalchemy
 from packaging.version import Version
-from sqlalchemy import pool, select, sql, text, util
+from sqlalchemy import event, pool, select, sql, text, util
+from sqlalchemy import schema as sa_schema
 from sqlalchemy import types as sqltypes
 from sqlalchemy.dialects.postgresql import UUID, insert
 from sqlalchemy.dialects.postgresql.base import (
+    PGDDLCompiler,
     PGDialect,
     PGIdentifierPreparer,
     PGInspector,
@@ -39,6 +42,7 @@ from sqlalchemy.engine.url import URL as SAURL
 from sqlalchemy.exc import InvalidRequestError, NoSuchTableError
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql import bindparam
+from sqlalchemy.sql.compiler import IdentifierPreparer
 from sqlalchemy.sql.selectable import Select
 
 from ._arrow import DuckDBArrowResult
@@ -126,7 +130,7 @@ else:
 try:
     __version__ = package_version("duckdb-sqlalchemy")
 except PackageNotFoundError:  # pragma: no cover - source tree import fallback
-    __version__ = "1.5.4"
+    __version__ = "1.5.4.2"
 sqlalchemy_version = sqlalchemy.__version__
 SQLALCHEMY_VERSION = Version(sqlalchemy_version)
 SQLALCHEMY_2 = SQLALCHEMY_VERSION >= Version("2.0.0")
@@ -671,6 +675,82 @@ class DuckDBIdentifierPreparer(PGIdentifierPreparer):
         return self.format_schema(schema)
 
 
+def _column_needs_implicit_sequence(column: Any) -> bool:
+    """Columns that PostgreSQL would render as SERIAL/BIGSERIAL.
+
+    DuckDB has no SERIAL type, so these columns are backed by an explicitly
+    created sequence instead (see :class:`DuckDBDDLCompiler` and the
+    ``before_create``/``after_drop`` hooks below).
+    """
+    table = getattr(column, "table", None)
+    if table is None:
+        return False
+    if not column.primary_key or column is not table._autoincrement_column:
+        return False
+    if getattr(column, "identity", None) is not None:
+        return False
+    if column.default is not None and not (
+        isinstance(column.default, sa_schema.Sequence) and column.default.optional
+    ):
+        return False
+    if column.server_default is not None:
+        return False
+    return True
+
+
+def _implicit_sequence_ddl_name(preparer: IdentifierPreparer, column: Any) -> str:
+    name = preparer.quote(f"{column.table.name}_{column.name}_seq")
+    schema = column.table.schema
+    if schema:
+        name = f"{preparer.quote_schema(schema)}.{name}"
+    return name
+
+
+def _create_implicit_sequences(target: Any, connection: Any, **kw: Any) -> None:
+    if connection.dialect.name != "duckdb":
+        return
+    preparer = connection.dialect.identifier_preparer
+    for column in target.columns:
+        if _column_needs_implicit_sequence(column):
+            connection.exec_driver_sql(
+                "CREATE SEQUENCE IF NOT EXISTS "
+                f"{_implicit_sequence_ddl_name(preparer, column)}"
+            )
+
+
+def _drop_implicit_sequences(target: Any, connection: Any, **kw: Any) -> None:
+    if connection.dialect.name != "duckdb":
+        return
+    preparer = connection.dialect.identifier_preparer
+    for column in target.columns:
+        if _column_needs_implicit_sequence(column):
+            connection.exec_driver_sql(
+                "DROP SEQUENCE IF EXISTS "
+                f"{_implicit_sequence_ddl_name(preparer, column)}"
+            )
+
+
+event.listen(sa_schema.Table, "before_create", _create_implicit_sequences)
+event.listen(sa_schema.Table, "after_drop", _drop_implicit_sequences)
+
+
+class DuckDBDDLCompiler(PGDDLCompiler):
+    def get_column_specification(self, column: Any, **kwargs: Any) -> str:
+        if not _column_needs_implicit_sequence(column):
+            return super().get_column_specification(column, **kwargs)
+        colspec = self.preparer.format_column(column)
+        colspec += " " + self.dialect.type_compiler_instance.process(
+            column.type, type_expression=column
+        )
+        seq_name = _implicit_sequence_ddl_name(self.preparer, column)
+        colspec += " DEFAULT nextval(%s)" % self.sql_compiler.render_literal_value(
+            seq_name, sqltypes.String()
+        )
+        if not column.nullable:
+            colspec += " NOT NULL"
+        return colspec
+
+
 class DuckDBNullType(sqltypes.NullType):
     def result_processor(self, dialect: Any, coltype: object) -> Any:
         if coltype == "JSON":
@@ -711,6 +791,7 @@ class Dialect(PGDialect_psycopg2):
     )
     preparer = DuckDBIdentifierPreparer
     identifier_preparer: DuckDBIdentifierPreparer
+    ddl_compiler = DuckDBDDLCompiler
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         kwargs["use_native_hstore"] = False
@@ -1326,6 +1407,20 @@ class Dialect(PGDialect_psycopg2):
     def _reflection_schema_key(self, schema: Optional[str]) -> Optional[str]:
         return schema
 
+    def _iter_reflection_results(
+        self,
+        schema: Optional[str],
+        table_names: Iterable[str],
+        reflected: Mapping[str, Any],
+        default_factory: Callable[[], Any],
+    ) -> Iterable[Tuple[Any, Any]]:
+        schema_key = self._reflection_schema_key(schema)
+        for table_name in table_names:
+            value = reflected.get(table_name)
+            if value is None:
+                value = default_factory()
+            yield (schema_key, table_name), value
+
     def _get_single_reflection_result(
         self,
         connection: "Connection",
@@ -1422,13 +1517,8 @@ class Dialect(PGDialect_psycopg2):
             }
             for row in constraint_rows
         }
-        schema_key = self._reflection_schema_key(schema)
-        return (
-            (
-                (schema_key, table_name),
-                constraints.get(table_name, ReflectionDefaults.pk_constraint()),
-            )
-            for table_name in table_names
+        return self._iter_reflection_results(
+            schema, table_names, constraints, ReflectionDefaults.pk_constraint
         )
 
     @cache  # type: ignore[call-arg]
@@ -1531,10 +1621,8 @@ class Dialect(PGDialect_psycopg2):
             if any(column_name is None for column_name in column_names):
                 reflected_index["expressions"] = expressions
             indexes[row["table_name"]].append(reflected_index)
-        schema_key = self._reflection_schema_key(schema)
-        return (
-            ((schema_key, table_name), indexes.get(table_name, []))
-            for table_name in table_names
+        return self._iter_reflection_results(
+            schema, table_names, indexes, ReflectionDefaults.indexes
         )
 
     def create_connect_args(self, url: SAURL) -> Tuple[tuple, dict]:

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/duckdb_sqlalchemy/_bulk_insert.py

@@ -1,17 +1,12 @@
 from __future__ import annotations
 
-from collections.abc import Mapping
 from typing import Any, Optional, Sequence, cast
 
-
-def _rows_use_mapping_shape(rows: Sequence[Any]) -> bool:
-    return bool(rows) and isinstance(rows[0], Mapping)
+from ._row_shape import infer_mapping_column_keys, rows_use_mapping_shape
 
 
 def infer_bulk_insert_column_keys(rows: Sequence[Any]) -> Optional[list[str]]:
-    if not _rows_use_mapping_shape(rows):
-        return None
-    return [str(key) for key in cast(Mapping[str, Any], rows[0]).keys()]
+    return infer_mapping_column_keys(rows)
 
 
 def build_bulk_insert_dataframe(
@@ -23,7 +18,7 @@ def build_bulk_insert_dataframe(
         return None
 
     try:
-        if _rows_use_mapping_shape(rows):
+        if rows_use_mapping_shape(rows):
             return pd.DataFrame.from_records(rows, columns=column_names)
         return pd.DataFrame(rows, columns=cast(Any, column_names))
     except Exception:
@@ -39,7 +34,7 @@ def build_bulk_insert_arrow_table(
         return None
 
     try:
-        if _rows_use_mapping_shape(rows):
+        if rows_use_mapping_shape(rows):
             table = pa.Table.from_pylist(rows)
             if column_names:
                 return table.select(column_names)

duckdb_sqlalchemy-1.5.4.2/duckdb_sqlalchemy/_row_shape.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+from itertools import chain
+from typing import Any, Optional, Tuple, Union, cast
+
+
+def rows_use_mapping_shape(rows: Sequence[Any]) -> bool:
+    return bool(rows) and isinstance(rows[0], Mapping)
+
+
+def infer_mapping_column_keys(rows: Sequence[Any]) -> Optional[list[str]]:
+    if not rows_use_mapping_shape(rows):
+        return None
+    return [str(key) for key in cast(Mapping[str, Any], rows[0]).keys()]
+
+
+def mapping_row_as_sequence(
+    row: Mapping[str, Any], columns: Sequence[str]
+) -> Sequence[Any]:
+    return [row.get(col) for col in columns]
+
+
+def rows_as_sequences(
+    first: Union[Mapping[str, Any], Sequence[Any]],
+    rows: Iterable[Union[Mapping[str, Any], Sequence[Any]]],
+    columns: Optional[Sequence[str]],
+) -> Tuple[Iterable[Sequence[Any]], Optional[Sequence[str]]]:
+    if isinstance(first, Mapping):
+        if columns is None:
+            columns = [str(col) for col in cast(Mapping[str, Any], first).keys()]
+
+        first_row = mapping_row_as_sequence(cast(Mapping[str, Any], first), columns)
+        remaining_rows = (
+            mapping_row_as_sequence(cast(Mapping[str, Any], row), columns)
+            for row in rows
+        )
+        return chain((first_row,), remaining_rows), columns
+
+    first_row = cast(Sequence[Any], first)
+    remaining_rows = (cast(Sequence[Any], row) for row in rows)
+    return chain((first_row,), remaining_rows), columns

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/duckdb_sqlalchemy/bulk.py

@@ -1,9 +1,9 @@
 import csv
 import tempfile
-from itertools import chain
 from pathlib import Path
-from typing import Any, Iterable, Mapping, Optional, Sequence, Tuple, Union, cast
+from typing import Any, Iterable, Mapping, Optional, Sequence, Tuple, Union
 
+from ._row_shape import rows_as_sequences
 from ._validation import (
     validate_dotted_identifier,
     validate_identifier,
@@ -160,20 +160,7 @@ def _copy_rows_as_sequences(
     rows: Iterable[Union[Mapping[str, Any], Sequence[Any]]],
     columns: Optional[Sequence[str]],
 ) -> Tuple[Iterable[Sequence[Any]], Optional[Sequence[str]]]:
-    if isinstance(first, Mapping):
-        if columns is None:
-            columns = [str(col) for col in cast(Mapping[str, Any], first).keys()]
-
-        def row_to_seq(row: Mapping[str, Any]) -> Sequence[Any]:
-            return [row.get(col) for col in columns or []]
-
-        first_row = row_to_seq(cast(Mapping[str, Any], first))
-        remaining_rows = (row_to_seq(cast(Mapping[str, Any], row)) for row in rows)
-        return chain((first_row,), remaining_rows), columns
-
-    first_row = cast(Sequence[Any], first)
-    remaining_rows = (cast(Sequence[Any], row) for row in rows)
-    return chain((first_row,), remaining_rows), columns
+    return rows_as_sequences(first, rows, columns)
 
 
 def copy_from_parquet(
@@ -246,16 +233,21 @@ def copy_from_rows(
     if first is None:
         return None
 
-    copy_options = {"header": include_header, **copy_options}
+    header = copy_options.pop("header", include_header)
+    copy_options = {"header": header, **copy_options}
 
     chunked_rows, columns = _copy_rows_as_sequences(first, iterator, columns)
+    if header and columns is None:
+        raise ValueError(
+            "copy_from_rows header mode requires columns for sequence rows"
+        )
     _copy_rows_as_csv_chunks(
         connection,
         table,
         chunked_rows,
         columns=columns,
         chunk_size=chunk_size,
-        include_header=include_header,
+        include_header=header,
         copy_options=copy_options,
     )
     return None

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/duckdb_sqlalchemy/olap.py

@@ -22,6 +22,10 @@ MOTHERDUCK_LIST_DIVES_COLUMNS = (
     "created_at",
     "updated_at",
     "owner_name",
+    "status",
+    "status_changed_at",
+    "status_set_by",
+    "status_applies_to_version",
     "required_resources",
 )
 MOTHERDUCK_ACCESS_TOKENS_COLUMNS = (

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/duckdb_sqlalchemy/tests/test_basic.py

@@ -37,6 +37,7 @@ from sqlalchemy.engine.reflection import Inspector
 from sqlalchemy.exc import DBAPIError, OperationalError
 from sqlalchemy.orm import Session, declarative_base, relationship, sessionmaker
 from sqlalchemy.pool import QueuePool, SingletonThreadPool
+from sqlalchemy.schema import CreateTable
 
 from .. import Dialect, checkpoint, insert, supports_attach, supports_user_agent
 from .._supports import has_comment_support
@@ -771,3 +772,37 @@ def test_register_filesystem() -> None:
     with engine.connect() as conn:
         duckdb_conn = getattr(conn.connection.dbapi_connection, "_ConnectionWrapper__c")
         assert duckdb.list_filesystems(connection=duckdb_conn) == ["memory", "file"]
+
+
+def test_autoincrement_pk_without_sequence() -> None:
+    """Plain Integer primary keys are backed by an implicit sequence (GH-128).
+
+    PostgreSQL renders these columns as SERIAL, which DuckDB does not support.
+    """
+    LocalBase = declarative_base()
+
+    class AutoUser(LocalBase):
+        __tablename__ = "auto_users"
+
+        id = Column(Integer, primary_key=True)
+        name = Column(String)
+
+    engine = create_engine("duckdb:///:memory:")
+    ddl = str(CreateTable(AutoUser.__table__).compile(engine))
+    assert "SERIAL" not in ddl
+    assert "DEFAULT nextval('auto_users_id_seq')" in ddl
+
+    LocalBase.metadata.create_all(engine)
+    with Session(engine) as session:
+        session.add(AutoUser(name="Ada"))
+        session.add(AutoUser(name="Grace"))
+        session.commit()
+        assert sorted(u.id for u in session.query(AutoUser).all()) == [1, 2]
+
+    # drop_all removes the implicit sequence so create_all starts fresh
+    LocalBase.metadata.drop_all(engine)
+    LocalBase.metadata.create_all(engine)
+    with Session(engine) as session:
+        session.add(AutoUser(name="Alan"))
+        session.commit()
+        assert session.query(AutoUser).one().id == 1

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/duckdb_sqlalchemy/tests/test_core_units.py

@@ -720,6 +720,10 @@ def test_md_list_dives_uses_released_motherduck_columns() -> None:
         "created_at",
         "updated_at",
         "owner_name",
+        "status",
+        "status_changed_at",
+        "status_set_by",
+        "status_applies_to_version",
         "required_resources",
     ]
 
@@ -932,6 +936,10 @@ def test_motherduck_dive_helpers_use_released_columns() -> None:
         "created_at",
         "updated_at",
         "owner_name",
+        "status",
+        "status_changed_at",
+        "status_set_by",
+        "status_applies_to_version",
         "required_resources",
         "version_id",
         "version_storage_url",
@@ -989,6 +997,21 @@ def test_motherduck_dive_helpers_render_named_parameters() -> None:
     ]
 
 
+def test_motherduck_dive_status_columns_compile() -> None:
+    dives = olap.md_list_dives()
+    stmt = select(
+        dives.c.id,
+        dives.c.status,
+        dives.c.status_changed_at,
+        dives.c.status_set_by,
+        dives.c.status_applies_to_version,
+    ).select_from(dives)
+    sql = str(stmt.compile(dialect=Dialect()))
+
+    assert "md_list_dives" in sql
+    assert "status_applies_to_version" in sql
+
+
 def test_cursorwrapper_execute_basic_paths() -> None:
     class DummyConn:
         def __init__(self) -> None:
@@ -1339,6 +1362,31 @@ def test_reflection_fallback_returns_empty_only_for_existing_tables(
         )
 
 
+def test_iter_reflection_results_defaults_only_missing_tables() -> None:
+    dialect = Dialect()
+    default_calls = 0
+
+    def default_factory() -> list[Any]:
+        nonlocal default_calls
+        default_calls += 1
+        return []
+
+    results = list(
+        dialect._iter_reflection_results(
+            "analytics",
+            ["orders", "customers"],
+            {"orders": [{"name": "orders_pk"}]},
+            default_factory,
+        )
+    )
+
+    assert results == [
+        (("analytics", "orders"), [{"name": "orders_pk"}]),
+        (("analytics", "customers"), []),
+    ]
+    assert default_calls == 1
+
+
 def test_parse_duckdb_enum_labels_unquotes_escaped_strings() -> None:
     labels, enum_name = Dialect()._parse_duckdb_enum_labels(
         "ENUM('alpha', 'it''s fine')",
@@ -1473,6 +1521,38 @@ def test_copy_from_rows_sequence_uses_explicit_columns_and_chunks() -> None:
     assert rows == [(1, "one"), (2, "two"), (3, "three")]
 
 
+def test_copy_from_rows_sequence_header_requires_columns() -> None:
+    conn = duckdb.connect(":memory:")
+    conn.execute("CREATE TABLE safe(i INTEGER, label VARCHAR)")
+
+    with pytest.raises(ValueError, match="header mode requires columns"):
+        copy_from_rows(
+            conn,
+            "safe",
+            [(1, "one"), (2, "two")],
+            include_header=True,
+        )
+
+    rows = conn.execute("SELECT i, label FROM safe ORDER BY i").fetchall()
+    assert rows == []
+
+
+def test_copy_from_rows_header_option_writes_header_with_columns() -> None:
+    conn = duckdb.connect(":memory:")
+    conn.execute("CREATE TABLE safe(i INTEGER, label VARCHAR)")
+
+    copy_from_rows(
+        conn,
+        "safe",
+        [(1, "one"), (2, "two")],
+        columns=["i", "label"],
+        header=True,
+    )
+
+    rows = conn.execute("SELECT i, label FROM safe ORDER BY i").fetchall()
+    assert rows == [(1, "one"), (2, "two")]
+
+
 def test_copy_rows_as_sequences_infers_mapping_columns() -> None:
     rows, columns = duckdb_sqlalchemy.bulk._copy_rows_as_sequences(
         {"id": 1, "label": "one"},

{duckdb_sqlalchemy-1.5.4 → duckdb_sqlalchemy-1.5.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "duckdb-sqlalchemy"
-version = "1.5.4"
+version = "1.5.4.2"
 description = "DuckDB SQLAlchemy dialect for DuckDB and MotherDuck"
 authors = [
     {name = "Leonardo Vida", email = "lleonardovida@gmail.com"},