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.

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

from unittest.mock import MagicMock, patch

import pytest

from marimo._data.models import (
    Database,
    DataSourceConnection,
    Schema,
)
from marimo._dependencies.dependencies import DependencyManager
from marimo._sql.engines.adbc import AdbcDBAPIEngine
from marimo._sql.engines.clickhouse import ClickhouseEmbedded
from marimo._sql.engines.dbapi import DBAPIEngine
from marimo._sql.engines.duckdb import INTERNAL_DUCKDB_ENGINE, DuckDBEngine
from marimo._sql.engines.ibis import IbisEngine
from marimo._sql.engines.redshift import RedshiftEngine
from marimo._sql.engines.sqlalchemy import SQLAlchemyEngine
from marimo._sql.get_engines import (
    engine_to_data_source_connection,
    get_engines_from_variables,
)
from marimo._types.ids import VariableName

HAS_SQLALCHEMY = DependencyManager.sqlalchemy.has()
HAS_IBIS = DependencyManager.ibis.has()
HAS_DUCKDB = DependencyManager.duckdb.has()
HAS_CLICKHOUSE = DependencyManager.chdb.has()
HAS_REDSHIFT = DependencyManager.redshift_connector.has()
HAS_PYARROW = DependencyManager.pyarrow.has()
HAS_IBIS = DependencyManager.ibis.has()


@pytest.mark.skipif(not HAS_SQLALCHEMY, reason="SQLAlchemy not installed")
def test_engine_to_data_source_connection() -> None:
    import sqlalchemy  # noqa: F401, needed for patching sqlalchemy.inspect

    # Test with DuckDB engine
    duckdb_engine = DuckDBEngine(None)
    connection = engine_to_data_source_connection(
        VariableName("my_duckdb"), duckdb_engine
    )
    assert isinstance(connection, DataSourceConnection)
    assert connection.source == "duckdb"
    assert connection.dialect == "duckdb"
    assert connection.name == "my_duckdb"
    assert connection.display_name == "duckdb (my_duckdb)"
    assert connection.default_database == "memory"
    assert connection.default_schema == "main"
    assert connection.databases == [
        Database(
            name=name,
            dialect="duckdb",
            schemas=[Schema(name="main", tables=[])],
        )
        for name in ("memory", "temp")
    ]

    # Test with ClickhouseEmbedded engine
    clickhouse_engine = ClickhouseEmbedded(None)
    connection = engine_to_data_source_connection(
        "my_clickhouse", clickhouse_engine
    )
    assert isinstance(connection, DataSourceConnection)
    assert connection.source == "clickhouse"
    assert connection.dialect == "clickhouse"
    assert connection.name == "my_clickhouse"
    assert connection.display_name == "clickhouse (my_clickhouse)"
    # assert connection.default_database == "default"
    # assert connection.default_schema == "default"
    assert connection.databases == []

    # Test with SQLAlchemy engine
    mock_sqlalchemy_engine = MagicMock()
    mock_sqlalchemy_engine.dialect.name = "postgresql"

    with patch("sqlalchemy.inspect", return_value=MagicMock()):
        sqlalchemy_engine = SQLAlchemyEngine(mock_sqlalchemy_engine)

    connection = engine_to_data_source_connection(
        "my_postgres", sqlalchemy_engine
    )
    assert isinstance(connection, DataSourceConnection)
    assert connection.source == "sqlalchemy"
    assert connection.dialect == "postgresql"
    assert connection.name == "my_postgres"
    assert connection.display_name == "postgresql (my_postgres)"

    # Test with Ibis engine
    var_name = "my_ibis"
    backend_name = "duckdb"
    backend_class = MagicMock
    mock_ibis_backend = MagicMock()
    mock_ibis_backend.dialect = backend_class
    mock_ibis_backend.dialect.classes = {backend_name: backend_class}

    ibis_engine = IbisEngine(mock_ibis_backend)
    connection = engine_to_data_source_connection(var_name, ibis_engine)
    assert isinstance(connection, DataSourceConnection)
    assert connection.source == "ibis"
    assert connection.dialect == backend_name
    assert connection.name == var_name
    assert connection.display_name == f"{backend_name} ({var_name})"


@pytest.mark.skipif(not HAS_IBIS, reason="Ibis not installed")
def test_engine_to_datasource_connection_error() -> None:
    ibis_engine = IbisEngine(MagicMock())

    # Mock the get_databases method to raise an error
    ibis_engine.get_databases = MagicMock(
        side_effect=Exception("Database connection failed")
    )

    connection = engine_to_data_source_connection(
        VariableName("my_ibis"), ibis_engine
    )
    assert isinstance(connection, DataSourceConnection)
    assert connection.databases == []


@pytest.mark.skipif(not HAS_DUCKDB, reason="DuckDB not installed")
def test_get_engines_from_variables_duckdb():
    import duckdb

    mock_duckdb_conn = MagicMock(spec=duckdb.DuckDBPyConnection)
    variables: list[tuple[str, object]] = [("duckdb_conn", mock_duckdb_conn)]

    engines = get_engines_from_variables(variables)
    assert len(engines) == 1
    var_name, engine = engines[0]
    assert var_name == "duckdb_conn"
    assert isinstance(engine, DuckDBEngine)


@pytest.mark.skipif(not HAS_DUCKDB, reason="DuckDB not installed")
def test_get_engines_from_variables_import_module_type():
    import duckdb

    variables: list[tuple[str, object]] = [("duckdb", duckdb)]

    # DuckDB import should not trigger a DuckDBEngine registration
    engines = get_engines_from_variables(variables)
    assert len(engines) == 0


@pytest.mark.skipif(not HAS_CLICKHOUSE, reason="Clickhouse not installed")
@pytest.mark.skip("chdb causes import errors locally")
def test_get_engines_from_variables_clickhouse():
    import chdb

    mock_clickhouse_conn = MagicMock(spec=chdb.state.sqlitelike.Connection)
    variables: list[tuple[str, object]] = [
        ("clickhouse_conn", mock_clickhouse_conn)
    ]

    engines = get_engines_from_variables(variables)
    assert len(engines) == 1
    var_name, engine = engines[0]
    assert var_name == "clickhouse_conn"
    assert isinstance(engine, ClickhouseEmbedded)


@pytest.mark.skipif(not HAS_REDSHIFT, reason="Redshift not installed")
def test_get_engines_from_variables_redshift():
    import redshift_connector

    mock_redshift_conn = MagicMock(spec=redshift_connector.Connection)
    variables: list[tuple[str, object]] = [
        ("redshift_conn", mock_redshift_conn)
    ]

    engines = get_engines_from_variables(variables)
    assert len(engines) == 1
    var_name, engine = engines[0]
    assert var_name == "redshift_conn"
    assert isinstance(engine, RedshiftEngine)


@pytest.mark.skipif(not HAS_SQLALCHEMY, reason="SQLAlchemy not installed")
def test_get_engines_from_variables_sqlalchemy() -> None:
    import sqlalchemy as sa

    sqlalchemy_engine = sa.create_engine("sqlite:///:memory:")
    variables: list[tuple[str, object]] = [("sa_engine", sqlalchemy_engine)]

    engines = get_engines_from_variables(variables)

    assert len(engines) == 1
    var_name, engine = engines[0]
    assert var_name == "sa_engine"
    assert isinstance(engine, SQLAlchemyEngine)


@pytest.mark.skipif(not HAS_IBIS, reason="Ibis not installed")
def test_get_engines_from_variables_ibis() -> None:
    import ibis

    ibis_backend = ibis.duckdb.connect()
    variables: list[tuple[str, object]] = [("ibis_backend", ibis_backend)]

    engines = get_engines_from_variables(variables)

    assert len(engines) == 1
    var_name, engine = engines[0]
    assert var_name == "ibis_backend"
    assert isinstance(engine, IbisEngine)


def test_get_engines_from_variables_mixed():
    variables: list[tuple[str, object]] = [
        ("not_an_engine", "some string"),
        ("another_not_engine", 42),
    ]

    engines = get_engines_from_variables(variables)
    assert len(engines) == 0


@pytest.mark.skipif(
    not (HAS_SQLALCHEMY and HAS_DUCKDB and HAS_CLICKHOUSE and HAS_IBIS),
    reason="SQLAlchemy, Clickhouse, Ibis, or DuckDB not installed",
)
def test_get_engines_from_variables_multiple():
    import duckdb
    import ibis
    import sqlalchemy as sa

    mock_duckdb_conn = MagicMock(spec=duckdb.DuckDBPyConnection)
    sqlalchemy_engine = sa.create_engine("sqlite:///:memory:")
    ibis_backend = ibis.duckdb.connect()

    variables: list[tuple[str, object]] = [
        ("sa_engine", sqlalchemy_engine),
        ("duckdb_conn", mock_duckdb_conn),
        ("ibis_backend", ibis_backend),
        ("not_an_engine", "some string"),
    ]

    engines = get_engines_from_variables(variables)

    assert len(engines) == 3

    # Check SQLAlchemy engine
    sa_var_name, _sa_engine = next(
        (name, eng)
        for name, eng in engines
        if isinstance(eng, SQLAlchemyEngine)
    )
    assert sa_var_name == "sa_engine"

    # Check DuckDB engine
    duckdb_var_name, _duckdb_engine = next(
        (name, eng) for name, eng in engines if isinstance(eng, DuckDBEngine)
    )
    assert duckdb_var_name == "duckdb_conn"

    ibis_var_name, _ibis_engine = next(
        (name, eng) for name, eng in engines if isinstance(eng, IbisEngine)
    )
    assert ibis_var_name == "ibis_backend"


def test_get_engines_dbapi():
    import sqlite3

    mock_sqlite_conn = MagicMock(spec=sqlite3.Connection)
    variables: list[tuple[str, object]] = [("sqlite_conn", mock_sqlite_conn)]

    engines = get_engines_from_variables(variables)
    assert len(engines) == 1
    var_name, engine = engines[0]
    assert var_name == "sqlite_conn"
    assert isinstance(engine, DBAPIEngine)


def test_get_engines_dbapi_databases():
    import sqlite3

    with sqlite3.connect(":memory:") as conn:
        engine = DBAPIEngine(conn)
        connection = engine_to_data_source_connection(
            VariableName("sqlite_conn"), engine
        )
        assert connection.databases == []
        assert connection.dialect == "sql"


@pytest.mark.skipif(
    not HAS_PYARROW, reason="pyarrow is required for ADBC sqlite driver"
)
def test_get_engines_from_variables_adbc_sqlite() -> None:
    adbc_sqlite_dbapi = pytest.importorskip("adbc_driver_sqlite.dbapi")

    # Explicitly use a fresh in-memory database per test run.
    conn = adbc_sqlite_dbapi.connect(":memory:")
    try:
        variables: list[tuple[str, object]] = [("adbc_sqlite", conn)]
        engines = get_engines_from_variables(variables)

        assert len(engines) == 1
        var_name, engine = engines[0]
        assert var_name == "adbc_sqlite"
        assert isinstance(engine, AdbcDBAPIEngine)
        assert engine.source == "adbc"
        assert engine.dialect == "sqlite"
    finally:
        conn.close()


def test_get_engines_from_variables_sqlite3_is_not_adbc() -> None:
    import sqlite3

    conn = sqlite3.connect(":memory:")
    try:
        variables: list[tuple[str, object]] = [("sqlite3_conn", conn)]
        engines = get_engines_from_variables(variables)

        assert len(engines) == 1
        var_name, engine = engines[0]
        assert var_name == "sqlite3_conn"
        assert isinstance(engine, DBAPIEngine)
        assert not isinstance(engine, AdbcDBAPIEngine)
    finally:
        conn.close()


@pytest.mark.skipif(not HAS_DUCKDB, reason="DuckDB not installed")
def test_get_engines_duckdb_databases() -> None:
    import duckdb

    duckdb_engine = DuckDBEngine(None)

    # Test display name when the name is DEFAULT_ENGINE_NAME
    connection = engine_to_data_source_connection(
        INTERNAL_DUCKDB_ENGINE, duckdb_engine
    )
    assert connection.display_name == "duckdb (In-Memory)"

    connection = engine_to_data_source_connection(
        VariableName("my_duckdb"), duckdb_engine
    )
    assert isinstance(connection, DataSourceConnection)

    assert connection.source == "duckdb"
    assert connection.dialect == "duckdb"
    assert connection.name == "my_duckdb"
    assert connection.display_name == "duckdb (my_duckdb)"
    assert connection.default_database == "memory"
    assert connection.default_schema == "main"

    duckdb.execute("CREATE TABLE test_table (id INTEGER);").fetchall()

    try:
        # Reload the connection to get the new table
        connection = engine_to_data_source_connection(
            VariableName("my_duckdb"), duckdb_engine
        )

        assert [database.name for database in connection.databases] == [
            "memory",
            "temp",
        ]
        database = connection.databases[0]
        assert database.name == "memory"
        assert len(database.schemas) == 1
        schema = database.schemas[0]
        assert schema.name == "main"
        assert len(schema.tables) == 1
        table = schema.tables[0]
        assert table.name == "test_table"
        assert table.columns == []
        assert table.num_columns is None
    finally:
        duckdb.execute("DROP TABLE test_table;").fetchall()


@pytest.mark.skipif(not HAS_SQLALCHEMY, reason="SQLAlchemy not installed")
def test_get_engines_sqlalchemy_databases() -> None:
    import sqlalchemy as sa

    sqlalchemy_engine = sa.create_engine("sqlite:///:memory:")
    engine = SQLAlchemyEngine(sqlalchemy_engine)

    connection = engine_to_data_source_connection(
        VariableName("sqlite"), engine
    )
    assert isinstance(connection, DataSourceConnection)

    assert connection.source == "sqlalchemy"
    assert connection.dialect == "sqlite"
    assert connection.name == "sqlite"
    assert connection.display_name == "sqlite (sqlite)"
    assert connection.default_database == ":memory:"
    assert connection.default_schema == "main"

    assert connection.databases == [
        Database(
            name=":memory:",
            dialect="sqlite",
            schemas=[Schema(name="main", tables=[])],
        )
    ]


@pytest.mark.skipif(not HAS_IBIS, reason="Ibis not installed")
def test_get_engines_ibis_databases() -> None:
    import ibis

    ibis_backend = ibis.duckdb.connect()
    engine = IbisEngine(ibis_backend)

    connection = engine_to_data_source_connection(
        VariableName("my_ibis"), engine
    )
    assert isinstance(connection, DataSourceConnection)

    assert connection.source == "ibis"
    assert connection.dialect == "duckdb"
    assert connection.name == "my_ibis"
    assert connection.display_name == "duckdb (my_ibis)"
    assert connection.default_database == "memory"
    assert connection.default_schema == "main"

    assert connection.databases == [
        Database(
            name="memory",
            dialect="duckdb",
            schemas=[Schema(name="main", tables=[])],
        ),
        Database(
            name="system",
            dialect="duckdb",
            schemas=[Schema(name="main", tables=[])],
        ),
        Database(
            name="temp",
            dialect="duckdb",
            schemas=[Schema(name="main", tables=[])],
        ),
    ]


@pytest.mark.skipif(not HAS_CLICKHOUSE, reason="Clickhouse not installed")
@pytest.mark.skip("chdb causes import errors locally")
def test_get_engines_clickhouse() -> None:
    import chdb

    clickhouse_conn = chdb.connect(":memory:")
    engine = ClickhouseEmbedded(
        clickhouse_conn, engine_name=VariableName("clickhouse")
    )
    variable_name = VariableName("clickhouse_conn")

    connection = engine_to_data_source_connection(variable_name, engine)
    assert isinstance(connection, DataSourceConnection)

    assert connection.source == "clickhouse"
    assert connection.dialect == "clickhouse"
    assert connection.name == variable_name
    assert connection.display_name == f"clickhouse ({variable_name})"
    # assert connection.default_database == "default"
    # assert connection.default_schema == "default"
    assert connection.databases == []


@pytest.mark.skipif(
    not HAS_IBIS,
    reason="Ibis not installed",
)
def test_variables_without_datasource_engine() -> None:
    # Ibis Deferred expression object should not be handled as a datasource engine #7791
    import ibis

    deferred_for_test = ibis._["a"]
    variables = [("deferred_for_test", deferred_for_test)]
    engines = get_engines_from_variables(variables)
    assert not engines


def test_fabricated_attributes_not_treated_as_engine() -> None:
    # Catch-all __getattr__ (e.g. ignite metrics) must not match.
    class FabricatingAttributes:
        def __getattr__(self, name: str) -> object:
            def _lazy(*_args: object, **_kwargs: object) -> object:
                return FabricatingAttributes()

            return _lazy

    variables = [(VariableName("metric"), FabricatingAttributes())]
    engines = get_engines_from_variables(variables)
    assert not engines