cellproof 0.2.0__py3-none-any.whl

cellproof/emitter.py

@@ -0,0 +1,160 @@
+"""Write the compiled workbook as a dbt project (DuckDB profile included).
+
+The models run the SQL the verifier ran: seed input_cells -> cellproof_cells/cells_0001 -> ... Each batch model
+holds only its own rows; a checkpoint model (cp_NNNN) unions everything every 64 batches and after the last
+batch, so no model reads more than ~65 sources. workbook_cells keeps the formula cells only.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from cellproof.compiler import Compiled, Step, render_batch, write_seed
+from cellproof.expr import CELLS
+from cellproof.region import WIDE
+from cellproof.model import Book
+
+PROJECT = """name: {name}
+version: "1.0.0"
+config-version: 2
+profile: cellproof
+flags:
+  send_anonymous_usage_stats: false
+seeds:
+  {name}:
+    +column_types:
+      sheet: varchar
+      row_num: integer
+      col_num: integer
+      kind: varchar
+      num: double
+      txt: varchar
+models:
+  {name}:
+    +materialized: table
+"""
+
+PROFILES = """cellproof:
+  target: dev
+  outputs:
+    dev:
+      type: duckdb
+      path: cellproof.duckdb
+"""
+
+SCHEMA = """version: 2
+models:
+  - name: workbook_cells
+    description: "Every formula cell of the workbook, recomputed in SQL. One row per cell."
+    columns:
+      - name: sheet
+        data_tests: [not_null]
+      - name: row_num
+        data_tests: [not_null]
+      - name: col_num
+        data_tests: [not_null]
+"""
+
+
+def project_name(stem: str) -> str:
+    name = re.sub(r"[^A-Za-z0-9]+", "_", stem).strip("_").lower() or "workbook"
+    return f"wb_{name}" if name[0].isdigit() else name
+
+
+def model_name(k: int) -> str:
+    return f"cells_{k:04d}"
+
+
+CHECKPOINT = 64  # a model reads the latest checkpoint plus at most this many batch models
+
+
+def checkpoint_name(k: int) -> str:
+    return f"cp_{k:04d}"
+
+
+def sources_for(k: int) -> list[str]:
+    """Models whose union is every cell known before batch k (1-based): latest checkpoint, then later batches."""
+    base = (k - 1) // CHECKPOINT * CHECKPOINT
+    first = "input_cells" if base == 0 else checkpoint_name(base)
+    return [first] + [model_name(i) for i in range(base + 1, k)]
+
+
+def _union(models: list[str]) -> str:
+    return "\nUNION ALL\n".join("SELECT * FROM {{ ref('" + m + "') }}" for m in models)
+
+
+def _escape(sql: str) -> str:
+    """Braces from workbook text are escaped so Jinja renders them literally."""
+    return re.sub(r"[{}]", lambda m: "{{ '" + m.group() + "' }}", sql)
+
+
+def dbt_sql(steps: list[Step], sources: list[str]) -> str:
+    """One batch as a dbt model: the new rows only, reading all earlier cells through the CTE all_cells."""
+    body = _escape(render_batch(steps, "all_cells", own_only=True))
+    return body.replace("WITH\n", f"WITH\nall_cells AS (\n{_union(sources)}\n),\n", 1)
+
+
+def dbt_region_wide(batch, sources: list[str]) -> str:
+    """The wide, readable model of a region: it reads every earlier cell through the CTE all_cells."""
+    body = _escape(batch.wide_sql.replace(CELLS, "all_cells"))
+    return body.replace("WITH\n", f"WITH\nall_cells AS (\n{_union(sources)}\n),\n", 1)
+
+
+def dbt_region_cells(batch) -> str:
+    """The long rows of a region: a mechanical unpivot of its wide model."""
+    return _escape(batch.unpivot(WIDE)).replace(WIDE, "{{ ref('" + batch.model + "') }}")
+
+
+def final_sql(last: str) -> str:
+    """The formula cells: every row of the last batch that is not an input."""
+    return ("SELECT c.* FROM {{ ref('" + last + "') }} AS c\nWHERE NOT EXISTS (\n"
+            "  SELECT 1 FROM {{ ref('input_cells') }} AS i\n"
+            "  WHERE i.sheet = c.sheet AND i.row_num = c.row_num AND i.col_num = c.col_num\n)")
+
+
+def write_project(book: Book, compiled: Compiled, out: Path, stem: str) -> None:
+    name = project_name(stem)
+    batches_dir = out / "models" / "cellproof_cells"
+    (out / "seeds").mkdir(parents=True, exist_ok=True)
+    batches_dir.mkdir(parents=True, exist_ok=True)
+    for old in batches_dir.glob("*.sql"):  # a rerun must not leave batches or checkpoints from a bigger workbook
+        old.unlink()
+    (out / "dbt_project.yml").write_text(PROJECT.format(name=name), encoding="utf-8")
+    (out / "profiles.yml").write_text(PROFILES, encoding="utf-8")
+    write_seed(book, out / "seeds" / "input_cells.csv")
+    n = len(compiled.batches)
+    last = "input_cells"
+    schema = SCHEMA
+    used: set[str] = set()
+    for k, batch in enumerate(compiled.batches, 1):
+        if hasattr(batch, "wide_sql"):
+            base, i = batch.model, 1
+            while batch.model in used:  # sheet names that slug alike must not share a model
+                i += 1
+                batch.model = f"{base}_{i}"
+            used.add(batch.model)
+            (batches_dir / f"{batch.model}.sql").write_text(dbt_region_wide(batch, sources_for(k)) + "\n", encoding="utf-8")
+            (batches_dir / f"{model_name(k)}.sql").write_text(dbt_region_cells(batch) + "\n", encoding="utf-8")
+            schema += (f'  - name: {batch.model}\n    description: "Region: rows of one sheet that repeat one formula down their rows, '
+                       f'computed in one statement. Wide and readable; its {model_name(k)} twin holds the same values as long rows."\n')
+        else:
+            (batches_dir / f"{model_name(k)}.sql").write_text(dbt_sql(batch, sources_for(k)) + "\n", encoding="utf-8")
+        if k % CHECKPOINT == 0 or k == n:
+            last = checkpoint_name(k)
+            (batches_dir / f"{last}.sql").write_text(_union(sources_for(k) + [model_name(k)]) + "\n", encoding="utf-8")
+    (out / "models" / "workbook_cells.sql").write_text(final_sql(last) + "\n", encoding="utf-8")
+    (out / "models" / "schema.yml").write_text(schema, encoding="utf-8")
+
+
+def run_dbt(out: Path) -> tuple[bool, str]:
+    """End-to-end check: dbt seeds the inputs and builds the models on DuckDB."""
+    exe = shutil.which("dbt")
+    if exe is None:
+        return False, "dbt is not installed - run: pip install cellproof[dbt]"
+    env = {**os.environ, "DBT_SEND_ANONYMOUS_USAGE_STATS": "False"}  # dbt phones home by default; cellproof never does
+    proc = subprocess.run([exe, "build", "--project-dir", str(out), "--profiles-dir", str(out)],
+                          capture_output=True, text=True, cwd=out, env=env)
+    return proc.returncode == 0, (proc.stdout + proc.stderr)[-4000:]

cellproof/expr.py

@@ -0,0 +1,233 @@
+"""Typed SQL expressions, Excel-style type coercion and Excel error codes."""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Literal
+
+from cellproof.model import Key, Unsupported
+
+CELLS = "__cellproof_cells__"  # every cell known before the current batch; replaced when SQL is rendered
+NO_ERR = "NULL"  # the err of an expression that cannot fail
+Type = Literal["num", "txt", "bool", "blank", "err", "any"]
+
+
+@dataclass(frozen=True)
+class Expr:
+    sql: str  # the value; for "any" its number part (numbers, TRUE/FALSE as 1/0); meaningless when err is set
+    type: Type
+    err: str = NO_ERR  # SQL giving the Excel error code ('#DIV/0!') or NULL
+    txt: str = "NULL"  # "any" only: the text part
+    kind: str = "NULL"  # "any" only: SQL giving 'n', 's' or 'b' - the value's type, known only when the SQL runs
+
+
+ZERO = Expr("CAST(0 AS DOUBLE)", "num")
+BLANK = Expr("NULL", "blank")  # an empty cell; always coerced before use, never rendered raw
+
+
+def lit_num(v: float) -> Expr:
+    if not math.isfinite(v):  # 1E+400 in a crafted file: Excel's limit is about 1.8E+308
+        raise Unsupported(f"number {v!r} is beyond Excel's range")
+    return Expr(f"CAST({v!r} AS DOUBLE)", "num")  # bare literals would be DECIMAL in DuckDB
+
+
+def lit_str(v: str) -> Expr:
+    return Expr("'" + v.replace("'", "''") + "'", "txt")
+
+
+def error(code: str) -> Expr:
+    """A value that is always this Excel error."""
+    return Expr("NULL", "err", lit_str(code).sql)
+
+
+def errs(*parts: str) -> str:
+    """Excel reports the first error it meets, left to right."""
+    live = [p for p in parts if p != NO_ERR]
+    if not live:
+        return NO_ERR
+    return live[0] if len(live) == 1 else f"COALESCE({', '.join(live)})"
+
+
+def any_of(kind: str, num_sql: str, txt_sql: str, err: str = NO_ERR) -> Expr:
+    return Expr(num_sql, "any", err, txt_sql, kind)
+
+
+def parse_num(t: str) -> str:
+    """Text -> number the way Excel's arithmetic reads it (' 3 ', '-1.5e3'), else NULL. 'inf', '1,000' -> NULL."""
+    return (f"(CASE WHEN regexp_matches(trim({t}), '^[+-]?([0-9]+[.]?[0-9]*|[.][0-9]+)([eE][+-]?[0-9]+)?$') "
+            f"THEN CAST(trim({t}) AS DOUBLE) END)")
+
+
+# Real Excel writes 1E-11 ... 1E+19 as plain digits (20 digits for 1E+19) and 1E+20 and up as 1E+20.
+# ponytail: PLAIN_FROM is only known to be <= -11; nothing smaller has been tried in real Excel yet.
+PLAIN_FROM, PLAIN_TO = -11, 19
+
+
+def num_text(x: str) -> str:
+    """Number -> text the way Excel writes it in a formula: up to 15 significant digits (0.1+0.2 -> '0.3')."""
+    digits = "rtrim(replace(split_part(s, 'e', 1), '.', ''), '0')"  # the 15 significant digits, no trailing zeros
+    plain = ("CASE WHEN e >= 0 THEN (CASE WHEN length(d) <= e + 1 THEN d || repeat('0', e + 1 - length(d)) "
+             "ELSE substr(d, 1, e + 1) || '.' || substr(d, e + 2) END) "
+             "ELSE '0.' || repeat('0', -e - 1) || d END")
+    return (f"(SELECT CASE WHEN v = 0 THEN '0' "
+            f"WHEN e IS NULL OR e < {PLAIN_FROM} OR e > {PLAIN_TO} THEN upper(printf('%.15g', v)) "
+            f"ELSE (CASE WHEN v < 0 THEN '-' ELSE '' END) || ({plain}) END "
+            f"FROM (SELECT v, {digits} AS d, TRY_CAST(split_part(s, 'e', 2) AS INTEGER) AS e "
+            f"FROM (SELECT v, printf('%.14e', abs(v)) AS s FROM (SELECT {x} AS v))))")
+
+
+def _value_error(bad: str) -> str:
+    return f"(CASE WHEN {bad} THEN '#VALUE!' END)"
+
+
+def num(e: Expr) -> Expr:
+    if e.type == "num":
+        return e
+    if e.type == "blank":
+        return ZERO
+    if e.type == "bool":
+        return Expr(f"CAST({e.sql} AS DOUBLE)", "num", e.err)
+    if e.type == "err":
+        return Expr("CAST(NULL AS DOUBLE)", "num", e.err)
+    if e.type == "txt":
+        n = parse_num(e.sql)
+        return Expr(n, "num", errs(e.err, _value_error(f"{n} IS NULL")))
+    n = parse_num(e.txt)
+    return Expr(f"(CASE WHEN {e.kind} = 's' THEN {n} ELSE {e.sql} END)", "num",
+                errs(e.err, _value_error(f"{e.kind} = 's' AND {n} IS NULL")))
+
+
+def _bool_text(b: str) -> str:
+    return f"(CASE WHEN {b} THEN 'TRUE' ELSE 'FALSE' END)"
+
+
+def txt(e: Expr) -> Expr:
+    if e.type == "txt":
+        return e
+    if e.type == "blank":
+        return Expr("''", "txt")
+    if e.type == "err":
+        return Expr("CAST(NULL AS VARCHAR)", "txt", e.err)
+    if e.type == "num":
+        return Expr(num_text(e.sql), "txt", e.err)
+    if e.type == "bool":
+        return Expr(_bool_text(e.sql), "txt", e.err)
+    return Expr(f"(CASE {e.kind} WHEN 's' THEN {e.txt} WHEN 'b' THEN {_bool_text(f'{e.sql} <> 0')} "
+                f"ELSE {num_text(e.sql)} END)", "txt", e.err)
+
+
+def _text_bool(t: str) -> str:
+    return f"(CASE upper({t}) WHEN 'TRUE' THEN TRUE WHEN 'FALSE' THEN FALSE END)"
+
+
+def as_bool(e: Expr) -> Expr:
+    if e.type == "bool":
+        return e
+    if e.type == "blank":
+        return Expr("FALSE", "bool")
+    if e.type == "num":
+        return Expr(f"({e.sql} <> 0)", "bool", e.err)
+    if e.type == "err":
+        return Expr("CAST(NULL AS BOOLEAN)", "bool", e.err)
+    if e.type == "txt":
+        b = _text_bool(e.sql)
+        return Expr(b, "bool", errs(e.err, _value_error(f"{b} IS NULL")))
+    b = _text_bool(e.txt)
+    return Expr(f"(CASE WHEN {e.kind} = 's' THEN {b} ELSE {e.sql} <> 0 END)", "bool",
+                errs(e.err, _value_error(f"{e.kind} = 's' AND {b} IS NULL")))
+
+
+def as_any(e: Expr) -> Expr:
+    """Any value as the run-time-typed form."""
+    if e.type == "any":
+        return e
+    if e.type in ("blank", "num"):
+        e = num(e)
+        return any_of("'n'", e.sql, "CAST(NULL AS VARCHAR)", e.err)
+    if e.type == "txt":
+        return any_of("'s'", "CAST(NULL AS DOUBLE)", e.sql, e.err)
+    if e.type == "bool":
+        return any_of("'b'", f"CAST({e.sql} AS DOUBLE)", "CAST(NULL AS VARCHAR)", e.err)
+    return any_of("'n'", "CAST(NULL AS DOUBLE)", "CAST(NULL AS VARCHAR)", e.err)  # err
+
+
+COERCE = {"num": num, "txt": txt, "bool": as_bool, "any": as_any}
+FLEX = ("blank", "err")  # types that take on the other side's type
+
+
+def unify(a: Expr, b: Expr) -> tuple[Expr, Expr]:
+    """Give two results one type (IF branches, IFERROR). Different types become 'any', as in Excel."""
+    return tuple(unify_all([a, b]))
+
+
+def unify_all(es: list[Expr]) -> list[Expr]:
+    fixed = {e.type for e in es} - set(FLEX)
+    if not fixed:
+        return [num(e) for e in es]
+    target = fixed.pop() if len(fixed) == 1 else "any"
+    return [COERCE[target](e) for e in es]
+
+
+def pick(cond: str, yes: Expr, no: Expr, err: str = NO_ERR) -> Expr:
+    """CASE WHEN cond THEN yes ELSE no, for two results of one type (see unify), keeping every part."""
+    def case(a: str, b: str) -> str:
+        return a if a == b else f"(CASE WHEN {cond} THEN {a} ELSE {b} END)"
+    return Expr(case(yes.sql, no.sql), yes.type, err, case(yes.txt, no.txt), case(yes.kind, no.kind))
+
+
+RANK = {"num": 0, "txt": 1, "bool": 2}  # Excel orders numbers < text < TRUE/FALSE across types
+
+
+def _rank(kind: str) -> str:
+    return f"(CASE {kind} WHEN 'n' THEN 0 WHEN 's' THEN 1 ELSE 2 END)"
+
+
+def _blank_like(other: Expr) -> Expr:
+    """An empty cell compared with something acts as 0, "" or FALSE - whatever the other side is."""
+    if other.type == "txt":
+        return Expr("''", "txt")
+    if other.type == "bool":
+        return Expr("FALSE", "bool")
+    if other.type == "any":
+        return any_of(other.kind, "CAST(0 AS DOUBLE)", "''")
+    return ZERO
+
+
+def compare(a: Expr, b: Expr, op: str) -> Expr:
+    """Excel comparison: text ignores case; different types compare by type (number < text < logical)."""
+    if a.type == "blank" and b.type == "blank":
+        a, b = ZERO, ZERO
+    elif a.type == "blank":
+        a = _blank_like(b)
+    elif b.type == "blank":
+        b = _blank_like(a)
+    if a.type == "err":
+        a = num(a)
+    if b.type == "err":
+        b = num(b)
+    err = errs(a.err, b.err)
+    if a.type == b.type and a.type != "any":
+        if a.type == "txt":
+            return Expr(f"(LOWER({a.sql}) {op} LOWER({b.sql}))", "bool", err)
+        return Expr(f"({a.sql} {op} {b.sql})", "bool", err)
+    if a.type != "any" and b.type != "any":
+        return Expr(f"({RANK[a.type]} {op} {RANK[b.type]})", "bool", err)
+    a, b = as_any(a), as_any(b)
+    ra, rb = _rank(a.kind), _rank(b.kind)
+    return Expr(f"(CASE WHEN {ra} <> {rb} THEN {ra} {op} {rb} WHEN {ra} = 1 THEN LOWER({a.txt}) {op} LOWER({b.txt}) "
+                f"ELSE {a.sql} {op} {b.sql} END)", "bool", err)
+
+
+def finalize(e: Expr) -> Expr:
+    return ZERO if e.type == "blank" else e  # =A1 on an empty cell shows 0 in Excel
+
+
+def where_cell(key: Key) -> str:
+    sheet, row, col = key
+    return f"sheet = {lit_str(sheet).sql} AND row_num = {row} AND col_num = {col}"
+
+
+def where_area(area, alias: str = "") -> str:
+    p = f"{alias}." if alias else ""
+    return (f"{p}sheet = {lit_str(area.sheet).sql} AND {p}row_num BETWEEN {area.r1} AND {area.r2} "
+            f"AND {p}col_num BETWEEN {area.c1} AND {area.c2}")

cellproof/fenwick.py

@@ -0,0 +1,47 @@
+"""Prefix sums over positions 0..n-1 with point updates and k-th lookup, all O(log n)."""
+from __future__ import annotations
+
+
+class Fenwick:
+    def __init__(self, values: list[int]):
+        n = len(values)
+        self.n = n
+        t = [0] + list(values)
+        for i in range(1, n + 1):  # O(n) build
+            j = i + (i & -i)
+            if j <= n:
+                t[j] += t[i]
+        self.t = t
+        self.top = 1 << n.bit_length()
+
+    def add(self, i: int, delta: int) -> None:
+        """Add delta to position i."""
+        i += 1
+        t, n = self.t, self.n
+        while i <= n:
+            t[i] += delta
+            i += i & -i
+
+    def prefix(self, i: int) -> int:
+        """Sum of positions 0..i-1."""
+        s, t = 0, self.t
+        while i > 0:
+            s += t[i]
+            i -= i & -i
+        return s
+
+    def range(self, i: int, j: int) -> int:
+        """Sum of positions i..j-1."""
+        return self.prefix(j) - self.prefix(i)
+
+    def kth(self, k: int) -> int:
+        """0-based position of the k-th unit (k >= 1) when every value is a non-negative count."""
+        pos, t, n = 0, self.t, self.n
+        step = self.top
+        while step:
+            nxt = pos + step
+            if nxt <= n and t[nxt] < k:
+                pos = nxt
+                k -= t[nxt]
+            step >>= 1
+        return pos

cellproof/fn/__init__.py

@@ -0,0 +1,2 @@
+"""The Excel function library. Importing this package registers every function in cellproof.functions.FUNCS."""
+from cellproof.fn import aggregate, criteria, dates, logic, lookup, maths, text  # noqa: F401

cellproof/fn/aggregate.py

@@ -0,0 +1,181 @@
+"""AVERAGE, MIN, MAX, COUNT, COUNTA, COUNTBLANK, PRODUCT, MEDIAN, SUMPRODUCT, SUBTOTAL.
+
+Like SUM: in a range only numbers count (text, TRUE/FALSE and empty cells are skipped); a value typed
+straight into the arguments is converted (AVERAGE(1, "3") = 2). An error in a range is the result.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+from cellproof.expr import BLANK, CELLS, NO_ERR, Expr, errs, lit_str, num, where_area
+from cellproof.functions import arity, note_text_numbers, register
+from cellproof.model import Unsupported
+from cellproof.parser import Num, RefNode
+from cellproof.refs import Area, resolve
+
+
+@dataclass(frozen=True)
+class Rng:
+    area: Area
+    keys: object  # compiler.Keys
+    skip: tuple = ()  # cells left out (SUBTOTAL leaves out other SUBTOTALs)
+
+    def where(self, alias: str = "") -> str:
+        p = f"{alias}." if alias else ""
+        return where_area(self.area, alias) + "".join(
+            f" AND NOT ({p}row_num = {r} AND {p}col_num = {col})" for _, r, col in self.skip)
+
+    def agg(self, fn: str, kinds: str = "('n')") -> str:
+        return f"(SELECT {fn} FROM {CELLS} WHERE {self.where()} AND kind IN {kinds})"
+
+    def err(self, c) -> str:
+        if self.skip:
+            if not any(c.may_err(k) for k in self.keys if k not in self.skip):
+                return NO_ERR
+        elif not self.keys.may_err:
+            return NO_ERR
+        return (f"(SELECT txt FROM {CELLS} WHERE {self.where()} AND kind = 'e' "
+                f"ORDER BY row_num, col_num LIMIT 1)")
+
+
+def _rng(c, node, sheet: str, skip_subtotals: bool = False) -> Rng:
+    area = resolve(node.text, sheet, c.book)
+    keys = c.ready(area)
+    note_text_numbers(c, keys)
+    skip = ()
+    if skip_subtotals:
+        skip = tuple(k for k in keys if "SUBTOTAL(" in (c.book.cells[k].formula or "").upper())
+    return Rng(area, keys, skip)
+
+
+def _split(c, args, sheet: str, skip_subtotals: bool = False) -> tuple[list[Rng], list[Expr]]:
+    ranges, values = [], []
+    for a in args:
+        if isinstance(a, RefNode):
+            ranges.append(_rng(c, a, sheet, skip_subtotals))
+        else:
+            values.append(num(c.expr(a, sheet) if a is not None else BLANK))
+    return ranges, values
+
+
+def _errs(c, ranges, values) -> str:
+    # Real Excel: MAX(H3, 1/0) is #DIV/0! although H3 holds #N/A. Typed-in expressions are evaluated before the
+    # function reads any cell, so their errors come first; errors inside referenced cells follow, in order.
+    return errs(*(v.err for v in values), *(r.err(c) for r in ranges))
+
+
+def _average(c, ranges, values) -> Expr:
+    total = " + ".join([*(r.agg("COALESCE(SUM(num), 0)") for r in ranges), *(v.sql for v in values)]) or "0"
+    count = " + ".join([*(r.agg("COUNT(*)") for r in ranges), *("1" for _ in values)]) or "0"
+    return Expr(f"(({total}) / NULLIF({count}, 0))", "num",
+                errs(_errs(c, ranges, values), f"(CASE WHEN ({count}) = 0 THEN '#DIV/0!' END)"))
+
+
+def _extreme(c, ranges, values, how: str) -> Expr:
+    parts = [*(r.agg(f"{how}(num)") for r in ranges), *(v.sql for v in values)]
+    fn = "LEAST" if how == "MIN" else "GREATEST"  # both skip NULLs in DuckDB; no numbers at all -> 0, like Excel
+    return Expr(f"COALESCE({fn}({', '.join(parts)}), CAST(0 AS DOUBLE))", "num", _errs(c, ranges, values))
+
+
+def _count(c, ranges, values) -> Expr:
+    if values:
+        raise Unsupported("COUNT of values typed into the formula not supported yet")
+    return Expr("(" + " + ".join(r.agg("CAST(COUNT(*) AS DOUBLE)") for r in ranges) + ")", "num")
+
+
+def _counta(c, ranges, values) -> Expr:
+    parts = [r.agg("CAST(COUNT(*) AS DOUBLE)", "('n', 's', 'b', 'e')") for r in ranges] + ["1" for _ in values]
+    return Expr("CAST((" + " + ".join(parts) + ") AS DOUBLE)", "num")
+
+
+def _product(c, ranges, values) -> Expr:
+    parts = [f"COALESCE({r.agg('product(num)')}, 1)" for r in ranges] + [v.sql for v in values]
+    count = " + ".join([*(r.agg("COUNT(*)") for r in ranges), *("1" for _ in values)])
+    return Expr(f"(CASE WHEN ({count}) = 0 THEN CAST(0 AS DOUBLE) ELSE {' * '.join(parts)} END)", "num",
+                _errs(c, ranges, values))
+
+
+def _sum(c, ranges, values) -> Expr:
+    parts = [*(r.agg("COALESCE(SUM(num), 0)") for r in ranges), *(v.sql for v in values)]
+    return Expr("(" + " + ".join(parts) + ")" if parts else "CAST(0 AS DOUBLE)", "num", _errs(c, ranges, values))
+
+
+def _plain(name, how):
+    def fn(c, args, sheet):
+        if not args:
+            raise Unsupported(f"{name} needs arguments")
+        ranges, values = _split(c, args, sheet)
+        result = how(c, ranges, values)
+        if name not in ("COUNT", "COUNTA"):
+            result = replace(result, err=errs(_errs(c, ranges, values), result.err))
+        return result
+    register(name)(fn)
+
+
+_plain("AVERAGE", _average)
+_plain("MIN", lambda c, r, v: _extreme(c, r, v, "MIN"))
+_plain("MAX", lambda c, r, v: _extreme(c, r, v, "MAX"))
+_plain("COUNT", _count)
+_plain("COUNTA", _counta)
+_plain("PRODUCT", _product)
+
+
+@register("COUNTBLANK")
+def countblank(c, args, sheet):
+    arity("COUNTBLANK", args, 1, 1)
+    if not isinstance(args[0], RefNode):
+        raise Unsupported("COUNTBLANK needs a cell range")
+    r = _rng(c, args[0], sheet)
+    a = r.area
+    size = (a.r2 - a.r1 + 1) * (a.c2 - a.c1 + 1)
+    filled = (f"(SELECT COUNT(*) FROM {CELLS} WHERE {r.where()} "
+              f"AND NOT (kind = 's' AND COALESCE(txt, '') = ''))")  # "" counts as blank here, like Excel
+    return Expr(f"CAST({size} - {filled} AS DOUBLE)", "num")
+
+
+@register("MEDIAN")
+def median(c, args, sheet):
+    if not args or not all(isinstance(a, RefNode) for a in args):
+        raise Unsupported("MEDIAN of values typed into the formula not supported yet")
+    ranges = [_rng(c, a, sheet) for a in args]
+    rows = " UNION ALL ".join(f"SELECT num FROM {CELLS} WHERE {r.where()} AND kind = 'n'" for r in ranges)
+    values = f"FROM ({rows}) median_values"
+    return Expr(f"(SELECT CAST(median(num) AS DOUBLE) {values})", "num",
+                errs(_errs(c, ranges, []), f"(CASE WHEN (SELECT COUNT(*) {values}) = 0 THEN '#NUM!' END)"))
+
+
+@register("SUMPRODUCT")
+def sumproduct(c, args, sheet):
+    if not args or not all(isinstance(a, RefNode) for a in args):
+        raise Unsupported("SUMPRODUCT of array expressions not supported yet")
+    ranges = [_rng(c, a, sheet) for a in args]
+    first = ranges[0].area
+    shape = (first.r2 - first.r1, first.c2 - first.c1)
+    if any((r.area.r2 - r.area.r1, r.area.c2 - r.area.c1) != shape for r in ranges):
+        return Expr("NULL", "num", "'#VALUE!'")  # Excel: ranges of different sizes
+    joins = "".join(
+        f" JOIN {CELLS} a{i} ON a{i}.sheet = {lit_str(r.area.sheet).sql} "
+        f"AND a{i}.row_num = a0.row_num + {r.area.r1 - first.r1} AND a{i}.col_num = a0.col_num + {r.area.c1 - first.c1} "
+        f"AND a{i}.kind = 'n'" for i, r in enumerate(ranges[1:], 1))
+    product = " * ".join(f"a{i}.num" for i in range(len(ranges)))  # blanks, text and TRUE/FALSE count as 0
+    return Expr(f"(SELECT COALESCE(SUM({product}), CAST(0 AS DOUBLE)) FROM {CELLS} a0{joins} "
+                f"WHERE {where_area(first, 'a0')} AND a0.kind = 'n')", "num", _errs(c, ranges, []))
+
+
+SUBTOTALS = {1: _average, 2: _count, 3: _counta, 4: lambda c, r, v: _extreme(c, r, v, "MAX"),
+             5: lambda c, r, v: _extreme(c, r, v, "MIN"), 6: _product, 9: _sum}
+
+
+@register("SUBTOTAL")
+def subtotal(c, args, sheet):
+    if len(args) < 2 or not isinstance(args[0], Num):
+        raise Unsupported("SUBTOTAL needs a function number and ranges")
+    code = int(args[0].value)
+    if code > 100:
+        raise Unsupported("SUBTOTAL that ignores hidden rows not supported yet")
+    if code not in SUBTOTALS:
+        raise Unsupported(f"SUBTOTAL function {code} not supported yet")
+    if not all(isinstance(a, RefNode) for a in args[1:]):
+        raise Unsupported("SUBTOTAL needs cell ranges")
+    ranges = [_rng(c, a, sheet, skip_subtotals=True) for a in args[1:]]
+    return SUBTOTALS[code](c, ranges, [])