cellproof 0.2.0__py3-none-any.whl

cellproof/fn/criteria.py

@@ -0,0 +1,188 @@
+"""COUNTIF, COUNTIFS, SUMIF, SUMIFS, AVERAGEIF, AVERAGEIFS, MINIFS, MAXIFS.
+
+A criterion is a number (matches equal numbers, and text that reads as that number), TRUE/FALSE, or text
+that may start with =, <>, <, >, <= or >= and may use the wildcards * and ? (~ escapes them). Text criteria
+can be built while the sheet runs (">"&B1), so they are parsed in SQL, not in Python.
+Empty cells have no row in the cells table. They match "" and "=" and "<>x", so they are counted from
+the range's size.
+"""
+from __future__ import annotations
+
+from cellproof.expr import CELLS, NO_ERR, Expr, errs, lit_str, parse_num, txt, where_area
+from cellproof.functions import arity, note_text_numbers, register
+from cellproof.model import Unsupported
+from cellproof.parser import RefNode
+from cellproof.refs import Area, resolve
+
+OPS = (">=", "<=", "<>", ">", "<", "=")
+
+
+def like_pattern(rhs: str) -> str:
+    """Excel wildcards -> a LIKE pattern (ESCAPE '\\'): * -> %, ? -> _, ~* and ~? are literal."""
+    p = f"lower({rhs})"
+    for a, b in (("'\\'", "'\\\\'"), ("'%'", "'\\%'"), ("'_'", "'\\_'"), ("'~*'", "chr(1)"), ("'~?'", "chr(2)"),
+                 ("'*'", "'%'"), ("'?'", "'_'"), ("chr(1)", "'*'"), ("chr(2)", "'?'")):
+        p = f"replace({p}, {a}, {b})"
+    return p
+
+
+def match_sql(alias: str, crit: Expr, q: str) -> tuple[str, str, str]:
+    """(SQL true when cell `alias` meets the criterion, SQL true when an empty cell does, a one-row table `q`).
+
+    A text criterion is parsed once, in the one-row table `q` the caller puts in its FROM clause:
+    repeating the criterion SQL inside every comparison overflowed DuckDB's expression depth.
+    """
+    if crit.err != NO_ERR:
+        raise Unsupported("criteria that can be an error not supported yet")
+    if crit.type == "blank":
+        raise Unsupported("criteria from an empty cell not supported yet")
+    k, n, t = f"{alias}.kind", f"{alias}.num", f"COALESCE({alias}.txt, '')"  # the seed CSV reads '' back as NULL
+    if crit.type == "num":
+        return f"COALESCE(({k} = 'n' AND {n} = {crit.sql}) OR ({k} = 's' AND {parse_num(t)} = {crit.sql}), FALSE)", \
+            "FALSE", f"(SELECT 1 AS one) {q}"
+    if crit.type == "bool":
+        return f"COALESCE({k} = 'b' AND {n} = CAST({crit.sql} AS DOUBLE), FALSE)", "FALSE", f"(SELECT 1 AS one) {q}"
+    ops = "(CASE " + " ".join(f"WHEN c LIKE '{o}%' THEN '{o}'" for o in OPS) + " ELSE '' END)"
+    parsed = (f"(SELECT op, rhs, {parse_num('rhs')} AS rn, "
+              f"(CASE upper(rhs) WHEN 'TRUE' THEN 1.0 WHEN 'FALSE' THEN 0.0 END) AS rb, {like_pattern('rhs')} AS pat "
+              f"FROM (SELECT op, substr(c, length(op) + 1) AS rhs FROM (SELECT c, {ops} AS op "
+              f"FROM (SELECT {txt(crit).sql} AS c)))) {q}")
+    op, rhs, rn, rb = f"{q}.op", f"{q}.rhs", f"{q}.rn", f"{q}.rb"
+
+    def order(a: str, b: str) -> str:
+        return " ".join(["(CASE", *(f"WHEN {op} = '{o}' THEN {a} {o} {b}" for o in (">", "<", ">=", "<=")), "END)"])
+
+    eq = (f"COALESCE(CASE WHEN {rn} IS NOT NULL THEN ({k} = 'n' AND {n} = {rn}) OR ({k} = 's' AND {parse_num(t)} = {rn}) "
+          f"WHEN {rb} IS NOT NULL THEN {k} = 'b' AND {n} = {rb} "
+          f"ELSE {k} = 's' AND lower({t}) LIKE {q}.pat ESCAPE '\\' END, FALSE)")
+    ordered = (f"COALESCE(CASE WHEN {rn} IS NOT NULL THEN {k} = 'n' AND {order(n, rn)} "
+               f"WHEN {rb} IS NOT NULL THEN {k} = 'b' AND {order(n, rb)} "
+               f"ELSE {k} = 's' AND {order(f'lower({t})', f'lower({rhs})')} END, FALSE)")
+    # Real Excel: "<>5" skips only the number 5. The text "5" matches =5 but still counts as "<>5".
+    same = (f"COALESCE(CASE WHEN {rn} IS NOT NULL THEN {k} = 'n' AND {n} = {rn} "
+            f"WHEN {rb} IS NOT NULL THEN {k} = 'b' AND {n} = {rb} "
+            f"ELSE {k} = 's' AND lower({t}) LIKE {q}.pat ESCAPE '\\' END, FALSE)")
+    # Real Excel: "<>" alone counts every cell that exists, including a formula that returns "".
+    match = (f"(CASE WHEN {op} = '<>' AND {rhs} = '' THEN TRUE WHEN {op} = '<>' THEN NOT {same} "
+             f"WHEN {op} IN ('', '=') THEN {eq} ELSE {ordered} END)")
+    blank = f"(({op} IN ('', '=') AND {rhs} = '') OR ({op} = '<>' AND {rhs} <> ''))"
+    return match, blank, parsed
+
+
+def _range(c, node, sheet: str, fname: str) -> tuple[Area, object]:
+    if not isinstance(node, RefNode):
+        raise Unsupported(f"{fname} needs a cell range")
+    area = resolve(node.text, sheet, c.book)
+    return area, c.ready(area)
+
+
+def _column(c, node, sheet: str, fname: str, height: int | None = None) -> tuple[Area, object]:
+    area, keys = _range(c, node, sheet, fname)
+    if area.c1 != area.c2 or (height is not None and area.r2 - area.r1 != height):
+        raise Unsupported(f"{fname} ranges must be single columns of the same height")
+    return area, keys
+
+
+def _pairs(c, args, sheet: str, fname: str, height: int | None) -> list[tuple[Area, Expr]]:
+    pairs = []
+    for i in range(0, len(args), 2):
+        area, _ = _column(c, args[i], sheet, fname, height)
+        height = area.r2 - area.r1
+        pairs.append((area, c.expr(args[i + 1], sheet)))
+    return pairs
+
+
+def _joined(pairs, base: str, base_r1) -> tuple[str, str, str]:
+    """(one-row criteria tables, LEFT JOINs of each criteria range to the driving rows, AND of conditions, AND of blanks)."""
+    parsed, joins, conds, blanks = [], [], [], []
+    for i, (area, crit) in enumerate(pairs, 1):
+        k = f"k{i}"
+        joins.append(f"LEFT JOIN {CELLS} {k} ON {k}.sheet = {lit_str(area.sheet).sql} "
+                     f"AND {k}.col_num = {area.c1} AND {k}.row_num = {base} + {area.r1 - base_r1}")
+        match, blank, source = match_sql(k, crit, f"q{i}")
+        parsed.append(source)
+        conds.append(f"(CASE WHEN {k}.kind IS NULL THEN {blank} ELSE {match} END)")
+        blanks.append(blank)
+    return parsed, " ".join(joins), " AND ".join(conds), " AND ".join(blanks)
+
+
+@register("COUNTIF")
+def countif(c, args, sheet):
+    arity("COUNTIF", args, 2, 2)
+    area, _ = _range(c, args[0], sheet, "COUNTIF")
+    match, blank, source = match_sql("x", c.expr(args[1], sheet), "q1")
+    size = (area.r2 - area.r1 + 1) * (area.c2 - area.c1 + 1)
+    inside = f"FROM {CELLS} x WHERE {where_area(area, 'x')}"
+    return Expr(f"(SELECT (SELECT COUNT(*) FILTER (WHERE {match}) {inside}) "
+                f"+ CASE WHEN {blank} THEN {size} - (SELECT COUNT(*) {inside}) ELSE 0 END FROM {source})", "num")
+
+
+@register("COUNTIFS")
+def countifs(c, args, sheet):
+    if not args or len(args) % 2:
+        raise Unsupported("COUNTIFS needs criteria pairs")
+    pairs = _pairs(c, args, sheet, "COUNTIFS", None)
+    height = pairs[0][0].r2 - pairs[0][0].r1 + 1
+    rows = " UNION ".join(f"SELECT row_num - {a.r1} AS off FROM {CELLS} WHERE {where_area(a)}" for a, _ in pairs)
+    tables, joins, cond, blanks = _joined(pairs, "o.off", 0)
+    o = f"({rows}) o"  # a derived table, not a CTE: DuckDB cannot bind a CTE inside a subquery on a row's value
+    return Expr(f"(SELECT (SELECT COUNT(*) FILTER (WHERE {cond}) FROM {o} {joins}) "
+                f"+ CASE WHEN {blanks} THEN {height} - (SELECT COUNT(*) FROM {o}) ELSE 0 END FROM {', '.join(tables)})", "num")
+
+
+def _aggregate(c, target: Area, pairs, how: str) -> Expr:
+    """SUM / AVERAGE / MIN / MAX of the target cells whose rows meet every criterion."""
+    keys = c.ready(target)
+    note_text_numbers(c, keys)
+    tables, joins, cond, _ = _joined(pairs, "s.row_num", target.r1)
+    crossed = " ".join(f"CROSS JOIN {t}" for t in tables)
+    src = f"FROM {CELLS} s {crossed} {joins} WHERE {where_area(target, 's')} AND {cond}"
+    numbers = "FILTER (WHERE s.kind = 'n')"
+    err = NO_ERR
+    if keys.may_err:  # a matched error cell makes the result that error
+        err = f"(SELECT arg_min(s.txt, s.row_num) {src} AND s.kind = 'e')"  # the first; ORDER BY..LIMIT cannot run row-wise
+    if how == "SUM":
+        return Expr(f"(SELECT COALESCE(SUM(s.num) {numbers}, CAST(0 AS DOUBLE)) {src})", "num", err)
+    if how in ("MIN", "MAX"):
+        return Expr(f"(SELECT COALESCE({how}(s.num) {numbers}, CAST(0 AS DOUBLE)) {src})", "num", err)
+    count = f"(SELECT COUNT(*) {numbers} {src})"
+    return Expr(f"(SELECT SUM(s.num) {numbers} / NULLIF(COUNT(*) {numbers}, 0) {src})", "num",
+                errs(err, f"(CASE WHEN {count} = 0 THEN '#DIV/0!' END)"))
+
+
+def _resized(area: Area, like: Area) -> Area:
+    """Excel's SUMIF uses the sum range's top-left cell and the criteria range's size."""
+    return Area(area.sheet, area.r1, area.c1, area.r1 + (like.r2 - like.r1), area.c1)
+
+
+def _if(how: str):
+    def fn(c, args, sheet):
+        fname = f"{how}IF" if how in ("SUM", "AVERAGE") else how
+        arity(fname, args, 2, 3)
+        area, _ = _column(c, args[0], sheet, fname)
+        target = area
+        if len(args) == 3:
+            if not isinstance(args[2], RefNode):
+                raise Unsupported(f"{fname} needs a cell range")
+            target = _resized(resolve(args[2].text, sheet, c.book), area)
+        return _aggregate(c, target, [(area, c.expr(args[1], sheet))], how)
+    return fn
+
+
+def _ifs(how: str):
+    def fn(c, args, sheet):
+        fname = f"{how}IFS"
+        if len(args) < 3 or len(args) % 2 == 0:
+            raise Unsupported(f"{fname} needs a sum range and criteria pairs")
+        target, _ = _column(c, args[0], sheet, fname)
+        pairs = _pairs(c, args[1:], sheet, fname, target.r2 - target.r1)
+        return _aggregate(c, target, pairs, how)
+    return fn
+
+
+register("SUMIF")(_if("SUM"))
+register("AVERAGEIF")(_if("AVERAGE"))
+register("SUMIFS")(_ifs("SUM"))
+register("AVERAGEIFS")(_ifs("AVERAGE"))
+register("MINIFS")(_ifs("MIN"))
+register("MAXIFS")(_ifs("MAX"))

cellproof/fn/dates.py

@@ -0,0 +1,171 @@
+"""DATE, YEAR, MONTH, DAY, WEEKDAY, DAYS, EDATE, EOMONTH, DAYS360, DATEDIF, and TEXT's date formats.
+
+Excel stores a date as a serial number: 1 = 1900-01-01, and it counts a 29 February 1900 that never existed
+(serial 60), so serials from 61 on are days since 1899-12-30. Serial 0 is "1900-01-00". Workbooks using the
+1904 date system are not supported yet.
+"""
+from __future__ import annotations
+
+from cellproof.expr import Expr, errs, num
+from cellproof.fn.lookup import int_literal
+from cellproof.fn.text import FORMATS
+from cellproof.functions import arity, register
+from cellproof.model import Unsupported
+from cellproof.parser import Bool, Str
+
+MAX_SERIAL = 2958465  # 9999-12-31
+
+
+def _check(c) -> None:
+    if c.book.date1904:
+        raise Unsupported("1904 date system not supported yet")
+
+
+def _serial(c, node, sheet: str) -> Expr:
+    _check(c)
+    s = num(c.expr(node, sheet))
+    return Expr(f"floor({s.sql})", "num", errs(s.err, f"(CASE WHEN {s.sql} < 0 OR {s.sql} > {MAX_SERIAL} THEN '#NUM!' END)"))
+
+
+def to_date(s: str) -> str:
+    """A whole serial (61 and up, or 1..59) as a DATE."""
+    return (f"(CASE WHEN {s} >= 61 THEN DATE '1899-12-30' + CAST({s} AS INTEGER) "
+            f"ELSE DATE '1899-12-31' + CAST({s} AS INTEGER) END)")
+
+
+def from_date(d: str) -> str:
+    return (f"CAST(CASE WHEN {d} >= DATE '1900-03-01' THEN {d} - DATE '1899-12-30' "
+            f"ELSE {d} - DATE '1899-12-31' END AS DOUBLE)")
+
+
+def _ok(s: Expr) -> str:
+    return f"(({s.err}) IS NULL)"
+
+
+def _part(name: str, fn: str, at0: int, at60: int):
+    def impl(c, args, sheet):
+        arity(name, args, 1, 1)
+        s = _serial(c, args[0], sheet)
+        return Expr(f"(CASE WHEN NOT {_ok(s)} THEN NULL WHEN {s.sql} = 0 THEN {at0} WHEN {s.sql} = 60 THEN {at60} "
+                    f"ELSE CAST({fn}({to_date(s.sql)}) AS DOUBLE) END)", "num", s.err)
+    register(name)(impl)
+
+
+_part("YEAR", "year", 1900, 1900)
+_part("MONTH", "month", 1, 2)
+_part("DAY", "day", 0, 29)
+
+
+@register("DATE")
+def date(c, args, sheet):
+    arity("DATE", args, 3, 3)
+    _check(c)
+    y, m, d = (num(c.expr(a, sheet)) for a in args)
+    year = f"(CASE WHEN trunc({y.sql}) < 1900 THEN trunc({y.sql}) + 1900 ELSE trunc({y.sql}) END)"
+    ok = (f"(trunc({y.sql}) BETWEEN 0 AND 9999 AND abs({m.sql}) < 120000 AND abs({d.sql}) < 4000000)")
+    day = (f"CAST(make_date(CAST({year} AS INTEGER), 1, 1) + to_months(CAST(trunc({m.sql}) - 1 AS INTEGER)) "
+           f"+ to_days(CAST(trunc({d.sql}) - 1 AS INTEGER)) AS DATE)")
+    # Real Excel: DATE(1900,2,29) is 60 - it counts a 29 February 1900 that never existed - so inside 1900 a date is
+    # (days before the month, with 1900 a leap year) + day, for any day (DATE(1900,3,0) is 60). Months outside 1-12
+    # use the real calendar.
+    before = "[0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]"
+    in_1900 = f"({year} = 1900 AND trunc({m.sql}) BETWEEN 1 AND 12)"
+    in_1900_serial = f"(CAST({before}[CAST(trunc({m.sql}) AS INTEGER)] AS DOUBLE) + trunc({d.sql}))"
+    serial = f"(CASE WHEN NOT {ok} THEN NULL WHEN {in_1900} THEN {in_1900_serial} ELSE {from_date(day)} END)"
+    return Expr(serial, "num", errs(y.err, m.err, d.err,
+                                    f"(CASE WHEN NOT {ok} OR {serial} < 0 OR {serial} > {MAX_SERIAL} THEN '#NUM!' END)"))
+
+
+@register("WEEKDAY")
+def weekday(c, args, sheet):
+    arity("WEEKDAY", args, 1, 2)
+    s = _serial(c, args[0], sheet)
+    kind = 1 if len(args) == 1 or args[1] is None else int_literal(args[1])
+    sunday0 = f"(CAST({s.sql} AS BIGINT) + 6) % 7"  # serial 1 was a Sunday in Excel's calendar
+    sql = {1: f"({sunday0} + 1)", 2: f"(({sunday0} + 6) % 7 + 1)", 3: f"(({sunday0} + 6) % 7)"}.get(kind)
+    if sql is None:
+        raise Unsupported("WEEKDAY return type must be 1, 2 or 3")
+    return Expr(f"(CASE WHEN {_ok(s)} THEN CAST({sql} AS DOUBLE) END)", "num", s.err)
+
+
+@register("DAYS")
+def days(c, args, sheet):
+    arity("DAYS", args, 2, 2)
+    end, start = _serial(c, args[0], sheet), _serial(c, args[1], sheet)
+    return Expr(f"({end.sql} - {start.sql})", "num", errs(end.err, start.err))
+
+
+def _shift(name: str, last: bool):
+    def impl(c, args, sheet):
+        arity(name, args, 2, 2)
+        s, m = _serial(c, args[0], sheet), num(c.expr(args[1], sheet))
+        d = f"CAST({to_date(s.sql)} + to_months(CAST(trunc({m.sql}) AS INTEGER)) AS DATE)"
+        if last:
+            d = f"last_day({d})"
+        ok = f"({_ok(s)} AND ({m.err}) IS NULL AND trunc({m.sql}) BETWEEN -120000 AND 120000)"
+        serial = f"(CASE WHEN {ok} THEN {from_date(d)} END)"
+        bad = f"(CASE WHEN NOT {ok} OR {serial} NOT BETWEEN 0 AND {MAX_SERIAL} THEN '#NUM!' END)"
+        return Expr(serial, "num", errs(s.err, m.err, bad))
+    register(name)(impl)
+
+
+_shift("EDATE", last=False)
+_shift("EOMONTH", last=True)
+
+
+@register("DAYS360")
+def days360(c, args, sheet):
+    arity("DAYS360", args, 2, 3)
+    if len(args) == 3 and not isinstance(args[2], Bool):
+        raise Unsupported("DAYS360 method must be TRUE/FALSE written in the formula")
+    european = len(args) == 3 and args[2].value
+    a, b = _serial(c, args[0], sheet), _serial(c, args[1], sheet)
+    d1, d2 = to_date(a.sql), to_date(b.sql)
+    y1, m1, y2, m2 = f"year({d1})", f"month({d1})", f"year({d2})", f"month({d2})"
+    if european:
+        day1, day2, m2 = f"least(day({d1}), 30)", f"least(day({d2}), 30)", m2
+    else:  # U.S. (NASD), as Microsoft documents it for DAYS360
+        day1 = f"(CASE WHEN {d1} = last_day({d1}) THEN 30 ELSE day({d1}) END)"
+        # Real Excel: the last day of February ends the period unchanged (28 or 29) unless the start is also the
+        # last day of February; only then does it become the 30th. Only a 31st is moved (to the 1st of the next
+        # month, or the 30th), never the 30th of a short month: Jan 15 -> Apr 30 is 105, not 106.
+        feb_end = f"({d2} = last_day({d2}) AND month({d2}) = 2)"
+        feb_start = f"({d1} = last_day({d1}) AND month({d1}) = 2)"
+        end_last = f"(day({d2}) = 31)"
+        day2 = (f"(CASE WHEN {feb_end} AND {feb_start} THEN 30 WHEN {end_last} AND {day1} < 30 THEN 1 "
+                f"WHEN {end_last} THEN 30 ELSE day({d2}) END)")
+        m2 = f"({m2} + CASE WHEN {end_last} AND {day1} < 30 THEN 1 ELSE 0 END)"
+    sql = f"CAST(({y2} - {y1}) * 360 + ({m2} - {m1}) * 30 + ({day2} - {day1}) AS DOUBLE)"
+    return Expr(f"(CASE WHEN {_ok(a)} AND {_ok(b)} THEN {sql} END)", "num", errs(a.err, b.err))
+
+
+@register("DATEDIF")
+def datedif(c, args, sheet):
+    arity("DATEDIF", args, 3, 3)
+    if not isinstance(args[2], Str) or args[2].value.upper() not in ("Y", "M", "D"):
+        raise Unsupported("DATEDIF unit must be \"Y\", \"M\" or \"D\" written in the formula")
+    unit = args[2].value.upper()
+    a, b = _serial(c, args[0], sheet), _serial(c, args[1], sheet)
+    d1, d2 = to_date(a.sql), to_date(b.sql)
+    months = (f"((year({d2}) - year({d1})) * 12 + month({d2}) - month({d1}) "
+              f"- CASE WHEN day({d2}) < day({d1}) THEN 1 ELSE 0 END)")
+    sql = {"D": f"({b.sql} - {a.sql})", "M": months, "Y": f"floor({months} / 12)"}[unit]
+    return Expr(f"(CASE WHEN {_ok(a)} AND {_ok(b)} AND {a.sql} <= {b.sql} THEN CAST({sql} AS DOUBLE) END)", "num",
+                errs(a.err, b.err, f"(CASE WHEN {a.sql} > {b.sql} THEN '#NUM!' END)"))
+
+
+def _date_format(pattern: str):
+    def sql(x: str) -> str:
+        s = f"floor({x})"
+        return f"(CASE WHEN {s} BETWEEN 1 AND {MAX_SERIAL} AND {s} <> 60 THEN strftime({to_date(s)}, '{pattern}') END)"
+    sql.is_date = True  # TEXT refuses date formats in 1904-system workbooks
+    return sql
+
+
+DATE_FORMATS = {
+    "yyyy-mm-dd": "%Y-%m-%d", "mm/dd/yyyy": "%m/%d/%Y", "m/d/yyyy": "%-m/%-d/%Y", "dd/mm/yyyy": "%d/%m/%Y",
+    "d/m/yyyy": "%-d/%-m/%Y", "dd-mmm-yyyy": "%d-%b-%Y", "d-mmm-yy": "%-d-%b-%y", "dd-mmm-yy": "%d-%b-%y",
+    "mmm": "%b", "mmmm": "%B", "yyyy": "%Y", "yy": "%y", "mmm-yy": "%b-%y", "mmm yyyy": "%b %Y",
+    "mmmm yyyy": "%B %Y", "ddd": "%a", "dddd": "%A", "dd": "%d", "d": "%-d", "mm": "%m",
+}
+FORMATS.update({k: _date_format(v) for k, v in DATE_FORMATS.items()})

cellproof/fn/logic.py

@@ -0,0 +1,131 @@
+"""IFS, SWITCH, NOT, XOR, IFNA, ISNA, ISERROR, ISERR, ISNUMBER, ISTEXT, ISLOGICAL, ISBLANK, NA, TRUE, FALSE.
+
+The IS functions look at a value without failing: an error in their argument is their answer, not their error.
+"""
+from __future__ import annotations
+
+from cellproof.expr import NO_ERR, Expr, as_bool, compare, error, errs, pick, unify, unify_all
+from cellproof.functions import arity, register
+from cellproof.model import Unsupported
+from cellproof.parser import RefNode
+from cellproof.refs import resolve
+
+
+def _chain(branches: list[tuple[Expr, Expr]], default: Expr | None) -> Expr:
+    """CASE WHEN cond1 THEN value1 ... ELSE default (or #N/A): IFS and SWITCH."""
+    values = unify_all([v for _, v in branches] + ([default] if default is not None else []))
+    fallback = values[-1] if default is not None else None
+
+    def case(attr: str) -> str:
+        parts = [getattr(v, attr) for v in values]
+        if len(set(parts)) == 1:
+            return parts[0]
+        whens = " ".join(f"WHEN {cnd.sql} THEN {getattr(v, attr)}" for (cnd, _), v in zip(branches, values))
+        return f"(CASE {whens} ELSE {getattr(fallback, attr) if fallback else 'NULL'} END)"
+    err_whens = []
+    for (cnd, _), v in zip(branches, values):
+        if cnd.err != NO_ERR:  # a condition that fails stops the chain, as in Excel
+            err_whens.append(f"WHEN ({cnd.err}) IS NOT NULL THEN {cnd.err}")
+        err_whens.append(f"WHEN {cnd.sql} THEN {v.err}")
+    last = fallback.err if fallback else "'#N/A'"
+    return Expr(case("sql"), values[0].type, f"(CASE {' '.join(err_whens)} ELSE {last} END)",
+                case("txt"), case("kind"))
+
+
+@register("IFS")
+def ifs(c, args, sheet):
+    if not args or len(args) % 2:
+        raise Unsupported("IFS needs condition/value pairs")
+    pairs = [(as_bool(c.expr(args[i], sheet)), c.expr(args[i + 1], sheet)) for i in range(0, len(args), 2)]
+    return _chain(pairs, None)
+
+
+@register("SWITCH")
+def switch(c, args, sheet):
+    if len(args) < 3:
+        raise Unsupported("SWITCH needs a value and value/result pairs")
+    x = c.expr(args[0], sheet)
+    rest = args[1:]
+    default = c.expr(rest[-1], sheet) if len(rest) % 2 else None
+    pairs = [(compare(x, c.expr(rest[i], sheet), "="), c.expr(rest[i + 1], sheet)) for i in range(0, len(rest) - 1, 2)]
+    return _chain(pairs, default)
+
+
+@register("NOT")
+def not_(c, args, sheet):
+    arity("NOT", args, 1, 1)
+    x = as_bool(c.expr(args[0], sheet))
+    return Expr(f"(NOT {x.sql})", "bool", x.err)
+
+
+@register("XOR")
+def xor(c, args, sheet):
+    if not args or any(isinstance(a, RefNode) and not resolve(a.text, sheet, c.book).is_single for a in args):
+        raise Unsupported("XOR over ranges not supported yet")
+    parts = [as_bool(c.expr(a, sheet)) for a in args]
+    total = " + ".join(f"CAST({p.sql} AS INTEGER)" for p in parts)
+    return Expr(f"(({total}) % 2 = 1)", "bool", errs(*(p.err for p in parts)))
+
+
+@register("IFNA")
+def ifna(c, args, sheet):
+    arity("IFNA", args, 2, 2)
+    value, fallback = unify(c.expr(args[0], sheet), c.expr(args[1], sheet))
+    if value.err == NO_ERR:
+        return value
+    na = f"COALESCE(({value.err}) = '#N/A', FALSE)"
+    return pick(f"(NOT {na})", value, fallback, f"(CASE WHEN {na} THEN {fallback.err} ELSE {value.err} END)")
+
+
+def _is(name: str, test):
+    def fn(c, args, sheet):
+        arity(name, args, 1, 1)
+        return Expr(test(c.expr(args[0], sheet)), "bool")
+    register(name)(fn)
+
+
+_is("ISNA", lambda x: f"COALESCE(({x.err}) = '#N/A', FALSE)")
+_is("ISERROR", lambda x: f"(({x.err}) IS NOT NULL)")
+_is("ISERR", lambda x: f"COALESCE(({x.err}) <> '#N/A', FALSE)")
+
+
+def _kind_is(kind: str, typ: str):
+    def test(x: Expr) -> str:
+        if x.type == "any":
+            return f"(({x.err}) IS NULL AND {x.kind} = '{kind}')"
+        return f"(({x.err}) IS NULL)" if x.type == typ else "FALSE"
+    return test
+
+
+_is("ISNUMBER", _kind_is("n", "num"))
+_is("ISTEXT", _kind_is("s", "txt"))
+_is("ISLOGICAL", _kind_is("b", "bool"))
+
+
+@register("ISBLANK")
+def isblank(c, args, sheet):
+    arity("ISBLANK", args, 1, 1)
+    if not isinstance(args[0], RefNode):
+        return Expr("FALSE", "bool")  # ISBLANK("") is FALSE: only an empty cell is blank
+    area = resolve(args[0].text, sheet, c.book)
+    cell = c.book.cells.get(area.key)
+    empty = cell is None or (cell.formula is None and cell.kind == "blank")
+    return Expr("TRUE" if empty else "FALSE", "bool")
+
+
+@register("NA")
+def na(c, args, sheet):
+    arity("NA", args, 0, 0)
+    return error("#N/A")
+
+
+@register("TRUE")
+def true(c, args, sheet):
+    arity("TRUE", args, 0, 0)
+    return Expr("TRUE", "bool")
+
+
+@register("FALSE")
+def false(c, args, sheet):
+    arity("FALSE", args, 0, 0)
+    return Expr("FALSE", "bool")