sqlalchemy-adbc 0.3.0__tar.gz → 0.4.0__tar.gz

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/CHANGELOG.md

@@ -6,6 +6,40 @@ this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.4.0] — 2026-11-07
+
+URL schemes now follow SQLAlchemy's `<backend>+adbc://` convention,
+plus compatibility fixes for SQLAlchemy 2.1 and ADBC 1.13. Existing
+`adbc+<backend>://` URLs keep working and emit a `DeprecationWarning`.
+
+### Changed
+
+- **URL schemes are now `<backend>+adbc://`** — `postgresql+adbc://`,
+  `sqlite+adbc://`, `flightsql+adbc://`, `snowflake+adbc://`,
+  `bigquery+adbc://`. This follows SQLAlchemy's `dialect+driver`
+  convention: ADBC is the driver. `URL.get_backend_name()` now agrees
+  with `dialect.name`, so tools that pick behavior from the URL (for
+  example Superset's engine specs) see the real backend.
+  ([#15](https://github.com/drls-io/sqlalchemy-adbc/issues/15))
+
+### Deprecated
+
+- **`adbc+<backend>://` URL spellings** — still registered and
+  functional, but `create_engine` emits a `DeprecationWarning`. They
+  will be removed in 1.0.
+
+### Fixed
+
+- **PostgreSQL database names with SQLAlchemy 2.1** — SQLAlchemy 2.1
+  percent-decodes `URL.database`, so the libpq URI lost its escapes
+  (`my%20db` became `my db`). The dialect now detects the parser's
+  behavior and quotes the database path exactly once on both 2.0 and
+  2.1. ([#19](https://github.com/drls-io/sqlalchemy-adbc/issues/19))
+- **CI on ADBC 1.13** — `adbc_driver_sqlite` 1.13.0 reports NOT NULL
+  correctly, which turned the strict xfail for column nullability into
+  a hard failure. The xfail now applies only to drivers older than
+  1.13. ([#13](https://github.com/drls-io/sqlalchemy-adbc/issues/13))
+
 ## [0.3.0] — 2026-04-21
 
 Largest release so far: table reflection, Alembic autogenerate,

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sqlalchemy-adbc
-Version: 0.3.0
+Version: 0.4.0
 Summary: Generic SQLAlchemy dialect for any ADBC driver (Flight SQL, PostgreSQL, SQLite, Snowflake, BigQuery).
 Project-URL: Homepage, https://github.com/drls-io/sqlalchemy-adbc
 Project-URL: Repository, https://github.com/drls-io/sqlalchemy-adbc
@@ -81,18 +81,18 @@ import sqlalchemy
 
 # Flight SQL
 engine = sqlalchemy.create_engine(
-    "adbc+flightsql://flight-sql.example.com:443?tls=true",
+    "flightsql+adbc://flight-sql.example.com:443?tls=true",
     connect_args={"db_kwargs": {
         "adbc.flight.sql.authorization_header": f"Bearer {token}",
     }},
 )
 
 # SQLite
-engine = sqlalchemy.create_engine("adbc+sqlite:///path/to/db.sqlite")
+engine = sqlalchemy.create_engine("sqlite+adbc:///path/to/db.sqlite")
 
 # PostgreSQL
 engine = sqlalchemy.create_engine(
-    "adbc+postgresql://user:pass@host:5432/mydb"
+    "postgresql+adbc://user:pass@host:5432/mydb"
 )
 
 # Works with pandas, Polars, marimo SQL cells, etc.
@@ -102,14 +102,18 @@ df = pd.read_sql("SELECT 1 AS n", engine)
 
 ## URL forms
 
-| Driver       | URL                                                        |
+URLs follow SQLAlchemy's `<backend>+<driver>://` convention, with `adbc`
+as the driver. The pre-0.4 `adbc+<backend>://` spelling still works but
+emits a `DeprecationWarning` and will be removed in 1.0.
+
+| Backend      | URL                                                        |
 |--------------|------------------------------------------------------------|
-| Flight SQL   | `adbc+flightsql://host:port?tls=true&authorization=...`    |
-| Flight SQL   | `adbc+flightsql://user:TOKEN@host:port?tls=true` (bearer)  |
-| PostgreSQL   | `adbc+postgresql://user:pass@host:port/database`           |
-| SQLite       | `adbc+sqlite:///path/to/db` or `adbc+sqlite:///:memory:`   |
-| Snowflake    | `adbc+snowflake://user:pass@account/db/schema?warehouse=W` |
-| BigQuery     | `adbc+bigquery:///my-project?dataset=my_dataset`           |
+| Flight SQL   | `flightsql+adbc://host:port?tls=true&authorization=...`    |
+| Flight SQL   | `flightsql+adbc://user:TOKEN@host:port?tls=true` (bearer)  |
+| PostgreSQL   | `postgresql+adbc://user:pass@host:port/database`           |
+| SQLite       | `sqlite+adbc:///path/to/db` or `sqlite+adbc:///:memory:`   |
+| Snowflake    | `snowflake+adbc://user:pass@account/db/schema?warehouse=W` |
+| BigQuery     | `bigquery+adbc:///my-project?dataset=my_dataset`           |
 
 ### Flight SQL query-string options
 
@@ -151,17 +155,18 @@ published wheels on [PyPI](https://pypi.org/project/sqlalchemy-adbc/).
   …) and **hstore** — not yet mapped to typed decorators; returned
   as raw strings. JSONB / JSON / UUID / INET / CIDR / MACADDR /
   MACADDR8 all round-trip through typed decorators as of 0.3.0
-  ([#3](https://github.com/drls-io/sqlalchemy-adbc/issues/3) —
-  JSONB/UUID/INET portion closed)
+  ([#11](https://github.com/drls-io/sqlalchemy-adbc/issues/11))
 - **Drivers exercised in CI** — SQLite fully, PostgreSQL
   integration-tested via service container. Snowflake / BigQuery /
   Flight SQL inherit the shared reflection path but have no
   per-driver CI
-- **ADBC SQLite NOT NULL reporting** — upstream driver always
-  reports nullable=True; reflection faithfully reflects that
-  (tracked, auto-reactivating xfail)
+  ([#12](https://github.com/drls-io/sqlalchemy-adbc/issues/12))
+- **ADBC SQLite NOT NULL reporting** — fixed upstream in
+  `adbc_driver_sqlite` 1.13 (Python ≥ 3.11). On older drivers every
+  column reflects as nullable=True
+  ([#13](https://github.com/drls-io/sqlalchemy-adbc/issues/13))
 
-Tests: 106 passing on Python 3.10–3.13, including 17 PostgreSQL
+Tests: 121 passing on Python 3.10–3.13, including 17 PostgreSQL
 integration tests against a service-container Postgres.
 
 ## Development

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/README.md

@@ -37,18 +37,18 @@ import sqlalchemy
 
 # Flight SQL
 engine = sqlalchemy.create_engine(
-    "adbc+flightsql://flight-sql.example.com:443?tls=true",
+    "flightsql+adbc://flight-sql.example.com:443?tls=true",
     connect_args={"db_kwargs": {
         "adbc.flight.sql.authorization_header": f"Bearer {token}",
     }},
 )
 
 # SQLite
-engine = sqlalchemy.create_engine("adbc+sqlite:///path/to/db.sqlite")
+engine = sqlalchemy.create_engine("sqlite+adbc:///path/to/db.sqlite")
 
 # PostgreSQL
 engine = sqlalchemy.create_engine(
-    "adbc+postgresql://user:pass@host:5432/mydb"
+    "postgresql+adbc://user:pass@host:5432/mydb"
 )
 
 # Works with pandas, Polars, marimo SQL cells, etc.
@@ -58,14 +58,18 @@ df = pd.read_sql("SELECT 1 AS n", engine)
 
 ## URL forms
 
-| Driver       | URL                                                        |
+URLs follow SQLAlchemy's `<backend>+<driver>://` convention, with `adbc`
+as the driver. The pre-0.4 `adbc+<backend>://` spelling still works but
+emits a `DeprecationWarning` and will be removed in 1.0.
+
+| Backend      | URL                                                        |
 |--------------|------------------------------------------------------------|
-| Flight SQL   | `adbc+flightsql://host:port?tls=true&authorization=...`    |
-| Flight SQL   | `adbc+flightsql://user:TOKEN@host:port?tls=true` (bearer)  |
-| PostgreSQL   | `adbc+postgresql://user:pass@host:port/database`           |
-| SQLite       | `adbc+sqlite:///path/to/db` or `adbc+sqlite:///:memory:`   |
-| Snowflake    | `adbc+snowflake://user:pass@account/db/schema?warehouse=W` |
-| BigQuery     | `adbc+bigquery:///my-project?dataset=my_dataset`           |
+| Flight SQL   | `flightsql+adbc://host:port?tls=true&authorization=...`    |
+| Flight SQL   | `flightsql+adbc://user:TOKEN@host:port?tls=true` (bearer)  |
+| PostgreSQL   | `postgresql+adbc://user:pass@host:port/database`           |
+| SQLite       | `sqlite+adbc:///path/to/db` or `sqlite+adbc:///:memory:`   |
+| Snowflake    | `snowflake+adbc://user:pass@account/db/schema?warehouse=W` |
+| BigQuery     | `bigquery+adbc:///my-project?dataset=my_dataset`           |
 
 ### Flight SQL query-string options
 
@@ -107,17 +111,18 @@ published wheels on [PyPI](https://pypi.org/project/sqlalchemy-adbc/).
   …) and **hstore** — not yet mapped to typed decorators; returned
   as raw strings. JSONB / JSON / UUID / INET / CIDR / MACADDR /
   MACADDR8 all round-trip through typed decorators as of 0.3.0
-  ([#3](https://github.com/drls-io/sqlalchemy-adbc/issues/3) —
-  JSONB/UUID/INET portion closed)
+  ([#11](https://github.com/drls-io/sqlalchemy-adbc/issues/11))
 - **Drivers exercised in CI** — SQLite fully, PostgreSQL
   integration-tested via service container. Snowflake / BigQuery /
   Flight SQL inherit the shared reflection path but have no
   per-driver CI
-- **ADBC SQLite NOT NULL reporting** — upstream driver always
-  reports nullable=True; reflection faithfully reflects that
-  (tracked, auto-reactivating xfail)
+  ([#12](https://github.com/drls-io/sqlalchemy-adbc/issues/12))
+- **ADBC SQLite NOT NULL reporting** — fixed upstream in
+  `adbc_driver_sqlite` 1.13 (Python ≥ 3.11). On older drivers every
+  column reflects as nullable=True
+  ([#13](https://github.com/drls-io/sqlalchemy-adbc/issues/13))
 
-Tests: 106 passing on Python 3.10–3.13, including 17 PostgreSQL
+Tests: 121 passing on Python 3.10–3.13, including 17 PostgreSQL
 integration tests against a service-container Postgres.
 
 ## Development

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlalchemy-adbc"
-version = "0.3.0"
+version = "0.4.0"
 description = "Generic SQLAlchemy dialect for any ADBC driver (Flight SQL, PostgreSQL, SQLite, Snowflake, BigQuery)."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -58,8 +58,15 @@ Issues = "https://github.com/drls-io/sqlalchemy-adbc/issues"
 
 # SQLAlchemy discovers dialects via the `sqlalchemy.dialects` entry point
 # group. The name form is `<name>` or `<name>.<driver>` — the second is what
-# lets us write `adbc+flightsql://` etc.
+# lets us write `flightsql+adbc://` etc.
 [project.entry-points."sqlalchemy.dialects"]
+# SQLAlchemy URLs are <backend>+<driver>; ADBC is the driver (#15).
+"flightsql.adbc" = "sqlalchemy_adbc.flightsql:ADBCFlightSQLDialect"
+"sqlite.adbc" = "sqlalchemy_adbc.sqlite:ADBCSQLiteDialect"
+"postgresql.adbc" = "sqlalchemy_adbc.postgresql:ADBCPostgreSQLDialect"
+"snowflake.adbc" = "sqlalchemy_adbc.snowflake:ADBCSnowflakeDialect"
+"bigquery.adbc" = "sqlalchemy_adbc.bigquery:ADBCBigQueryDialect"
+# Deprecated adbc+<backend> spellings; removed in 1.0.
 "adbc" = "sqlalchemy_adbc.base:ADBCDialect"
 "adbc.flightsql" = "sqlalchemy_adbc.flightsql:ADBCFlightSQLDialect"
 "adbc.sqlite" = "sqlalchemy_adbc.sqlite:ADBCSQLiteDialect"

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/src/sqlalchemy_adbc/__init__.py

@@ -3,10 +3,10 @@
 Register dialects via the ``sqlalchemy.dialects`` entry-point group (see
 pyproject.toml). URL forms::
 
-    adbc+flightsql://host:port/...?tls=true
-    adbc+sqlite:///path/to/db.sqlite
-    adbc+postgresql://user:pass@host:port/db
-    adbc+snowflake://user:pass@account/db/schema?warehouse=WH
+    flightsql+adbc://host:port/...?tls=true
+    sqlite+adbc:///path/to/db.sqlite
+    postgresql+adbc://user:pass@host:port/db
+    snowflake+adbc://user:pass@account/db/schema?warehouse=WH
 """
 
 from sqlalchemy_adbc.base import ADBCDialect

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/src/sqlalchemy_adbc/base.py

@@ -16,6 +16,7 @@ Subclasses implement:
 from __future__ import annotations
 
 import importlib
+import warnings
 from typing import Any
 
 from sqlalchemy.engine.default import DefaultDialect
@@ -33,8 +34,10 @@ class ADBCDialect(DefaultDialect):
     """Base class for SQLAlchemy dialects backed by ADBC drivers.
 
     This class is registered as the plain ``adbc://`` scheme. In practice
-    callers should use a driver-specific variant like ``adbc+flightsql://``;
+    callers should use a backend-specific variant like ``flightsql+adbc://``;
     the plain scheme requires ``adbc_driver_name`` in the URL query string.
+    The pre-0.4 ``adbc+<backend>://`` spellings remain registered as
+    deprecated aliases.
     """
 
     # SQLAlchemy convention: `name` = backend identity (used by
@@ -76,6 +79,15 @@ class ADBCDialect(DefaultDialect):
 
         Subclasses should override ``build_connect_args`` instead of this.
         """
+        if url.drivername.startswith("adbc+"):
+            backend = url.get_driver_name()
+            warnings.warn(
+                f"URL scheme 'adbc+{backend}://' is deprecated; use "
+                f"'{backend}+adbc://' (SQLAlchemy's backend+driver order). "
+                "The old spelling will be removed in 1.0.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         return self.build_connect_args(url)
 
     def build_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/src/sqlalchemy_adbc/bigquery.py

@@ -2,7 +2,7 @@
 
 URL form::
 
-    adbc+bigquery:///<project>?dataset=<dataset>&credentials_path=/path/to/sa.json
+    bigquery+adbc:///<project>?dataset=<dataset>&credentials_path=/path/to/sa.json
 
 adbc_driver_bigquery reads the GCP project and optional dataset via
 db_kwargs; we pass the URL query string through verbatim.

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/src/sqlalchemy_adbc/flightsql.py

@@ -2,7 +2,7 @@
 
 URL form::
 
-    adbc+flightsql://host:port?tls=true&authorization=Bearer%20...
+    flightsql+adbc://host:port?tls=true&authorization=Bearer%20...
 
 All query-string keys are forwarded to the driver as ``db_kwargs``. The
 dialect also understands a few shorthands:
@@ -69,7 +69,7 @@ class ADBCFlightSQLDialect(ADBCDialect):
             db_kwargs[auth_key] = query.pop("authorization")
 
         # Caller can also set the bearer via SQLAlchemy URL password:
-        #     adbc+flightsql://user:<token>@host:443?tls=true
+        #     flightsql+adbc://user:<token>@host:443?tls=true
         # The "user" part is ignored by Flight SQL; we just read the
         # password into the Authorization header.
         if url.password:

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/src/sqlalchemy_adbc/postgresql.py

@@ -10,14 +10,19 @@ corrupt the DSN or change its parse. Without quoting, a password like
 from __future__ import annotations
 
 from typing import Any
-from urllib.parse import quote
+from urllib.parse import quote, unquote
 
 from sqlalchemy.engine.interfaces import ReflectedColumn, ReflectedIndex
-from sqlalchemy.engine.url import URL
+from sqlalchemy.engine.url import URL, make_url
 
 from sqlalchemy_adbc.base import ADBCDialect
 from sqlalchemy_adbc.postgresql_types import pg_ischema_names
 
+# SQLAlchemy 2.0 leaves ``URL.database`` percent-encoded; 2.1 decodes it
+# like userinfo. Probe once so the libpq URI is quoted exactly once on
+# either version.
+_URL_DECODES_DATABASE = make_url("postgresql://h/a%20b").database == "a b"
+
 
 class ADBCPostgreSQLDialect(ADBCDialect):
     # `name = "postgresql"` makes Alembic pick the standard Postgres
@@ -45,20 +50,20 @@ class ADBCPostgreSQLDialect(ADBCDialect):
         super().__init__(**kwargs)
 
     def build_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
-        # SQLAlchemy's URL parser decodes percent-escapes in userinfo
-        # (`url.username`, `url.password`) but leaves the path component
-        # (`url.database`) untouched. So we re-quote userinfo before
-        # rebuilding the libpq URI — without it, a password like ``p@ss``
-        # would silently re-route to a different host — but we pass the
-        # database through as-is. Re-quoting the database would
-        # double-encode already-percent-escaped names (``my%20db`` →
-        # ``my%2520db``).
+        # Every user-supplied component is reduced to its raw value and
+        # then quoted once, so a password like ``p@ss`` cannot re-route
+        # libpq to another host and a database named ``my%20db`` is not
+        # collapsed to ``my db``. Userinfo is always decoded by SQLAlchemy;
+        # the database path only from 2.1 (``_URL_DECODES_DATABASE``).
         user = quote(url.username, safe="") if url.username else ""
         password = f":{quote(url.password, safe='')}" if url.password else ""
         auth = f"{user}{password}@" if user or url.password else ""
         host = url.host or "localhost"
         port = f":{url.port}" if url.port else ""
-        database = f"/{url.database}" if url.database else ""
+        database = ""
+        if url.database:
+            raw = url.database if _URL_DECODES_DATABASE else unquote(url.database)
+            database = f"/{quote(raw, safe='')}"
         uri = f"postgresql://{auth}{host}{port}{database}"
 
         kwargs: dict[str, Any] = {}

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/src/sqlalchemy_adbc/snowflake.py

@@ -2,7 +2,7 @@
 
 URL form::
 
-    adbc+snowflake://user:password@account/database/schema?warehouse=WH&role=R
+    snowflake+adbc://user:password@account/database/schema?warehouse=WH&role=R
 
 adbc_driver_snowflake expects a DSN of the form
 ``user:password@account/database/schema?warehouse=...``. We URL-quote

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_alembic_autogenerate.py

@@ -25,7 +25,7 @@ from alembic.migration import MigrationContext  # noqa: E402
 
 
 def _make_engine() -> sa.Engine:
-    return sa.create_engine("adbc+sqlite:///:memory:")
+    return sa.create_engine("sqlite+adbc:///:memory:")
 
 
 def _diff(engine: sa.Engine, target: sa.MetaData, **opts: Any) -> tuple[str, str]:

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_bigquery_url.py

@@ -12,21 +12,21 @@ def _build(url_str: str):
 
 
 def test_project_from_database_segment():
-    """``adbc+bigquery:///my-project`` → project_id set."""
-    args, kwargs = _build("adbc+bigquery:///my-project")
+    """``bigquery+adbc:///my-project`` → project_id set."""
+    args, kwargs = _build("bigquery+adbc:///my-project")
     assert args == []
     assert kwargs["db_kwargs"]["adbc.bigquery.sql.project_id"] == "my-project"
 
 
 def test_project_plus_dataset():
-    _, kwargs = _build("adbc+bigquery:///my-project?dataset=events")
+    _, kwargs = _build("bigquery+adbc:///my-project?dataset=events")
     db = kwargs["db_kwargs"]
     assert db["adbc.bigquery.sql.project_id"] == "my-project"
     assert db["dataset"] == "events"
 
 
 def test_only_query_params():
-    _, kwargs = _build("adbc+bigquery://?adbc.bigquery.sql.project_id=p&x=y")
+    _, kwargs = _build("bigquery+adbc://?adbc.bigquery.sql.project_id=p&x=y")
     db = kwargs["db_kwargs"]
     assert db["adbc.bigquery.sql.project_id"] == "p"
     assert db["x"] == "y"
@@ -35,11 +35,11 @@ def test_only_query_params():
 def test_explicit_project_kwarg_wins_over_url():
     """If both URL-database and ``?project_id=...`` are present, the
     explicit query string must not be overwritten by the implicit default."""
-    _, kwargs = _build("adbc+bigquery:///implicit?adbc.bigquery.sql.project_id=explicit")
+    _, kwargs = _build("bigquery+adbc:///implicit?adbc.bigquery.sql.project_id=explicit")
     assert kwargs["db_kwargs"]["adbc.bigquery.sql.project_id"] == "explicit"
 
 
 def test_no_kwargs_at_all():
-    args, kwargs = _build("adbc+bigquery://")
+    args, kwargs = _build("bigquery+adbc://")
     assert args == []
     assert kwargs == {}

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_flightsql_url.py

@@ -18,35 +18,35 @@ def _build(url_str: str):
 
 def test_tls_is_default():
     """No ``tls`` query param → scheme is grpc+tls (secure by default)."""
-    args, kwargs = _build("adbc+flightsql://flight-sql.example.com:443")
+    args, kwargs = _build("flightsql+adbc://flight-sql.example.com:443")
     assert args == ["grpc+tls://flight-sql.example.com:443"]
     assert "db_kwargs" not in kwargs
 
 
 def test_tls_explicit_opt_out():
     """``?tls=false`` drops back to plaintext gRPC — needed for local dev."""
-    args, kwargs = _build("adbc+flightsql://localhost:50051?tls=false")
+    args, kwargs = _build("flightsql+adbc://localhost:50051?tls=false")
     assert args == ["grpc://localhost:50051"]
     assert "db_kwargs" not in kwargs
 
 
 def test_default_port_tls():
-    args, _ = _build("adbc+flightsql://flight-sql.example.com")
+    args, _ = _build("flightsql+adbc://flight-sql.example.com")
     assert args == ["grpc+tls://flight-sql.example.com:443"]
 
 
 def test_default_port_plaintext():
-    args, _ = _build("adbc+flightsql://localhost?tls=false")
+    args, _ = _build("flightsql+adbc://localhost?tls=false")
     assert args == ["grpc://localhost:50051"]
 
 
 def test_tls_scheme_explicit():
-    args, _ = _build("adbc+flightsql://flight-sql.example.com:443?tls=true")
+    args, _ = _build("flightsql+adbc://flight-sql.example.com:443?tls=true")
     assert args == ["grpc+tls://flight-sql.example.com:443"]
 
 
 def test_bearer_from_password():
-    args, kwargs = _build("adbc+flightsql://user:TOKEN@host:443?tls=true")
+    args, kwargs = _build("flightsql+adbc://user:TOKEN@host:443?tls=true")
     assert args == ["grpc+tls://host:443"]
     # We can't assert on the exact key name without the driver installed —
     # the flightsql dialect has a fallback constant for this case.
@@ -55,13 +55,13 @@ def test_bearer_from_password():
 
 
 def test_authorization_passthrough():
-    args, kwargs = _build("adbc+flightsql://host:443?tls=true&authorization=Bearer%20abc")
+    args, kwargs = _build("flightsql+adbc://host:443?tls=true&authorization=Bearer%20abc")
     db = kwargs["db_kwargs"]
     assert any(v == "Bearer abc" for v in db.values())
 
 
 def test_custom_headers():
-    _, kwargs = _build("adbc+flightsql://host:443?tls=true&header.x-workspace-id=ws-1")
+    _, kwargs = _build("flightsql+adbc://host:443?tls=true&header.x-workspace-id=ws-1")
     db = kwargs["db_kwargs"]
     # Header keys use the RPC_CALL_HEADER_PREFIX; just check the value made
     # it through.
@@ -69,5 +69,5 @@ def test_custom_headers():
 
 
 def test_unknown_query_passthrough():
-    _, kwargs = _build("adbc+flightsql://host:443?tls=true&some_opt=value")
+    _, kwargs = _build("flightsql+adbc://host:443?tls=true&some_opt=value")
     assert kwargs["db_kwargs"]["some_opt"] == "value"

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_postgresql_types.py

@@ -29,7 +29,7 @@ from sqlalchemy import inspect
 PG_URL = os.environ.get("DRLS_PG_URL")
 pytestmark = pytest.mark.skipif(
     not PG_URL,
-    reason="Requires DRLS_PG_URL (e.g. adbc+postgresql://user:pw@host/db)",
+    reason="Requires DRLS_PG_URL (e.g. postgresql+adbc://user:pw@host/db)",
 )
 
 # Lazy-imported so the pytest collection doesn't fail when the extra

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_postgresql_url.py

@@ -12,72 +12,85 @@ def _build(url_str: str):
 
 
 def test_full_url():
-    args, kwargs = _build("adbc+postgresql://user:pass@host:5432/mydb")
+    args, kwargs = _build("postgresql+adbc://user:pass@host:5432/mydb")
     assert args == ["postgresql://user:pass@host:5432/mydb"]
     assert kwargs == {}
 
 
 def test_no_credentials():
-    args, _ = _build("adbc+postgresql://host:5432/mydb")
+    args, _ = _build("postgresql+adbc://host:5432/mydb")
     assert args == ["postgresql://host:5432/mydb"]
 
 
 def test_no_port():
-    args, _ = _build("adbc+postgresql://user:pass@host/mydb")
+    args, _ = _build("postgresql+adbc://user:pass@host/mydb")
     assert args == ["postgresql://user:pass@host/mydb"]
 
 
 def test_query_options_in_db_kwargs():
-    _, kwargs = _build("adbc+postgresql://user:pass@host:5432/mydb?sslmode=require&app=x")
+    _, kwargs = _build("postgresql+adbc://user:pass@host:5432/mydb?sslmode=require&app=x")
     assert kwargs["db_kwargs"] == {"sslmode": "require", "app": "x"}
 
 
 def test_password_with_at_sign_quoted():
     """A password containing @ must not be interpreted as host delimiter."""
-    args, _ = _build("adbc+postgresql://user:p%40ss@host:5432/db")
+    args, _ = _build("postgresql+adbc://user:p%40ss@host:5432/db")
     # SQLAlchemy decodes %40 → @; we must re-encode for the DSN.
     assert args == ["postgresql://user:p%40ss@host:5432/db"]
 
 
 def test_password_with_colon_quoted():
-    args, _ = _build("adbc+postgresql://user:a%3Ab@host/db")
+    args, _ = _build("postgresql+adbc://user:a%3Ab@host/db")
     assert args == ["postgresql://user:a%3Ab@host/db"]
 
 
 def test_password_with_slash_quoted():
-    args, _ = _build("adbc+postgresql://user:a%2Fb@host/db")
+    args, _ = _build("postgresql+adbc://user:a%2Fb@host/db")
     assert args == ["postgresql://user:a%2Fb@host/db"]
 
 
 def test_password_with_hash_quoted():
     """``#`` in a DSN starts a fragment; must be quoted."""
-    args, _ = _build("adbc+postgresql://user:a%23b@host/db")
+    args, _ = _build("postgresql+adbc://user:a%23b@host/db")
     assert args == ["postgresql://user:a%23b@host/db"]
 
 
 def test_password_with_percent_quoted():
-    args, _ = _build("adbc+postgresql://user:a%25b@host/db")
+    args, _ = _build("postgresql+adbc://user:a%25b@host/db")
     # SQLAlchemy decodes %25 → %; we must re-encode.
     assert args == ["postgresql://user:a%25b@host/db"]
 
 
 def test_username_special_chars_quoted():
-    args, _ = _build("adbc+postgresql://u%40me:pw@host/db")
+    args, _ = _build("postgresql+adbc://u%40me:pw@host/db")
     assert args == ["postgresql://u%40me:pw@host/db"]
 
 
 def test_database_with_spaces_quoted():
-    args, _ = _build("adbc+postgresql://host/my%20db")
+    args, _ = _build("postgresql+adbc://host/my%20db")
     assert args == ["postgresql://host/my%20db"]
 
 
+def test_database_with_encoded_percent_sequence_roundtrips():
+    # A database literally named ``my%20db`` arrives as ``%2520``. It must
+    # come out exactly as it went in, not collapsed to a space.
+    args, _ = _build("postgresql+adbc://host/my%2520db")
+    assert args == ["postgresql://host/my%2520db"]
+
+
+def test_database_with_encoded_slash_quoted():
+    # libpq reads ``/`` as a path separator, so it must stay escaped.
+    args, _ = _build("postgresql+adbc://host/a%2Fb")
+    assert args == ["postgresql://host/a%2Fb"]
+
+
 def test_defaults_localhost():
-    args, _ = _build("adbc+postgresql:///mydb")
+    args, _ = _build("postgresql+adbc:///mydb")
     assert args == ["postgresql://localhost/mydb"]
 
 
 def test_password_no_username_still_builds():
     """SQLAlchemy URL can have a password-only userinfo (edge case)."""
-    args, _ = _build("adbc+postgresql://:pw@host/db")
+    args, _ = _build("postgresql+adbc://:pw@host/db")
     # We emit auth=":pw@" — libpq accepts this as password-only.
     assert args[0].startswith("postgresql://:pw@host")

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_reflection.py

@@ -8,15 +8,18 @@ and are manually smoke-tested.
 
 from __future__ import annotations
 
+from importlib.metadata import version
 from typing import Any
 
 import pytest
 import sqlalchemy as sa
 from sqlalchemy import inspect
 
+_ADBC_SQLITE_VERSION = tuple(int(part) for part in version("adbc-driver-sqlite").split(".")[:2])
+
 
 def _make_engine():
-    return sa.create_engine("adbc+sqlite:///:memory:")
+    return sa.create_engine("sqlite+adbc:///:memory:")
 
 
 def _seed(engine) -> None:
@@ -362,10 +365,9 @@ def test_metadata_reflect_full_schema():
 
 
 @pytest.mark.xfail(
-    reason="ADBC SQLite driver reports xdbc_is_nullable='YES' for every "
-    "column, including NOT NULL ones — upstream limitation in "
-    "adbc_driver_sqlite GetObjects. Reflection code is correct; this "
-    "test unblocks automatically when the driver is fixed.",
+    _ADBC_SQLITE_VERSION < (1, 13),
+    reason="adbc_driver_sqlite < 1.13 reports xdbc_is_nullable='YES' for "
+    "every column, including NOT NULL ones (fixed upstream in 1.13.0).",
     strict=True,
 )
 def test_metadata_reflect_column_nullability():

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_snowflake_url.py

@@ -12,52 +12,52 @@ def _build(url_str: str):
 
 
 def test_basic_dsn():
-    args, kwargs = _build("adbc+snowflake://user:pw@myacct/db/schema?warehouse=WH")
+    args, kwargs = _build("snowflake+adbc://user:pw@myacct/db/schema?warehouse=WH")
     assert args == ["user:pw@myacct/db/schema?warehouse=WH"]
     assert kwargs == {}
 
 
 def test_multiple_query_params_preserved():
-    args, _ = _build("adbc+snowflake://u:p@acct/db/s?warehouse=WH&role=R")
+    args, _ = _build("snowflake+adbc://u:p@acct/db/s?warehouse=WH&role=R")
     # Order of dict.items() in Python 3.7+ is insertion order; SQLAlchemy
     # preserves URL order, so this is deterministic.
     assert args[0].endswith("?warehouse=WH&role=R")
 
 
 def test_password_at_sign_escaped():
-    args, _ = _build("adbc+snowflake://u:p%40w@acct/db")
+    args, _ = _build("snowflake+adbc://u:p%40w@acct/db")
     assert args == ["u:p%40w@acct/db"]
 
 
 def test_query_value_with_space_escaped():
     """warehouse names can legally contain spaces when quoted in SQL."""
-    args, _ = _build("adbc+snowflake://u:p@acct/db?warehouse=MY%20WH")
+    args, _ = _build("snowflake+adbc://u:p@acct/db?warehouse=MY%20WH")
     assert args[0].endswith("?warehouse=MY%20WH")
 
 
 def test_query_ampersand_in_value_escaped():
-    args, _ = _build("adbc+snowflake://u:p@acct/db?role=A%26B")
+    args, _ = _build("snowflake+adbc://u:p@acct/db?role=A%26B")
     # & inside a value must be %26 or the parser will treat it as a separator
     assert args[0].endswith("?role=A%26B")
 
 
 def test_no_database():
-    args, _ = _build("adbc+snowflake://u:p@acct")
+    args, _ = _build("snowflake+adbc://u:p@acct")
     assert args == ["u:p@acct"]
 
 
 def test_no_query():
-    args, _ = _build("adbc+snowflake://u:p@acct/db")
+    args, _ = _build("snowflake+adbc://u:p@acct/db")
     assert args == ["u:p@acct/db"]
 
 
 def test_username_only():
-    args, _ = _build("adbc+snowflake://u@acct/db")
+    args, _ = _build("snowflake+adbc://u@acct/db")
     assert args == ["u@acct/db"]
 
 
 def test_database_path_with_schema():
     # SQLAlchemy treats everything after the host as `database`; we must
     # NOT over-escape ``/`` between db and schema.
-    args, _ = _build("adbc+snowflake://u:p@acct/my_db/public")
+    args, _ = _build("snowflake+adbc://u:p@acct/my_db/public")
     assert args == ["u:p@acct/my_db/public"]

{sqlalchemy_adbc-0.3.0 → sqlalchemy_adbc-0.4.0}/tests/test_sqlite.py

@@ -10,7 +10,7 @@ pytest.importorskip("adbc_driver_sqlite")
 
 
 def test_engine_created():
-    engine = sqlalchemy.create_engine("adbc+sqlite:///:memory:")
+    engine = sqlalchemy.create_engine("sqlite+adbc:///:memory:")
     # `.name` is the backend identity (used by Alembic's DDL impl
     # registry); `.driver` is the wire path. Reporting name="sqlite"
     # lets Alembic autogenerate find the standard SQLite DDL impl.
@@ -19,7 +19,7 @@ def test_engine_created():
 
 
 def test_select_one():
-    engine = sqlalchemy.create_engine("adbc+sqlite:///:memory:")
+    engine = sqlalchemy.create_engine("sqlite+adbc:///:memory:")
     with engine.connect() as conn:
         result = conn.execute(text("SELECT 1 AS n"))
         row = result.fetchone()
@@ -28,7 +28,7 @@ def test_select_one():
 
 
 def test_create_insert_select():
-    engine = sqlalchemy.create_engine("adbc+sqlite:///:memory:")
+    engine = sqlalchemy.create_engine("sqlite+adbc:///:memory:")
     with engine.begin() as conn:
         conn.execute(text("CREATE TABLE t (id INTEGER, name TEXT)"))
         conn.execute(text("INSERT INTO t VALUES (1, 'a'), (2, 'b'), (3, 'c')"))
@@ -41,7 +41,7 @@ def test_create_insert_select():
 
 def test_file_backed(tmp_path):
     db_path = tmp_path / "test.db"
-    engine = sqlalchemy.create_engine(f"adbc+sqlite:///{db_path}")
+    engine = sqlalchemy.create_engine(f"sqlite+adbc:///{db_path}")
     with engine.begin() as conn:
         conn.execute(text("CREATE TABLE kv (k TEXT PRIMARY KEY, v TEXT)"))
         conn.execute(text("INSERT INTO kv VALUES ('hello', 'world')"))
@@ -52,7 +52,7 @@ def test_file_backed(tmp_path):
 
 
 def test_do_ping():
-    engine = sqlalchemy.create_engine("adbc+sqlite:///:memory:")
+    engine = sqlalchemy.create_engine("sqlite+adbc:///:memory:")
     with engine.connect() as conn:
         # pool_pre_ping path exercises dialect.do_ping
         raw = conn.connection.dbapi_connection

sqlalchemy_adbc-0.4.0/tests/test_url_schemes.py

@@ -0,0 +1,55 @@
+"""URL scheme registration.
+
+SQLAlchemy URLs are ``<backend>+<driver>://``. ADBC is the driver, so the
+documented form is ``postgresql+adbc://``. The original ``adbc+postgresql://``
+spelling stays registered as a deprecated alias (#15).
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import pytest
+import sqlalchemy as sa
+from sqlalchemy.engine.url import make_url
+
+from sqlalchemy_adbc.bigquery import ADBCBigQueryDialect
+from sqlalchemy_adbc.flightsql import ADBCFlightSQLDialect
+from sqlalchemy_adbc.postgresql import ADBCPostgreSQLDialect
+from sqlalchemy_adbc.snowflake import ADBCSnowflakeDialect
+from sqlalchemy_adbc.sqlite import ADBCSQLiteDialect
+
+BACKENDS = [
+    ("flightsql", ADBCFlightSQLDialect),
+    ("sqlite", ADBCSQLiteDialect),
+    ("postgresql", ADBCPostgreSQLDialect),
+    ("snowflake", ADBCSnowflakeDialect),
+    ("bigquery", ADBCBigQueryDialect),
+]
+
+
+@pytest.mark.parametrize(("backend", "dialect_cls"), BACKENDS)
+def test_backend_plus_adbc_resolves(backend, dialect_cls):
+    url = make_url(f"{backend}+adbc://host/db")
+    assert url.get_dialect() is dialect_cls
+    # URL and dialect agree on which side is the backend and which the driver.
+    assert url.get_backend_name() == dialect_cls.name
+    assert url.get_driver_name() == dialect_cls.driver == "adbc"
+
+
+@pytest.mark.parametrize(("backend", "dialect_cls"), BACKENDS)
+def test_legacy_adbc_plus_backend_still_resolves(backend, dialect_cls):
+    assert make_url(f"adbc+{backend}://host/db").get_dialect() is dialect_cls
+
+
+def test_legacy_scheme_warns_on_engine_creation():
+    with pytest.warns(DeprecationWarning, match=r"sqlite\+adbc://"):
+        sa.create_engine("adbc+sqlite:///:memory:")
+
+
+def test_documented_scheme_does_not_warn():
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        engine = sa.create_engine("sqlite+adbc:///:memory:")
+    with engine.connect() as conn:
+        assert conn.exec_driver_sql("SELECT 1").scalar() == 1