refactor!: reduce sql-transform to an unimplemented interface

Nuke the SQLTransform implementation entirely. What remains is the class, its
method signatures, defaults and return types -- every body raises
NotImplementedError naming itself.

Deleted: the fit pipeline (_compose, _rewrite, _schema, _sql, _state,
_transformer_ref) and their tests. With them went the last uses of datafusion,
sqlglot and numpy, so those drop out of the package's dependencies -- it now
needs only pyarrow and pydantic, the two types its signatures mention.

Also deleted scripts/gen_datafusion_catalogue.py: datafusion is no longer
installed anywhere in the workspace, so the generator could not run at all.

Moved, not deleted: tests/test_serving_scenarios.py -> packages/confit/tests/.
It is the three-way parity gate (confit == DuckDB == handcrafted twin) and
never touched sql_transform; leaving it behind would have orphaned it in an
empty package.

The replacement tests assert shape, not behaviour: each method still exists
with its exact parameter list, the properties are still properties, and every
one raises. They fail if a method is dropped or renamed, and -- the failure
mode a stub package invites -- if one quietly starts returning something.

confit is untouched: 258 passed + 1 xfailed, cargo 168.
Gate: pytest 270 passed + 1 xfailed, pre-commit clean, uv sync --locked clean.

Author: ahrzb

README.md

@@ -10,11 +10,13 @@ This repository is a workspace of two packages:
 | package | what it is |
 |---|---|
 | [`packages/confit`](packages/confit) | **Confit** — the serving engine. SQL plus static tables frozen at fit time are partially evaluated, once, into a native function. Serves bit-exact with DuckDB or refuses at build time. Usable on its own. |
-| [`packages/sql-transform`](packages/sql-transform) | The authoring layer: `SQLTransform` — fit window-aggregate state from training data, then serve through Confit. |
+| [`packages/sql-transform`](packages/sql-transform) | The authoring surface: `SQLTransform`. **Not implemented** — signatures only, being rebuilt on Confit. |
 
-> **sql-transform was reset.** The DataFusion-differentiated native engine, the
-> Python codegen backend, and the batch `transform()` path were removed; the
-> package is being rebuilt on Confit. Confit itself is unaffected.
+> **sql-transform is a stub.** Its implementation was deliberately removed --
+> the DataFusion engine, the codegen backend, the batch `transform()` path and
+> the fit pipeline are all gone. What remains is the interface, raising
+> `NotImplementedError`, as the contract for a rebuild on Confit.
+> **Confit itself is complete and unaffected.**
 
 ## Installation
 
@@ -45,80 +47,67 @@ uv run pytest -q && cargo test --release
 
 ## Quick Start
 
+Confit, the serving engine, works today:
+
 ```python
 import pyarrow as pa
-from sql_transform import SQLTransform
-
-data = pa.table({
-    "feature1": [1.0, 2.0, 3.0, 4.0, 5.0],
-    "feature2": [10, 20, 30, 40, 50],
-})
-
-# The input table is always referenced as __THIS__.
-sql = """
-SELECT
-    feature1 / MEAN(feature1) OVER () AS feature1_norm,
-    feature2 / SUM(feature2) OVER () AS feature2_share
-FROM __THIS__
-"""
-
-t = SQLTransform(sql)
-t.fit(data)
-
-# Serving: dict or Pydantic model in, typed model out.
-one = t.infer({"feature1": 2.0, "feature2": 20})
-print(one.feature1_norm)
-many = t.infer_batch([{"feature1": 2.0, "feature2": 20}])
+from pydantic import BaseModel
+from confit import DuckDBInferFn
+
+class Row(BaseModel):
+    age: float
+
+fn = DuckDBInferFn(
+    "SELECT (age - 30.0) / 10.0 AS age_z FROM __THIS__",
+    row_tables={"__THIS__": Row},
+    static_tables={},
+    shape="map",
+)
+fn.infer_rows([Row(age=40.0)])          # row objects in, row objects out
+fn.infer_arrow(pa.table({"age": [40.0]}))  # pa.Table in, pa.Table out
 ```
 
-Per-group statistics use `OVER (PARTITION BY ...)` — the group means/counts are
-frozen at `fit` and looked up per row at inference:
-
-```python
-sql = "SELECT target / MEAN(target) OVER (PARTITION BY city) AS enc FROM __THIS__"
-```
+`sql_transform.SQLTransform` is the intended authoring layer on top of it --
+write SQL with window aggregates, `fit()` to freeze them, then serve. It is
+currently **not implemented**; see [packages/sql-transform](packages/sql-transform).
 
 ## Architecture
 
-Two phases, one rewritten query:
+The intended two-phase shape, of which **only the second phase exists today**:
 
 ```
 SQL over __THIS__
       │
       ▼
-   fit(train) ── DataFusion runs the SQL, freezes each window aggregate (e.g.
-      │          MEAN(age)) into a typed __STATE__ table, and rewrites the SQL
-      │          to reference __STATE__ + the raw row __THIS__ instead of
-      │          recomputing aggregates.
+   fit(train) ── freeze each window aggregate (e.g. MEAN(age)) into a typed
+      │          __STATE__ table and rewrite the SQL to reference it instead
+      │          of recomputing.                         [NOT IMPLEMENTED]
       │
       │  rewritten SQL + frozen state
       ▼
-   Confit ── partially evaluates the pair into a native function:
-      │      binding-time analysis collapses every static lookup into a
-      │      prepare-time probe, so nothing general remains at call time.
+   Confit ── partially evaluates the pair into a native function: binding-time
+      │      analysis collapses every static lookup into a prepare-time probe,
+      │      so nothing general remains at call time.             [WORKS]
       ▼
  infer(row) / infer_batch(rows)
 ```
 
-`fit` pays for a real query engine once; serving pays only for straight-line
-native code over the frozen state. Confit's contract carries through: the fitted
-SQL either serves bit-exact with DuckDB, or `fit()` raises and names the
-construct it will not serve — see
-[Confit's known limitations](docs/known-limitations.md).
-
-## What it supports
-
-- **Window aggregates**, computed once at `fit` and frozen: whole-table `OVER ()`
-  and per-group `OVER (PARTITION BY ...)` (`MEAN`, `SUM`, `COUNT`, `STDDEV`, …).
-- **Everything Confit serves** at inference — the expression surface, joins to
-  static tables, and the row-shape contract are documented in
-  [`packages/confit`](packages/confit) and
-  [docs/known-limitations.md](docs/known-limitations.md).
-- **Typed I/O**: Pydantic models for the input row and output, validated when the
-  transform is fitted and again at call time.
-
-Not currently supported, pending the rebuild: batch `transform()`, sklearn
-transformer references, and composing one `SQLTransform` into another.
+Confit's contract: SQL plus frozen tables either specialize into a function
+bit-exact with DuckDB, or construction raises and names the construct it will
+not serve — see [Confit's known limitations](docs/known-limitations.md).
+
+## What Confit supports
+
+The expression surface, joins to static tables, the row-shape contract
+(`map`/`filter`/`many`) and the Arrow boundary are documented in
+[`packages/confit`](packages/confit) and
+[docs/known-limitations.md](docs/known-limitations.md): **550 of 678** statements
+mined from DuckDB's own test suite replay bit-exact, with the remainder clean,
+named build-time rejections.
+
+The authoring layer on top — window-aggregate `fit`, typed I/O, sklearn
+transformer references, and composing one transform into another — is what the
+rebuild has to supply.
 
 ## Reports
 

…ransform/tests/test_serving_scenarios.py …s/confit/tests/test_serving_scenarios.pypackages/sql-transform/tests/test_serving_scenarios.py renamed to packages/confit/tests/test_serving_scenarios.py packages/sql-transform/tests/test_serving_scenarios.py renamed to packages/confit/tests/test_serving_scenarios.py

@@ -1,21 +1,29 @@
 # sql-transform
 
-SQL feature transforms, fitted once and served by [Confit](../confit).
+The authoring surface for SQL feature transforms — **not implemented**.
 
 ```python
 from sql_transform import SQLTransform
 
-t = SQLTransform("SELECT (age - avg(age) OVER ()) AS age_c FROM __THIS__")
-t.fit(train_table)
-t.infer({"age": 40})
+t = SQLTransform(sql)   # NotImplementedError
 ```
 
-`fit()` runs the SQL over training data to freeze each window aggregate into a
-static table, rewrites the SQL into plain-column form, and hands the pair to
-Confit, which partially evaluates them into a native serving function.
+Every method raises `NotImplementedError`. The signatures, defaults and return
+types are all that remain, and they are the contract a rebuild has to satisfy:
 
-**This package was reset.** The DataFusion-differentiated native engine, the
-Python codegen backend, and the batch `transform()` path have been removed; what
-remains is the fit-and-serve path built on Confit. Composing one transform into
-another (`t"... {other}(col) ..."`) is kept as a surface but refuses by name
-until it is rebuilt.
+| method | intended behaviour |
+|---|---|
+| `SQLTransform(sql)` | accept SQL (or a t-string) over `__THIS__` |
+| `from_file(path)` | same, read from a file |
+| `fit(table, this_model=None)` | freeze window-aggregate state into static tables, rewrite the SQL to reference them, specialize via Confit; returns self |
+| `infer(row)` / `infer_batch(rows)` | serve rows through the specialized function |
+| `backend` / `boundary` | report which engine and boundary the fitted function uses |
+
+The serving half already exists and is unaffected: [Confit](../confit) takes SQL
+plus frozen static tables and partially evaluates them into a native function,
+bit-exact with DuckDB or refusing at build time. What was removed here is the
+fit half, the DataFusion batch engine, the codegen backend, and transform
+composition.
+
+Tests in this package assert only that the surface exists and refuses honestly —
+they fail if a method is dropped, renamed, or quietly starts returning something.

packages/sql-transform/README.md

@@ -1,23 +1,16 @@
 [project]
 name = "sql-transform"
 version = "0.1.0"
-description = "SQL feature transforms, fitted once and served by Confit"
+description = "SQL feature transforms — authoring surface, being rebuilt on Confit"
 readme = "README.md"
 requires-python = ">=3.14"
+# Only what the surface itself references. The fit-time engine (datafusion,
+# sqlglot, numpy) went with the implementation; add back what the rebuild needs.
 dependencies = [
-    "confit",
-    "datafusion>=46.0.0",
-    "numpy>=2.0",
     "pyarrow>=19.0",
     "pydantic>=2.0,<3.0",
-    "sqlglot>=30.12.0",
 ]
 
-[tool.uv.sources]
-confit = { workspace = true }
-
-# Pure Python: the native engine is confit's. This package fits state and
-# hands the pair to it.
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -27,7 +20,4 @@ packages = ["sql_transform"]
 
 [tool.pytest.ini_options]
 python_files = ["*_test.py", "test_*.py"]
-# The repo-root `benchmarks` package carries the shared serving-scenario
-# parity fixtures used by these tests.
-pythonpath = ["../.."]
-testpaths = ["tests", "sql_transform"]
+testpaths = ["sql_transform"]

packages/sql-transform/pyproject.toml

@@ -1,17 +1,11 @@
-"""SQLTransform — SQL feature transforms, fitted once and served by Confit.
+"""SQLTransform — the authoring surface, awaiting reimplementation.
 
-Author the transform as SQL, `fit()` it against training data to freeze the
-window-aggregate state into static tables, then serve it row-at-a-time:
+Every method raises `NotImplementedError`. The signatures are the contract a
+rebuild has to satisfy; the previous implementation (a DataFusion batch engine,
+a codegen backend, and transform composition) was deleted deliberately.
 
-    t = SQLTransform("SELECT (age - avg(age) OVER ()) AS age_c FROM __THIS__")
-    t.fit(train_table)
-    t.infer({"age": 40})
-
-`fit()` hands the rewritten SQL and the frozen tables to Confit
-(`packages/confit`), which partially evaluates the pair into a native
-function. Confit's contract carries through: the fitted SQL either serves
-bit-exact with DuckDB, or `fit()` raises and names the construct it will not
-serve.
+The serving half already exists and is unaffected: confit takes SQL plus static
+tables frozen at fit time and partially evaluates them into a native function.
 """
 
 from __future__ import annotations