sqlalchemy-adbc 0.1.0__tar.gz → 0.2.0__tar.gz

{sqlalchemy_adbc-0.1.0 → sqlalchemy_adbc-0.2.0}/.github/workflows/ci.yml

@@ -24,6 +24,8 @@ jobs:
         run: ruff check src/ tests/
       - name: Ruff format
         run: ruff format --check src/ tests/
+      - name: Mypy
+        run: mypy src tests
 
   test:
     runs-on: ubuntu-latest

{sqlalchemy_adbc-0.1.0 → sqlalchemy_adbc-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlalchemy-adbc
-Version: 0.1.0
+Version: 0.2.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
@@ -118,11 +118,29 @@ df = pd.read_sql("SELECT 1 AS n", engine)
 ## Status
 
 Alpha — the core dialect machinery works for simple `SELECT` / `INSERT` /
-`CREATE TABLE` use. More advanced SQLAlchemy features (table reflection,
-dialect-specific types, DDL compilers per backend) are still to come. PRs
-welcome.
-
-Ship tests: 11 passing against ADBC SQLite on Python 3.9–3.13.
+`CREATE TABLE` use. More advanced SQLAlchemy features are still to come;
+the known gaps are called out below so you don't waste time debugging a
+missing feature:
+
+- **Table reflection** (`MetaData.reflect()`): not implemented. The ADBC
+  driver exposes table/column metadata via the Arrow-based `GetObjects`
+  call, but this library doesn't yet wire that into SQLAlchemy's
+  `Inspector` contract. PRs welcome.
+- **Alembic autogenerate**: follows from reflection — won't work until
+  reflection lands. `alembic upgrade` against already-written migrations
+  is fine (it's pure SQL).
+- **PostgreSQL-specific types** (JSONB, ARRAY, UUID, TSTZMULTIRANGE,
+  …): ADBC's Arrow-over-the-wire codec returns these as strings / lists
+  of primitives, not as SQLAlchemy's typed objects. If you need ORM-level
+  round-tripping of PG-specific types, use `psycopg2` until we add a
+  type compiler.
+- **Query parameterization**: uses ADBC's native `$1`-style placeholders
+  for PostgreSQL and `?` for SQLite. Flight SQL and Snowflake delegate
+  to the driver's default.
+
+PRs welcome.
+
+Tests: 52+ passing against ADBC SQLite + URL/DSN translators on Python 3.9–3.13.
 
 ## Development
 

{sqlalchemy_adbc-0.1.0 → sqlalchemy_adbc-0.2.0}/README.md

@@ -79,11 +79,29 @@ df = pd.read_sql("SELECT 1 AS n", engine)
 ## Status
 
 Alpha — the core dialect machinery works for simple `SELECT` / `INSERT` /
-`CREATE TABLE` use. More advanced SQLAlchemy features (table reflection,
-dialect-specific types, DDL compilers per backend) are still to come. PRs
-welcome.
-
-Ship tests: 11 passing against ADBC SQLite on Python 3.9–3.13.
+`CREATE TABLE` use. More advanced SQLAlchemy features are still to come;
+the known gaps are called out below so you don't waste time debugging a
+missing feature:
+
+- **Table reflection** (`MetaData.reflect()`): not implemented. The ADBC
+  driver exposes table/column metadata via the Arrow-based `GetObjects`
+  call, but this library doesn't yet wire that into SQLAlchemy's
+  `Inspector` contract. PRs welcome.
+- **Alembic autogenerate**: follows from reflection — won't work until
+  reflection lands. `alembic upgrade` against already-written migrations
+  is fine (it's pure SQL).
+- **PostgreSQL-specific types** (JSONB, ARRAY, UUID, TSTZMULTIRANGE,
+  …): ADBC's Arrow-over-the-wire codec returns these as strings / lists
+  of primitives, not as SQLAlchemy's typed objects. If you need ORM-level
+  round-tripping of PG-specific types, use `psycopg2` until we add a
+  type compiler.
+- **Query parameterization**: uses ADBC's native `$1`-style placeholders
+  for PostgreSQL and `?` for SQLite. Flight SQL and Snowflake delegate
+  to the driver's default.
+
+PRs welcome.
+
+Tests: 52+ passing against ADBC SQLite + URL/DSN translators on Python 3.9–3.13.
 
 ## Development
 

{sqlalchemy_adbc-0.1.0 → sqlalchemy_adbc-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlalchemy-adbc"
-version = "0.1.0"
+version = "0.2.0"
 description = "Generic SQLAlchemy dialect for any ADBC driver (Flight SQL, PostgreSQL, SQLite, Snowflake, BigQuery)."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -70,6 +70,30 @@ target-version = "py39"
 select = ["E", "F", "W", "I", "B", "UP"]
 ignore = ["E501"]
 
+[tool.mypy]
+# Intentionally 3.10 (not 3.9) — mypy traverses third-party packages
+# via follow-imports, and pytest itself uses `match`/`case` syntax that
+# the 3.9 parser can't even tokenize. Our own source is still
+# 3.9-compatible; runtime compat is covered by the pytest matrix.
+python_version = "3.10"
+strict_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+follow_imports = "silent"
+
+# ADBC driver wheels don't ship type stubs; lazy imports in the dialect
+# modules guard on ImportError so we only pay the type-ignore cost here.
+[[tool.mypy.overrides]]
+module = [
+    "adbc_driver_manager.*",
+    "adbc_driver_flightsql.*",
+    "adbc_driver_postgresql.*",
+    "adbc_driver_sqlite.*",
+    "adbc_driver_snowflake.*",
+    "adbc_driver_bigquery.*",
+]
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-v"

{sqlalchemy_adbc-0.1.0 → sqlalchemy_adbc-0.2.0}/src/sqlalchemy_adbc/flightsql.py

@@ -29,11 +29,23 @@ class ADBCFlightSQLDialect(ADBCDialect):
     supports_statement_cache = True
 
     def build_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
-        query = dict(url.query)
-
-        scheme = "grpc+tls" if _pop_bool(query, "tls", default=False) else "grpc"
+        # SQLAlchemy's URL.query is `immutabledict[str, str | tuple[str, ...]]`
+        # — repeated keys (``?h=a&h=b``) collapse to a tuple. Flatten to
+        # `dict[str, str]` so the ADBC driver always sees scalar values;
+        # for repeated keys we keep the last (typical shell + HTTP layer
+        # behavior) rather than silently dropping them.
+        query: dict[str, str] = {k: _scalar(v) for k, v in url.query.items()}
+
+        # TLS defaults to ON — Flight SQL is typically exposed as a
+        # public service (e.g., flight-sql.drls.io), and a bearer token
+        # sent over plaintext gRPC is a credential leak. Local/dev
+        # setups on a plaintext listener can opt out with ``?tls=false``.
+        tls = _pop_bool(query, "tls", default=True)
+        scheme = "grpc+tls" if tls else "grpc"
         host = url.host or "localhost"
-        port = url.port or 443
+        # Flight SQL convention: 443 for TLS (matches HTTPS), 50051 for
+        # plaintext gRPC (the Arrow Flight default).
+        port = url.port or (443 if tls else 50051)
         uri = f"{scheme}://{host}:{port}"
 
         db_kwargs: dict[str, str] = {}
@@ -42,10 +54,10 @@ class ADBCFlightSQLDialect(ADBCDialect):
         # extra — tests and IDE tooling shouldn't have to pull the
         # flightsql wheel.
         try:
-            from adbc_driver_flightsql import DatabaseOptions  # type: ignore[import-not-found]
+            from adbc_driver_flightsql import DatabaseOptions
 
-            auth_key = DatabaseOptions.AUTHORIZATION_HEADER.value
-            header_prefix = DatabaseOptions.RPC_CALL_HEADER_PREFIX.value
+            auth_key: str = DatabaseOptions.AUTHORIZATION_HEADER.value
+            header_prefix: str = DatabaseOptions.RPC_CALL_HEADER_PREFIX.value
         except ImportError:  # pragma: no cover - hit only without extra
             auth_key = "adbc.flight.sql.authorization_header"
             header_prefix = "adbc.flight.sql.rpc.call_header."
@@ -72,8 +84,16 @@ class ADBCFlightSQLDialect(ADBCDialect):
         return [uri], {"db_kwargs": db_kwargs} if db_kwargs else {}
 
 
-def _pop_bool(d: dict[str, Any], key: str, *, default: bool) -> bool:
+def _scalar(v: str | tuple[str, ...]) -> str:
+    """Collapse a possibly-repeated URL query value to a single string.
+
+    SQLAlchemy gives us a tuple for ``?k=a&k=b`` (both values); we keep
+    the last, matching shell/HTTP conventions where the later value wins.
+    """
+    return v[-1] if isinstance(v, tuple) else v
+
+
+def _pop_bool(d: dict[str, str], key: str, *, default: bool) -> bool:
     if key not in d:
         return default
-    v = d.pop(key)
-    return str(v).lower() in {"1", "true", "yes", "on"}
+    return d.pop(key).lower() in {"1", "true", "yes", "on"}

sqlalchemy_adbc-0.2.0/src/sqlalchemy_adbc/postgresql.py

@@ -0,0 +1,46 @@
+"""ADBC PostgreSQL dialect.
+
+We build a libpq connection *URI* rather than putting credentials in a
+query string, but everything user-supplied is URL-quoted so that a
+password containing ``@``, ``:``, ``/``, ``%``, ``?``, or ``#`` does not
+corrupt the DSN or change its parse. Without quoting, a password like
+``p@ss`` would silently re-route libpq to the wrong host.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from sqlalchemy.engine.url import URL
+
+from sqlalchemy_adbc.base import ADBCDialect
+
+
+class ADBCPostgreSQLDialect(ADBCDialect):
+    name = "adbc"
+    driver = "postgresql"
+    driver_module = "adbc_driver_postgresql.dbapi"
+    supports_statement_cache = True
+
+    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``).
+        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 ""
+        uri = f"postgresql://{auth}{host}{port}{database}"
+
+        kwargs: dict[str, Any] = {}
+        if url.query:
+            kwargs["db_kwargs"] = dict(url.query)
+        return [uri], kwargs

sqlalchemy_adbc-0.2.0/src/sqlalchemy_adbc/snowflake.py

@@ -0,0 +1,48 @@
+"""ADBC Snowflake dialect.
+
+URL form::
+
+    adbc+snowflake://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
+every user-supplied component so passwords with ``@``, ``:``, ``/``,
+``%``, ``?``, ``#`` and query values with spaces don't corrupt the DSN.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from sqlalchemy.engine.url import URL
+
+from sqlalchemy_adbc.base import ADBCDialect
+
+
+class ADBCSnowflakeDialect(ADBCDialect):
+    name = "adbc"
+    driver = "snowflake"
+    driver_module = "adbc_driver_snowflake.dbapi"
+    supports_statement_cache = True
+
+    def build_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
+        # SQLAlchemy decodes userinfo but leaves the database path
+        # untouched. Re-quoting userinfo keeps a password like ``p@ss``
+        # from being parsed as a second @-separator; the path is
+        # already in the encoded form the caller wrote.
+        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 ""
+        account = url.host or ""
+        path = f"/{url.database}" if url.database else ""
+
+        query_str = ""
+        if url.query:
+            pairs = [
+                f"{quote(str(k), safe='')}={quote(str(v), safe='')}" for k, v in url.query.items()
+            ]
+            query_str = "?" + "&".join(pairs)
+
+        dsn = f"{auth}{account}{path}{query_str}"
+        return [dsn], {}

sqlalchemy_adbc-0.2.0/tests/test_base.py

@@ -0,0 +1,81 @@
+"""Unit tests for the base dialect."""
+
+from __future__ import annotations
+
+import pytest
+from sqlalchemy.engine.url import make_url
+
+from sqlalchemy_adbc.base import ADBCDialect
+
+
+def test_import_dbapi_without_driver_module_raises():
+    """Plain ADBCDialect has no driver_module — must error clearly."""
+
+    class NoDriver(ADBCDialect):
+        name = "adbc"
+        driver = "none"
+
+    with pytest.raises(RuntimeError, match="driver_module"):
+        NoDriver.import_dbapi()
+
+
+def test_import_dbapi_subclass_imports_module():
+    """A subclass pointing at a real module successfully imports it."""
+
+    class Fake(ADBCDialect):
+        name = "adbc"
+        driver = "fake"
+        driver_module = "importlib"  # any importable module works for the smoke
+
+    assert Fake.import_dbapi().__name__ == "importlib"
+
+
+def test_format_uri_host_port_database():
+    url = make_url("adbc://host:9999/mydb")
+    assert ADBCDialect()._format_uri(url) == "host:9999/mydb"
+
+
+def test_format_uri_host_only():
+    url = make_url("adbc://host")
+    assert ADBCDialect()._format_uri(url) == "host"
+
+
+def test_format_uri_database_only():
+    url = make_url("adbc:///mydb")
+    assert ADBCDialect()._format_uri(url) == "mydb"
+
+
+def test_format_uri_empty_returns_none():
+    url = make_url("adbc://")
+    assert ADBCDialect()._format_uri(url) is None
+
+
+def test_build_connect_args_forwards_query_as_db_kwargs():
+    class WithDriver(ADBCDialect):
+        driver_module = "adbc_driver_sqlite.dbapi"
+
+    url = make_url("adbc://host:1234/db?key=value")
+    args, kwargs = WithDriver().build_connect_args(url)
+    assert args == ["host:1234/db"]
+    assert kwargs == {"db_kwargs": {"key": "value"}}
+
+
+def test_build_connect_args_empty_query_omits_db_kwargs():
+    class WithDriver(ADBCDialect):
+        driver_module = "adbc_driver_sqlite.dbapi"
+
+    url = make_url("adbc://host:1234/db")
+    args, kwargs = WithDriver().build_connect_args(url)
+    assert args == ["host:1234/db"]
+    assert kwargs == {}
+
+
+def test_dialect_name_and_driver_attrs():
+    """SQLAlchemy uses these for URL scheme resolution."""
+    assert ADBCDialect.name == "adbc"
+    assert ADBCDialect.driver == "adbc"
+
+
+def test_supports_statement_cache_true():
+    """Required to silence SQLAlchemy's caching-disabled warning."""
+    assert ADBCDialect.supports_statement_cache is True

sqlalchemy_adbc-0.2.0/tests/test_bigquery_url.py

@@ -0,0 +1,45 @@
+"""Unit tests for the BigQuery URL → ADBC kwargs translation."""
+
+from __future__ import annotations
+
+from sqlalchemy.engine.url import make_url
+
+from sqlalchemy_adbc.bigquery import ADBCBigQueryDialect
+
+
+def _build(url_str: str):
+    return ADBCBigQueryDialect().build_connect_args(make_url(url_str))
+
+
+def test_project_from_database_segment():
+    """``adbc+bigquery:///my-project`` → project_id set."""
+    args, kwargs = _build("adbc+bigquery:///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")
+    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")
+    db = kwargs["db_kwargs"]
+    assert db["adbc.bigquery.sql.project_id"] == "p"
+    assert db["x"] == "y"
+
+
+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")
+    assert kwargs["db_kwargs"]["adbc.bigquery.sql.project_id"] == "explicit"
+
+
+def test_no_kwargs_at_all():
+    args, kwargs = _build("adbc+bigquery://")
+    assert args == []
+    assert kwargs == {}

{sqlalchemy_adbc-0.1.0 → sqlalchemy_adbc-0.2.0}/tests/test_flightsql_url.py

@@ -16,13 +16,31 @@ def _build(url_str: str):
     return ADBCFlightSQLDialect().build_connect_args(make_url(url_str))
 
 
-def test_plain_grpc():
-    args, kwargs = _build("adbc+flightsql://localhost:50051")
+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")
+    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")
     assert args == ["grpc://localhost:50051"]
     assert "db_kwargs" not in kwargs
 
 
-def test_tls_scheme():
+def test_default_port_tls():
+    args, _ = _build("adbc+flightsql://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")
+    assert args == ["grpc://localhost:50051"]
+
+
+def test_tls_scheme_explicit():
     args, _ = _build("adbc+flightsql://flight-sql.example.com:443?tls=true")
     assert args == ["grpc+tls://flight-sql.example.com:443"]
 

sqlalchemy_adbc-0.2.0/tests/test_postgresql_url.py

@@ -0,0 +1,83 @@
+"""Unit tests for the PostgreSQL URL → ADBC kwargs translation."""
+
+from __future__ import annotations
+
+from sqlalchemy.engine.url import make_url
+
+from sqlalchemy_adbc.postgresql import ADBCPostgreSQLDialect
+
+
+def _build(url_str: str):
+    return ADBCPostgreSQLDialect().build_connect_args(make_url(url_str))
+
+
+def test_full_url():
+    args, kwargs = _build("adbc+postgresql://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")
+    assert args == ["postgresql://host:5432/mydb"]
+
+
+def test_no_port():
+    args, _ = _build("adbc+postgresql://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")
+    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")
+    # 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")
+    assert args == ["postgresql://user:a%3Ab@host/db"]
+
+
+def test_password_with_slash_quoted():
+    args, _ = _build("adbc+postgresql://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")
+    assert args == ["postgresql://user:a%23b@host/db"]
+
+
+def test_password_with_percent_quoted():
+    args, _ = _build("adbc+postgresql://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")
+    assert args == ["postgresql://u%40me:pw@host/db"]
+
+
+def test_database_with_spaces_quoted():
+    args, _ = _build("adbc+postgresql://host/my%20db")
+    assert args == ["postgresql://host/my%20db"]
+
+
+def test_defaults_localhost():
+    args, _ = _build("adbc+postgresql:///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")
+    # We emit auth=":pw@" — libpq accepts this as password-only.
+    assert args[0].startswith("postgresql://:pw@host")

sqlalchemy_adbc-0.2.0/tests/test_snowflake_url.py

@@ -0,0 +1,63 @@
+"""Unit tests for the Snowflake URL → ADBC DSN translation."""
+
+from __future__ import annotations
+
+from sqlalchemy.engine.url import make_url
+
+from sqlalchemy_adbc.snowflake import ADBCSnowflakeDialect
+
+
+def _build(url_str: str):
+    return ADBCSnowflakeDialect().build_connect_args(make_url(url_str))
+
+
+def test_basic_dsn():
+    args, kwargs = _build("adbc+snowflake://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")
+    # 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")
+    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")
+    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")
+    # & 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")
+    assert args == ["u:p@acct"]
+
+
+def test_no_query():
+    args, _ = _build("adbc+snowflake://u:p@acct/db")
+    assert args == ["u:p@acct/db"]
+
+
+def test_username_only():
+    args, _ = _build("adbc+snowflake://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")
+    assert args == ["u:p@acct/my_db/public"]

sqlalchemy_adbc-0.1.0/src/sqlalchemy_adbc/postgresql.py

@@ -1,31 +0,0 @@
-"""ADBC PostgreSQL dialect."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from sqlalchemy.engine.url import URL
-
-from sqlalchemy_adbc.base import ADBCDialect
-
-
-class ADBCPostgreSQLDialect(ADBCDialect):
-    name = "adbc"
-    driver = "postgresql"
-    driver_module = "adbc_driver_postgresql.dbapi"
-    supports_statement_cache = True
-
-    def build_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
-        # adbc_driver_postgresql expects a standard libpq URI.
-        user = url.username or ""
-        password = f":{url.password}" if url.password else ""
-        auth = f"{user}{password}@" if user else ""
-        host = url.host or "localhost"
-        port = f":{url.port}" if url.port else ""
-        database = f"/{url.database}" if url.database else ""
-        uri = f"postgresql://{auth}{host}{port}{database}"
-
-        kwargs: dict[str, Any] = {}
-        if url.query:
-            kwargs["db_kwargs"] = dict(url.query)
-        return [uri], kwargs

sqlalchemy_adbc-0.1.0/src/sqlalchemy_adbc/snowflake.py

@@ -1,38 +0,0 @@
-"""ADBC Snowflake dialect.
-
-URL form::
-
-    adbc+snowflake://user:password@account/database/schema?warehouse=WH&role=R
-
-adbc_driver_snowflake expects a DSN of the form
-``user:password@account/database/schema?warehouse=...``.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from sqlalchemy.engine.url import URL
-
-from sqlalchemy_adbc.base import ADBCDialect
-
-
-class ADBCSnowflakeDialect(ADBCDialect):
-    name = "adbc"
-    driver = "snowflake"
-    driver_module = "adbc_driver_snowflake.dbapi"
-    supports_statement_cache = True
-
-    def build_connect_args(self, url: URL) -> tuple[list[Any], dict[str, Any]]:
-        user = url.username or ""
-        password = f":{url.password}" if url.password else ""
-        auth = f"{user}{password}@" if user else ""
-        account = url.host or ""
-        path = ""
-        if url.database:
-            path = f"/{url.database}"
-        query_str = ""
-        if url.query:
-            query_str = "?" + "&".join(f"{k}={v}" for k, v in url.query.items())
-        dsn = f"{auth}{account}{path}{query_str}"
-        return [dsn], {}