fix(python): update custom reader tests to use DuckDB backend

The execution pipeline now generates SQL with column renames
(e.g., SELECT x AS "__ggsql_aes_x__") that custom readers must
execute. Static readers returning hardcoded DataFrames no longer
work. Updated test readers to use in-memory DuckDB connections
so they properly execute the SQL they receive.

Added duckdb and pyarrow as test dependencies.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: cpsievert

ggsql-python/pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-test = ["pytest>=7.0"]
+test = ["pytest>=7.0", "duckdb>=1.0", "pyarrow>=14.0"]
 dev = ["maturin>=1.4"]
 
 [tool.maturin]
@@ -31,6 +31,8 @@ module-name = "ggsql._ggsql"
 
 [dependency-groups]
 dev = [
+    "duckdb>=1.4.4",
     "maturin>=1.11.5",
+    "pyarrow>=23.0.1",
     "pytest>=9.0.2",
 ]

ggsql-python/tests/test_ggsql.py

@@ -10,6 +10,7 @@
 
 import json
 
+import duckdb
 import pytest
 import polars as pl
 import altair
@@ -399,8 +400,16 @@ def test_simple_custom_reader(self):
         """Custom reader with execute_sql() method works."""
 
         class SimpleReader:
+            def __init__(self):
+                self.conn = duckdb.connect()
+                self.conn.execute(
+                    "CREATE TABLE data AS SELECT * FROM ("
+                    "VALUES (1, 10), (2, 20), (3, 30)"
+                    ") AS t(x, y)"
+                )
+
             def execute_sql(self, sql: str) -> pl.DataFrame:
-                return pl.DataFrame({"x": [1, 2, 3], "y": [10, 20, 30]})
+                return self.conn.execute(sql).pl()
 
         reader = SimpleReader()
         spec = ggsql.execute("SELECT * FROM data VISUALISE x, y DRAW point", reader)
@@ -411,19 +420,16 @@ def test_custom_reader_with_register(self):
 
         class RegisterReader:
             def __init__(self):
-                self.tables = {}
+                self.conn = duckdb.connect()
 
             def execute_sql(self, sql: str) -> pl.DataFrame:
-                # Simple: just return the first registered table
-                if self.tables:
-                    return next(iter(self.tables.values()))
-                return pl.DataFrame({"x": [1], "y": [2]})
+                return self.conn.execute(sql).pl()
 
             def supports_register(self) -> bool:
                 return True
 
             def register(self, name: str, df: pl.DataFrame) -> None:
-                self.tables[name] = df
+                self.conn.register(name, df)
 
         reader = RegisterReader()
         spec = ggsql.execute("SELECT 1 AS x, 2 AS y VISUALISE x, y DRAW point", reader)
@@ -460,17 +466,20 @@ def test_native_reader_fast_path(self):
     def test_custom_reader_can_render(self):
         """Custom reader result can be rendered to Vega-Lite."""
 
-        class StaticReader:
-            def execute_sql(self, sql: str) -> pl.DataFrame:
-                return pl.DataFrame(
-                    {
-                        "x": [1, 2, 3, 4, 5],
-                        "y": [10, 40, 20, 50, 30],
-                        "category": ["A", "B", "A", "B", "A"],
-                    }
+        class DuckDBReader:
+            def __init__(self):
+                self.conn = duckdb.connect()
+                self.conn.execute(
+                    "CREATE TABLE data AS SELECT * FROM ("
+                    "VALUES (1, 10, 'A'), (2, 40, 'B'), (3, 20, 'A'), "
+                    "(4, 50, 'B'), (5, 30, 'A')"
+                    ") AS t(x, y, category)"
                 )
 
-        reader = StaticReader()
+            def execute_sql(self, sql: str) -> pl.DataFrame:
+                return self.conn.execute(sql).pl()
+
+        reader = DuckDBReader()
         spec = ggsql.execute(
             "SELECT * FROM data VISUALISE x, y, category AS color DRAW point",
             reader,
@@ -488,11 +497,16 @@ def test_custom_reader_execute_sql_called(self):
 
         class RecordingReader:
             def __init__(self):
+                self.conn = duckdb.connect()
+                self.conn.execute(
+                    "CREATE TABLE data AS SELECT * FROM ("
+                    "VALUES (1, 2)) AS t(x, y)"
+                )
                 self.execute_calls = []
 
             def execute_sql(self, sql: str) -> pl.DataFrame:
                 self.execute_calls.append(sql)
-                return pl.DataFrame({"x": [1], "y": [2]})
+                return self.conn.execute(sql).pl()
 
         reader = RecordingReader()
         ggsql.execute(