Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

31.8 KB
Raw Blame
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations

from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, cast

import pytest

from marimo._data.models import Database, DataTable, Schema
from marimo._sql.engines.adbc import (
    AdbcConnectionCatalog,
    AdbcDBAPIEngine,
    _adbc_info_to_dialect,
    _schema_field_to_data_type,
)
from marimo._sql.engines.types import default_inference_config
from marimo._sql.get_engines import get_engines_from_variables
from marimo._types.ids import VariableName

if TYPE_CHECKING:
    from collections.abc import Iterator, Sequence

    import pyarrow as pa


@dataclass
class FakeAdbcSchemaField:
    name: str
    type: str


class FakeAdbcTableSchema:
    def __init__(self, fields: list[FakeAdbcSchemaField]) -> None:
        self._fields = fields

    def __iter__(self) -> Iterator[FakeAdbcSchemaField]:
        return iter(self._fields)


class FakeAdbcObjectsTable:
    def __init__(self, pylist: list[dict[str, Any]]) -> None:
        self._pylist = pylist

    def to_pylist(self) -> list[dict[str, Any]]:
        return self._pylist


class FakeAdbcObjectsReader:
    def __init__(self, pylist: list[dict[str, Any]]) -> None:
        self._table = FakeAdbcObjectsTable(pylist)

    def read_all(self) -> FakeAdbcObjectsTable:
        return self._table


class FakeAdbcDbApiCursor:
    def __init__(
        self,
        *,
        description: list[tuple[str, Any]] | None,
        arrow_table: pa.Table | None = None,
    ) -> None:
        self.description = description
        self._arrow_table: pa.Table | None = arrow_table
        self.did_execute = False
        self.did_fetch_arrow = False
        self.did_close = False

    def execute(
        self, query: str, parameters: Sequence[Any] = ()
    ) -> FakeAdbcDbApiCursor:
        _ = query, parameters
        self.did_execute = True
        return self

    def fetch_arrow_table(self) -> pa.Table:
        self.did_fetch_arrow = True
        assert self._arrow_table is not None
        return self._arrow_table

    def close(self) -> None:
        self.did_close = True


class FakeAdbcDbApiConnection:
    adbc_current_catalog: str
    adbc_current_db_schema: str

    def __init__(
        self,
        *,
        cursor: FakeAdbcDbApiCursor,
        objects_pylist: list[dict[str, Any]],
        table_schema: FakeAdbcTableSchema,
    ) -> None:
        self._cursor = cursor
        self._objects_pylist = objects_pylist
        self._table_schema = table_schema
        self.did_commit = False
        self.did_rollback = False
        self.did_close = False
        self.dialect = "postgresql"
        self.adbc_current_catalog = "db1"
        self.adbc_current_db_schema = "public"
        self.did_create_cursor = False
        self.last_get_objects_kwargs: dict[str, Any] | None = None
        self.adbc_get_info_calls = 0

    def cursor(self) -> FakeAdbcDbApiCursor:
        self.did_create_cursor = True
        return self._cursor

    def commit(self) -> None:
        self.did_commit = True

    def rollback(self) -> None:
        self.did_rollback = True

    def close(self) -> None:
        self.did_close = True

    # ADBC DB-API extension methods
    def adbc_get_objects(
        self,
        *,
        depth: str = "all",
        catalog_filter: str | None = None,
        db_schema_filter: str | None = None,
        table_name_filter: str | None = None,
        table_types_filter: list[str] | None = None,
        column_name_filter: str | None = None,
    ) -> pa.RecordBatchReader:
        self.last_get_objects_kwargs = {
            "depth": depth,
            "catalog_filter": catalog_filter,
            "db_schema_filter": db_schema_filter,
            "table_name_filter": table_name_filter,
            "table_types_filter": table_types_filter,
            "column_name_filter": column_name_filter,
        }

        catalogs: list[dict[str, Any]] = []
        for catalog_row in self._objects_pylist:
            catalog_name_obj = catalog_row.get("catalog_name")
            catalog_name = (
                "" if catalog_name_obj is None else str(catalog_name_obj)
            )
            if catalog_filter is not None and catalog_name != catalog_filter:
                continue

            next_catalog_row: dict[str, Any] = dict(catalog_row)
            if depth == "catalogs":
                next_catalog_row["catalog_db_schemas"] = []
                catalogs.append(next_catalog_row)
                continue

            schemas = catalog_row.get("catalog_db_schemas") or []
            next_schemas: list[dict[str, Any]] = []
            for schema_row in schemas:
                schema_name_obj = schema_row.get("db_schema_name")
                schema_name = (
                    "" if schema_name_obj is None else str(schema_name_obj)
                )
                if (
                    db_schema_filter is not None
                    and schema_name != db_schema_filter
                ):
                    continue

                next_schema_row: dict[str, Any] = dict(schema_row)
                if depth == "db_schemas":
                    next_schema_row["db_schema_tables"] = []
                    next_schemas.append(next_schema_row)
                    continue

                tables = schema_row.get("db_schema_tables") or []
                next_tables: list[dict[str, Any]] = []
                for table_row in tables:
                    table_name_obj = table_row.get("table_name")
                    if table_name_obj is None:
                        continue
                    table_name = str(table_name_obj)
                    if (
                        table_name_filter is not None
                        and table_name != table_name_filter
                    ):
                        continue

                    table_type_obj = table_row.get("table_type")
                    table_type = (
                        "" if table_type_obj is None else str(table_type_obj)
                    )
                    if (
                        table_types_filter is not None
                        and table_type not in table_types_filter
                    ):
                        continue

                    next_tables.append(dict(table_row))

                next_schema_row["db_schema_tables"] = next_tables
                next_schemas.append(next_schema_row)

            next_catalog_row["catalog_db_schemas"] = next_schemas
            catalogs.append(next_catalog_row)

        # ADBC DB-API wrapper returns a pyarrow.RecordBatchReader; our fake
        # emulates the reader's `read_all().to_pylist()` interface.
        return cast(Any, FakeAdbcObjectsReader(catalogs))

    def adbc_get_table_schema(
        self, table_name: str, *, db_schema_filter: str | None = None
    ) -> pa.Schema:
        _ = table_name, db_schema_filter
        return cast(Any, self._table_schema)

    def adbc_get_info(self) -> dict[str | int, Any]:
        self.adbc_get_info_calls += 1
        return cast(dict[str | int, Any], {"vendor_name": "PostgreSQL"})


def test_adbc_info_to_dialect() -> None:
    # Vendor string is lowercased (and stripped); driver_name is ignored.
    assert (
        _adbc_info_to_dialect(
            info={"vendor_name": "PostgreSQL", "driver_name": "SQLite"}
        )
        == "postgresql"
    )
    assert (
        _adbc_info_to_dialect(info={"vendor_name": "Microsoft SQL Server"})
        == "microsoft sql server"
    )
    assert _adbc_info_to_dialect(info={"vendor_name": "Dremio"}) == "dremio"

    # Missing/blank/non-string vendor_name falls back to "sql".
    assert _adbc_info_to_dialect(info={"vendor_name": "   "}) == "sql"
    assert _adbc_info_to_dialect(info={"vendor_name": 123}) == "sql"
    assert _adbc_info_to_dialect(info={"driver_name": "AcmeDB"}) == "sql"
    assert _adbc_info_to_dialect(info={}) == "sql"


@pytest.mark.parametrize(
    "external_type",
    [
        "list<$data$: bool not null>",
        "list<$data$: int64 not null>",
        "large_list<$data$: double>",
        "fixed_size_list<item: string>[3]",
        "array<int32>",
        "int64[]",
        " struct<id: int64, enabled: bool> ",
        "struct<id: int64, enabled: bool>",
        "map<string, int64>",
    ],
)
def test_schema_field_to_data_type_returns_unknown_for_nested_types(
    external_type: str,
) -> None:
    assert _schema_field_to_data_type(external_type) == "unknown"


@pytest.mark.parametrize(
    ("external_type", "data_type"),
    [
        ("int8", "integer"),
        ("int64", "integer"),
        ("uint32", "integer"),
        ("uint64", "integer"),
        ("string", "string"),
        ("large_string", "string"),
        ("binary", "string"),
        ("fixed_size_binary[16]", "string"),
        ("interval", "unknown"),
        ("dictionary<values=string, indices=int8, ordered=0>", "unknown"),
        ("bool", "boolean"),
    ],
)
def test_schema_field_to_data_type_handles_scalar_types(
    external_type: str, data_type: str
) -> None:
    assert _schema_field_to_data_type(external_type) == data_type


def test_get_engines_from_variables_prefers_adbc_dbapi_engine() -> None:
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=[],
        table_schema=FakeAdbcTableSchema([]),
    )

    engines = get_engines_from_variables([(VariableName("conn"), conn)])
    assert len(engines) == 1
    _, engine = engines[0]
    assert isinstance(engine, AdbcDBAPIEngine)


def test_adbc_catalog_parses_adbc_get_objects() -> None:
    objects_pylist = [
        {
            "catalog_name": "db1",
            "catalog_db_schemas": [
                {
                    "db_schema_name": "public",
                    "db_schema_tables": [
                        {"table_name": "t1", "table_type": "TABLE"},
                        {"table_name": "v1", "table_type": "VIEW"},
                    ],
                }
            ],
        }
    ]
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=objects_pylist,
        table_schema=FakeAdbcTableSchema(
            [
                FakeAdbcSchemaField(name="id", type="int64"),
                FakeAdbcSchemaField(name="name", type="utf8"),
            ]
        ),
    )

    engine = AdbcDBAPIEngine(conn, engine_name=VariableName("adbc_conn"))
    databases = engine.get_databases(
        include_schemas=True,
        include_tables=True,
        include_table_details=False,
    )
    assert conn.last_get_objects_kwargs is not None
    assert conn.last_get_objects_kwargs["depth"] == "tables"

    assert databases == [
        Database(
            name="db1",
            dialect="postgresql",
            engine=VariableName("adbc_conn"),
            schemas=[
                Schema(
                    name="public",
                    tables=[
                        DataTable(
                            source_type="connection",
                            source="postgresql",
                            name="t1",
                            num_rows=None,
                            num_columns=None,
                            variable_name=None,
                            engine=VariableName("adbc_conn"),
                            type="table",
                            columns=[],
                            primary_keys=[],
                            indexes=[],
                        ),
                        DataTable(
                            source_type="connection",
                            source="postgresql",
                            name="v1",
                            num_rows=None,
                            num_columns=None,
                            variable_name=None,
                            engine=VariableName("adbc_conn"),
                            type="view",
                            columns=[],
                            primary_keys=[],
                            indexes=[],
                        ),
                    ],
                )
            ],
        )
    ]


@pytest.fixture
def adbc_execution() -> tuple[FakeAdbcDbApiConnection, FakeAdbcDbApiCursor]:
    cursor = FakeAdbcDbApiCursor(
        description=[("id", None)],
        arrow_table=cast("pa.Table", object()),
    )
    conn = FakeAdbcDbApiConnection(
        cursor=cursor,
        objects_pylist=[],
        table_schema=FakeAdbcTableSchema([]),
    )
    return conn, cursor


def test_adbc_execute_prefers_arrow_fetch(
    monkeypatch: pytest.MonkeyPatch,
    adbc_execution: tuple[FakeAdbcDbApiConnection, FakeAdbcDbApiCursor],
) -> None:
    sentinel_result = object()

    def fake_convert_to_output(*args: Any, **kwargs: Any) -> Any:
        _ = args, kwargs
        return sentinel_result

    monkeypatch.setattr(
        "marimo._sql.engines.adbc.convert_to_output", fake_convert_to_output
    )

    conn, cursor = adbc_execution
    engine = AdbcDBAPIEngine(conn)

    monkeypatch.setattr(engine, "sql_output_format", lambda: "auto")
    result = engine.execute("SELECT 1")

    assert result is sentinel_result
    assert cursor.did_fetch_arrow is True
    assert conn.did_commit is True
    assert cursor.did_close is True


def test_adbc_execute_commits_before_conversion_failure(
    monkeypatch: pytest.MonkeyPatch,
    adbc_execution: tuple[FakeAdbcDbApiConnection, FakeAdbcDbApiCursor],
) -> None:
    conn, cursor = adbc_execution
    engine = AdbcDBAPIEngine(conn)
    monkeypatch.setattr(engine, "sql_output_format", lambda: "auto")
    conversion_error = ValueError("dataframe conversion failed")

    def fail_conversion(**_kwargs: Any) -> Any:
        raise conversion_error

    monkeypatch.setattr(
        "marimo._sql.engines.adbc.convert_to_output", fail_conversion
    )
    with pytest.raises(ValueError) as exc_info:
        engine.execute("INSERT INTO items VALUES (1) RETURNING id")

    assert exc_info.value is conversion_error
    assert cursor.did_fetch_arrow is True
    assert conn.did_commit is True
    assert cursor.did_close is True


@pytest.mark.parametrize("failing_method", ["execute", "fetch_arrow_table"])
def test_adbc_execute_does_not_commit_failed_query_or_fetch(
    monkeypatch: pytest.MonkeyPatch,
    adbc_execution: tuple[FakeAdbcDbApiConnection, FakeAdbcDbApiCursor],
    failing_method: str,
) -> None:
    conn, cursor = adbc_execution
    query_error = RuntimeError("query or fetch failed")

    def fail(*_args: Any, **_kwargs: Any) -> Any:
        raise query_error

    monkeypatch.setattr(cursor, failing_method, fail)
    with pytest.raises(RuntimeError) as exc_info:
        AdbcDBAPIEngine(conn).execute(
            "INSERT INTO items VALUES (1) RETURNING id"
        )

    assert exc_info.value is query_error
    assert conn.did_commit is False
    assert cursor.did_close is True


def test_adbc_execute_native_returns_arrow_table(
    monkeypatch: pytest.MonkeyPatch,
    adbc_execution: tuple[FakeAdbcDbApiConnection, FakeAdbcDbApiCursor],
) -> None:
    conn, cursor = adbc_execution
    engine = AdbcDBAPIEngine(conn)

    monkeypatch.setattr(engine, "sql_output_format", lambda: "native")
    result = engine.execute("SELECT 1")

    assert result is cursor._arrow_table
    assert cursor.did_execute is True
    assert cursor.did_fetch_arrow is True
    assert conn.did_commit is True
    assert cursor.did_close is True


def test_adbc_is_compatible_does_not_create_cursor() -> None:
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=[],
        table_schema=FakeAdbcTableSchema([]),
    )
    # is_compatible() validates cursor shape; it should not execute or fetch.
    assert AdbcDBAPIEngine.is_compatible(conn) is True
    assert conn.did_create_cursor is True
    assert conn._cursor.did_execute is False  # type: ignore[attr-defined]
    assert conn._cursor.did_fetch_arrow is False  # type: ignore[attr-defined]
    assert conn._cursor.did_close is True  # type: ignore[attr-defined]


def test_adbc_is_compatible_rejects_fabricated_attributes() -> None:
    # Catch-all __getattr__ (e.g. ignite metrics) must not match.
    # See https://github.com/marimo-team/marimo/issues/10213.
    class FabricatingAttributes:
        def __getattr__(self, name: str) -> object:
            def _lazy(*_args: object, **_kwargs: object) -> object:
                return FabricatingAttributes()

            return _lazy

    assert AdbcDBAPIEngine.is_compatible(FabricatingAttributes()) is False


def test_adbc_engine_uses_default_inference_config() -> None:
    """ADBC shares the default discovery config (see #9775)."""
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=[],
        table_schema=FakeAdbcTableSchema([]),
    )
    engine = AdbcDBAPIEngine(conn)
    assert engine.inference_config == default_inference_config()
    assert engine.inference_config.auto_discover_schemas == "auto"


def test_adbc_catalog_auto_discovery_uses_cheap_dialect_heuristic() -> None:
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=[],
        table_schema=FakeAdbcTableSchema([]),
    )
    cheap = AdbcConnectionCatalog(
        adbc_connection=conn,
        dialect="sqlite",
        engine_name=None,
    )
    assert cheap._resolve_should_auto_discover("auto") is True
    assert cheap._resolve_should_auto_discover(True) is True
    assert cheap._resolve_should_auto_discover(False) is False

    expensive = AdbcConnectionCatalog(
        adbc_connection=conn,
        dialect="snowflake",
        engine_name=None,
    )
    assert expensive._resolve_should_auto_discover("auto") is False


def test_adbc_catalog_get_databases_uses_depth_catalogs_when_no_schemas() -> (
    None
):
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=[
            {
                "catalog_name": "db1",
                "catalog_db_schemas": [
                    {"db_schema_name": "public", "db_schema_tables": []}
                ],
            },
            {"catalog_name": "db2", "catalog_db_schemas": []},
        ],
        table_schema=FakeAdbcTableSchema([]),
    )
    engine = AdbcDBAPIEngine(conn)
    databases = engine.get_databases(
        include_schemas=False,
        include_tables=True,
        include_table_details=True,
    )
    assert conn.last_get_objects_kwargs is not None
    assert conn.last_get_objects_kwargs["depth"] == "catalogs"
    assert [db.name for db in databases] == ["db1", "db2"]
    assert [db.schemas for db in databases] == [[], []]


def test_adbc_catalog_get_databases_uses_depth_db_schemas_when_no_tables() -> (
    None
):
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=[
            {
                "catalog_name": "db1",
                "catalog_db_schemas": [
                    {"db_schema_name": "public", "db_schema_tables": []},
                    {"db_schema_name": "empty", "db_schema_tables": []},
                ],
            }
        ],
        table_schema=FakeAdbcTableSchema([]),
    )
    engine = AdbcDBAPIEngine(conn)
    databases = engine.get_databases(
        include_schemas=True,
        include_tables=False,
        include_table_details=False,
    )
    assert conn.last_get_objects_kwargs is not None
    assert conn.last_get_objects_kwargs["depth"] == "db_schemas"
    assert [s.name for s in databases[0].schemas] == ["public", "empty"]
    assert [s.tables for s in databases[0].schemas] == [[], []]


def test_adbc_get_tables_in_schema_passes_filters() -> None:
    conn = FakeAdbcDbApiConnection(
        cursor=FakeAdbcDbApiCursor(description=None),
        objects_pylist=[
            {
                "catalog_name": "db1",
                "catalog_db_schemas": [
                    {
                        "db_schema_name": "public",
                        "db_schema_tables": [
                            {"table_name": "t1", "table_type": "TABLE"}
                        ],
                    },
                    {
                        "db_schema_name": "other",
                        "db_schema_tables": [
                            {"table_name": "t2", "table_type": "TABLE"}
                        ],
                    },
                ],
            },
            {
                "catalog_name": "db2",
                "catalog_db_schemas": [
                    {
                        "db_schema_name": "public",
                        "db_schema_tables": [
                            {"table_name": "t3", "table_type": "TABLE"}
                        ],
                    }
                ],
            },
        ],
        table_schema=FakeAdbcTableSchema([]),
    )
    engine = AdbcDBAPIEngine(conn)
    tables = engine.get_tables_in_schema(
        schema="public", database="db1", include_table_details=False
    )
    assert conn.last_get_objects_kwargs is not None
    assert conn.last_get_objects_kwargs["depth"] == "tables"
    assert conn.last_get_objects_kwargs["catalog_filter"] == "db1"
    assert conn.last_get_objects_kwargs["db_schema_filter"] == "public"
    assert [t.name for t in tables] == ["t1"]


def _find_table_location(
    *, databases: list[Any], table_name: str
) -> tuple[str, str]:
    for db in databases:
        for schema in db.schemas:
            for table in schema.tables:
                if table.name == table_name:
                    return db.name, schema.name
    raise AssertionError(f"Did not find table {table_name!r} in catalog")


def _table_summary(table: DataTable) -> dict[str, Any]:
    """Return a stable representation of a DataTable for assertions."""
    return {
        "name": table.name,
        "type": table.type,
        "num_columns": table.num_columns,
        "column_names": [c.name for c in table.columns],
        "column_types": {c.name: c.type for c in table.columns},
    }


def test_adbc_sqlite_driver_catalog_interface() -> None:
    """Smoke test marimo ADBC catalog interface against the real SQLite driver."""
    pytest.importorskip(
        "pyarrow", reason="ADBC DBAPI wrapper requires PyArrow"
    )
    adbc_sqlite_dbapi = pytest.importorskip("adbc_driver_sqlite.dbapi")

    # Explicitly use a fresh in-memory database per test run.
    conn: Any = adbc_sqlite_dbapi.connect(":memory:")
    try:

        def get_table(
            *,
            databases: list[Any],
            database_name: str,
            schema_name: str,
            table_name: str,
        ) -> DataTable:
            for db in databases:
                if getattr(db, "name", None) != database_name:
                    continue
                for schema in getattr(db, "schemas", []):
                    if getattr(schema, "name", None) != schema_name:
                        continue
                    for table in getattr(schema, "tables", []):
                        if getattr(table, "name", None) == table_name:
                            return cast(DataTable, table)
            raise AssertionError(
                f"Did not find table {table_name!r} "
                f"in {database_name!r}.{schema_name!r}"
            )

        def sorted_table_summaries(
            tables: list[DataTable],
        ) -> list[dict[str, Any]]:
            return sorted(
                (_table_summary(t) for t in tables),
                key=lambda d: str(d["name"]),
            )

        engine = AdbcDBAPIEngine(conn)
        assert engine.source == "adbc"
        assert engine.dialect == "sqlite"
        assert AdbcDBAPIEngine.is_compatible(conn) is True

        # Minimal schema for catalog discovery.
        cursor = conn.cursor()
        try:
            cursor.execute("CREATE TABLE t (id INTEGER, name TEXT)")
            cursor.execute("CREATE TABLE t2 (x REAL)")
            # NOTE: The SQLite ADBC driver infers Arrow types from observed data.
            # Without any rows, some declared TEXT columns can come back as int64.
            # Insert at least one row to make schema inference deterministic.
            cursor.execute("INSERT INTO t VALUES (1, 'hello')")
            cursor.execute("INSERT INTO t2 VALUES (1.5)")
            cursor.execute(
                """
                CREATE TABLE t_types (
                    int_col INTEGER,
                    real_col REAL,
                    text_col TEXT,
                    blob_col BLOB,
                    bool_col BOOLEAN,
                    date_col DATE,
                    time_col TIME,
                    ts_col TIMESTAMP,
                    numeric_col NUMERIC
                )
                """
            )
            cursor.execute(
                """
                INSERT INTO t_types (
                    int_col,
                    real_col,
                    text_col,
                    blob_col,
                    bool_col,
                    date_col,
                    time_col,
                    ts_col,
                    numeric_col
                ) VALUES (
                    1,
                    1.5,
                    'hello',
                    X'0001',
                    1,
                    '2026-01-04',
                    '12:34:56',
                    '2026-01-04 12:34:56',
                    123.45
                )
                """
            )
            conn.commit()
        finally:
            cursor.close()

        # Default database/schema should be readable (may be None on SQLite).
        _ = engine.get_default_database()
        _ = engine.get_default_schema()

        # When schemas are excluded, we should not return any schema information.
        dbs = engine.get_databases(
            include_schemas=False,
            include_tables=True,
            include_table_details=True,
        )
        assert all(db.schemas == [] for db in dbs)

        # When tables are excluded, we should not return any tables.
        dbs = engine.get_databases(
            include_schemas=True,
            include_tables=False,
            include_table_details=True,
        )
        assert all(
            all(schema.tables == [] for schema in db.schemas) for db in dbs
        )

        # When table details are excluded, tables should have no columns.
        dbs_without_details = engine.get_databases(
            include_schemas=True,
            include_tables=True,
            include_table_details=False,
        )
        db_name, schema_name = _find_table_location(
            databases=dbs_without_details, table_name="t"
        )
        db_name_types, schema_name_types = _find_table_location(
            databases=dbs_without_details, table_name="t_types"
        )
        assert _table_summary(
            get_table(
                databases=dbs_without_details,
                database_name=db_name,
                schema_name=schema_name,
                table_name="t",
            )
        ) == {
            "name": "t",
            "type": "table",
            "num_columns": None,
            "column_names": [],
            "column_types": {},
        }
        assert _table_summary(
            get_table(
                databases=dbs_without_details,
                database_name=db_name_types,
                schema_name=schema_name_types,
                table_name="t_types",
            )
        ) == {
            "name": "t_types",
            "type": "table",
            "num_columns": None,
            "column_names": [],
            "column_types": {},
        }

        # With details enabled, columns should be populated.
        dbs_with_details = engine.get_databases(
            include_schemas=True,
            include_tables=True,
            include_table_details=True,
        )
        assert _table_summary(
            get_table(
                databases=dbs_with_details,
                database_name=db_name,
                schema_name=schema_name,
                table_name="t",
            )
        ) == {
            "name": "t",
            "type": "table",
            "num_columns": 2,
            "column_names": ["id", "name"],
            "column_types": {"id": "integer", "name": "string"},
        }

        types_summary = _table_summary(
            get_table(
                databases=dbs_with_details,
                database_name=db_name_types,
                schema_name=schema_name_types,
                table_name="t_types",
            )
        )
        assert types_summary == {
            "name": "t_types",
            "type": "table",
            "num_columns": 9,
            "column_names": [
                "int_col",
                "real_col",
                "text_col",
                "blob_col",
                "bool_col",
                "date_col",
                "time_col",
                "ts_col",
                "numeric_col",
            ],
            "column_types": {
                "int_col": "integer",
                "real_col": "number",
                "text_col": "string",
                "blob_col": "string",
                "bool_col": "integer",
                "date_col": "string",
                "time_col": "string",
                "ts_col": "string",
                "numeric_col": "number",
            },
        }

        tables = engine.get_tables_in_schema(
            schema=schema_name, database=db_name, include_table_details=False
        )
        assert sorted_table_summaries(tables) == [
            {
                "name": "t",
                "type": "table",
                "num_columns": None,
                "column_names": [],
                "column_types": {},
            },
            {
                "name": "t2",
                "type": "table",
                "num_columns": None,
                "column_names": [],
                "column_types": {},
            },
            {
                "name": "t_types",
                "type": "table",
                "num_columns": None,
                "column_names": [],
                "column_types": {},
            },
        ]

        tables_with_details = engine.get_tables_in_schema(
            schema=schema_name, database=db_name, include_table_details=True
        )
        assert sorted_table_summaries(tables_with_details) == [
            {
                "name": "t",
                "type": "table",
                "num_columns": 2,
                "column_names": ["id", "name"],
                "column_types": {"id": "integer", "name": "string"},
            },
            {
                "name": "t2",
                "type": "table",
                "num_columns": 1,
                "column_names": ["x"],
                "column_types": {"x": "number"},
            },
            types_summary,
        ]
    finally:
        conn.close()


def test_adbc_sqlite_driver_execute_polars(monkeypatch) -> None:
    """Smoke test marimo ADBC engine against the real ADBC SQLite driver."""
    pytest.importorskip(
        "pyarrow", reason="ADBC DBAPI wrapper requires PyArrow"
    )
    pl = pytest.importorskip("polars")
    adbc_sqlite_dbapi = pytest.importorskip("adbc_driver_sqlite.dbapi")

    # Explicitly use a fresh in-memory database per test run.
    conn: Any = adbc_sqlite_dbapi.connect(":memory:")
    try:
        engine = AdbcDBAPIEngine(conn)
        assert engine.source == "adbc"
        assert engine.dialect == "sqlite"
        assert AdbcDBAPIEngine.is_compatible(conn) is True

        engine.execute("CREATE TABLE t (id INTEGER)")
        engine.execute("INSERT INTO t VALUES (1), (2)")

        from marimo._sql.get_engines import engine_to_data_source_connection

        # Ensure we can produce a DataSourceConnection for the UI/kernel message path.
        connection = engine_to_data_source_connection(
            VariableName("adbc_sqlite"), engine
        )
        assert connection.source == "adbc"
        assert connection.dialect == "sqlite"
        assert connection.name == "adbc_sqlite"
        assert "sqlite" in connection.display_name.lower()

        monkeypatch.setattr(engine, "sql_output_format", lambda: "polars")
        df = engine.execute("SELECT id FROM t ORDER BY id")
        assert isinstance(df, pl.DataFrame)
        assert df.to_dicts() == [{"id": 1}, {"id": 2}]
    finally:
        conn.close()