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

{duckdb_sqlalchemy-1.5.3 → duckdb_sqlalchemy-1.5.4}/.github/workflows/pythonapp.yaml

@@ -66,4 +66,5 @@ jobs:
           token: ${{ secrets.CODECOV_TOKEN }}
           env_vars: PYTHON
           fail_ci_if_error: true
+          use_pypi: true
           verbose: true

{duckdb_sqlalchemy-1.5.3 → duckdb_sqlalchemy-1.5.4}/.pre-commit-config.yaml

@@ -23,10 +23,10 @@ repos:
         language: python
         files: ^duckdb_sqlalchemy/(?!tests/).*\.py$
         additional_dependencies:
-          - "ty==0.0.38"
+          - "ty==0.0.54"
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: 'v0.15.11'
+    rev: 'v0.15.20'
     hooks:
       - id: ruff
         args:

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

@@ -8,6 +8,26 @@ preserved from the upstream project for historical context.
 
 ## Unreleased
 
+## [1.5.4](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.3...v1.5.4) (2026-06-26)
+
+### Features
+
+- expose MotherDuck `md_user_info().c.region` and Flight run `config` columns in the SQLAlchemy table-function helpers
+- document one-off `md_run_flight(config=...)` overrides and selecting effective Flight run config
+- route `motherduck_enable_server_side_temp_tables` through the MotherDuck startup URL parameter bucket
+
+### Bug Fixes
+
+- restore SQLAlchemy 2.0.0+ compatibility by using a reflection fallback on early 2.0 releases
+- reject empty MotherDuck Flight config keys before compiling Flight helper calls
+- reject invalid MotherDuck Flight config map keys and NUL-containing values before compiling Flight helper calls
+
+### Tooling
+
+- extend the validated compatibility matrix to DuckDB 1.5.4 and SQLAlchemy 2.0.51
+- bump the local `ty` pin to `0.0.54` and the Ruff pre-commit hook to `0.15.20` after validating the current checks against the latest non-breaking releases
+- refresh the locked development dependency set to the latest non-breaking transitive releases within existing version caps
+
 ## [1.5.3](https://github.com/leonardovida/duckdb-sqlalchemy/compare/v1.5.2.2...v1.5.3) (2026-06-02)
 
 ### Features

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckdb-sqlalchemy
-Version: 1.5.3
+Version: 1.5.4
 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
@@ -27,7 +27,8 @@ Classifier: Topic :: Database :: Front-Ends
 Requires-Python: <4,>=3.9
 Requires-Dist: duckdb>=0.5.0
 Requires-Dist: packaging>=21
-Requires-Dist: sqlalchemy>=2.0.45
+Requires-Dist: sqlalchemy>=2.0.0; python_version < '3.14'
+Requires-Dist: sqlalchemy>=2.0.45; python_version >= '3.14'
 Provides-Extra: dev
 Requires-Dist: fsspec<2027.0.0,>=2025.2.0; extra == 'dev'
 Requires-Dist: github-action-utils<2.0.0,>=1.1.0; extra == 'dev'
@@ -46,7 +47,7 @@ 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.38; extra == 'dev'
+Requires-Dist: ty==0.0.54; extra == 'dev'
 Provides-Extra: devtools
 Requires-Dist: nox<2027.0.0,>=2026.4.10; extra == 'devtools'
 Requires-Dist: pdbpp<0.13.0,>=0.11.0; extra == 'devtools'
@@ -106,8 +107,8 @@ Current direction in this repository:
 | Component | Supported versions |
 | --- | --- |
 | Python | 3.9+ |
-| SQLAlchemy | 2.0.45+ (CI-tested: 2.0.45, 2.0.50) |
-| DuckDB | 0.5.0+ (CI-tested currently: 1.3.0 to 1.5.3) |
+| SQLAlchemy | 2.0.0+ on Python <3.14; 2.0.45+ on Python 3.14+ (CI-tested: 2.0.0, 2.0.51) |
+| DuckDB | 0.5.0+ (CI-tested currently: 1.3.0 to 1.5.4) |
 
 ## Install
 

{duckdb_sqlalchemy-1.5.3 → duckdb_sqlalchemy-1.5.4}/README.md

@@ -51,8 +51,8 @@ Current direction in this repository:
 | Component | Supported versions |
 | --- | --- |
 | Python | 3.9+ |
-| SQLAlchemy | 2.0.45+ (CI-tested: 2.0.45, 2.0.50) |
-| DuckDB | 0.5.0+ (CI-tested currently: 1.3.0 to 1.5.3) |
+| SQLAlchemy | 2.0.0+ on Python <3.14; 2.0.45+ on Python 3.14+ (CI-tested: 2.0.0, 2.0.51) |
+| DuckDB | 0.5.0+ (CI-tested currently: 1.3.0 to 1.5.4) |
 
 ## Install
 

{duckdb_sqlalchemy-1.5.3 → duckdb_sqlalchemy-1.5.4}/docs/configuration.md

@@ -50,7 +50,8 @@ engine = create_engine("duckdb:///analytics.db", connect_args={"read_only": True
 - Unknown but syntactically valid keys are forwarded to DuckDB and may fail with
   DuckDB's native "unrecognized configuration parameter" error.
 - MotherDuck path-query options (`attach_mode`, `session_name`, `access_mode`,
-  and related keys) are handled specially for `md:` URLs. See
+  `motherduck_enable_server_side_temp_tables`, and related keys) are handled
+  specially for `md:` URLs. See
   [motherduck.md](motherduck) and [connection-urls.md](connection-urls).
 
 ## Preload extensions

{duckdb_sqlalchemy-1.5.3 → duckdb_sqlalchemy-1.5.4}/docs/motherduck.md

@@ -70,6 +70,7 @@ Parameters that are treated as part of the database string:
 - `dbinstance_inactivity_ttl` (preferred; `motherduck_dbinstance_inactivity_ttl`
   remains supported but is deprecated)
 - `saas_mode` (`pgendpoint` is supported when you need PG endpoint-compatible routing)
+- `motherduck_enable_server_side_temp_tables`
 - `cache_buster`
 
 For backward compatibility the dialect also accepts `session_hint`,

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

@@ -99,6 +99,7 @@ user_stmt = select(
     user_info.c.org_id,
     user_info.c.org_name,
     user_info.c.org_type,
+    user_info.c.region,
 )
 
 dives = md_list_dives()
@@ -143,28 +144,36 @@ versions = md_list_dive_versions(id="00000000-0000-0000-0000-000000000000")
 versions_stmt = select(versions.c.version, versions.c.created_at)
 ```
 
-## MotherDuck jobs
+## MotherDuck Flights
 
-MotherDuck also exposes preview table functions for job metadata. The read-only
-helpers are useful for listing jobs, runs, logs, and versions:
+MotherDuck also exposes preview table functions for Flight metadata. The
+read-only helpers are useful for listing Flights, runs, logs, and versions:
 
 ```python
 from sqlalchemy import select
-from duckdb_sqlalchemy import md_job_runs, md_job_versions, md_jobs
+from duckdb_sqlalchemy import md_flight_runs, md_flight_versions, md_flights
 
-jobs = md_jobs(limit=10)
-jobs_stmt = select(jobs.c.job_id, jobs.c.job_name, jobs.c.status)
+flights = md_flights(limit=10)
+flights_stmt = select(flights.c.flight_id, flights.c.flight_name, flights.c.status)
 
-runs = md_job_runs(job_id="00000000-0000-0000-0000-000000000000", limit=10)
-runs_stmt = select(runs.c.run_number, runs.c.status, runs.c.started_at)
+runs = md_flight_runs(flight_id="00000000-0000-0000-0000-000000000000", limit=10)
+runs_stmt = select(runs.c.run_number, runs.c.status, runs.c.config, runs.c.started_at)
 
-versions = md_job_versions(job_id="00000000-0000-0000-0000-000000000000")
-versions_stmt = select(versions.c.version, versions.c.requirements_txt)
+versions = md_flight_versions(flight_id="00000000-0000-0000-0000-000000000000")
+versions_stmt = select(versions.c.flight_version, versions.c.requirements_txt)
 ```
 
-Mutating job functions are available as helpers too:
-`md_create_job`, `md_update_job`, `md_delete_job`, `md_run_job`, and
-`md_cancel_job_run`. They only execute when the SQLAlchemy statement is run.
+Mutating Flight functions are available as helpers too:
+`md_create_flight`, `md_update_flight`, `md_delete_flight`, `md_run_flight`,
+and `md_cancel_flight_run`. They only execute when the SQLAlchemy statement is
+run. `md_run_flight` accepts a `config` map to override a Flight's config for
+that run only; run result helpers expose the effective `config` column. Config
+map keys must be strings, non-empty, and cannot contain `=` or NUL bytes.
+Config values must be strings or `None`, and cannot contain NUL bytes.
+
+The older `md_*job*` helper names remain as deprecated compatibility aliases.
+They compile through the current Flight functions while preserving legacy
+`job_*` column access where possible.
 
 ## Arrow results
 

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

@@ -41,6 +41,7 @@ from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql import bindparam
 from sqlalchemy.sql.selectable import Select
 
+from ._arrow import DuckDBArrowResult
 from ._bulk_insert import build_bulk_insert_data as _build_bulk_insert_data
 from ._bulk_insert import (
     infer_bulk_insert_column_keys as _infer_bulk_insert_column_keys,
@@ -60,6 +61,7 @@ from .motherduck import (
     DIALECT_QUERY_KEYS,
     MOTHERDUCK_CONFIG_KEYS,
     MotherDuckURL,
+    _database_with_path_query,
     _normalize_config_aliases,
     append_query_to_database,
     create_engine_from_paths,
@@ -72,13 +74,22 @@ from .motherduck import (
 )
 from .olap import (
     md_access_tokens,
+    md_cancel_flight_run,
     md_cancel_job_run,
     md_create_dive,
+    md_create_flight,
     md_create_job,
     md_delete_dive,
+    md_delete_flight,
     md_delete_job,
+    md_flight_logs,
+    md_flight_runs,
+    md_flight_versions,
+    md_flights,
     md_get_dive,
     md_get_dive_version,
+    md_get_flight,
+    md_get_flight_version,
     md_get_job,
     md_get_job_version,
     md_job_run_logs,
@@ -87,9 +98,11 @@ from .olap import (
     md_jobs,
     md_list_dive_versions,
     md_list_dives,
+    md_run_flight,
     md_run_job,
     md_update_dive_content,
     md_update_dive_metadata,
+    md_update_flight,
     md_update_job,
     md_user_info,
     pragma_storage_info,
@@ -113,7 +126,7 @@ else:
 try:
     __version__ = package_version("duckdb-sqlalchemy")
 except PackageNotFoundError:  # pragma: no cover - source tree import fallback
-    __version__ = "1.5.3"
+    __version__ = "1.5.4"
 sqlalchemy_version = sqlalchemy.__version__
 SQLALCHEMY_VERSION = Version(sqlalchemy_version)
 SQLALCHEMY_2 = SQLALCHEMY_VERSION >= Version("2.0.0")
@@ -146,12 +159,14 @@ __all__ = [
     "insert",  # reexport of sqlalchemy.dialects.postgresql.insert
     "MotherDuckURL",
     "URL",
+    "append_query_to_database",
     "create_engine_from_paths",
     "create_motherduck_engine",
     "make_url",
     "stable_session_hint",
     "stable_session_name",
     "table_function",
+    "validate_motherduck_database_name",
     "read_parquet",
     "read_csv",
     "read_csv_auto",
@@ -160,6 +175,17 @@ __all__ = [
     "md_user_info",
     "md_list_dives",
     "md_access_tokens",
+    "md_create_flight",
+    "md_flights",
+    "md_get_flight",
+    "md_update_flight",
+    "md_delete_flight",
+    "md_run_flight",
+    "md_cancel_flight_run",
+    "md_flight_runs",
+    "md_flight_logs",
+    "md_flight_versions",
+    "md_get_flight_version",
     "md_create_job",
     "md_jobs",
     "md_get_job",
@@ -455,44 +481,6 @@ def _normalize_execution_options(execution_options: Dict[str, Any]) -> Dict[str,
     return execution_options
 
 
-class DuckDBArrowResult:
-    def __init__(self, result: Any) -> None:
-        self._result = result
-        self._arrow = None
-
-    def _fetch_arrow(self) -> Any:
-        if self._arrow is not None:
-            return self._arrow
-        cursor = getattr(self._result, "cursor", None)
-        if cursor is None:
-            cursor = getattr(self._result, "_cursor", None)
-        if cursor is None:
-            raise NotImplementedError("Arrow results are not available on this cursor")
-        fetch_arrow_table = getattr(cursor, "to_arrow_table", None)
-        if fetch_arrow_table is None:
-            fetch_arrow_table = getattr(cursor, "fetch_arrow_table", None)
-        if fetch_arrow_table is None:
-            raise NotImplementedError("Arrow results are not available on this cursor")
-        self._arrow = fetch_arrow_table()
-        return self._arrow
-
-    @property
-    def arrow(self) -> Any:
-        return self._fetch_arrow()
-
-    def all(self) -> Any:
-        return self._fetch_arrow()
-
-    def fetchall(self) -> Any:
-        return self._fetch_arrow()
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._result, name)
-
-    def __iter__(self) -> Any:
-        return iter(self._result)
-
-
 class DuckDBExecutionContext(_PGExecutionContext):
     @classmethod
     def _init_compiled(
@@ -621,6 +609,32 @@ def _normalize_motherduck_config(config: Dict[str, Any]) -> None:
     _normalize_config_aliases(config)
 
 
+def _pop_application_name(config: Dict[str, Any]) -> Optional[str]:
+    application_name = config.pop("application_name", None)
+    if application_name is None:
+        return None
+    return str(application_name)
+
+
+def _prepare_connection_params(
+    cparams: Dict[str, Any], core_keys: Collection[str]
+) -> Tuple[Dict[str, Any], Optional[str]]:
+    config = dict(cparams.get("config", {}))
+    cparams["config"] = config
+    config.update(cparams.pop("url_config", {}))
+    for key in DIALECT_QUERY_KEYS:
+        config.pop(key, None)
+    if cparams.get("database") in {None, ""}:
+        cparams["database"] = ":memory:"
+    _apply_motherduck_defaults(config, cparams.get("database"))
+    path_query = extract_path_query_from_config(config)
+    cparams["database"] = _database_with_path_query(cparams.get("database"), path_query)
+    _normalize_motherduck_config(config)
+    application_name = _pop_application_name(config)
+    ext = {k: config.pop(k) for k in list(config) if k not in core_keys}
+    return ext, application_name
+
+
 class DuckDBIdentifierPreparer(PGIdentifierPreparer):
     def __init__(self, dialect: "Dialect", **kwargs: Any) -> None:
         super().__init__(dialect, **kwargs)
@@ -725,27 +739,14 @@ class Dialect(PGDialect_psycopg2):
     def connect(self, *cargs: Any, **cparams: Any) -> Any:
         core_keys = get_core_config()
         preload_extensions = cparams.pop("preload_extensions", [])
-        config = dict(cparams.get("config", {}))
-        cparams["config"] = config
-        config.update(cparams.pop("url_config", {}))
-        for key in DIALECT_QUERY_KEYS:
-            config.pop(key, None)
-        if cparams.get("database") in {None, ""}:
-            cparams["database"] = ":memory:"
-        _apply_motherduck_defaults(config, cparams.get("database"))
-        path_query = extract_path_query_from_config(config)
-        if path_query:
-            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}
+        ext, application_name = _prepare_connection_params(cparams, core_keys)
+        config = cparams["config"]
         if supports_user_agent:
             user_agent = (
                 f"duckdb-sqlalchemy/{__version__}(sqlalchemy/{sqlalchemy_version})"
             )
+            if application_name:
+                user_agent = f"{user_agent} application_name({application_name})"
             if "custom_user_agent" in config:
                 user_agent = f"{user_agent} {config['custom_user_agent']}"
             config["custom_user_agent"] = user_agent
@@ -1176,6 +1177,79 @@ class Dialect(PGDialect_psycopg2):
                 column_names.append(None)
         return expressions, column_names
 
+    def _reflect_pg_type_compat(
+        self,
+        format_type: Optional[str],
+        *,
+        type_description: str,
+    ) -> Any:
+        reflect_type = getattr(super(), "_reflect_type", None)
+        if reflect_type is not None:
+            return reflect_type(
+                format_type,
+                {},
+                {},
+                type_description=type_description,
+                collation=None,
+            )
+
+        if format_type is None:
+            util.warn(
+                "PostgreSQL format_type() returned NULL for %s" % type_description
+            )
+            return sqltypes.NULLTYPE
+
+        args_match = re.search(r"\((.*)\)$", format_type)
+        type_args: List[str]
+        if args_match and args_match.group(1):
+            type_args = [part.strip() for part in args_match.group(1).split(",")]
+        else:
+            type_args = []
+
+        type_name = re.sub(r"\(.*\)$", "", format_type).strip().lower()
+        schema_type = self.ischema_names.get(type_name)
+        args: Tuple[Any, ...] = ()
+        kwargs: Dict[str, Any] = {}
+
+        if type_name == "numeric" and len(type_args) == 2:
+            args = (int(type_args[0]), int(type_args[1]))
+        elif type_name == "double precision":
+            args = (53,)
+        elif type_name in (
+            "timestamp with time zone",
+            "time with time zone",
+        ):
+            kwargs["timezone"] = True
+            if len(type_args) == 1:
+                kwargs["precision"] = int(type_args[0])
+        elif type_name in (
+            "timestamp without time zone",
+            "time without time zone",
+            "time",
+        ):
+            kwargs["timezone"] = False
+            if len(type_args) == 1:
+                kwargs["precision"] = int(type_args[0])
+        elif type_name == "bit varying":
+            kwargs["varying"] = True
+            if len(type_args) == 1:
+                args = (int(type_args[0]),)
+        else:
+            try:
+                charlen = int(type_args[0])
+            except (IndexError, ValueError):
+                args = tuple(type_args)
+            else:
+                args = (charlen, *type_args[1:])
+
+        if schema_type is None:
+            util.warn(
+                "Did not recognize type '%s' of %s" % (type_name, type_description)
+            )
+            return sqltypes.NULLTYPE
+
+        return schema_type(*args, **kwargs)
+
     def _reflect_duckdb_data_type(
         self,
         data_type: str,
@@ -1213,12 +1287,9 @@ class Dialect(PGDialect_psycopg2):
         elif upper.startswith(("STRUCT(", "MAP(", "UNION(")):
             reflected = sqltypes.NULLTYPE
         else:
-            reflected = self._reflect_type(  # type: ignore[attr-defined]
+            reflected = self._reflect_pg_type_compat(
                 normalized,
-                {},
-                {},
                 type_description=type_description,
-                collation=None,
             )
 
         if dimensions:
@@ -1473,8 +1544,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)
+        opts["database"] = _database_with_path_query(database, path_query)
         return (), opts
 
     @classmethod
@@ -1525,7 +1595,9 @@ class Dialect(PGDialect_psycopg2):
         view_name = f"__duckdb_sa_bulk_{uuid.uuid4().hex}"
         dbapi_conn = cursor.connection
         dbapi_conn.register(view_name, data)
-        preparer = getattr(context, "identifier_preparer", self.identifier_preparer)
+        preparer: Any = getattr(
+            context, "identifier_preparer", self.identifier_preparer
+        )
         target = preparer.format_table(table)
         columns = ", ".join(preparer.quote(col) for col in column_names)
         insert_sql = (
@@ -1566,11 +1638,9 @@ class Dialect(PGDialect_psycopg2):
 
     def _execute_with_retry(
         self,
-        cursor: Any,
         statement: str,
-        parameters: Any,
         context: Optional[Any],
-        executor: Any,
+        executor: Callable[[], Any],
     ) -> Any:
         options = self._get_execution_options(context)
         retry_count = int(options.get("duckdb_retry_count", 0) or 0)
@@ -1602,7 +1672,7 @@ class Dialect(PGDialect_psycopg2):
                 self, cursor, statement, parameters, context
             )
 
-        self._execute_with_retry(cursor, statement, parameters, context, executor)
+        self._execute_with_retry(statement, context, executor)
 
     def do_execute_no_params(
         self, cursor: Any, statement: str, context: Optional[Any] = None
@@ -1610,7 +1680,7 @@ class Dialect(PGDialect_psycopg2):
         def executor() -> Any:
             return DefaultDialect.do_execute_no_params(self, cursor, statement, context)
 
-        self._execute_with_retry(cursor, statement, None, context, executor)
+        self._execute_with_retry(statement, context, executor)
 
     def _pg_class_filter_scope_schema(
         self,

duckdb_sqlalchemy-1.5.4/duckdb_sqlalchemy/_arrow.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+
+class DuckDBArrowResult:
+    def __init__(self, result: Any) -> None:
+        self._result = result
+        self._arrow = None
+
+    def _fetch_arrow(self) -> Any:
+        if self._arrow is not None:
+            return self._arrow
+        cursor = getattr(self._result, "cursor", None)
+        if cursor is None:
+            cursor = getattr(self._result, "_cursor", None)
+        if cursor is None:
+            raise NotImplementedError("Arrow results are not available on this cursor")
+        fetch_arrow_table = getattr(cursor, "to_arrow_table", None)
+        if fetch_arrow_table is None:
+            fetch_arrow_table = getattr(cursor, "fetch_arrow_table", None)
+        if fetch_arrow_table is None:
+            raise NotImplementedError("Arrow results are not available on this cursor")
+        self._arrow = fetch_arrow_table()
+        return self._arrow
+
+    @property
+    def arrow(self) -> Any:
+        return self._fetch_arrow()
+
+    def all(self) -> Any:
+        return self._fetch_arrow()
+
+    def fetchall(self) -> Any:
+        return self._fetch_arrow()
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._result, name)
+
+    def __iter__(self) -> Any:
+        return iter(self._result)

{duckdb_sqlalchemy-1.5.3 → duckdb_sqlalchemy-1.5.4}/duckdb_sqlalchemy/datatypes.py

@@ -13,10 +13,11 @@ from typing import Any, Dict, Optional, Tuple, Type
 import duckdb
 from packaging.version import Version
 from sqlalchemy import exc, util
-from sqlalchemy.dialects.postgresql.base import PGIdentifierPreparer, PGTypeCompiler
+from sqlalchemy.dialects.postgresql.base import PGTypeCompiler
 from sqlalchemy.engine import Dialect
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql import sqltypes, type_api
+from sqlalchemy.sql.compiler import IdentifierPreparer
 from sqlalchemy.sql.type_api import TypeEngine
 from sqlalchemy.types import BigInteger, Integer, SmallInteger, String
 
@@ -305,20 +306,18 @@ def register_extension_types() -> None:
 def visit_struct(
     instance: Struct,
     compiler: PGTypeCompiler,
-    identifier_preparer: PGIdentifierPreparer,
     **kw: Any,
 ) -> str:
-    return "STRUCT" + struct_or_union(instance, compiler, identifier_preparer, **kw)
+    return "STRUCT" + struct_or_union(instance, compiler, **kw)
 
 
 @compiles(Union, "duckdb")  # type: ignore[misc]
 def visit_union(
     instance: Union,
     compiler: PGTypeCompiler,
-    identifier_preparer: PGIdentifierPreparer,
     **kw: Any,
 ) -> str:
-    return "UNION" + struct_or_union(instance, compiler, identifier_preparer, **kw)
+    return "UNION" + struct_or_union(instance, compiler, **kw)
 
 
 @compiles(Variant, "duckdb")  # type: ignore[misc]
@@ -342,25 +341,15 @@ def visit_geometry(
 def struct_or_union(
     instance: typing.Union[Union, Struct],
     compiler: PGTypeCompiler,
-    identifier_preparer: PGIdentifierPreparer,
+    identifier_preparer: Optional[IdentifierPreparer] = None,
     **kw: Any,
 ) -> str:
-    fields = getattr(instance, "_fields", None)
-    if fields is None:
-        fields = _normalize_fields(instance.fields)
+    fields = instance._fields
     if fields is None:
         raise exc.CompileError(f"DuckDB {repr(instance)} type requires fields")
-    return "({})".format(
-        ", ".join(
-            "{} {}".format(
-                identifier_preparer.quote_identifier(key),
-                process_type(
-                    value, compiler, identifier_preparer=identifier_preparer, **kw
-                ),
-            )
-            for key, value in (fields.items() if isinstance(fields, dict) else fields)
-        )
-    )
+    if identifier_preparer is None:
+        identifier_preparer = compiler.dialect.identifier_preparer
+    return _render_struct_or_union_fields(fields, compiler, identifier_preparer, **kw)
 
 
 def process_type(
@@ -371,6 +360,24 @@ def process_type(
     return compiler.process(type_api.to_instance(value), **kw)
 
 
+def _render_struct_or_union_fields(
+    fields: Tuple[Tuple[str, TypeEngine], ...],
+    compiler: PGTypeCompiler,
+    identifier_preparer: IdentifierPreparer,
+    **kw: Any,
+) -> str:
+    rendered_fields = (
+        "{} {}".format(
+            identifier_preparer.quote_identifier(key),
+            process_type(
+                value, compiler, identifier_preparer=identifier_preparer, **kw
+            ),
+        )
+        for key, value in fields
+    )
+    return "({})".format(", ".join(rendered_fields))
+
+
 @compiles(Map, "duckdb")  # type: ignore[misc]
 def visit_map(instance: Map, compiler: PGTypeCompiler, **kw: Any) -> str:
     return "MAP({}, {})".format(