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.

skip chdb (embedded clickhouse) tests as they error locally (#6663)

Shahmir Varqhaf94aaf6b57d3
diff --git a/tests/_sql/test_clickhouse.py b/tests/_sql/test_clickhouse.py
index 5879779672..dc06d872d6 100644
--- a/tests/_sql/test_clickhouse.py
+++ b/tests/_sql/test_clickhouse.py
@@ -37,120 +37,126 @@ def test_clickhouse_server_creation() -> None:
assert connection.source == "clickhouse"
[email protected](not HAS_CHDB, reason="chdb not installed")
-def test_clickhouse_embedded_creation() -> None:
- import chdb
-
- chdb_conn = chdb.connect(":memory:")
- engine = ClickhouseEmbedded(
- connection=chdb_conn, engine_name="clickhouse_embedded"
- )
- assert engine.dialect == "clickhouse"
- assert engine._engine_name == "clickhouse_embedded"
-
- connection = engine_to_data_source_connection("clickhouse", engine=engine)
- assert isinstance(connection, DataSourceConnection)
-
- assert connection.databases == []
- # assert connection.default_database == "default"
- # assert connection.default_schema == "default"
- assert connection.display_name == "clickhouse (clickhouse)"
- assert connection.dialect == "clickhouse"
- assert connection.name == "clickhouse"
- assert connection.source == "clickhouse"
-
- assert isinstance(engine, ClickhouseEmbedded)
- assert isinstance(engine, EngineCatalog)
- assert isinstance(engine, QueryEngine)
-
- chdb_conn.close()
-
-
@pytest.mark.skipif(
- not HAS_CHDB and not HAS_POLARS, reason="chdb and polars not installed"
+ not HAS_CHDB and not HAS_POLARS and not HAS_PANDAS,
+ reason="chdb, polars, and pandas not installed",
)
-def test_clickhouse_embedded_execute() -> None:
- import chdb
- import polars as pl
[email protected]("chdb is too slow to run")
+class TestClickhouseEmbedded:
+ def test_clickhouse_embedded_creation(self) -> None:
+ import chdb
- chdb_conn = None
- try:
chdb_conn = chdb.connect(":memory:")
-
- sql(
- "CREATE TABLE test (id Int32, name String) ENGINE = Memory",
- engine=chdb_conn,
+ engine = ClickhouseEmbedded(
+ connection=chdb_conn, engine_name="clickhouse_embedded"
)
- sql(
- "INSERT INTO test VALUES (1, 'Alice'), (2, 'Bob')",
- engine=chdb_conn,
+ assert engine.dialect == "clickhouse"
+ assert engine._engine_name == "clickhouse_embedded"
+
+ connection = engine_to_data_source_connection(
+ "clickhouse", engine=engine
)
- result = sql("SELECT * FROM test", engine=chdb_conn)
+ assert isinstance(connection, DataSourceConnection)
- assert isinstance(result, pl.DataFrame)
- expected = pl.DataFrame({"id": [1, 2], "name": ["Alice", "Bob"]})
- assert result.equals(expected)
- finally:
- if chdb_conn is not None:
- chdb_conn.close()
+ assert connection.databases == []
+ # assert connection.default_database == "default"
+ # assert connection.default_schema == "default"
+ assert connection.display_name == "clickhouse (clickhouse)"
+ assert connection.dialect == "clickhouse"
+ assert connection.name == "clickhouse"
+ assert connection.source == "clickhouse"
+ assert isinstance(engine, ClickhouseEmbedded)
+ assert isinstance(engine, EngineCatalog)
+ assert isinstance(engine, QueryEngine)
- not HAS_CHDB and not HAS_POLARS and not HAS_PANDAS,
- reason="chdb, polars, and pandas not installed",
-)
-def test_clickhouse_emdbedded_connection_based_output_formats() -> None:
- import chdb
- import pandas as pd
- import polars as pl
-
- # Test different output formats
- output_formats: tuple[SqlOutputType, Any, Any] = [
- ("native", None, None),
- ("polars", pl.DataFrame, pl.DataFrame({"1": [1], "2": [2]})),
- ("lazy-polars", pl.LazyFrame, None),
- ("pandas", pd.DataFrame, pd.DataFrame({"1": [1], "2": [2]})),
- ("auto", pl.DataFrame, pl.DataFrame({"1": [1]})),
- ]
-
- for format_name, expected_type, expected_result in output_formats:
- with mock.patch.object(
- ClickhouseEmbedded, "sql_output_format", return_value=format_name
- ):
- chdb_conn = None
- try:
- chdb_conn = chdb.connect(":memory:")
- query = "SELECT 1, 2" if format_name != "auto" else "SELECT 1"
- if format_name == "lazy-polars":
- query = "SELECT 1, 2 FROM generate_series(1, 2)"
-
- result = sql(query, engine=chdb_conn)
-
- if format_name == "native":
- assert result is None
- else:
- assert isinstance(result, expected_type)
- if expected_result is not None:
- assert result.equals(expected_result)
- if format_name == "lazy-polars":
- assert len(result.collect()) == 2
- finally:
- if chdb_conn is not None:
- chdb_conn.close()
+ chdb_conn.close()
+
+ def test_clickhouse_embedded_execute(self) -> None:
+ import chdb
+ import polars as pl
- # Test auto when polars not available
- with (
- mock.patch.object(
- ClickhouseEmbedded, "sql_output_format", return_value="auto"
- ),
- mock.patch.object(DependencyManager.polars, "has", return_value=False),
- ):
chdb_conn = None
try:
chdb_conn = chdb.connect(":memory:")
- result = sql("SELECT 1", engine=chdb_conn)
- assert isinstance(result, pd.DataFrame)
- assert result.equals(pd.DataFrame({"1": [1]}))
+
+ sql(
+ "CREATE TABLE test (id Int32, name String) ENGINE = Memory",
+ engine=chdb_conn,
+ )
+ sql(
+ "INSERT INTO test VALUES (1, 'Alice'), (2, 'Bob')",
+ engine=chdb_conn,
+ )
+ result = sql("SELECT * FROM test", engine=chdb_conn)
+
+ assert isinstance(result, pl.DataFrame)
+ expected = pl.DataFrame({"id": [1, 2], "name": ["Alice", "Bob"]})
+ assert result.equals(expected)
finally:
if chdb_conn is not None:
chdb_conn.close()
+
+ def test_clickhouse_emdbedded_connection_based_output_formats(
+ self,
+ ) -> None:
+ import chdb
+ import pandas as pd
+ import polars as pl
+
+ # Test different output formats
+ output_formats: tuple[SqlOutputType, Any, Any] = [
+ ("native", None, None),
+ ("polars", pl.DataFrame, pl.DataFrame({"1": [1], "2": [2]})),
+ ("lazy-polars", pl.LazyFrame, None),
+ ("pandas", pd.DataFrame, pd.DataFrame({"1": [1], "2": [2]})),
+ ("auto", pl.DataFrame, pl.DataFrame({"1": [1]})),
+ ]
+
+ for format_name, expected_type, expected_result in output_formats:
+ with mock.patch.object(
+ ClickhouseEmbedded,
+ "sql_output_format",
+ return_value=format_name,
+ ):
+ chdb_conn = None
+ try:
+ chdb_conn = chdb.connect(":memory:")
+ query = (
+ "SELECT 1, 2" if format_name != "auto" else "SELECT 1"
+ )
+ if format_name == "lazy-polars":
+ query = "SELECT 1, 2 FROM generate_series(1, 2)"
+
+ result = sql(query, engine=chdb_conn)
+
+ if format_name == "native":
+ assert result is None
+ else:
+ assert isinstance(result, expected_type)
+ if expected_result is not None:
+ assert result.equals(expected_result)
+ if format_name == "lazy-polars":
+ assert len(result.collect()) == 2
+ finally:
+ if chdb_conn is not None:
+ chdb_conn.close()
+
+ # Test auto when polars not available
+ with (
+ mock.patch.object(
+ ClickhouseEmbedded, "sql_output_format", return_value="auto"
+ ),
+ mock.patch.object(
+ DependencyManager.polars, "has", return_value=False
+ ),
+ ):
+ chdb_conn = None
+ try:
+ chdb_conn = chdb.connect(":memory:")
+ result = sql("SELECT 1", engine=chdb_conn)
+ assert isinstance(result, pd.DataFrame)
+ assert result.equals(pd.DataFrame({"1": [1]}))
+ finally:
+ if chdb_conn is not None:
+ chdb_conn.close()
diff --git a/tests/_sql/test_engines.py b/tests/_sql/test_engines.py
index 44a2ebbe60..a470a38862 100644
--- a/tests/_sql/test_engines.py
+++ b/tests/_sql/test_engines.py
@@ -50,39 +50,45 @@ def test_raise_df_import_error() -> None:
@pytest.mark.skipif(
- not (HAS_DUCKDB and HAS_SQLALCHEMY and HAS_CLICKHOUSE),
+ not (HAS_DUCKDB and HAS_SQLALCHEMY),
reason="Duckdb, sqlalchemy, and Clickhouse not installed",
)
def test_engine_name_initialization() -> None:
"""Test engine name initialization."""
- import chdb
import duckdb
import sqlalchemy as sa
duckdb_conn = duckdb.connect(":memory:")
sqlite_engine = sa.create_engine("sqlite:///:memory:")
- clickhouse_conn = chdb.connect(":memory:")
duck_engine = DuckDBEngine(duckdb_conn, engine_name="my_duck")
sql_engine = SQLAlchemyEngine(sqlite_engine, engine_name="my_sql")
- clickhouse_engine = SQLAlchemyEngine(
- clickhouse_conn, engine_name="my_clickhouse"
- )
assert duck_engine._engine_name == "my_duck"
assert sql_engine._engine_name == "my_sql"
- assert clickhouse_engine._engine_name == "my_clickhouse"
# Test default names
duck_engine_default = DuckDBEngine(duckdb_conn)
sql_engine_default = SQLAlchemyEngine(sqlite_engine)
- clickhouse_engine_default = ClickhouseEmbedded(clickhouse_conn)
assert duck_engine_default._engine_name is None
assert sql_engine_default._engine_name is None
- assert clickhouse_engine_default._engine_name is None
duckdb_conn.close()
+
+
[email protected](not HAS_CLICKHOUSE, reason="Clickhouse not installed")
[email protected]("chdb is flakey")
+def test_clickhouse_engine_name_initialization() -> None:
+ """Test ClickhouseEngine engine name initialization."""
+ import chdb
+
+ clickhouse_conn = chdb.connect(":memory:")
+ engine = ClickhouseEmbedded(clickhouse_conn, engine_name="my_clickhouse")
+ assert engine._engine_name == "my_clickhouse"
+
+ clickhouse_engine_default = ClickhouseEmbedded(clickhouse_conn)
+ assert clickhouse_engine_default._engine_name is None
clickhouse_conn.close()
diff --git a/tests/_sql/test_get_engines.py b/tests/_sql/test_get_engines.py
index 6c71cb8e69..105552f6a3 100644
--- a/tests/_sql/test_get_engines.py
+++ b/tests/_sql/test_get_engines.py
@@ -144,6 +144,7 @@ def test_get_engines_from_variables_import_module_type():
@pytest.mark.skipif(not HAS_CLICKHOUSE, reason="Clickhouse not installed")
[email protected]("chdb causes import errors locally")
def test_get_engines_from_variables_clickhouse():
import chdb
@@ -220,27 +221,24 @@ def test_get_engines_from_variables_mixed():
reason="SQLAlchemy, Clickhouse, Ibis, or DuckDB not installed",
)
def test_get_engines_from_variables_multiple():
- import chdb
import duckdb
import ibis
import sqlalchemy as sa
mock_duckdb_conn = MagicMock(spec=duckdb.DuckDBPyConnection)
- mock_clickhouse = MagicMock(spec=chdb.state.sqlitelike.Connection)
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),
- ("clickhouse_conn", mock_clickhouse),
("ibis_backend", ibis_backend),
("not_an_engine", "some string"),
]
engines = get_engines_from_variables(variables)
- assert len(engines) == 4
+ assert len(engines) == 3
# Check SQLAlchemy engine
sa_var_name, _sa_engine = next(
@@ -256,15 +254,6 @@ def test_get_engines_from_variables_multiple():
)
assert duckdb_var_name == "duckdb_conn"
- # Check Clickhouse engine
- ch_var_name, _ch_engine = next(
- (name, eng)
- for name, eng in engines
- if isinstance(eng, ClickhouseEmbedded)
- )
- assert ch_var_name == "clickhouse_conn"
-
- # Check Clickhouse engine
ibis_var_name, _ibis_engine = next(
(name, eng) for name, eng in engines if isinstance(eng, IbisEngine)
)
@@ -412,6 +401,7 @@ def test_get_engines_ibis_databases() -> None:
@pytest.mark.skipif(not HAS_CLICKHOUSE, reason="Clickhouse not installed")
[email protected]("chdb causes import errors locally")
def test_get_engines_clickhouse() -> None:
import chdb