duckdb-sqlalchemy 1.5.2__tar.gz → 1.5.2.2__tar.gz

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/.pre-commit-config.yaml

@@ -19,11 +19,11 @@ repos:
     hooks:
       - id: ty
         name: ty
-        entry: ty check --ignore unresolved-import --ignore unused-type-ignore-comment
+        entry: ty check --ignore unresolved-import
         language: python
         files: ^duckdb_sqlalchemy/(?!tests/).*\.py$
         additional_dependencies:
-          - "ty==0.0.31"
+          - "ty==0.0.34"
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
     rev: 'v0.15.11'

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/CHANGELOG.md

@@ -8,6 +8,41 @@ preserved from the upstream project for historical context.
 
 ## Unreleased
 
+## [1.5.2.2](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.2.1...v1.5.2.2) (2026-05-11)
+
+### Features
+
+- add `md_user_info()` for querying MotherDuck user and organization metadata through SQLAlchemy table-valued functions
+
+### Bug Fixes
+
+- prefer the documented `MOTHERDUCK_TOKEN` environment variable over the lowercase fallback when both are set
+- reject MotherDuck database names containing commas before building SQLAlchemy URLs
+- ignore common PostgreSQL session setup statements and transaction isolation declarations emitted by PostgreSQL-oriented clients
+
+### Tooling
+
+- extract bulk insert builder logic into a focused helper module without changing the public execution option behavior
+- revert unreleased PostgreSQL compatibility-mode aliases before publishing them
+- bump the local `ty` pin to `0.0.34` after validating the current checks against the latest non-breaking release
+- refresh the locked development dependency set to the latest non-breaking releases within existing version caps
+- deduplicate reflection fallback wrapper handling
+
+## [1.5.2.1](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.2...v1.5.2.1) (2026-04-25)
+
+### Bug Fixes
+
+- treat MotherDuck transport overrides such as `host`, `region_host`, `port`, `tls`, and `grpc_local_subchannel_pool` as startup URL parameters so SQLAlchemy URLs and `connect_args["config"]` keep working with current MotherDuck routing behavior
+- derive `duckdb_sqlalchemy.__version__` from installed package metadata so the runtime version matches published package metadata and generated user agents
+- normalize legacy MotherDuck transport aliases such as `motherduck_host`, `motherduck_port`, `motherduck_use_tls`, `motherduck_region_host`, and `motherduck_grpc_local_subchannel_pool` into the startup URL parameters the current extension expects, while emitting deprecation warnings
+- restore the exported package version to `1.5.2` so the runtime version matches published package metadata
+
+### Tooling
+
+- bump the local `ty` pin to `0.0.32` after validating the current checks against the latest non-breaking release
+- allow `pre-commit` 4.6.x in the devtools extra
+- refresh validated dev minimums for `nox` and `pytest-cov`
+
 ## [1.5.2](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.1.4...v1.5.2) (2026-04-17)
 
 ### Features

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckdb-sqlalchemy
-Version: 1.5.2
+Version: 1.5.2.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
@@ -33,24 +33,24 @@ Requires-Dist: fsspec<2027.0.0,>=2025.2.0; extra == 'dev'
 Requires-Dist: github-action-utils<2.0.0,>=1.1.0; extra == 'dev'
 Requires-Dist: hypothesis<7.0.0,>=6.75.2; extra == 'dev'
 Requires-Dist: jupysql<0.12.0,>=0.11.1; extra == 'dev'
-Requires-Dist: nox<2027.0.0,>=2026.2.9; extra == 'dev'
+Requires-Dist: nox<2027.0.0,>=2026.4.10; extra == 'dev'
 Requires-Dist: numpy<2.0,>=1.24; (python_version < '3.12') and extra == 'dev'
 Requires-Dist: numpy<3.0,>=1.26; (python_version >= '3.12' and python_version < '3.13') and extra == 'dev'
 Requires-Dist: numpy<3.0,>=2.0; (python_version >= '3.13') and extra == 'dev'
 Requires-Dist: pandas<2.0,>=1; (python_version < '3.12') and extra == 'dev'
 Requires-Dist: pandas<4.0,>=2.2; (python_version >= '3.12') and extra == 'dev'
 Requires-Dist: pyarrow>=22.0.0; (python_version >= '3.10') and extra == 'dev'
-Requires-Dist: pytest-cov<8.0.0,>=5.0.0; extra == 'dev'
+Requires-Dist: pytest-cov<8.0.0,>=7.1.0; extra == 'dev'
 Requires-Dist: pytest-remotedata<0.5.0,>=0.4.0; extra == 'dev'
 Requires-Dist: pytest-snapshot<1.0.0,>=0.9.0; extra == 'dev'
 Requires-Dist: pytest<10.0.0,>=8.0.0; extra == 'dev'
 Requires-Dist: pytz>=2024.2; (python_version >= '3.12') and extra == 'dev'
 Requires-Dist: toml<0.11.0,>=0.10.2; extra == 'dev'
-Requires-Dist: ty==0.0.31; extra == 'dev'
+Requires-Dist: ty==0.0.34; extra == 'dev'
 Provides-Extra: devtools
-Requires-Dist: nox<2027.0.0,>=2026.2.9; extra == 'devtools'
+Requires-Dist: nox<2027.0.0,>=2026.4.10; extra == 'devtools'
 Requires-Dist: pdbpp<0.13.0,>=0.11.0; extra == 'devtools'
-Requires-Dist: pre-commit<4.6.0,>=4.5.1; (python_version >= '3.10') and extra == 'devtools'
+Requires-Dist: pre-commit<4.7.0,>=4.6.0; (python_version >= '3.10') and extra == 'devtools'
 Description-Content-Type: text/markdown
 
 # duckdb-sqlalchemy

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/docs/connection-urls.md

@@ -82,6 +82,17 @@ url = MotherDuckURL(
 engine = create_engine(url)
 ```
 
+Local or staging endpoint overrides belong in the same path-query bucket:
+
+```python
+url = MotherDuckURL(
+    database="md:my_db",
+    host="localhost",
+    port=1984,
+    tls="off",
+)
+```
+
 ## Manual escaping
 
 If you build URLs manually and your token contains special characters, escape it:

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/docs/motherduck.md

@@ -6,6 +6,7 @@ title: MotherDuck
 # MotherDuck
 
 MotherDuck connections use the `md:` database prefix.
+Database names may not contain commas.
 
 ```python
 from sqlalchemy import create_engine
@@ -62,12 +63,13 @@ string for MotherDuck connections.
 Parameters that are treated as part of the database string:
 
 - `user`
+- `host`, `region_host`, `port`, `tls`, `grpc_local_subchannel_pool`
 - `session_name` (read-scaling affinity)
 - `attach_mode` (`workspace` or `single`)
 - `access_mode` (`read_only` for read-scaling tokens)
 - `dbinstance_inactivity_ttl` (preferred; `motherduck_dbinstance_inactivity_ttl`
   remains supported but is deprecated)
-- `saas_mode`
+- `saas_mode` (`pgendpoint` is supported when you need PG endpoint-compatible routing)
 - `cache_buster`
 
 For backward compatibility the dialect also accepts `session_hint`,
@@ -81,6 +83,13 @@ Example:
 duckdb:///md:my_db?attach_mode=single&access_mode=read_only&session_name=team-a
 ```
 
+For local or staging routing, keep the endpoint override in the database string
+as well:
+
+```
+duckdb:///md:my_db?host=localhost&port=1984&tls=off
+```
+
 If you pass these in `connect_args["config"]`, the dialect will move them into the database string automatically.
 
 ### Config parameters
@@ -88,7 +97,15 @@ If you pass these in `connect_args["config"]`, the dialect will move them into t
 Other DuckDB settings can be passed as URL query params or via `connect_args["config"]`:
 
 - Any DuckDB `SET`-table config option (for example `memory_limit`, `threads`)
-- MotherDuck startup auth keys such as `motherduck_token` and `motherduck_oauth_token`
+- MotherDuck startup auth keys such as `motherduck_token`, `token`, `motherduck_oauth_token`, and `oauth_token`
+
+Example with a MotherDuck host override / PG endpoint-style routing:
+
+```python
+engine = create_engine(
+    "duckdb:///md:my_db?host=custom.motherduck.com&port=443&tls=true&saas_mode=pgendpoint"
+)
+```
 
 ## Recommended defaults for apps/BI
 

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/docs/olap.md

@@ -50,6 +50,25 @@ parquet = table_function(
 stmt = select(parquet.c.event_id, parquet.c.ts)
 ```
 
+## MotherDuck user metadata
+
+MotherDuck exposes `md_user_info()` for the current user and organization.
+The helper names the released columns so they are available through SQLAlchemy:
+
+```python
+from sqlalchemy import select
+from duckdb_sqlalchemy import md_user_info
+
+user_info = md_user_info()
+stmt = select(
+    user_info.c.user_id,
+    user_info.c.username,
+    user_info.c.org_id,
+    user_info.c.org_name,
+    user_info.c.org_type,
+)
+```
+
 ## Arrow results
 
 For large reads, you can request Arrow tables directly:

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/duckdb_sqlalchemy/__init__.py

@@ -5,9 +5,12 @@ import uuid
 import warnings
 from collections import defaultdict
 from functools import lru_cache
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as package_version
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Collection,
     Dict,
     Iterable,
@@ -38,6 +41,7 @@ from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql import bindparam
 from sqlalchemy.sql.selectable import Select
 
+from ._bulk_insert import build_bulk_insert_data as _build_bulk_insert_data
 from ._supports import has_comment_support
 from ._validation import validate_extension_name
 from .bulk import copy_from_csv, copy_from_parquet, copy_from_rows
@@ -56,8 +60,9 @@ from .motherduck import (
     split_url_query,
     stable_session_hint,
     stable_session_name,
+    validate_motherduck_database_name,
 )
-from .olap import read_csv, read_csv_auto, read_parquet, table_function
+from .olap import md_user_info, read_csv, read_csv_auto, read_parquet, table_function
 from .url import URL, make_url
 
 try:
@@ -69,7 +74,10 @@ else:
         _pg_base, "PGExecutionContext", DefaultExecutionContext
     )
 
-__version__ = "1.5.1.4"
+try:
+    __version__ = package_version("duckdb-sqlalchemy")
+except PackageNotFoundError:  # pragma: no cover - source tree import fallback
+    __version__ = "1.5.2.2"
 sqlalchemy_version = sqlalchemy.__version__
 SQLALCHEMY_VERSION = Version(sqlalchemy_version)
 SQLALCHEMY_2 = SQLALCHEMY_VERSION >= Version("2.0.0")
@@ -111,6 +119,7 @@ __all__ = [
     "read_parquet",
     "read_csv",
     "read_csv_auto",
+    "md_user_info",
     "copy_from_parquet",
     "copy_from_csv",
     "copy_from_rows",
@@ -202,6 +211,26 @@ class ConnectionWrapper:
 
 _REGISTER_NAME_KEYS = ("name", "view_name", "table")
 _REGISTER_DATA_KEYS = ("df", "dataframe", "relation", "data")
+_IGNORED_POSTGRES_CONFIG_SETTINGS = frozenset(
+    {
+        "extra_float_digits",
+        "application_name",
+        "standard_conforming_strings",
+        "client_min_messages",
+        "datestyle",
+        "ssl_renegotiation_limit",
+        "statement_timeout",
+    }
+)
+_SET_POSTGRES_CONFIG_RE = re.compile(r"^set\s+(?:session\s+|local\s+)?(\w+)\b")
+_SET_TRANSACTION_ISOLATION_RE = re.compile(
+    r"^set\s+(?:session\s+characteristics\s+as\s+)?transaction\s+isolation\s+level\s+"
+    r"(?:serializable|repeatable\s+read|read\s+committed|read\s+uncommitted)$"
+)
+_BEGIN_TRANSACTION_ISOLATION_RE = re.compile(
+    r"^begin\s+(?:transaction\s+)?isolation\s+level\s+"
+    r"(?:serializable|repeatable\s+read|read\s+committed|read\s+uncommitted)$"
+)
 
 
 def _parse_register_params(parameters: Optional[Any]) -> Tuple[str, Any]:
@@ -236,6 +265,9 @@ class CursorWrapper:
         self.__c = c
         self.__connection_wrapper = connection_wrapper
 
+    def _clear_result(self) -> None:
+        self.__c.execute("")
+
     def executemany(
         self,
         statement: str,
@@ -260,11 +292,19 @@ class CursorWrapper:
             norm = statement.strip().lower().rstrip(";")
             if norm == "commit":  # this is largely for ipython-sql
                 self.__c.commit()
+            elif _BEGIN_TRANSACTION_ISOLATION_RE.fullmatch(norm):
+                self.__c.begin()
+            elif _SET_TRANSACTION_ISOLATION_RE.fullmatch(norm):
+                self._clear_result()
+            elif _is_ignored_postgres_config_set(norm):
+                self._clear_result()
             elif norm.startswith("register"):
                 view_name, df = _parse_register_params(parameters)
                 self.__c.register(view_name, df)
             elif norm == "show transaction isolation level":
                 self.__c.execute("select 'read committed' as transaction_isolation")
+            elif norm == "show standard_conforming_strings":
+                self.__c.execute("select 'on' as standard_conforming_strings")
             elif parameters is None:
                 self.__c.execute(statement)
             else:
@@ -316,6 +356,13 @@ class CursorWrapper:
             return self.__c.fetchmany(size)
 
 
+def _is_ignored_postgres_config_set(statement: str) -> bool:
+    match = _SET_POSTGRES_CONFIG_RE.match(statement)
+    if match is None:
+        return False
+    return match.group(1) in _IGNORED_POSTGRES_CONFIG_SETTINGS
+
+
 class DuckDBEngineWarning(Warning):
     pass
 
@@ -350,49 +397,6 @@ def _normalize_execution_options(execution_options: Dict[str, Any]) -> Dict[str,
     return execution_options
 
 
-def _build_bulk_insert_dataframe(
-    rows: Sequence[Any], column_names: Sequence[str]
-) -> Any:
-    try:
-        import pandas as pd  # type: ignore[import-not-found]
-    except Exception:
-        return None
-
-    try:
-        if isinstance(rows[0], dict):
-            return pd.DataFrame.from_records(rows, columns=column_names)
-        return pd.DataFrame(rows, columns=cast(Any, column_names))
-    except Exception:
-        return None
-
-
-def _build_bulk_insert_arrow_table(
-    rows: Sequence[Any], column_names: Sequence[str]
-) -> Any:
-    try:
-        import pyarrow as pa  # type: ignore[import-not-found]
-    except Exception:
-        return None
-
-    try:
-        if isinstance(rows[0], dict):
-            table = pa.Table.from_pylist(rows)
-            if column_names:
-                return table.select(column_names)
-            return table
-        columns = list(zip(*rows)) if rows else [[] for _ in column_names]
-        return pa.Table.from_arrays(columns, names=column_names)
-    except Exception:
-        return None
-
-
-def _build_bulk_insert_data(rows: Sequence[Any], column_names: Sequence[str]) -> Any:
-    data = _build_bulk_insert_dataframe(rows, column_names)
-    if data is not None:
-        return data
-    return _build_bulk_insert_arrow_table(rows, column_names)
-
-
 class DuckDBArrowResult:
     def __init__(self, result: Any) -> None:
         self._result = result
@@ -622,7 +626,7 @@ def _default_pool_class_for_database(
 
 def _apply_motherduck_defaults(config: Dict[str, Any], database: Optional[str]) -> None:
     if "motherduck_token" not in config:
-        token = os.getenv("motherduck_token") or os.getenv("MOTHERDUCK_TOKEN")
+        token = os.getenv("MOTHERDUCK_TOKEN") or os.getenv("motherduck_token")
         if token and _looks_like_motherduck(database, config):
             config["motherduck_token"] = token
 
@@ -751,6 +755,7 @@ class Dialect(PGDialect_psycopg2):
             cparams["database"] = append_query_to_database(
                 cparams.get("database"), path_query
             )
+        validate_motherduck_database_name(cparams.get("database"))
         _normalize_motherduck_config(config)
 
         ext = {k: config.pop(k) for k in list(config) if k not in core_keys}
@@ -966,6 +971,35 @@ class Dialect(PGDialect_psycopg2):
         sql += where_sql
         return connection.execute(text(sql), params).first() is not None
 
+    def _get_reflection_or_empty_for_existing_table(
+        self,
+        getter: Callable[[], List[Any]],
+        connection: "Connection",
+        table_name: str,
+        schema: Optional[str],
+    ) -> List[Any]:
+        try:
+            return getter()
+        except NoSuchTableError:
+            if self._duckdb_table_exists(connection, table_name, schema):
+                return []
+            raise
+
+    def _get_super_reflection_or_empty(
+        self,
+        getter: Callable[..., List[Any]],
+        connection: "Connection",
+        table_name: str,
+        schema: Optional[str],
+        **kw: Any,
+    ) -> List[Any]:
+        return self._get_reflection_or_empty_for_existing_table(
+            lambda: getter(connection, table_name, schema=schema, **kw),
+            connection,
+            table_name,
+            schema,
+        )
+
     def _duckdb_columns(
         self, connection: "Connection", table_name: str, schema: Optional[str]
     ) -> Optional[List[Dict[str, Any]]]:
@@ -1352,18 +1386,14 @@ class Dialect(PGDialect_psycopg2):
         postgresql_ignore_search_path: bool = False,
         **kw: Any,
     ) -> List["ReflectedForeignKeyConstraint"]:
-        try:
-            return super().get_foreign_keys(
-                connection,
-                table_name,
-                schema=schema,
-                postgresql_ignore_search_path=postgresql_ignore_search_path,
-                **kw,
-            )
-        except NoSuchTableError:
-            if self._duckdb_table_exists(connection, table_name, schema):
-                return []
-            raise
+        return self._get_super_reflection_or_empty(
+            super().get_foreign_keys,
+            connection,
+            table_name,
+            schema,
+            postgresql_ignore_search_path=postgresql_ignore_search_path,
+            **kw,
+        )
 
     @cache  # type: ignore[call-arg]
     def get_unique_constraints(
@@ -1373,14 +1403,13 @@ class Dialect(PGDialect_psycopg2):
         schema: Optional[str] = None,
         **kw: Any,
     ) -> List["ReflectedUniqueConstraint"]:
-        try:
-            return super().get_unique_constraints(
-                connection, table_name, schema=schema, **kw
-            )
-        except NoSuchTableError:
-            if self._duckdb_table_exists(connection, table_name, schema):
-                return []
-            raise
+        return self._get_super_reflection_or_empty(
+            super().get_unique_constraints,
+            connection,
+            table_name,
+            schema,
+            **kw,
+        )
 
     @cache  # type: ignore[call-arg]
     def get_check_constraints(
@@ -1390,14 +1419,13 @@ class Dialect(PGDialect_psycopg2):
         schema: Optional[str] = None,
         **kw: Any,
     ) -> List["ReflectedCheckConstraint"]:
-        try:
-            return super().get_check_constraints(
-                connection, table_name, schema=schema, **kw
-            )
-        except NoSuchTableError:
-            if self._duckdb_table_exists(connection, table_name, schema):
-                return []
-            raise
+        return self._get_super_reflection_or_empty(
+            super().get_check_constraints,
+            connection,
+            table_name,
+            schema,
+            **kw,
+        )
 
     def get_indexes(
         self,
@@ -1462,6 +1490,7 @@ class Dialect(PGDialect_psycopg2):
         database = opts.get("database")
         if database in {None, ""}:
             database = ":memory:"
+        validate_motherduck_database_name(database)
         opts["database"] = append_query_to_database(database, path_query)
         return (), opts
 

duckdb_sqlalchemy-1.5.2.2/duckdb_sqlalchemy/_bulk_insert.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Any, Sequence, cast
+
+
+def _rows_use_mapping_shape(rows: Sequence[Any]) -> bool:
+    return bool(rows) and isinstance(rows[0], dict)
+
+
+def build_bulk_insert_dataframe(
+    rows: Sequence[Any], column_names: Sequence[str]
+) -> Any:
+    try:
+        import pandas as pd  # type: ignore[import-not-found]
+    except Exception:
+        return None
+
+    try:
+        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:
+        return None
+
+
+def build_bulk_insert_arrow_table(
+    rows: Sequence[Any], column_names: Sequence[str]
+) -> Any:
+    try:
+        import pyarrow as pa  # type: ignore[import-not-found]
+    except Exception:
+        return None
+
+    try:
+        if _rows_use_mapping_shape(rows):
+            table = pa.Table.from_pylist(rows)
+            if column_names:
+                return table.select(column_names)
+            return table
+        columns = list(zip(*rows)) if rows else [[] for _ in column_names]
+        return pa.Table.from_arrays(columns, names=column_names)
+    except Exception:
+        return None
+
+
+def build_bulk_insert_data(rows: Sequence[Any], column_names: Sequence[str]) -> Any:
+    data = build_bulk_insert_dataframe(rows, column_names)
+    if data is not None:
+        return data
+    return build_bulk_insert_arrow_table(rows, column_names)

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/duckdb_sqlalchemy/_validation.py

@@ -5,31 +5,35 @@ IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 EXTENSION_RE = re.compile(r"^[A-Za-z0-9_]+$")
 
 
-def validate_identifier(value: str, *, kind: str = "identifier") -> str:
+def _require_string(value: str, *, kind: str) -> str:
     if not isinstance(value, str):
         raise ValueError(f"{kind} must be a string")
-    if not IDENTIFIER_RE.fullmatch(value):
-        raise ValueError(f"invalid {kind}: {value!r}")
     return value
 
 
+def _validate_pattern(value: str, *, kind: str, pattern: re.Pattern[str]) -> str:
+    validated = _require_string(value, kind=kind)
+    if not pattern.fullmatch(validated):
+        raise ValueError(f"invalid {kind}: {validated!r}")
+    return validated
+
+
+def validate_identifier(value: str, *, kind: str = "identifier") -> str:
+    return _validate_pattern(value, kind=kind, pattern=IDENTIFIER_RE)
+
+
 def validate_dotted_identifier(value: str, *, kind: str = "identifier") -> str:
-    if not isinstance(value, str):
-        raise ValueError(f"{kind} must be a string")
-    parts = value.split(".")
+    validated = _require_string(value, kind=kind)
+    parts = validated.split(".")
     if not parts or any(not part for part in parts):
-        raise ValueError(f"invalid {kind}: {value!r}")
+        raise ValueError(f"invalid {kind}: {validated!r}")
     for part in parts:
         validate_identifier(part, kind=kind)
-    return value
+    return validated
 
 
 def validate_extension_name(value: str) -> str:
-    if not isinstance(value, str):
-        raise ValueError("extension name must be a string")
-    if not EXTENSION_RE.fullmatch(value):
-        raise ValueError(f"invalid extension name: {value!r}")
-    return value
+    return _validate_pattern(value, kind="extension name", pattern=EXTENSION_RE)
 
 
 def validate_identifier_list(

{duckdb_sqlalchemy-1.5.2 → duckdb_sqlalchemy-1.5.2.2}/duckdb_sqlalchemy/bulk.py

@@ -155,6 +155,27 @@ def _copy_rows_as_csv_chunks(
             _close_and_unlink_tempfile(tmp)
 
 
+def _copy_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()]
+
+        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
+
+
 def copy_from_parquet(
     connection: Any,
     table: TableLike,
@@ -227,20 +248,7 @@ def copy_from_rows(
 
     copy_options = {"header": include_header, **copy_options}
 
-    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 iterator)
-    else:
-        first_row = cast(Sequence[Any], first)
-        remaining_rows = (cast(Sequence[Any], row) for row in iterator)
-
-    chunked_rows = chain((first_row,), remaining_rows)
+    chunked_rows, columns = _copy_rows_as_sequences(first, iterator, columns)
     _copy_rows_as_csv_chunks(
         connection,
         table,