@mason-data/cli 0.8.0 → 0.9.0

package/dist/src/duck/pgtree.js

@@ -12,6 +12,7 @@
  * `(o …)` OIDs, `(i …)` ints), `<>` for NULL, a quoted string, a bare token (outToken backslash-escapes the
  * characters that would end one), or a datum `N [ b b … ]` (a Const's value).
  */
+import { constantExpression } from "./constant-key.js";
 /** Parses one node-format text (outfuncs.c's nodeToString), or throws with the offset where it went wrong. */
 export function parseTree(text) {
     let i = 0;
@@ -108,8 +109,68 @@ export function parseTree(text) {
         fail("text after the tree");
     return v;
 }
+/** Postgres's first OID for an object not of its own (FirstNormalObjectId): below it, Postgres's catalog; past it, a
+ *  table copied, a type an extension made, or what the catalog Postgres made itself (catalog.ts LATEST_SQL) */
+export const FIRST_USER_OID = 16384;
 const isNode = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 const num = (v) => typeof v === "string" && /^-?\d+$/.test(v) ? Number(v) : null;
+/** the integers of an integer list (`(i 2 3)`) */
+const ints = (v) => Array.isArray(v) ? v.map((x) => typeof x === "string" ? num(x) : null).filter((x) => x !== null) : [];
+/** each GROUPINGFUNC of an analysed expression, in the order a walk of it meets them, outside its subqueries */
+function groupingsIn(v) {
+    if (Array.isArray(v))
+        return v.flatMap(groupingsIn);
+    if (v === undefined || !isNode(v) || v._node === "QUERY")
+        return [];
+    const own = v._node === "GROUPINGFUNC" ? [{ levelsUp: num(v.agglevelsup ?? null) ?? 0, refs: ints(v.refs) }] : [];
+    return [...own, ...Object.entries(v).flatMap(([k, x]) => k === "_node" ? [] : groupingsIn(x))];
+}
+/** Keys: `targets` a TARGETENTRY list, `sort` and `distinct` SORTGROUPCLAUSE lists over it */
+function keysOf(targets, sort, distinct, rtable, windows) {
+    const list = Array.isArray(targets) ? targets.filter(isNode) : [];
+    // (a grouped key's entry is a VAR of the GROUP entry by the time the tree is printed; it was bound as what it groups)
+    const exprs = list.map((t) => ungrouped(t.expr ?? null, rtable));
+    const entries = exprs.map((e, i) => ({
+        constant: constantExpression(e),
+        at: isNode(e) ? num(e.location) : null,
+        first: exprs.findIndex((o, j) => j <= i && sameExpression(o, e)),
+        reads: readsVar(e),
+        output: list[i].resjunk !== "true",
+        ref: num(list[i].ressortgroupref ?? null),
+        groupings: groupingsIn(list[i].expr ?? null),
+    }));
+    const refs = (v) => (Array.isArray(v) ? v.filter(isNode) : []).map((c) => {
+        const ref = num(c.tleSortGroupRef ?? null);
+        return list.findIndex((t) => ref !== null && ref !== 0 && num(t.ressortgroupref ?? null) === ref);
+    });
+    const clauses = Array.isArray(windows) ? windows.filter(isNode) : [];
+    return {
+        entries, sorted: refs(sort), distinct: refs(distinct),
+        windows: clauses.map((w) => ({ name: typeof w.name === "string" ? w.name : null, winref: num(w.winref ?? null), partition: refs(w.partitionClause), order: refs(w.orderClause) })),
+    };
+}
+/** whether an analysed expression reads a column: a VAR outside a subquery's own QUERY */
+function readsVar(v) {
+    if (Array.isArray(v))
+        return v.some(readsVar);
+    if (v === undefined || !isNode(v) || v._node === "QUERY")
+        return false;
+    return v._node === "VAR" || Object.entries(v).some(([k, x]) => k !== "_node" && readsVar(x));
+}
+/** Postgres's equal() of two analysed expressions: alike in every field but an offset and a cast's form (`::` or an
+ *  implicit cast, which its equal() ignores too: COMPARE_COERCIONFORM_FIELD) */
+const IGNORED = new Set(["location", "funcformat", "relabelformat", "coerceformat", "convertformat", "row_format"]);
+function sameExpression(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((x, i) => sameExpression(x, b[i]));
+    }
+    if (a === undefined || b === undefined || !isNode(a) || !isNode(b))
+        return false;
+    const ka = Object.keys(a).filter((k) => !IGNORED.has(k)), kb = Object.keys(b).filter((k) => !IGNORED.has(k));
+    return ka.length === kb.length && ka.every((k) => sameExpression(a[k], b[k]));
+}
 /** a `constvalue`'s bytes: `<length> [ b0 b1 … ]`, each a signed byte */
 export function datumBytes(v) {
     if (typeof v !== "string")
@@ -117,6 +178,84 @@ export function datumBytes(v) {
     const m = /^\s*\d+\s*\[([-\d\s]*)\]\s*$/.exec(v);
     return m ? m[1].trim().split(/\s+/).filter((x) => x !== "").map((x) => Number(x) & 255) : null;
 }
+const [TEXT, VARCHAR, TEXT_ARRAY, VARCHAR_ARRAY] = [25, 1043, 1009, 1015];
+const int32 = (b, at) => ((b[at] ?? 0) | ((b[at + 1] ?? 0) << 8) | ((b[at + 2] ?? 0) << 16) | ((b[at + 3] ?? 0) << 24)) >>> 0;
+/** a varlena's text and the bytes it takes, in a datum's bytes at `at`; null for a form no constant is written in
+ *  (compressed, external), which the caller reads as no constant */
+function varlena(b, at) {
+    const first = b[at];
+    if (first === undefined)
+        return null;
+    // a 1-byte header (low bit 1) holds its length, itself included, in the seven bits above; 0x01 is an external pointer
+    const short = (first & 1) === 1;
+    if (first === 1 || (!short && (first & 3) !== 0))
+        return null;
+    const size = short ? first >>> 1 : int32(b, at) >>> 2, head = short ? 1 : 4;
+    if (size < head || at + size > b.length)
+        return null;
+    return { text: Buffer.from(b.slice(at + head, at + size)).toString("utf8"), size };
+}
+/**
+ * A text[] or varchar[] datum's elements as `array_in` read them (array.h: the varlena header, ndim, dataoffset,
+ * elemtype, the dims and lower bounds, the null bitmap where dataoffset is set, then the elements, each aligned to 4
+ * bytes; the catalog is little-endian). Null for what is not a plain array of at most one dimension.
+ */
+export function textArrayElements(b) {
+    if (b.length < 16)
+        return null;
+    const ndim = int32(b, 4), offset = int32(b, 8), element = int32(b, 12);
+    if (ndim > 1 || (element !== TEXT && element !== VARCHAR))
+        return null;
+    if (ndim === 0)
+        return [];
+    if (b.length < 24)
+        return null;
+    const count = int32(b, 16), bitmap = 24;
+    let at = offset !== 0 ? offset : 24;
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        if (offset !== 0 && (((b[bitmap + (i >> 3)] ?? 0) >> (i & 7)) & 1) === 0) {
+            out.push(null);
+            continue;
+        }
+        const v = varlena(b, at);
+        if (v === null)
+            return null;
+        out.push(v.text);
+        at = (at + v.size + 3) & ~3;
+    }
+    return out;
+}
+/** a CONST of text or varchar as Postgres read it; undefined for any other node */
+function constText(v) {
+    if (!isNode(v) || v._node !== "CONST" || (num(v.consttype) !== TEXT && num(v.consttype) !== VARCHAR))
+        return undefined;
+    if (v.constisnull === "true")
+        return null;
+    const b = datumBytes(v.constvalue);
+    return (b === null ? null : varlena(b, 0))?.text;
+}
+/** a text[] or varchar[] that is constant, as Postgres read it; undefined for any other node */
+function constTextArray(v) {
+    if (v._node === "CONST") {
+        if (num(v.consttype) !== TEXT_ARRAY && num(v.consttype) !== VARCHAR_ARRAY)
+            return undefined;
+        if (v.constisnull === "true")
+            return null;
+        const b = datumBytes(v.constvalue);
+        return (b === null ? null : textArrayElements(b)) ?? undefined;
+    }
+    if (v._node !== "ARRAYEXPR" || v.multidims === "true" || (num(v.array_typeid) !== TEXT_ARRAY && num(v.array_typeid) !== VARCHAR_ARRAY))
+        return undefined;
+    const out = [];
+    for (const e of Array.isArray(v.elements) ? v.elements : []) {
+        const text = constText(e);
+        if (text === undefined)
+            return undefined;
+        out.push(text);
+    }
+    return out;
+}
 const BOOL = 16;
 /** The type an expression node yields: exprType (nodeFuncs.c), for the nodes a SELECT's expressions are made of. */
 export function exprType(n) {
@@ -130,6 +269,7 @@ export function exprType(n) {
         case "PARAM": return t("paramtype", "paramtypmod");
         case "AGGREF": return t("aggtype");
         case "WINDOWFUNC": return t("wintype");
+        case "GROUPINGFUNC": return { type: 23, typmod: -1 };
         case "FUNCEXPR": {
             const r = t("funcresulttype");
             // a length coercion (numeric(p, s), varchar(n)) carries its typmod as its second argument's constant
@@ -148,7 +288,8 @@ export function exprType(n) {
         case "SCALARARRAYOPEXPR":
         case "BOOLEXPR":
         case "NULLTEST":
-        case "BOOLEANTEST": return { type: BOOL, typmod: -1 };
+        case "BOOLEANTEST":
+        case "ROWCOMPAREEXPR": return { type: BOOL, typmod: -1 };
         case "RELABELTYPE":
         case "COERCEVIAIO":
         case "ARRAYCOERCEEXPR":
@@ -190,6 +331,10 @@ const argsOf = (n) => {
  */
 export function typesByLocation(tree) {
     const out = new Map();
+    // the arguments Postgres wrapped in its implicit time→timetz cast (`Typed.implicitTimetz`)
+    const asTimetz = new WeakSet();
+    // the char(n) arguments Postgres wrapped in its implicit cast to text or varchar (`Typed.implicitText`)
+    const asText = new WeakMap();
     // the range tables of the queries around the node being visited, innermost last
     const rtables = [];
     const visit = (v) => {
@@ -212,45 +357,516 @@ export function typesByLocation(tree) {
             }
             return;
         }
-        const loc = num(v.location);
+        // a row comparison has no offset of its own: it is found at its first left column's (`rowCompareAt`)
+        const first = v._node === "ROWCOMPAREEXPR" && Array.isArray(v.largs) && isNode(v.largs[0] ?? null) ? v.largs[0] : null;
+        const placed = (x) => {
+            const at = num(x.location ?? null);
+            // (an implicit cast Postgres added has none of its own: its argument's)
+            return (at === null || at < 0) && isNode(x.arg ?? null) ? placed(x.arg) : at;
+        };
+        const loc = first !== null ? placed(first) : num(v.location);
         const t = exprType(v);
+        const wrapped = implicitTimetzArg(v);
+        if (wrapped !== null)
+            asTimetz.add(wrapped);
+        const trimmed = implicitTextArg(v);
+        if (trimmed !== null)
+            asText.set(trimmed, exprType(v).type);
         if (loc !== null && loc >= 0 && t !== null) {
-            const raw = v._node === "AGGREF" || v._node === "WINDOWFUNC"
-                ? argsOf(v).map((a) => isNode(a) && a._node === "TARGETENTRY" ? a.expr ?? null : a)
-                : argsOf(v);
-            const args = raw.filter(isNode).map((a) => exprType(a) ?? { type: 0, typmod: -1 });
-            const typed = {
-                node: v._node, type: t.type, typmod: t.typmod, args,
-                oid: num(v.opno ?? v.funcid ?? v.aggfnoid ?? v.winfnoid ?? null),
-                format: num(v.funcformat ?? null),
-                collation: num(v.opcollid ?? v.funccollid ?? v.aggcollid ?? v.wincollid ?? v.varcollid ?? v.constcollid ?? v.collid ?? null) ?? 0,
-                inputCollation: num(v.inputcollid ?? null) ?? 0,
-                levelsUp: v._node === "VAR" ? num(v.varlevelsup ?? null) : null,
-                datum: v._node === "CONST" && v.constisnull !== "true" ? datumBytes(v.constvalue) : null,
-                qualifier: v._node === "VAR" ? qualifierOf(v, rtables) : null,
-                renamed: v._node === "VAR" ? renamedOf(v, rtables) : null,
-            };
-            const relation = v._node === "VAR" ? relationOf(v, rtables) : null;
-            if (relation !== null)
-                typed.relation = relation;
-            const fromFunction = v._node === "VAR" ? functionColumnOf(v, rtables) : null;
-            if (fromFunction !== null)
-                typed.functionColumn = fromFunction;
+            const typed = typedOf(v, t, rtables);
+            if (asTimetz.has(v))
+                typed.implicitTimetz = true;
+            const text = asText.get(v);
+            if (text !== undefined)
+                typed.implicitText = text;
             const list = out.get(loc);
             if (list)
                 list.push(typed);
             else
                 out.set(loc, [typed]);
         }
+        // a row compared with a subquery's rows is found at its SubLink's offset too: a grouped column's Var has none
+        // (PR 674 class round r3: `(id, a) < ANY (…) … GROUP BY id` placed nothing at its first column)
+        const test = v._node === "SUBLINK" && isNode(v.testexpr ?? null) ? v.testexpr : null;
+        const at = num(v.location);
+        if (test !== null && test._node === "ROWCOMPAREEXPR" && at !== null && at >= 0) {
+            const typed = typedOf(test, { type: BOOL, typmod: -1 }, rtables);
+            const list = out.get(at);
+            if (list)
+                list.push(typed);
+            else
+                out.set(at, [typed]);
+        }
+        for (const [k, x] of Object.entries(v))
+            if (k !== "_node")
+                visit(x);
+    };
+    visit(tree);
+    return out;
+}
+/** the argument of Postgres's IMPLICIT cast of a char(n) to a text or a varchar (a FUNCEXPR whose one argument is a
+ *  bpchar and whose result a text or a varchar, COERCE_IMPLICIT_CAST: text(bpchar), which drops the trailing blanks),
+ *  or null for any other node */
+function implicitTextArg(v) {
+    if (v._node !== "FUNCEXPR" || num(v.funcformat ?? null) !== 2)
+        return null;
+    const to = num(v.funcresulttype ?? null);
+    if (to !== 25 && to !== 1043)
+        return null;
+    const args = argsOf(v).filter(isNode);
+    const a = args[0];
+    return args.length === 1 && a !== undefined && a._node !== "CASETESTEXPR" && exprType(a)?.type === 1042 ? a : null;
+}
+/** a SubLink's output column (PARAM_SUBLINK) an argument holds, beneath any coercion, its type as the subquery gave it */
+function sublinkParamOf(v) {
+    if (!isNode(v))
+        return null;
+    if (v._node === "PARAM")
+        return num(v.paramkind ?? null) === 2 ? exprType(v) : null;
+    if (v._node === "FUNCEXPR" || v._node === "RELABELTYPE" || v._node === "COERCEVIAIO") {
+        const args = v._node === "FUNCEXPR" ? argsOf(v).filter(isNode) : isNode(v.arg ?? null) ? [v.arg] : [];
+        return args.length >= 1 ? sublinkParamOf(args[0]) : null;
+    }
+    return null;
+}
+/** the argument of Postgres's IMPLICIT time→timetz cast (FUNCEXPR of time_timetz, function 2047, COERCE_IMPLICIT_CAST),
+ *  or null for any other node: the one test of it (`typesByLocation`, `implicitTimetzCasts`) */
+function implicitTimetzArg(v) {
+    // `CASE tm WHEN '12:30-05'::timetz …`: each WHEN compares a placeholder of the CASE's value (CaseTestExpr), which
+    // Postgres casts in each: the CASE's own value is the one cast, where every WHEN casts it (`caseCasts`)
+    if (v._node === "CASEEXPR" && isNode(v.arg ?? null)) {
+        const c = caseCasts(v);
+        return c.cast > 0 && c.cast === c.whens ? v.arg : null;
+    }
+    const a = timetzCastOf(v);
+    return a !== null && a._node !== "CASETESTEXPR" ? a : null;
+}
+const timetzCastOf = (v) => {
+    if (v === undefined || !isNode(v) || v._node !== "FUNCEXPR" || num(v.funcid ?? null) !== 2047 || num(v.funcformat ?? null) !== 2)
+        return null;
+    const a = argsOf(v)[0];
+    return a !== undefined && isNode(a) ? a : null;
+};
+/** a `CASE x WHEN …`'s WHENs, and how many of them cast its placeholder (x) to a timetz */
+function caseCasts(v) {
+    const whens = (Array.isArray(v.args) ? v.args : []).filter(isNode);
+    const cast = whens.filter((w) => { const e = w.expr ?? null; const first = isNode(e) ? argsOf(e)[0] : undefined; return timetzCastOf(first)?._node === "CASETESTEXPR"; }).length;
+    return { whens: whens.length, cast };
+}
+/** how many implicit time→timetz casts Postgres's analysis holds, a CASE's WHENs that cast its value counted once:
+ *  each must be written where its argument is (src/duck/rewrite.ts `coerceImplicit` counts what it wrote against this,
+ *  and refuses the statement when one was not: a CASE whose WHENs cast its value in some and not others among them) */
+export function implicitTimetzCasts(tree) {
+    let n = 0;
+    const visit = (v) => {
+        if (Array.isArray(v)) {
+            for (const x of v)
+                visit(x);
+            return;
+        }
+        if (!isNode(v))
+            return;
+        const a = timetzCastOf(v);
+        if (a !== null && a._node !== "CASETESTEXPR")
+            n++;
+        if (v._node === "CASEEXPR" && isNode(v.arg ?? null) && caseCasts(v).cast > 0)
+            n++;
+        for (const [k, x] of Object.entries(v))
+            if (k !== "_node")
+                visit(x);
+    };
+    visit(tree);
+    return n;
+}
+/** one expression of a query whose range tables are `rtables`, innermost last, as `Typed` says it */
+function typedOf(v, t, rtables) {
+    const raw = v._node === "AGGREF" || v._node === "WINDOWFUNC"
+        ? argsOf(v).map((a) => isNode(a) && a._node === "TARGETENTRY" ? a.expr ?? null : a)
+        : argsOf(v);
+    const args = raw.filter(isNode).map((a) => exprType(a) ?? { type: 0, typmod: -1 });
+    const typed = {
+        node: v._node, type: t.type, typmod: t.typmod, args,
+        oid: num(v.opno ?? v.funcid ?? v.aggfnoid ?? v.winfnoid ?? null),
+        format: num(v.funcformat ?? null),
+        collation: collationOf(v),
+        inputCollation: num(v.inputcollid ?? null) ?? 0,
+        levelsUp: v._node === "VAR" ? num(v.varlevelsup ?? null) : null,
+        datum: v._node === "CONST" && v.constisnull !== "true" ? datumBytes(v.constvalue) : null,
+        qualifier: v._node === "VAR" ? qualifierOf(v, rtables) : null,
+        renamed: v._node === "VAR" ? renamedOf(v, rtables) : null,
+    };
+    if (constantExpression(v))
+        typed.constant = true;
+    // a row comparison compares each column under its own collation (RowCompareExpr's inputcollids)
+    if (v._node === "ROWCOMPAREEXPR" && Array.isArray(v.inputcollids))
+        typed.inputCollations = v.inputcollids.filter((x) => x !== "o").map((x) => typeof x === "string" ? num(x) ?? 0 : 0);
+    if (v._node === "ROWCOMPAREEXPR" && Array.isArray(v.largs))
+        typed.inputTypes = v.largs.filter(isNode).map((a) => exprType(a)?.type ?? 0);
+    // a SubLink's output columns, as the operator reads them (PR 674 class round r3)
+    const outputs = v._node === "OPEXPR" ? argsOf(v) : v._node === "ROWCOMPAREEXPR" && Array.isArray(v.rargs) ? v.rargs : [];
+    if (outputs.some((a) => sublinkParamOf(a) !== null))
+        typed.params = outputs.map(sublinkParamOf);
+    if (v._node === "AGGREF" && Array.isArray(v.aggdirectargs))
+        typed.directArgs = v.aggdirectargs.filter(isNode).map((a) => exprType(a) ?? { type: 0, typmod: -1 });
+    if (v._node === "AGGREF")
+        typed.keys = keysOf(v.args, v.aggorder, v.aggdistinct, []);
+    // a GROUPING(…): its query level and the GROUP BY entries its arguments read; a window function: its WINDOW clause
+    if (v._node === "GROUPINGFUNC")
+        typed.grouping = groupingsIn(v)[0];
+    if (v._node === "WINDOWFUNC")
+        typed.winref = num(v.winref ?? null);
+    const text = constText(v);
+    if (text !== undefined)
+        typed.text = text;
+    const textArray = constTextArray(v);
+    if (textArray !== undefined)
+        typed.textArray = textArray;
+    const relation = v._node === "VAR" ? relationOf(v, rtables) : null;
+    if (relation !== null)
+        typed.relation = relation;
+    const column = v._node === "VAR" ? columnOf(v, rtables) : null;
+    if (column !== null)
+        typed.column = column;
+    const fromFunction = v._node === "VAR" ? functionColumnOf(v, rtables) : null;
+    if (fromFunction !== null)
+        typed.functionColumn = fromFunction;
+    return typed;
+}
+/**
+ * THE COLLATION AN EXPRESSION'S RESULT CARRIES, as Postgres's exprCollation reads it: each node keeps it in a field of
+ * its own (a COLLATE's `collOid`, a relabel's `resultcollid`, a CASE's `casecollid` …). A SUBLINK's is its subselect's
+ * first output's (an EXPR or ARRAY sublink; a test of one carries none). 0: none (a type that is not collatable).
+ */
+export function collationOf(v) {
+    if (v._node === "SUBLINK") {
+        const sub = v.subselect;
+        const tl = isNode(sub ?? null) ? sub.targetList : undefined;
+        const first = Array.isArray(tl) ? tl.find((e) => isNode(e) && e.resjunk !== "true") : undefined;
+        const kind = num(v.subLinkType);
+        return (kind === 4 || kind === 5) && first !== undefined && isNode(first.expr ?? null) ? collationOf(first.expr) : 0;
+    }
+    return num(v.opcollid ?? v.funccollid ?? v.aggcollid ?? v.wincollid ?? v.varcollid ?? v.constcollid ?? v.collOid ?? v.resultcollid ?? v.casecollid
+        ?? v.coalescecollid ?? v.minmaxcollid ?? v.array_collid ?? v.paramcollid ?? v.refcollid ?? v.collid ?? v.collation ?? null) ?? 0;
+}
+/**
+ * WHERE A STATEMENT'S ANALYSIS ORDERS A COLLATABLE VALUE, by the collation it orders under: a sort key of any query
+ * (its ORDER BY, a window's ORDER BY, an aggregate's ORDER BY or WITHIN GROUP), a GREATEST / LEAST, a row comparison,
+ * and — as candidates whose operator or function the caller names from the catalog — an operator's and an aggregate's
+ * or window function's input collation (`<` orders, `=` does not; `max` orders, `count` does not), and a plain
+ * function's (`calls`: `upper` maps case under it, issue 406; `length` reads none of it).
+ */
+export function textOrdering(tree) {
+    const orders = new Set(), operators = new Map(), functions = new Map(), calls = new Map();
+    const add = (m, oid, coll) => { if (oid === null || coll === 0)
+        return; const s = m.get(oid) ?? new Set(); s.add(coll); m.set(oid, s); };
+    const sorted = (clauses, targets) => {
+        if (!Array.isArray(clauses) || !Array.isArray(targets))
+            return;
+        for (const c of clauses) {
+            if (!isNode(c))
+                continue;
+            const ref = num(c.tleSortGroupRef ?? null);
+            const t = targets.find((x) => isNode(x) && ref !== null && num(x.ressortgroupref ?? null) === ref);
+            const e = t !== undefined && isNode(t.expr ?? null) ? t.expr : null;
+            if (e !== null) {
+                const coll = collationOf(e);
+                if (coll !== 0)
+                    orders.add(coll);
+            }
+        }
+    };
+    const visit = (v) => {
+        if (Array.isArray(v)) {
+            for (const x of v)
+                visit(x);
+            return;
+        }
+        if (v === undefined || !isNode(v))
+            return;
+        if (v._node === "QUERY") {
+            sorted(v.sortClause, v.targetList);
+            if (Array.isArray(v.windowClause))
+                for (const w of v.windowClause)
+                    if (isNode(w))
+                        sorted(w.orderClause, v.targetList);
+        }
+        if (v._node === "AGGREF") {
+            sorted(v.aggorder, v.args);
+            add(functions, num(v.aggfnoid ?? null), num(v.inputcollid ?? null) ?? 0);
+        }
+        if (v._node === "WINDOWFUNC")
+            add(functions, num(v.winfnoid ?? null), num(v.inputcollid ?? null) ?? 0);
+        if (v._node === "OPEXPR")
+            add(operators, num(v.opno ?? null), num(v.inputcollid ?? null) ?? 0);
+        if (v._node === "FUNCEXPR")
+            add(calls, num(v.funcid ?? null), num(v.inputcollid ?? null) ?? 0);
+        if (v._node === "MINMAXEXPR") {
+            const coll = num(v.inputcollid ?? null) ?? 0;
+            if (coll !== 0)
+                orders.add(coll);
+        }
+        if (v._node === "ROWCOMPAREEXPR" && Array.isArray(v.inputcollids))
+            for (const x of v.inputcollids) {
+                const coll = typeof x === "string" ? num(x) ?? 0 : 0;
+                if (coll !== 0)
+                    orders.add(coll);
+            }
+        for (const [k, x] of Object.entries(v))
+            if (k !== "_node")
+                visit(x);
+    };
+    visit(tree);
+    return { orders, operators, functions, calls };
+}
+/**
+ * WHAT A STATEMENT'S ANALYSIS CALLS: every function, by OID, however it is called (a function's `funcid`, an operator's,
+ * NULLIF's or IS DISTINCT FROM's `opfuncid`, an aggregate's `aggfnoid`, a window function's `winfnoid`; 0 where the
+ * analysis left one unset), and whether it reads its session by a keyword or a sequence (`current_user`, `user`,
+ * `current_catalog`, CURRENT_DATE: a SQLVALUEFUNCTION; nextval's NEXTVALUEEXPR). The caller asks the catalog's pg_proc
+ * whether each depends on its arguments alone (`provolatile`), Postgres's own word for it (issue 406).
+ */
+export function functionsCalled(tree) {
+    const oids = new Set();
+    let session = false;
+    const visit = (v) => {
+        if (Array.isArray(v)) {
+            for (const x of v)
+                visit(x);
+            return;
+        }
+        if (v === undefined || !isNode(v))
+            return;
+        if (v._node === "SQLVALUEFUNCTION" || v._node === "NEXTVALUEEXPR" || v._node === "CURRENTOFEXPR")
+            session = true;
+        for (const k of ["funcid", "opfuncid", "aggfnoid", "winfnoid"])
+            if (k in v)
+                oids.add(num(v[k] ?? null) ?? 0);
         for (const [k, x] of Object.entries(v))
             if (k !== "_node")
                 visit(x);
     };
     visit(tree);
+    return { oids, session };
+}
+/** EVERY COLLATION A STATEMENT'S ANALYSIS NAMES (an expression's, an operator's input, a row comparison's per column, a
+ *  FROM item's columns'), by OID: what src/duck/collation.ts resolves before the rewrite reads any */
+export function collationOids(tree) {
+    const out = new Set();
+    const field = /(collid|collids|collOid|^collation|^colcollations)$/;
+    const visit = (v, key) => {
+        if (Array.isArray(v)) {
+            if (field.test(key)) {
+                for (const x of v)
+                    if (typeof x === "string" && x !== "o") {
+                        const n = num(x);
+                        if (n !== null)
+                            out.add(n);
+                    }
+                return;
+            }
+            for (const x of v)
+                visit(x, "");
+            return;
+        }
+        if (typeof v === "string") {
+            if (field.test(key)) {
+                const n = num(v);
+                if (n !== null)
+                    out.add(n);
+            }
+            return;
+        }
+        if (v === undefined || !isNode(v))
+            return;
+        for (const [k, x] of Object.entries(v))
+            if (k !== "_node")
+                visit(x, k);
+    };
+    visit(tree, "");
+    out.delete(0);
     return out;
 }
+/**
+ * Each SELECT's outputs, found by any offset its targets hold. THE ORDER OF A `*` IS ITS QUERY'S `targetList`, NEVER THE
+ * ORDER ITS VARS ARE MET IN THE TREE: under a GROUP BY (Postgres 17+) a key's output is a VAR of the RTE_GROUP entry at
+ * no offset, and the column it groups is in that entry's `groupexprs`, which comes first and in the GROUP BY's order. So
+ * the offset of a star says nothing of which of its columns is which; a set operation's own outputs are left out, as
+ * they carry its first SELECT's offsets.
+ */
+export function outputsByLocation(tree) {
+    return analysedQueries(tree).byOffset;
+}
+/**
+ * Each SELECT's outputs, by any offset its targets hold (`outputsByLocation`), and those of each SELECT whose outputs hold
+ * none: `TABLE t`, whose `*` the grammar writes at no offset, so Postgres's expansion of it is at none either. Such a
+ * one is known by the FROM items it reads, by the names its range table gives them (`eref`), in order, and by the
+ * offsets its own LIMIT and OFFSET hold (`limits`).
+ */
+export function analysedQueries(tree) {
+    const found = new Map();
+    const unplaced = [];
+    const visit = (v) => {
+        if (Array.isArray(v)) {
+            for (const x of v)
+                visit(x);
+            return;
+        }
+        if (!isNode(v))
+            return;
+        if (v._node === "QUERY" && Array.isArray(v.targetList) && !isNode(v.setOperations ?? null)) {
+            const rtable = Array.isArray(v.rtable) ? v.rtable.filter(isNode) : [];
+            const entries = v.targetList.filter(isNode).filter((t) => t.resjunk !== "true");
+            const exprs = entries.map((t) => ungrouped(t.expr ?? null, rtable));
+            const widths = new Map();
+            for (const rte of rtable) {
+                const eref = rte.eref ?? null;
+                if (isNode(eref) && typeof eref.aliasname === "string" && !widths.has(eref.aliasname))
+                    widths.set(eref.aliasname, strings(eref.colnames).filter((c) => c !== "").length);
+            }
+            const joins = rtable.filter((rte) => num(rte.rtekind ?? null) === RTE_JOIN).map((rte) => {
+                const eref = rte.eref ?? null;
+                return isNode(eref) ? strings(eref.colnames).slice(0, num(rte.joinmergedcols ?? null) ?? 0) : [];
+            });
+            const outputs = {
+                columns: exprs.map((e) => { const t = isNode(e) && e._node === "VAR" ? exprType(e) : null; return t === null ? null : typedOf(e, t, [rtable]); }),
+                widths,
+                joins,
+                keys: keysOf(v.targetList, v.sortClause, v.distinctClause, rtable, v.windowClause),
+            };
+            let placed = false;
+            const offsets = (x) => {
+                if (Array.isArray(x)) {
+                    x.forEach(offsets);
+                    return;
+                }
+                // (a subquery in a target is a query of its own, which registers its own offsets)
+                if (!isNode(x) || x._node === "QUERY")
+                    return;
+                const loc = num(x.location);
+                if (loc !== null && loc >= 0) {
+                    placed = true;
+                    if (!found.has(loc))
+                        found.set(loc, outputs);
+                }
+                const inner = ungrouped(x, rtable);
+                if (inner !== x) {
+                    offsets(inner);
+                    return;
+                }
+                for (const [k, y] of Object.entries(x))
+                    if (k !== "_node")
+                        offsets(y);
+            };
+            offsets(exprs);
+            if (!placed) {
+                const from = rtable.filter((rte) => num(rte.rtekind ?? null) !== RTE_JOIN).map((rte) => { const eref = rte.eref ?? null; return isNode(eref) && typeof eref.aliasname === "string" ? eref.aliasname : ""; });
+                unplaced.push({ from, limits: limitOffsets(v), outputs });
+            }
+        }
+        for (const [k, x] of Object.entries(v))
+            if (k !== "_node")
+                visit(x);
+    };
+    visit(tree);
+    return { byOffset: found, unplaced };
+}
+/** the offsets a query's own LIMIT and OFFSET hold (a count of `FETCH FIRST ROW` the grammar writes at none) */
+function limitOffsets(q) {
+    const held = (x) => {
+        if (Array.isArray(x))
+            return x.flatMap(held);
+        if (x === undefined || !isNode(x) || x._node === "QUERY")
+            return [];
+        const loc = num(x.location);
+        return [...(loc !== null && loc >= 0 ? [loc] : []), ...Object.entries(x).flatMap(([k, y]) => k === "_node" ? [] : held(y))];
+    };
+    return [...held(q.limitCount), ...held(q.limitOffset)];
+}
+/**
+ * EACH SET OPERATION'S OWN OUTPUTS, AS POSTGRES RESOLVED THEM: a column's type, typmod and collation are the set
+ * operation's (`SELECT <citext> … UNION ALL SELECT <text> …` is text, its first SELECT's is citext), never its first
+ * SELECT's. Each is known by the SELECTs it combines, in order: the offsets their outputs hold (a SELECT that is a set
+ * operation of its own, with an ORDER BY or a LIMIT, is one of them, by its first SELECT's; a `TABLE t` by none, as
+ * its outputs hold none), and the offsets its own LIMIT and OFFSET hold. Each column is typed as no table's column:
+ * what is known of it is the set operation's alone.
+ */
+export function setOperationOutputs(tree) {
+    const found = [];
+    const held = (x) => {
+        if (Array.isArray(x))
+            return x.flatMap(held);
+        // (a subquery in an output is a query of its own)
+        if (x === undefined || !isNode(x) || x._node === "QUERY")
+            return [];
+        const loc = num(x.location);
+        return [...(loc !== null && loc >= 0 ? [loc] : []), ...Object.entries(x).flatMap(([k, y]) => k === "_node" ? [] : held(y))];
+    };
+    const visit = (v) => {
+        if (Array.isArray(v)) {
+            for (const x of v)
+                visit(x);
+            return;
+        }
+        if (!isNode(v))
+            return;
+        if (v._node === "QUERY" && isNode(v.setOperations ?? null) && Array.isArray(v.targetList)) {
+            const rtable = Array.isArray(v.rtable) ? v.rtable : [];
+            const arms = [];
+            // each arm's own output types, before the set operation coerced them to its columns' (null: not known)
+            const armTypes = [];
+            const leaves = (s) => {
+                if (s === undefined || !isNode(s))
+                    return;
+                if (s._node === "SETOPERATIONSTMT") {
+                    leaves(s.larg);
+                    leaves(s.rarg);
+                    return;
+                }
+                const rte = s._node === "RANGETBLREF" ? rtable[(num(s.rtindex ?? null) ?? 0) - 1] : undefined;
+                const q = isNode(rte ?? null) ? rte.subquery ?? null : null;
+                if (!isNode(q)) {
+                    arms.push([]);
+                    armTypes.push(null);
+                    return;
+                }
+                armTypes.push(Array.isArray(q.targetList) ? q.targetList.filter((t) => isNode(t) && t.resjunk !== "true").map((t) => { const e = t.expr ?? null; return isNode(e) ? exprType(e)?.type ?? 0 : 0; }) : null);
+                const own = Array.isArray(q.targetList) ? held(q.targetList.filter((t) => isNode(t) && t.resjunk !== "true").map((t) => t.expr ?? null)) : [];
+                // (a VALUES's outputs read its rows at no offset of their own: it is known by its rows')
+                const rows = own.length > 0 || !Array.isArray(q.rtable) ? [] : q.rtable.filter(isNode).flatMap((r) => held(r.values_lists));
+                arms.push([...own, ...rows]);
+            };
+            leaves(v.setOperations);
+            const columns = v.targetList.filter(isNode).filter((t) => t.resjunk !== "true").map((t) => {
+                const e = t.expr ?? null;
+                const type = isNode(e) ? exprType(e) : null;
+                if (!isNode(e) || type === null)
+                    return null;
+                const { relation: _r, column: _c, functionColumn: _f, ...own } = typedOf(e, type, [rtable.filter(isNode)]);
+                return { ...own, qualifier: null, renamed: null };
+            });
+            found.push({ arms, limits: limitOffsets(v), columns, armTypes });
+        }
+        for (const [k, x] of Object.entries(v))
+            if (k !== "_node")
+                visit(x);
+    };
+    visit(tree);
+    return found;
+}
+/** an output as what it reads: a VAR of the query's RTE_GROUP is the expression it groups */
+function ungrouped(v, rtable) {
+    if (!isNode(v) || v._node !== "VAR")
+        return v;
+    const rte = rtable[(num(v.varno ?? null) ?? 0) - 1];
+    const exprs = rte !== undefined && num(rte.rtekind ?? null) === RTE_GROUP ? rte.groupexprs : undefined;
+    return Array.isArray(exprs) ? exprs[(num(v.varattno ?? null) ?? 0) - 1] ?? v : v;
+}
 const RTE_JOIN = 2;
+const RTE_GROUP = 9;
 const RTE_RELATION = 0;
+/** the FROM items whose name in the analysis (`unnamed_join`, `*VALUES*`, `unnamed_subquery`) no statement can say:
+ *  RTE_SUBQUERY, RTE_JOIN, RTE_VALUES */
+const UNNAMED = new Set([1, RTE_JOIN, 5]);
 /** Typed.relation: the table a VAR's FROM item is, by the catalog's OID, and the column's number in it */
 function relationOf(v, rtables) {
     const up = num(v.varlevelsup ?? null) ?? 0, varno = num(v.varno ?? null), attno = num(v.varattno ?? null);
@@ -258,6 +874,21 @@ function relationOf(v, rtables) {
     const relid = rte === undefined ? null : num(rte.relid ?? null);
     return rte === undefined || attno === null || attno < 1 || num(rte.rtekind ?? null) !== RTE_RELATION || relid === null || relid === 0 ? null : { relid, attno };
 }
+/** Typed.column */
+function columnOf(v, rtables) {
+    const up = num(v.varlevelsup ?? null) ?? 0, varno = num(v.varnosyn ?? null), attno = num(v.varattnosyn ?? null);
+    const rte = varno === null ? undefined : rtables[rtables.length - 1 - up]?.[varno - 1];
+    if (rte === undefined || attno === null || attno < 1 || !isNode(rte.eref ?? null))
+        return null;
+    const eref = rte.eref;
+    const columns = strings(eref.colnames), name = columns[attno - 1];
+    if (name === undefined || typeof eref.aliasname !== "string" || /^\*SELECT\* \d+$/.test(eref.aliasname))
+        return null;
+    const kind = num(rte.rtekind ?? null) ?? -1;
+    const named = isNode(rte.alias ?? null);
+    return { owner: UNNAMED.has(kind) && !named ? null : eref.aliasname, name,
+        ...(kind === RTE_JOIN && named && columns.filter((c) => c === name).length > 1 ? { twin: true } : {}) };
+}
 const RTE_FUNCTION = 3;
 /** Typed.functionColumn */
 function functionColumnOf(v, rtables) {
@@ -367,6 +998,126 @@ export function joinsUsing(tree, types) {
     };
     return visit(tree);
 }
+/**
+ * The analysed expression of each output column, in order (resjunk ones left out): what computes its value, every node
+ * with the type Postgres gave it, FOLLOWED wherever the analysis says a value comes from. A VAR that reads a FROM
+ * subquery (a generated table's `order_by:` shell among them), a CTE, a set operation's arms (each arm's column), a join's
+ * alias column or a grouped key carries what it reads as `followed`, itself followed; a sublink's subselect is followed
+ * as a query of its own, its VARs read against the queries around it. A recursive CTE's reading of itself is not
+ * followed again. Null for no query.
+ *
+ * LINEAR IN THE ANALYSED TREE, NEVER IN ITS EXPANSION (PR 202 round 14): a VAR's `followed` is the ONE followed node of
+ * what it reads, by reference, shared by every VAR that reads it (`Follow`), so the result is a graph whose shared nodes
+ * a reader visits once (src/duck/generated-plan.ts memoises by node). A copy per VAR grew 3^depth for a statement whose
+ * levels each read the level below three times: 880 ms at depth 12, about 70 s at 16. The generated planner alone asks
+ * for this (src/duck/plan.ts `PlanOptions.outputs`); a wire statement never pays for it.
+ */
+export function outputExpressions(tree) {
+    if (!isNode(tree) || tree._node !== "QUERY" || !Array.isArray(tree.targetList))
+        return null;
+    const top = tree, list = tree.targetList, walk = new Follow();
+    // a set operation's own column is a VAR of its leftmost arm's: it reads every arm's, and its location is the leftmost
+    // arm's expression's, no column reference of its own (-1)
+    const own = (e) => isNode(top.setOperations ?? null)
+        ? { ...e.expr, location: "-1", followed: walk.outputOf(top, num(e.resno ?? null) ?? 0, []) } : walk.followed(e.expr, [top]);
+    return list.filter((e) => isNode(e) && e.resjunk !== "true").map((e) => isNode(e.expr ?? null) ? own(e) : null);
+}
+/** the followed walk of one analysed tree (`outputExpressions`): each analysed node followed ONCE and each query's output
+ *  column found once, memoised by the analysed node, every VAR that reads one sharing the result. A node's stack (the
+ *  queries around it) is where it stands in the tree, so one result serves every path to it; `open` is the queries being
+ *  followed, so a recursive CTE's reading of itself reads nothing */
+class Follow {
+    nodes = new Map();
+    columns = new Map();
+    open = new Set();
+    /** `v` with every VAR it holds followed; `stack` the queries around it, its own last */
+    followed(v, stack) {
+        if (Array.isArray(v))
+            return v.map((x) => this.followed(x, stack));
+        if (!isNode(v))
+            return v;
+        const done = this.nodes.get(v);
+        if (done !== undefined)
+            return done;
+        const result = this.follow(v, stack);
+        this.nodes.set(v, result);
+        return result;
+    }
+    follow(v, stack) {
+        const inner = v._node === "QUERY" ? [...stack, v] : stack;
+        const out = Object.fromEntries(Object.entries(v).map(([k, x]) => [k, k === "_node" ? x : this.followed(x, inner)]));
+        if (v._node !== "VAR")
+            return out;
+        const up = num(v.varlevelsup ?? null) ?? 0, attno = num(v.varattno ?? null);
+        const base = stack.slice(0, stack.length - up), q = base[base.length - 1];
+        if (q === undefined || attno === null || attno < 1 || !Array.isArray(q.rtable))
+            return out;
+        const rte = q.rtable[(num(v.varno ?? null) ?? 0) - 1];
+        if (rte === undefined || !isNode(rte))
+            return out;
+        const kind = num(rte.rtekind ?? null);
+        let reads = [];
+        if (kind === RTE_SUBQUERY && isNode(rte.subquery ?? null))
+            reads = this.outputOf(rte.subquery, attno, base);
+        else if (kind === RTE_CTE) {
+            // the CTE of the query `ctelevelsup` above, read with that query's own outer queries around it
+            const levels = num(rte.ctelevelsup ?? null) ?? 0, owner = base[base.length - 1 - levels];
+            const cte = owner !== undefined && Array.isArray(owner.cteList) ? owner.cteList.find((c) => isNode(c) && c.ctename === rte.ctename) : undefined;
+            if (cte !== undefined && isNode(cte) && isNode(cte.ctequery ?? null))
+                reads = this.outputOf(cte.ctequery, attno, base.slice(0, base.length - levels));
+        }
+        else if (kind === RTE_JOIN || kind === RTE_GROUP) {
+            const list = kind === RTE_JOIN ? rte.joinaliasvars : rte.groupexprs;
+            const e = Array.isArray(list) ? list[attno - 1] : undefined;
+            if (e !== undefined && isNode(e))
+                reads = [this.followed(e, base)];
+        }
+        return reads.length === 0 ? out : { ...out, followed: reads };
+    }
+    /** what output column `attno` of query `q` computes, followed: one expression, or a set operation's, one per arm */
+    outputOf(q, attno, outer) {
+        if (this.open.has(q))
+            return [];
+        const known = this.columns.get(q)?.get(attno);
+        if (known !== undefined)
+            return known;
+        this.open.add(q);
+        let found;
+        try {
+            found = this.outputFound(q, attno, [...outer, q]);
+        }
+        finally {
+            this.open.delete(q);
+        }
+        const byColumn = this.columns.get(q) ?? new Map();
+        this.columns.set(q, byColumn.set(attno, found));
+        return found;
+    }
+    outputFound(q, attno, stack) {
+        if (isNode(q.setOperations ?? null)) {
+            const leaves = [];
+            const walk = (s) => {
+                if (s === undefined || !isNode(s))
+                    return;
+                if (s._node === "RANGETBLREF")
+                    leaves.push(num(s.rtindex ?? null) ?? 0);
+                else {
+                    walk(s.larg);
+                    walk(s.rarg);
+                }
+            };
+            walk(q.setOperations);
+            return leaves.flatMap((i) => {
+                const rte = Array.isArray(q.rtable) ? q.rtable[i - 1] : undefined;
+                return rte !== undefined && isNode(rte) && isNode(rte.subquery ?? null) ? this.outputOf(rte.subquery, attno, stack) : [];
+            });
+        }
+        const entry = Array.isArray(q.targetList) ? q.targetList.find((t) => isNode(t) && num(t.resno ?? null) === attno) : undefined;
+        return entry !== undefined && isNode(entry) && isNode(entry.expr ?? null) ? [this.followed(entry.expr, stack)] : [];
+    }
+}
+const RTE_SUBQUERY = 1;
+const RTE_CTE = 6;
 /** The analysed query's output columns, in order (resjunk ones, which a sort may add, left out): their types. */
 export function outputTypes(tree) {
     if (!isNode(tree) || tree._node !== "QUERY" || !Array.isArray(tree.targetList))