@crvouga/postgres-mem 1.0.1 → 1.1.0

package/dist/unstable.js

@@ -503,10 +503,26 @@ function timestampAddInterval(ts, iv) {
   return result;
 }
 
+// src/runtime/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw pgError("internal", message, "XX000");
+  }
+}
+function assertBounds(value, min, max, label) {
+  if (value < min || value > max) {
+    throw pgError("internal", `${label} out of bounds: ${value} not in [${min}, ${max}]`, "XX000");
+  }
+}
+function assertNever(value, message = "unreachable") {
+  throw pgError("internal", `${message}: ${String(value)}`, "XX000");
+}
+
 // src/types/numeric.ts
 var MAX_DISPLAY_SCALE = 1e3;
 var MIN_SIG_DIGITS = 16;
 function makeNumeric(coef, dscale) {
+  assertBounds(dscale, 0, MAX_DISPLAY_SCALE, "numeric dscale");
   return { kind: "numeric", coef, dscale, special: null };
 }
 var NUMERIC_NAN = { kind: "numeric", coef: 0n, dscale: 0, special: "nan" };
@@ -650,7 +666,13 @@ function numericMul(a, b) {
     if (sa === 0 || sb === 0) return NUMERIC_NAN;
     return sa * sb > 0 ? NUMERIC_PINF : NUMERIC_NINF;
   }
-  return makeNumeric(a.coef * b.coef, a.dscale + b.dscale);
+  let dscale = a.dscale + b.dscale;
+  let coef = a.coef * b.coef;
+  if (dscale > MAX_DISPLAY_SCALE) {
+    coef = roundToScale(coef, dscale, MAX_DISPLAY_SCALE);
+    dscale = MAX_DISPLAY_SCALE;
+  }
+  return makeNumeric(coef, dscale);
 }
 function decimalWeight(v) {
   if (v.coef === 0n) return 0;
@@ -805,7 +827,7 @@ function numericSqrt(a) {
   return makeNumeric(roundToScale(root, extraScale, rscale), rscale);
 }
 function bigintSqrt(n) {
-  if (n < 0n) throw new Error("negative");
+  if (n < 0n) throw pgError("internal", "bigintSqrt: negative operand", "XX000");
   if (n < 2n) return n;
   let x = 1n << BigInt(Math.ceil(n.toString(2).length / 2));
   for (; ; ) {
@@ -1083,6 +1105,8 @@ function numericStripTrailingZeros(v) {
 }
 
 // src/types/jsonb.ts
+var MAX_JSON_PARSE_DEPTH = 512;
+var JSON_TEXT_ENCODER = new TextEncoder();
 var JSONB_NULL = { j: "null" };
 function jsonbBool(v) {
   return { j: "bool", v };
@@ -1109,7 +1133,7 @@ var JsonParser = class {
   pos = 0;
   parse() {
     this.skipWs();
-    const v = this.parseValue();
+    const v = this.parseValue(0);
     this.skipWs();
     if (this.pos < this.text.length) this.fail("expected end of input");
     return v;
@@ -1124,11 +1148,14 @@ var JsonParser = class {
       else break;
     }
   }
-  parseValue() {
+  parseValue(depth) {
+    if (depth > MAX_JSON_PARSE_DEPTH) {
+      throw pgError("program_limit_exceeded", "json nesting depth exceeds maximum", "54000");
+    }
     const c = this.text[this.pos];
     if (c === void 0) this.fail("unexpected end");
-    if (c === "{") return this.parseObject();
-    if (c === "[") return this.parseArray();
+    if (c === "{") return this.parseObject(depth + 1);
+    if (c === "[") return this.parseArray(depth + 1);
     if (c === '"') return jsonbStr(this.parseString());
     if (c === "t") {
       this.expect("true");
@@ -1148,7 +1175,7 @@ var JsonParser = class {
     if (this.text.slice(this.pos, this.pos + word.length) !== word) this.fail(`expected ${word}`);
     this.pos += word.length;
   }
-  parseObject() {
+  parseObject(depth) {
     this.pos++;
     const m = /* @__PURE__ */ new Map();
     this.skipWs();
@@ -1164,7 +1191,7 @@ var JsonParser = class {
       if (this.text[this.pos] !== ":") this.fail("expected :");
       this.pos++;
       this.skipWs();
-      const value = this.parseValue();
+      const value = this.parseValue(depth);
       m.set(key, value);
       this.skipWs();
       const c = this.text[this.pos];
@@ -1179,7 +1206,7 @@ var JsonParser = class {
       this.fail("expected , or }");
     }
   }
-  parseArray() {
+  parseArray(depth) {
     this.pos++;
     const items = [];
     this.skipWs();
@@ -1189,7 +1216,7 @@ var JsonParser = class {
     }
     for (; ; ) {
       this.skipWs();
-      items.push(this.parseValue());
+      items.push(this.parseValue(depth));
       this.skipWs();
       const c = this.text[this.pos];
       if (c === ",") {
@@ -1305,8 +1332,8 @@ function escapeJsonString(s) {
   return `${out}"`;
 }
 function jsonbKeyCompare(a, b) {
-  const ea = new TextEncoder().encode(a);
-  const eb = new TextEncoder().encode(b);
+  const ea = JSON_TEXT_ENCODER.encode(a);
+  const eb = JSON_TEXT_ENCODER.encode(b);
   const n = Math.min(ea.length, eb.length);
   for (let i = 0; i < n; i++) {
     if (ea[i] !== eb[i]) return ea[i] < eb[i] ? -1 : 1;
@@ -1380,15 +1407,7 @@ function jsonbCompare(a, b) {
     }
     case "num": {
       const bb = b;
-      const na = numericStripTrailingZeros(a.v);
-      const nb = numericStripTrailingZeros(bb.v);
-      const ta = numericText(na);
-      const tb = numericText(nb);
-      if (ta === tb) return 0;
-      const fa = Number(ta);
-      const fb = Number(tb);
-      if (fa !== fb) return fa < fb ? -1 : 1;
-      return ta < tb ? -1 : 1;
+      return numericCmp(numericStripTrailingZeros(a.v), numericStripTrailingZeros(bb.v));
     }
     case "str": {
       const bb = b;
@@ -1418,6 +1437,8 @@ function jsonbCompare(a, b) {
       }
       return 0;
     }
+    default:
+      return assertNever(a);
   }
 }
 function jsonbContains(a, b) {
@@ -2196,6 +2217,74 @@ function tsvectorSetweight(vec, weight) {
   }).join(" ");
 }
 
+// src/types/jsonpath.ts
+function invalidJsonpath() {
+  throw pgError("invalid_text_representation", "invalid input syntax for type jsonpath", "22P02");
+}
+function parseJsonpath(text) {
+  const s = text.trim();
+  if (s.length === 0 || s[0] !== "$") invalidJsonpath();
+  let i = 1;
+  const steps = [];
+  while (i < s.length) {
+    const c = s[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    if (c === ".") {
+      i++;
+      if (s[i] === '"') {
+        i++;
+        let name = "";
+        while (i < s.length && s[i] !== '"') {
+          if (s[i] === "\\" && i + 1 < s.length) {
+            name += s[i + 1];
+            i += 2;
+          } else {
+            name += s[i];
+            i++;
+          }
+        }
+        if (s[i] !== '"') invalidJsonpath();
+        i++;
+        steps.push({ kind: "member", name });
+        continue;
+      }
+      const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(s.slice(i));
+      if (!m) invalidJsonpath();
+      steps.push({ kind: "member", name: m[0] });
+      i += m[0].length;
+      continue;
+    }
+    if (c === "[") {
+      const rest = s.slice(i);
+      const m = /^\[\s*(\d+)\s*\]/.exec(rest);
+      if (!m) invalidJsonpath();
+      steps.push({ kind: "index", index: Number(m[1]) });
+      i += m[0].length;
+      continue;
+    }
+    invalidJsonpath();
+  }
+  return steps;
+}
+function jsonpathQueryFirst(doc, pathText) {
+  const steps = parseJsonpath(pathText);
+  let cur = doc;
+  for (const step of steps) {
+    if (cur === null) return null;
+    if (step.kind === "member") {
+      if (cur.j !== "obj") return null;
+      cur = cur.v.get(step.name) ?? null;
+    } else {
+      if (cur.j !== "arr") return null;
+      cur = cur.v[step.index] ?? null;
+    }
+  }
+  return cur;
+}
+
 // src/types/value.ts
 function wrapJsonb(value) {
   return { kind: "jsonb", value };
@@ -2257,6 +2346,7 @@ var TYPE_ALIASES = {
   uuid: "uuid",
   json: "json",
   jsonb: "jsonb",
+  jsonpath: "jsonpath",
   regclass: "regclass",
   regtype: "regtype",
   regproc: "regproc",
@@ -2356,6 +2446,7 @@ var TYPE_OIDS = {
   record: 2249,
   uuid: 2950,
   jsonb: 3802,
+  jsonpath: 4072,
   tsvector: 3614,
   tsquery: 3615,
   void: 2278,
@@ -2477,8 +2568,8 @@ function parseFloatText(text, type) {
       throw pgError("numeric_value_out_of_range", `"${text}" is out of range for type real`);
     }
   }
-  if (v === 0) v = 0;
-  return Number(t) === 0 && t.startsWith("-") ? -0 : v;
+  if (Number(t) === 0 && t.startsWith("-")) return -0;
+  return v;
 }
 var INT2_MIN = -32768;
 var INT2_MAX = 32767;
@@ -2681,6 +2772,7 @@ function datumText(t, v, ctx) {
     case "regclass":
     case "regtype":
     case "regproc":
+    case "jsonpath":
     case "tsvector":
     case "tsquery":
     case "bit":
@@ -2762,6 +2854,9 @@ function datumFromText(t, text, ctx) {
       return text;
     case "jsonb":
       return wrapJsonb(parseJsonText(text));
+    case "jsonpath":
+      parseJsonpath(text);
+      return text;
     case "bytea":
       return parseByteaText(text);
     case "date":
@@ -3663,6 +3758,21 @@ function getJsonFunctions() {
   });
   m.set("json_typeof", typeofFn);
   m.set("jsonb_typeof", typeofFn);
+  m.set("jsonb_path_query_first", (ctx, args) => {
+    if (args.length < 2) {
+      throw pgError(
+        "undefined_function",
+        `function jsonb_path_query_first(${args.map((a) => a.t).join(", ")}) does not exist`,
+        "42883"
+      );
+    }
+    if (args[0].v === null || args[1].v === null) return tv("jsonb", null);
+    const doc = jsonArg(ctx, args[0]);
+    const path = args[1].t === "jsonpath" ? args[1].v : argText(ctx, args[1]);
+    const found = jsonpathQueryFirst(doc, path);
+    if (found === null) return tv("jsonb", null);
+    return outJsonb(found);
+  });
   m.set(
     "json_array_length",
     strict("int4", (ctx, args) => {
@@ -5975,7 +6085,7 @@ function getMathFunctions() {
         if (isFloatArg(a)) {
           const f = argFloat(ctx, a);
           const r = f >= 0 ? Math.round(f) : -Math.round(-f);
-          return tv("float8", Object.is(r, -0) ? 0 : r);
+          return tv("float8", r);
         }
         if (isIntType(a.t)) return tv(a.t, a.v);
         return tv("numeric", numericRound(argNumeric(ctx, a), 0));
@@ -6429,6 +6539,7 @@ function parseQualifiedName(name) {
   return parts.map((p) => p.trim()).filter((p) => p.length > 0);
 }
 function sequenceNextval(ctx, seq) {
+  seq = ctx.state.ensureWritableSequence(seq);
   let next;
   if (!seq.isCalled) {
     next = seq.lastValue;
@@ -6555,7 +6666,7 @@ function getMiscFunctions() {
   m.set(
     "setval",
     strict("int8", (ctx, args) => {
-      const seq = findSequenceForCall(ctx, argText(ctx, args[0]));
+      const seq = ctx.state.ensureWritableSequence(findSequenceForCall(ctx, argText(ctx, args[0])));
       const value = argBigInt(ctx, args[1]);
       const isCalled = args.length > 2 ? args[2].v === true : true;
       if (value < seq.minValue || value > seq.maxValue) {
@@ -8428,7 +8539,7 @@ function pgClass(ctx) {
   for (const schemaData of state.schemas.values()) {
     for (const t of schemaData.tables.values()) {
       const hasIndex = t.constraints.some((c) => c.kind === "primary_key" || c.kind === "unique") || [...schemaData.indexes.values()].some((i) => i.table === t.name);
-      push(t.oid, t.name, t.schema, "r", t.columns.length, t.rows.length, hasIndex, true, t.temp);
+      push(t.oid, t.name, t.schema, "r", t.columns.length, t.rowCount(), hasIndex, true, t.temp);
     }
     for (const v of schemaData.views.values()) {
       push(
@@ -9624,6 +9735,7 @@ var TYPE_LITERAL_NAMES = /* @__PURE__ */ new Set([
   "uuid",
   "json",
   "jsonb",
+  "jsonpath",
   "money",
   "name",
   "oid",
@@ -10025,6 +10137,23 @@ var Parser = class {
   skipToStatementEnd() {
     while (this.peek().type !== "eof" && !this.atPunct(";")) this.pos++;
   }
+  /** Consume tokens until the matching `)` after an opening `(` already eaten. */
+  skipBalancedCloseParen() {
+    let depth = 1;
+    while (depth > 0) {
+      const t = this.peek();
+      if (t.type === "eof") throw pgError("syntax", 'unterminated "(" in ALTER TABLE SET', "42601");
+      if (this.eatPunct("(")) {
+        depth++;
+        continue;
+      }
+      if (this.eatPunct(")")) {
+        depth--;
+        continue;
+      }
+      this.pos++;
+    }
+  }
   // --- WITH-able statements --------------------------------------------------
   parseWithableStatement() {
     if (this.atKw("with")) {
@@ -11921,6 +12050,10 @@ var Parser = class {
     }
     if (this.eatKw("set")) {
       if (this.eatKw("schema")) return { kind: "set_schema", to: this.ident() };
+      if (this.eatPunct("(")) {
+        this.skipBalancedCloseParen();
+        return { kind: "reloptions" };
+      }
       throw unsupported("this ALTER TABLE SET form");
     }
     if (this.eatKw("owner")) {
@@ -13149,6 +13282,55 @@ function parseSingle(sql) {
   return statements[0];
 }
 
+// src/types/resolve.ts
+var SERIALS = {
+  smallserial: "int2",
+  serial2: "int2",
+  serial: "int4",
+  serial4: "int4",
+  bigserial: "int8",
+  serial8: "int8"
+};
+function modOf(t, mods) {
+  if (mods.length === 0) return null;
+  if (t === "numeric") return { a: mods[0], b: mods[1] ?? 0 };
+  return { a: mods[0] };
+}
+function resolveTypeName(state, tn) {
+  const joined = tn.parts.join(".");
+  const bare = tn.parts.length === 1 ? tn.parts[0] : tn.parts.length === 2 && tn.parts[0] === "pg_catalog" ? tn.parts[1] : null;
+  if (bare !== null) {
+    const serial = SERIALS[bare];
+    if (serial !== void 0 && tn.arrayDims === 0) {
+      return { column: { id: serial, mod: null }, domain: null, serial };
+    }
+    const builtin = normalizeTypeName(bare);
+    if (builtin !== null) {
+      const id = tn.arrayDims > 0 ? arrayTypeOf(builtin) : builtin;
+      return { column: { id, mod: modOf(builtin, tn.mods) }, domain: null, serial: null };
+    }
+  }
+  const enumData = state.findEnum(tn.parts);
+  if (enumData) {
+    const elem = `enum:${enumData.schema}.${enumData.name}`;
+    const id = tn.arrayDims > 0 ? arrayTypeOf(elem) : elem;
+    return { column: { id, mod: null }, domain: null, serial: null };
+  }
+  const domainData = state.findDomain(tn.parts);
+  if (domainData) {
+    if (tn.arrayDims > 0) {
+      const id = arrayTypeOf(domainData.baseType.id);
+      return { column: { id, mod: domainData.baseType.mod }, domain: null, serial: null };
+    }
+    return {
+      column: domainData.baseType,
+      domain: `${domainData.schema}.${domainData.name}`,
+      serial: null
+    };
+  }
+  throw pgError("undefined_object", `type "${joined}" does not exist`);
+}
+
 // src/executor/relation.ts
 var RowScope = class {
   constructor(columns, row, parent = null, rangeVars = /* @__PURE__ */ new Set()) {
@@ -13283,55 +13465,6 @@ function inferColumnName(e) {
   }
 }
 
-// src/types/resolve.ts
-var SERIALS = {
-  smallserial: "int2",
-  serial2: "int2",
-  serial: "int4",
-  serial4: "int4",
-  bigserial: "int8",
-  serial8: "int8"
-};
-function modOf(t, mods) {
-  if (mods.length === 0) return null;
-  if (t === "numeric") return { a: mods[0], b: mods[1] ?? 0 };
-  return { a: mods[0] };
-}
-function resolveTypeName(state, tn) {
-  const joined = tn.parts.join(".");
-  const bare = tn.parts.length === 1 ? tn.parts[0] : tn.parts.length === 2 && tn.parts[0] === "pg_catalog" ? tn.parts[1] : null;
-  if (bare !== null) {
-    const serial = SERIALS[bare];
-    if (serial !== void 0 && tn.arrayDims === 0) {
-      return { column: { id: serial, mod: null }, domain: null, serial };
-    }
-    const builtin = normalizeTypeName(bare);
-    if (builtin !== null) {
-      const id = tn.arrayDims > 0 ? arrayTypeOf(builtin) : builtin;
-      return { column: { id, mod: modOf(builtin, tn.mods) }, domain: null, serial: null };
-    }
-  }
-  const enumData = state.findEnum(tn.parts);
-  if (enumData) {
-    const elem = `enum:${enumData.schema}.${enumData.name}`;
-    const id = tn.arrayDims > 0 ? arrayTypeOf(elem) : elem;
-    return { column: { id, mod: null }, domain: null, serial: null };
-  }
-  const domainData = state.findDomain(tn.parts);
-  if (domainData) {
-    if (tn.arrayDims > 0) {
-      const id = arrayTypeOf(domainData.baseType.id);
-      return { column: { id, mod: domainData.baseType.mod }, domain: null, serial: null };
-    }
-    return {
-      column: domainData.baseType,
-      domain: `${domainData.schema}.${domainData.name}`,
-      serial: null
-    };
-  }
-  throw pgError("undefined_object", `type "${joined}" does not exist`);
-}
-
 // src/expressions/operators.ts
 var NUM_LADDER = ["int2", "int4", "int8", "numeric", "float4", "float8"];
 function opNotExist(op, l, r) {
@@ -14954,12 +15087,12 @@ function evalFuncCall(ctx, scope, e) {
   if (bare !== null) {
     const stateful = scope.callStatefulFunction?.(bare, args);
     if (stateful !== void 0) return stateful;
-    if (hasScalarFunction(bare)) {
-      return callScalarFunction(ctx, bare, args);
-    }
   }
   const user = scope.callUserFunction?.(e.name, args, e);
   if (user !== void 0) return user;
+  if (bare !== null && hasScalarFunction(bare)) {
+    return callScalarFunction(ctx, bare, args);
+  }
   throw pgError(
     "undefined_function",
     `function ${e.name.join(".")}(${args.map((a) => a.t).join(", ")}) does not exist`
@@ -15075,82 +15208,524 @@ function evalLazyFunc(ctx, scope, name, argExprs) {
   }
 }
 
-// src/executor/window.ts
-function compareKeys(ctx, a, b) {
-  for (let i = 0; i < a.values.length; i++) {
-    const av = a.values[i];
-    const bv = b.values[i];
-    const desc = a.dirs[i] === "desc";
-    const nullsFirst = a.nullsFirst[i];
-    if (av === null || bv === null) {
-      if (av === null && bv === null) continue;
-      const nullCmp = av === null ? -1 : 1;
-      const cmp = nullsFirst ? nullCmp : -nullCmp;
-      if (cmp !== 0) return cmp;
-      continue;
-    }
-    let c = datumCompare(a.types[i], av, bv, ctx);
-    if (desc) c = -c;
-    if (c !== 0) return c;
-  }
-  return 0;
-}
-function computeWindowValues(ctx, calls, rowCount, evalAt, namedWindows) {
-  const out = /* @__PURE__ */ new Map();
-  for (const call of calls) {
-    const spec = resolveWindowSpec(call.over, namedWindows);
-    out.set(call, computeOneWindow(ctx, call, spec, rowCount, evalAt));
-  }
-  return out;
-}
-function resolveWindowSpec(spec, named) {
-  if (!spec.name) return spec;
-  const base = named.find((w) => w.name === spec.name);
-  if (!base) throw pgError("undefined_object", `window "${spec.name}" does not exist`, "42704");
-  return {
-    partitionBy: base.spec.partitionBy.length > 0 ? base.spec.partitionBy : spec.partitionBy,
-    orderBy: base.spec.orderBy.length > 0 ? base.spec.orderBy : spec.orderBy,
-    frame: spec.frame ?? base.spec.frame
-  };
+// src/constraints/enforce.ts
+function tableScope(table, row) {
+  const cols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: table.name }));
+  return new RowScope(cols, row, null, /* @__PURE__ */ new Set([table.name]));
 }
-function computeOneWindow(ctx, call, spec, rowCount, evalAt) {
-  const partitions = /* @__PURE__ */ new Map();
-  const partitionOf = [];
-  for (let i = 0; i < rowCount; i++) {
-    const keyParts = [];
-    for (const p of spec.partitionBy) {
-      const v = evalAt(i, p);
-      keyParts.push(v.v === null ? "\0N" : datumKey(v.t === UNKNOWN ? "text" : v.t, v.v));
+function checkNotNull(env, table, row) {
+  void env;
+  for (let i = 0; i < table.columns.length; i++) {
+    const c = table.columns[i];
+    if (c.notNull && (row[i] ?? null) === null) {
+      throw pgError(
+        "not_null_violation",
+        `null value in column "${c.name}" of relation "${table.name}" violates not-null constraint`,
+        "23502"
+      );
     }
-    const key = keyParts.join("
");
-    partitionOf.push(key);
-    const list = partitions.get(key) ?? [];
-    list.push(i);
-    partitions.set(key, list);
-  }
-  const results = new Array(rowCount);
-  for (const rowIdxs of partitions.values()) {
-    computePartition(ctx, call, spec, rowIdxs, evalAt, results);
   }
-  return results;
 }
-function computePartition(ctx, call, spec, rowIdxs, evalAt, results) {
-  const keys = /* @__PURE__ */ new Map();
-  if (spec.orderBy.length > 0) {
-    for (const i of rowIdxs) {
-      keys.set(i, sortKeyFor(ctx, spec.orderBy, i, evalAt));
-    }
-    rowIdxs = [...rowIdxs].sort((a, b) => compareKeys(ctx, keys.get(a), keys.get(b)));
-  }
-  const n = rowIdxs.length;
-  const peerGroup = new Array(n);
-  let group = 0;
-  for (let pos = 0; pos < n; pos++) {
-    if (pos > 0) {
-      const same = spec.orderBy.length === 0 || compareKeys(ctx, keys.get(rowIdxs[pos - 1]), keys.get(rowIdxs[pos])) === 0;
-      if (!same) group++;
+function checkChecks(env, table, row) {
+  for (const con of table.constraints) {
+    if (con.kind !== "check") continue;
+    const scope = makeEvalScope(env, tableScope(table, row));
+    const v = evalExpr(env.ctx, scope, con.expr);
+    if (v.v === null) continue;
+    const b = castTo(env.ctx, v, "bool", {});
+    if (b.v !== true) {
+      throw pgError(
+        "check_violation",
+        `new row for relation "${table.name}" violates check constraint "${con.name}"`,
+        "23514"
+      );
     }
-    peerGroup[pos] = group;
+  }
+}
+function uniqueSpecsFor(env, table) {
+  const specs = [];
+  for (const con of table.constraints) {
+    if (con.kind !== "primary_key" && con.kind !== "unique") continue;
+    specs.push({
+      name: con.name,
+      keys: con.columns.map((c) => ({ colIdx: table.columnIndex(c), expr: null })),
+      columnNames: con.columns,
+      nullsNotDistinct: con.kind === "unique" ? con.nullsNotDistinct : false,
+      where: null,
+      isPrimary: con.kind === "primary_key"
+    });
+  }
+  const schema = env.ctx.state.schemas.get(table.schema);
+  if (schema) {
+    for (const idx of schema.indexes.values()) {
+      if (idx.table !== table.name || !idx.unique || idx.isConstraint) continue;
+      specs.push({
+        name: idx.name,
+        keys: idx.columns.map((c) => ({
+          colIdx: c.column !== null ? table.columnIndex(c.column) : -1,
+          expr: c.expr
+        })),
+        columnNames: idx.columns.map((c) => c.column ?? "expr"),
+        nullsNotDistinct: idx.nullsNotDistinct,
+        where: idx.where,
+        isPrimary: false
+      });
+    }
+  }
+  return specs;
+}
+function uniqueKeyOf(env, table, spec, row) {
+  if (spec.where) {
+    const scope = makeEvalScope(env, tableScope(table, row));
+    const v = evalExpr(env.ctx, scope, spec.where);
+    if (v.v !== true) return null;
+  }
+  const parts = [];
+  let hasNull = false;
+  for (const k of spec.keys) {
+    let value;
+    let type;
+    if (k.expr) {
+      const scope = makeEvalScope(env, tableScope(table, row));
+      const v = evalExpr(env.ctx, scope, k.expr);
+      value = v.v;
+      type = v.t === "unknown" ? "text" : v.t;
+    } else {
+      value = row[k.colIdx] ?? null;
+      type = table.columns[k.colIdx].type.id;
+    }
+    if (value === null) {
+      hasNull = true;
+      parts.push("\0N");
+    } else {
+      parts.push(datumKey(type, value));
+    }
+  }
+  if (hasNull && !spec.nullsNotDistinct) return null;
+  return parts.join("
");
+}
+function checkUnique(env, table, row, selfIdx) {
+  for (const spec of uniqueSpecsFor(env, table)) {
+    const key = uniqueKeyOf(env, table, spec, row);
+    if (key === null) continue;
+    indexStoreFor(env, table, spec).checkUnique(key, selfIdx);
+  }
+}
+function findConflict(env, table, spec, row) {
+  const key = uniqueKeyOf(env, table, spec, row);
+  if (key === null) return null;
+  const hits = indexStoreFor(env, table, spec).lookup(key);
+  return hits.length > 0 ? hits[0] : null;
+}
+function checkForeignKeys(env, table, row) {
+  const state = env.ctx.state;
+  for (const con of table.constraints) {
+    if (con.kind !== "foreign_key") continue;
+    const values = con.columns.map((c) => row[table.columnIndex(c)] ?? null);
+    const nulls = values.filter((v) => v === null).length;
+    if (con.match === "simple" && nulls > 0) continue;
+    if (con.match === "full") {
+      if (nulls === values.length) continue;
+      if (nulls > 0) {
+        throw pgError(
+          "constraint_foreign_key",
+          `insert or update on table "${table.name}" violates foreign key constraint "${con.name}"`,
+          "23503"
+        );
+      }
+    }
+    const refTable = state.schemas.get(con.refSchema)?.tables.get(con.refTable);
+    if (!refTable) {
+      throw pgError("undefined_table", `relation "${con.refSchema}.${con.refTable}" does not exist`, "42P01");
+    }
+    const refIdxs = con.refColumns.map((c) => refTable.columnIndex(c));
+    const keyTypes = con.refColumns.map((_c, i) => refTable.columns[refIdxs[i]].type.id);
+    const wanted = values.map((v, i) => {
+      const localT = table.columns[table.columnIndex(con.columns[i])].type.id;
+      const cast = castTo(env.ctx, tv(localT, v), keyTypes[i], {});
+      return cast.v === null ? "\0N" : datumKey(keyTypes[i], cast.v);
+    }).join("
");
+    let found = false;
+    for (let i = 0; i < refTable.rowCount(); i++) {
+      const r = refTable.rowAt(i);
+      const key = refIdxs.map((ri, j) => {
+        const v = r[ri] ?? null;
+        return v === null ? "\0N" : datumKey(keyTypes[j], v);
+      }).join("
");
+      if (key === wanted) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      throw pgError(
+        "constraint_foreign_key",
+        `insert or update on table "${table.name}" violates foreign key constraint "${con.name}"`,
+        "23503"
+      );
+    }
+  }
+}
+function referencingConstraints(env, table) {
+  const out = [];
+  for (const schema of env.ctx.state.schemas.values()) {
+    for (const t of schema.tables.values()) {
+      for (const con of t.constraints) {
+        if (con.kind === "foreign_key" && con.refSchema === table.schema && con.refTable === table.name) {
+          out.push({ table: t, constraint: con });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// src/indexes/index.ts
+var IndexStore = class _IndexStore {
+  name;
+  unique;
+  entries = /* @__PURE__ */ new Map();
+  constructor(name, unique = false) {
+    this.name = name;
+    this.unique = unique;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  checkUnique(key, rowIdx) {
+    const existing = this.entries.get(key);
+    if (!existing) return;
+    for (const i of existing) {
+      if (rowIdx === void 0 || i !== rowIdx) {
+        throw pgError("constraint_unique", `duplicate key value violates unique constraint "${this.name}"`, "23505");
+      }
+    }
+  }
+  insert(key, rowIdx) {
+    if (this.unique) this.checkUnique(key, rowIdx);
+    const existing = this.entries.get(key);
+    if (!existing) {
+      this.entries.set(key, [rowIdx]);
+      return;
+    }
+    if (existing.includes(rowIdx)) return;
+    existing.push(rowIdx);
+  }
+  remove(key, rowIdx) {
+    const existing = this.entries.get(key);
+    if (!existing) return;
+    const at = existing.indexOf(rowIdx);
+    if (at < 0) return;
+    existing.splice(at, 1);
+    if (existing.length === 0) this.entries.delete(key);
+  }
+  lookup(key) {
+    return this.entries.get(key) ?? [];
+  }
+  clear() {
+    this.entries.clear();
+  }
+  clone() {
+    const copy = new _IndexStore(this.name, this.unique);
+    for (const [key, rowids] of this.entries) copy.entries.set(key, [...rowids]);
+    return copy;
+  }
+};
+
+// src/indexes/maintain.ts
+function ensureIndexStores(env, table) {
+  if (table.indexStores) return table.indexStores;
+  const stores = /* @__PURE__ */ new Map();
+  for (const spec of uniqueSpecsFor(env, table)) {
+    const store = new IndexStore(spec.name, true);
+    for (let i = 0; i < table.rowCount(); i++) {
+      const key = uniqueKeyOf(env, table, spec, table.rowAt(i));
+      if (key !== null) store.insert(key, i);
+    }
+    stores.set(spec.name, store);
+  }
+  const schema = env.ctx.state.schemas.get(table.schema);
+  if (schema) {
+    for (const idx of schema.indexes.values()) {
+      if (idx.table !== table.name || idx.unique) continue;
+      stores.set(idx.name, new IndexStore(idx.name, false));
+    }
+  }
+  table.indexStores = stores;
+  return stores;
+}
+function indexStoreFor(env, table, spec) {
+  const stores = ensureIndexStores(env, table);
+  let store = stores.get(spec.name);
+  if (!store) {
+    store = new IndexStore(spec.name, true);
+    for (let i = 0; i < table.rowCount(); i++) {
+      const key = uniqueKeyOf(env, table, spec, table.rowAt(i));
+      if (key !== null) store.insert(key, i);
+    }
+    stores.set(spec.name, store);
+  }
+  return store;
+}
+function indexInsertRow(env, table, rowIdx, row) {
+  for (const spec of uniqueSpecsFor(env, table)) {
+    const key = uniqueKeyOf(env, table, spec, row);
+    if (key === null) continue;
+    indexStoreFor(env, table, spec).insert(key, rowIdx);
+  }
+}
+function indexRemoveRow(env, table, rowIdx, row) {
+  if (!table.indexStores) return;
+  for (const spec of uniqueSpecsFor(env, table)) {
+    const key = uniqueKeyOf(env, table, spec, row);
+    if (key === null) continue;
+    table.indexStores.get(spec.name)?.remove(key, rowIdx);
+  }
+}
+function indexUpdateRow(env, table, rowIdx, oldRow, newRow) {
+  indexRemoveRow(env, table, rowIdx, oldRow);
+  indexInsertRow(env, table, rowIdx, newRow);
+}
+function rebuildTableIndexes(env, table) {
+  table.indexStores = null;
+  ensureIndexStores(env, table);
+}
+
+// src/planner/access.ts
+function isRowIndependentExpr(expr) {
+  return expr.type !== "colref";
+}
+function equalityAgainstConst(expr) {
+  if (expr.type !== "binop" || expr.op !== "=") return null;
+  if (expr.left.type === "colref" && isRowIndependentExpr(expr.right)) {
+    const parts = expr.left.parts;
+    const column = parts[parts.length - 1];
+    return { column, valueExpr: expr.right };
+  }
+  if (expr.right.type === "colref" && isRowIndependentExpr(expr.left)) {
+    const parts = expr.right.parts;
+    const column = parts[parts.length - 1];
+    return { column, valueExpr: expr.left };
+  }
+  return null;
+}
+function conjunctions(expr) {
+  if (expr.type === "binop" && expr.op === "and") {
+    return [...conjunctions(expr.left), ...conjunctions(expr.right)];
+  }
+  return [expr];
+}
+function tryIndexedTableRows(env, table, alias, where) {
+  const parts = conjunctions(where);
+  const eqs = [];
+  for (const part of parts) {
+    const eq = equalityAgainstConst(part);
+    if (!eq) return null;
+    eqs.push(eq);
+  }
+  if (eqs.length === 0) return null;
+  let spec = null;
+  for (const candidate of uniqueSpecsFor(env, table)) {
+    if (candidate.keys.length !== eqs.length) continue;
+    const names = candidate.columnNames;
+    if (eqs.every((eq, i) => names[i] === eq.column)) {
+      spec = candidate;
+      break;
+    }
+  }
+  if (!spec) return null;
+  const probeRow = table.columns.map(() => null);
+  const scope = new RowScope(
+    table.columns.map((c) => ({ name: c.name, type: c.type.id, table: alias })),
+    probeRow,
+    env.outer,
+    /* @__PURE__ */ new Set([alias])
+  );
+  for (let i = 0; i < eqs.length; i++) {
+    const k = spec.keys[i];
+    if (k.expr) return null;
+    const colIdx = k.colIdx;
+    const v = evalExpr(env.ctx, makeEvalScope(env, scope), eqs[i].valueExpr);
+    probeRow[colIdx] = castTo(env.ctx, v, table.columns[colIdx].type.id, {}).v;
+  }
+  const key = uniqueKeyOf(env, table, spec, probeRow);
+  if (key === null) return [];
+  const hits = indexStoreFor(env, table, spec).lookup(key);
+  return hits.map((i) => table.rowAt(i));
+}
+function tryIndexedFromItem(env, item, where) {
+  if (!where || item.type !== "from_table") return null;
+  const state = env.ctx.state;
+  const table = state.findTable(item.name);
+  if (!table) return null;
+  const alias = item.alias ?? item.name[item.name.length - 1];
+  table.materializeSlab();
+  return tryIndexedTableRows(env, table, alias, where);
+}
+function joinKeyFromRow(row, colIdxs, srcTypes, unifiedTypes, ctx) {
+  const parts = [];
+  for (let i = 0; i < colIdxs.length; i++) {
+    const v = row[colIdxs[i]] ?? null;
+    if (v === null) return null;
+    const cast = castTo(ctx, tv(srcTypes[i], v), unifiedTypes[i], {}).v;
+    if (cast === null) return null;
+    parts.push(datumKey(unifiedTypes[i], cast));
+  }
+  return parts.join("
");
+}
+function rowsMatchEqKeys(ctx, left, right, leftIdxs, rightIdxs, leftTypes, rightTypes, unifiedTypes) {
+  for (let k = 0; k < leftIdxs.length; k++) {
+    const lv = left[leftIdxs[k]] ?? null;
+    const rv = right[rightIdxs[k]] ?? null;
+    if (lv === null || rv === null) return false;
+    const lc = castTo(ctx, tv(leftTypes[k], lv), unifiedTypes[k], {}).v;
+    const rc = castTo(ctx, tv(rightTypes[k], rv), unifiedTypes[k], {}).v;
+    if (lc === null || rc === null) return false;
+    if (datumCompare(unifiedTypes[k], lc, rc, ctx) !== 0) return false;
+  }
+  return true;
+}
+
+// src/api/bind.ts
+var INT4_MIN2 = -2147483648;
+var INT4_MAX2 = 2147483647;
+function bindValueToTyped(value, index) {
+  if (value === null || value === void 0) return tv(UNKNOWN, null);
+  switch (typeof value) {
+    case "boolean":
+      return tv("bool", value);
+    case "number":
+      if (Number.isInteger(value) && value >= INT4_MIN2 && value <= INT4_MAX2) {
+        return tv("int4", value);
+      }
+      if (Number.isInteger(value) && Number.isSafeInteger(value)) {
+        return tv("int8", BigInt(value));
+      }
+      return tv("float8", value);
+    case "bigint":
+      if (value < -9223372036854775808n || value > 9223372036854775807n) {
+        throw pgError("numeric_value_out_of_range", `bigint parameter $${index + 1} out of int8 range`, "22003");
+      }
+      return tv("int8", value);
+    case "string":
+      return tv(UNKNOWN, value);
+    case "object": {
+      if (value instanceof Uint8Array) return tv("bytea", value);
+      if (value instanceof Date) {
+        const ms = value.getTime();
+        if (Number.isNaN(ms)) {
+          throw pgError("invalid_datetime", `invalid Date parameter $${index + 1}`, "22008");
+        }
+        return tv("timestamptz", BigInt(Math.round(ms)) * 1000n + UNIX_EPOCH_MICROS_FROM_PG);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  throw pgError("misuse", `unsupported parameter type for $${index + 1}: ${typeof value}`, "XX000");
+}
+function datumToJs(t, v, ctx, int8 = "bigint") {
+  if (v === null) return null;
+  switch (t) {
+    case "bool":
+      return v;
+    case "int2":
+    case "int4":
+    case "oid":
+      return typeof v === "bigint" ? Number(v) : v;
+    case "int8": {
+      const n = typeof v === "bigint" ? v : BigInt(v);
+      if (int8 === "string") return n.toString();
+      if (int8 === "number") return Number(n);
+      return n;
+    }
+    case "float4":
+    case "float8":
+      return v;
+    case "bytea":
+      return v;
+    default:
+      return datumText(t === UNKNOWN ? "text" : t, v, ctx);
+  }
+}
+
+// src/executor/window.ts
+function compareKeys(ctx, a, b) {
+  for (let i = 0; i < a.values.length; i++) {
+    const av = a.values[i];
+    const bv = b.values[i];
+    const desc = a.dirs[i] === "desc";
+    const nullsFirst = a.nullsFirst[i];
+    if (av === null || bv === null) {
+      if (av === null && bv === null) continue;
+      const nullCmp = av === null ? -1 : 1;
+      const cmp = nullsFirst ? nullCmp : -nullCmp;
+      if (cmp !== 0) return cmp;
+      continue;
+    }
+    let c = datumCompare(a.types[i], av, bv, ctx);
+    if (desc) c = -c;
+    if (c !== 0) return c;
+  }
+  return 0;
+}
+function computeWindowValues(ctx, calls, rowCount, evalAt, namedWindows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const spec = resolveWindowSpec(call.over, namedWindows);
+    out.set(call, computeOneWindow(ctx, call, spec, rowCount, evalAt));
+  }
+  return out;
+}
+function resolveWindowSpec(spec, named) {
+  if (!spec.name) return spec;
+  const base = named.find((w) => w.name === spec.name);
+  if (!base) throw pgError("undefined_object", `window "${spec.name}" does not exist`, "42704");
+  return {
+    partitionBy: base.spec.partitionBy.length > 0 ? base.spec.partitionBy : spec.partitionBy,
+    orderBy: base.spec.orderBy.length > 0 ? base.spec.orderBy : spec.orderBy,
+    frame: spec.frame ?? base.spec.frame
+  };
+}
+function computeOneWindow(ctx, call, spec, rowCount, evalAt) {
+  const partitions = /* @__PURE__ */ new Map();
+  const partitionOf = [];
+  for (let i = 0; i < rowCount; i++) {
+    const keyParts = [];
+    for (const p of spec.partitionBy) {
+      const v = evalAt(i, p);
+      keyParts.push(v.v === null ? "\0N" : datumKey(v.t === UNKNOWN ? "text" : v.t, v.v));
+    }
+    const key = keyParts.join("
");
+    partitionOf.push(key);
+    const list = partitions.get(key) ?? [];
+    list.push(i);
+    partitions.set(key, list);
+  }
+  const results = new Array(rowCount);
+  for (const rowIdxs of partitions.values()) {
+    computePartition(ctx, call, spec, rowIdxs, evalAt, results);
+  }
+  return results;
+}
+function computePartition(ctx, call, spec, rowIdxs, evalAt, results) {
+  const keys = /* @__PURE__ */ new Map();
+  if (spec.orderBy.length > 0) {
+    for (const i of rowIdxs) {
+      keys.set(i, sortKeyFor(ctx, spec.orderBy, i, evalAt));
+    }
+    rowIdxs = [...rowIdxs].sort((a, b) => compareKeys(ctx, keys.get(a), keys.get(b)));
+  }
+  const n = rowIdxs.length;
+  const peerGroup = new Array(n);
+  let group = 0;
+  for (let pos = 0; pos < n; pos++) {
+    if (pos > 0) {
+      const same = spec.orderBy.length === 0 || compareKeys(ctx, keys.get(rowIdxs[pos - 1]), keys.get(rowIdxs[pos])) === 0;
+      if (!same) group++;
+    }
+    peerGroup[pos] = group;
   }
   const groupCount = n === 0 ? 0 : peerGroup[n - 1] + 1;
   const name = call.name[call.name.length - 1];
@@ -15162,6 +15737,10 @@ function computePartition(ctx, call, spec, rowIdxs, evalAt, results) {
     throw pgError("undefined_function", `function ${name} does not exist as a window function`, "42883");
   }
   const frame = spec.frame ?? defaultFrame(spec);
+  if (!call.filter && (name === "sum" || name === "count") && isRunningRowsFrame(frame, spec)) {
+    computeRunningAgg(ctx, call, name, rowIdxs, evalAt, results);
+    return;
+  }
   for (let pos = 0; pos < n; pos++) {
     const [lo, hi] = frameBounds(ctx, frame, pos, rowIdxs, peerGroup, keys, spec, evalAt);
     const included = [];
@@ -15212,6 +15791,28 @@ function defaultFrame(spec) {
     exclusion: null
   };
 }
+function isRunningRowsFrame(frame, spec) {
+  if (frame.exclusion) return false;
+  if (frame.mode !== "rows") return false;
+  if (frame.start.kind !== "unbounded_preceding") return false;
+  const end = frame.end ?? (spec.orderBy.length > 0 ? { kind: "current_row" } : { kind: "unbounded_following" });
+  return end.kind === "current_row";
+}
+function computeRunningAgg(ctx, call, name, rowIdxs, evalAt, results) {
+  const argTypes = call.args.map((_, ai) => {
+    for (const rowIdx of rowIdxs) {
+      const v = evalAt(rowIdx, call.args[ai]);
+      if (v.t !== UNKNOWN) return v.t;
+    }
+    return UNKNOWN;
+  });
+  const acc = createAggregate(ctx, name, argTypes);
+  for (const rowIdx of rowIdxs) {
+    const argRows = call.star ? [] : call.args.map((a) => evalAt(rowIdx, a));
+    acc.step(argRows);
+    results[rowIdx] = acc.result();
+  }
+}
 function excluded(frame, pos, current, peerGroup) {
   switch (frame.exclusion) {
     case "current_row":
@@ -15527,7 +16128,7 @@ function makeEvalScope(env, scope, extras) {
     },
     callUserFunction(name, args, node) {
       void node;
-      const fn = resolveUserFunction(env, name, args.length);
+      const fn = resolveUserFunctionForArgs(env, name, args);
       if (!fn) return void 0;
       return callSqlFunctionScalar(env, fn, args);
     },
@@ -15543,11 +16144,19 @@ function evalPredicate(env, scope, e, extras) {
   const b = castTo(env.ctx, v, "bool", {});
   return b.v === true;
 }
-function resolveUserFunction(env, name, argCount) {
+function resolveUserFunctionForArgs(env, name, args) {
   const candidates = env.ctx.state.findFunctions(name);
   for (const fn of candidates) {
     const required = fn.argDefaults.filter((d) => d === null).length;
-    if (argCount >= required && argCount <= fn.argTypes.length) return fn;
+    if (args.length < required || args.length > fn.argTypes.length) continue;
+    let ok = true;
+    for (let i = 0; i < args.length; i++) {
+      if (!canImplicitCast(args[i].t, fn.argTypes[i])) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return fn;
   }
   return null;
 }
@@ -15585,6 +16194,19 @@ function runFunctionBody(env, fn, args) {
 }
 function callSqlFunctionScalar(env, fn, args) {
   const retT = fn.returns ?? "text";
+  if (fn.language === "plpgsql") {
+    return callPlpgsqlScalar(env, fn, args);
+  }
+  if (fn.language === "js") {
+    if (!fn.jsImpl) {
+      throw pgError("undefined_function", `JavaScript function ${fn.name} is not registered`, "42883");
+    }
+    if (fn.strict && args.some((a) => a.v === null)) return tv(retT, null);
+    const jsArgs = args.map((a) => datumToJs(a.t, a.v, env.ctx));
+    const out = fn.jsImpl(...jsArgs);
+    if (out === null || out === void 0) return tv(retT, null);
+    return castTo(env.ctx, bindValueToTyped(out, 0), retT, {});
+  }
   const last = runFunctionBody(env, fn, args);
   if (last === null) return tv(retT, null);
   if (fn.returnsSet || fn.returnsTable) {
@@ -15596,6 +16218,9 @@ function callSqlFunctionScalar(env, fn, args) {
   return castTo(env.ctx, tv(rawT, raw), retT, {});
 }
 function callSqlFunctionSet(env, fn, args) {
+  if (fn.language === "plpgsql") {
+    return callPlpgsqlSet(env, fn, args);
+  }
   const last = runFunctionBody(env, fn, args);
   if (last === null) return { columns: [], rows: [] };
   if (fn.returnsTable) {
@@ -15756,6 +16381,7 @@ function materializeItem(env, item, scope) {
       const state = env.ctx.state;
       const table = state.findTable(item.name);
       if (table) {
+        table.materializeSlab();
         const rel2 = {
           columns: table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
           rows: table.rows
@@ -15820,6 +16446,14 @@ function srfCallRelation(env, call, scope, alias) {
   const bare = call.name.length === 1 ? call.name[0] : call.name.length === 2 && call.name[0] === "pg_catalog" ? call.name[1] : call.name[call.name.length - 1];
   const evalScope = makeEvalScope(env, scope);
   const args = call.args.map((a) => evalExpr(env.ctx, evalScope, a));
+  const userFn = resolveUserFunctionForArgs(env, call.name, args);
+  if (userFn) {
+    if (userFn.returnsSet || userFn.returnsTable) {
+      return callSqlFunctionSet(env, userFn, args);
+    }
+    const v2 = callSqlFunctionScalar(env, userFn, args);
+    return { columns: [{ name: userFn.name, type: v2.t === UNKNOWN ? "text" : v2.t, table: null }], rows: [[v2.v]] };
+  }
   const srf = getSrfFunctions().get(bare);
   if (srf) {
     const res = srf(env.ctx, args, alias ?? bare);
@@ -15828,14 +16462,6 @@ function srfCallRelation(env, call, scope, alias) {
       rows: res.rows
     };
   }
-  const userFn = resolveUserFunction(env, call.name, args.length);
-  if (userFn) {
-    if (userFn.returnsSet || userFn.returnsTable) {
-      return callSqlFunctionSet(env, userFn, args);
-    }
-    const v2 = callSqlFunctionScalar(env, userFn, args);
-    return { columns: [{ name: userFn.name, type: v2.t === UNKNOWN ? "text" : v2.t, table: null }], rows: [[v2.v]] };
-  }
   const v = evalExpr(env.ctx, evalScope, call);
   return { columns: [{ name: bare, type: v.t === UNKNOWN ? "text" : v.t, table: null }], rows: [[v.v]] };
 }
@@ -16006,7 +16632,35 @@ function checkFullJoinCondition(on, left, right) {
     "0A000"
   );
 }
-function combineJoin(env, kind, left, right, on, using, usingAlias, rangeVars) {
+function extractOnEquijoinKeys(on, left, right) {
+  const leftIdxs = [];
+  const rightIdxs = [];
+  for (const part of conjunctions(on)) {
+    if (part.type !== "binop" || part.op !== "=") continue;
+    const ls = joinSideOf(part.left, left, right);
+    const rs = joinSideOf(part.right, left, right);
+    let leftExpr;
+    let rightExpr;
+    if (ls === "left" && rs === "right") {
+      leftExpr = part.left;
+      rightExpr = part.right;
+    } else if (ls === "right" && rs === "left") {
+      leftExpr = part.right;
+      rightExpr = part.left;
+    } else {
+      continue;
+    }
+    if (leftExpr.type !== "colref" || rightExpr.type !== "colref") continue;
+    const li = resolveColIdx(left.columns, leftExpr.parts);
+    const ri = resolveColIdx(right.columns, rightExpr.parts);
+    if (li === null || ri === null) continue;
+    leftIdxs.push(li);
+    rightIdxs.push(ri);
+  }
+  if (leftIdxs.length === 0) return null;
+  return { leftIdxs, rightIdxs };
+}
+function combineJoin(env, kind, left, right, on, using, usingAlias, rangeVars, equijoinOverride = null) {
   const ctx = env.ctx;
   if (kind === "full" && on !== null) checkFullJoinCondition(on, left, right);
   let columns;
@@ -16067,19 +16721,46 @@ function combineJoin(env, kind, left, right, on, using, usingAlias, rangeVars) {
     for (let i = 0; i < right.columns.length; i++) row.push(rrow?.[i] ?? null);
     rows.push(row);
   };
+  let hashLeftIdxs = [];
+  let hashRightIdxs = [];
+  let hashKeyTypes = [];
+  if (equijoinOverride) {
+    hashLeftIdxs = equijoinOverride.leftIdxs;
+    hashRightIdxs = equijoinOverride.rightIdxs;
+    hashKeyTypes = hashLeftIdxs.map((li, k) => {
+      const lt = left.columns[li].type;
+      const rt = right.columns[hashRightIdxs[k]].type;
+      const t = unifyTypes(lt, rt);
+      if (t === null) {
+        throw pgError("datatype_mismatch", `JOIN types ${lt} and ${rt} cannot be matched`, "42804");
+      }
+      return t;
+    });
+  } else if (using && using.length > 0) {
+    hashLeftIdxs = usingLeftIdx;
+    hashRightIdxs = usingRightIdx;
+    hashKeyTypes = columns.slice(0, mergedCount).map((c) => c.type);
+  } else if (on !== null && kind !== "cross") {
+    const extracted = extractOnEquijoinKeys(on, left, right);
+    if (extracted) {
+      hashLeftIdxs = extracted.leftIdxs;
+      hashRightIdxs = extracted.rightIdxs;
+      hashKeyTypes = hashLeftIdxs.map((li, k) => {
+        const lt = left.columns[li].type;
+        const rt = right.columns[extracted.rightIdxs[k]].type;
+        const t = unifyTypes(lt, rt);
+        if (t === null) {
+          throw pgError("datatype_mismatch", `JOIN types ${lt} and ${rt} cannot be matched`, "42804");
+        }
+        return t;
+      });
+    }
+  }
   const matchRows = (lrow, rrow) => {
     if (using && using.length > 0) {
-      for (let k = 0; k < using.length; k++) {
-        const lv = lrow[usingLeftIdx[k]] ?? null;
-        const rv = rrow[usingRightIdx[k]] ?? null;
-        if (lv === null || rv === null) return false;
-        const t = columns[k].type;
-        const lc = castTo(ctx, tv(left.columns[usingLeftIdx[k]].type, lv), t, {}).v;
-        const rc = castTo(ctx, tv(right.columns[usingRightIdx[k]].type, rv), t, {}).v;
-        if (lc === null || rc === null) return false;
-        if (datumCompare(t, lc, rc, ctx) !== 0) return false;
-      }
-      return true;
+      const leftTypes = hashLeftIdxs.map((i) => left.columns[i].type);
+      const rightTypes = hashRightIdxs.map((i) => right.columns[i].type);
+      return rowsMatchEqKeys(ctx, lrow, rrow, hashLeftIdxs, hashRightIdxs, leftTypes, rightTypes, hashKeyTypes);
     }
     if (on === null) return true;
     const row = [];
@@ -16089,18 +16770,47 @@ function combineJoin(env, kind, left, right, on, using, usingAlias, rangeVars) {
     const jscope = new RowScope(columns, row, env.outer, rangeVars);
     return evalPredicate(env, jscope, on);
   };
-  for (const lrow of left.rows) {
-    let matched = false;
+  const useHashJoin = kind !== "cross" && hashLeftIdxs.length > 0;
+  if (useHashJoin) {
+    const leftTypes = hashLeftIdxs.map((i) => left.columns[i].type);
+    const rightTypes = hashRightIdxs.map((i) => right.columns[i].type);
+    const buckets = /* @__PURE__ */ new Map();
     for (let ri = 0; ri < right.rows.length; ri++) {
-      const rrow = right.rows[ri];
-      if (matchRows(lrow, rrow)) {
+      const key = joinKeyFromRow(right.rows[ri], hashRightIdxs, rightTypes, hashKeyTypes, ctx);
+      if (key === null) continue;
+      const bucket = buckets.get(key);
+      if (bucket) bucket.push(ri);
+      else buckets.set(key, [ri]);
+    }
+    for (const lrow of left.rows) {
+      let matched = false;
+      const key = joinKeyFromRow(lrow, hashLeftIdxs, leftTypes, hashKeyTypes, ctx);
+      const candidates = key === null ? [] : buckets.get(key) ?? [];
+      for (const ri of candidates) {
+        const rrow = right.rows[ri];
+        if (!matchRows(lrow, rrow)) continue;
         matched = true;
         rightMatched[ri] = true;
         emit(lrow, rrow);
       }
+      if (!matched && (kind === "left" || kind === "full")) {
+        emit(lrow, null);
+      }
     }
-    if (!matched && (kind === "left" || kind === "full")) {
-      emit(lrow, null);
+  } else {
+    for (const lrow of left.rows) {
+      let matched = false;
+      for (let ri = 0; ri < right.rows.length; ri++) {
+        const rrow = right.rows[ri];
+        if (matchRows(lrow, rrow)) {
+          matched = true;
+          rightMatched[ri] = true;
+          emit(lrow, rrow);
+        }
+      }
+      if (!matched && (kind === "left" || kind === "full")) {
+        emit(lrow, null);
+      }
     }
   }
   if (kind === "right" || kind === "full") {
@@ -16110,7 +16820,7 @@ function combineJoin(env, kind, left, right, on, using, usingAlias, rangeVars) {
   }
   return { columns, rows };
 }
-function buildFrom(env, items) {
+function buildFrom(env, items, where = null) {
   if (items.length === 0) {
     return { rel: { columns: [], rows: [[]] }, rangeVars: /* @__PURE__ */ new Set() };
   }
@@ -16152,14 +16862,23 @@ function buildFrom(env, items) {
       acc = { rel: { columns: cols, rows }, rangeVars: vars };
     } else {
       const src = materializeItem(env, item, env.outer);
-      const cols = [...accRel.columns, ...src.rel.columns];
-      const rows = [];
-      for (const lrow of accRel.rows) {
-        for (const rrow of src.rel.rows) {
-          rows.push([...lrow, ...rrow]);
+      const rangeVars = /* @__PURE__ */ new Set([...accVars, ...src.rangeVars]);
+      const eq = where ? extractOnEquijoinKeys(where, accRel, src.rel) : null;
+      if (eq) {
+        acc = {
+          rel: combineJoin(env, "inner", accRel, src.rel, null, null, null, rangeVars, eq),
+          rangeVars
+        };
+      } else {
+        const cols = [...accRel.columns, ...src.rel.columns];
+        const rows = [];
+        for (const lrow of accRel.rows) {
+          for (const rrow of src.rel.rows) {
+            rows.push([...lrow, ...rrow]);
+          }
         }
+        acc = { rel: { columns: cols, rows }, rangeVars };
       }
-      acc = { rel: { columns: cols, rows }, rangeVars: /* @__PURE__ */ new Set([...accVars, ...src.rangeVars]) };
     }
   }
   return acc;
@@ -16699,14 +17418,24 @@ function expandTargets(core, columns) {
 function executeCore(env0, core, orderBy) {
   const env = env0;
   const ctx = env.ctx;
-  const source = buildFrom(env, core.from);
+  const source = buildFrom(env, core.from, core.where);
   const srcCols = source.rel.columns;
   const rangeVars = source.rangeVars;
   const rowScope = (row) => new RowScope(srcCols, row, env.outer, rangeVars);
   let srcRows = source.rel.rows;
   if (core.where) {
-    const where = core.where;
-    srcRows = srcRows.filter((row) => evalPredicate(env, rowScope(row), where));
+    if (core.from.length === 1) {
+      const indexed = tryIndexedFromItem(env, core.from[0], core.where);
+      if (indexed !== null) {
+        srcRows = indexed;
+      } else {
+        const where = core.where;
+        srcRows = srcRows.filter((row) => evalPredicate(env, rowScope(row), where));
+      }
+    } else {
+      const where = core.where;
+      srcRows = srcRows.filter((row) => evalPredicate(env, rowScope(row), where));
+    }
   }
   const collector = { aggs: [], windows: [], groupings: [] };
   for (const t of core.targets) collectCalls(t.expr.type === "star" ? null : t.expr, collector);
@@ -16975,24 +17704,34 @@ function executeCore(env0, core, orderBy) {
     }
   }
   if (ctxs.length === 0) {
+    const probeScope = new RowScope(
+      srcCols,
+      srcCols.map(() => null),
+      env.outer,
+      rangeVars
+    );
+    const probeExtras = {
+      aggMap: /* @__PURE__ */ new Map(),
+      windowAt: () => tv(UNKNOWN, null)
+    };
+    const probeType = (expr) => {
+      if (expr.type === "cast") {
+        return resolveTypeName(ctx.state, expr.target).column.id;
+      }
+      if (expr.type === "func") {
+        const name = expr.name[expr.name.length - 1];
+        if (isAggregateName(name)) {
+          const argTypes = expr.args.map((a) => probeType(a));
+          return createAggregate(ctx, name, argTypes).result().t;
+        }
+      }
+      return evalScalar(env, probeScope, expr, probeExtras).t;
+    };
     for (let k = 0; k < projItems.length; k++) {
       const p = projItems[k];
       if (outColumns[k].type !== UNKNOWN || p.kind === "col") continue;
-      try {
-        const probeScope = new RowScope(
-          srcCols,
-          srcCols.map(() => null),
-          env.outer,
-          rangeVars
-        );
-        const v = evalScalar(env, probeScope, p.expr, {
-          aggMap: /* @__PURE__ */ new Map(),
-          windowAt: () => tv(UNKNOWN, null)
-        });
-        outColumns[k].type = v.t;
-      } catch {
-        outColumns[k].type = "text";
-      }
+      const t = probeType(p.expr);
+      outColumns[k].type = t === UNKNOWN ? "text" : t;
     }
   }
   for (const c of outColumns) {
@@ -17062,29 +17801,7 @@ function executeSelectStmt(env0, stmt) {
   return applyLimitOffset(env, rel2, stmt.limit, stmt.offset);
 }
 
-// src/executor/triggers.ts
-function matches(t, event) {
-  return t.events.some((e) => e.event === event);
-}
-var executor = null;
-function setTriggerExecutor(e) {
-  executor = e;
-}
-function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
-  let row = newRow ?? oldRow;
-  for (const t of table.triggers) {
-    if (t.timing !== timing || !matches(t, event) || !t.forEachRow) continue;
-    if (!executor) throw unsupported(`trigger "${t.name}" execution`);
-    const result = executor(env, table, t, event, oldRow, timing === "before" ? row : newRow);
-    if (timing === "before") {
-      if (result === null) return { row: null };
-      row = result;
-    }
-  }
-  return { row };
-}
-
-// src/executor/triggers-exec.ts
+// src/executor/plpgsql.ts
 var PlParser = class {
   constructor(src) {
     this.src = src;
@@ -17101,67 +17818,149 @@ var PlParser = class {
     if (t.type !== "eof") this.pos++;
     return t;
   }
-  atKw(kw) {
-    const t = this.peek();
+  atKw(kw, offset = 0) {
+    const t = this.peek(offset);
     return t.type === "ident" && t.value === kw;
   }
   expectKw(kw) {
-    if (!this.atKw(kw)) throw unsupported(`trigger body: expected "${kw.toUpperCase()}" near "${this.peek().value}"`);
+    if (!this.atKw(kw)) throw unsupported(`plpgsql: expected "${kw.toUpperCase()}" near "${this.peek().value}"`);
     this.pos++;
   }
   expectSemi() {
     const t = this.next();
-    if (t.type !== "punct" || t.value !== ";") throw unsupported(`trigger body: expected ";" near "${t.value}"`);
+    if (t.type !== "punct" || t.value !== ";") throw unsupported(`plpgsql: expected ";" near "${t.value}"`);
+  }
+  parseProgram() {
+    const decls = [];
+    if (this.atKw("declare")) {
+      this.pos++;
+      while (!this.atKw("begin") && this.peek().type !== "eof") {
+        decls.push(this.parseDecl());
+      }
+    }
+    const block = this.parseBlock();
+    if (this.peek().type !== "eof") throw unsupported(`plpgsql: trailing content near "${this.peek().value}"`);
+    return { decls, body: [block] };
   }
-  parseBody() {
+  /** Trigger bodies are a BEGIN block (no DECLARE). */
+  parseTriggerBody() {
     if (this.atKw("declare")) throw unsupported("trigger body: DECLARE section");
+    const block = this.parseBlock();
+    if (this.peek().type !== "eof") throw unsupported(`trigger body: trailing content near "${this.peek().value}"`);
+    return block.kind === "block" && block.handler === null ? block.body : [block];
+  }
+  parseDecl() {
+    const nameTok = this.next();
+    if (nameTok.type !== "ident" && nameTok.type !== "quoted_ident") {
+      throw unsupported(`plpgsql DECLARE near "${nameTok.value}"`);
+    }
+    const name = nameTok.value;
+    const typeStart = this.peek().pos;
+    while (!(this.peek().type === "punct" && this.peek().value === ";") && !(this.peek().type === "op" && (this.peek().value === ":=" || this.peek().value === "=")) && this.peek().type !== "eof") {
+      this.pos++;
+    }
+    const typeText = this.src.slice(typeStart, this.peek().pos);
+    const typeName = parseTypeNameText(typeText);
+    let init = null;
+    if (this.peek().type === "op" && (this.peek().value === ":=" || this.peek().value === "=")) {
+      this.pos++;
+      init = this.parseExprUntilSemi();
+    } else {
+      this.expectSemi();
+    }
+    return { name, typeName, init };
+  }
+  parseBlock() {
     this.expectKw("begin");
-    const stmts = this.parseStmts();
+    const body = this.parseStmts(/* @__PURE__ */ new Set(["end", "exception"]));
+    let handler = null;
+    if (this.atKw("exception")) {
+      this.pos++;
+      this.expectKw("when");
+      if (!this.atKw("others")) throw unsupported(`plpgsql EXCEPTION WHEN ${this.peek().value}`);
+      this.pos++;
+      this.expectKw("then");
+      handler = this.parseStmts(/* @__PURE__ */ new Set(["end", "when"]));
+      while (this.atKw("when")) {
+        throw unsupported("plpgsql EXCEPTION WHEN (only OTHERS is implemented)");
+      }
+    }
     this.expectKw("end");
     if (this.peek().type === "punct" && this.peek().value === ";") this.pos++;
-    if (this.peek().type !== "eof") throw unsupported(`trigger body: trailing content near "${this.peek().value}"`);
-    return stmts;
+    return { kind: "block", body, handler };
   }
-  parseStmts() {
+  parseStmts(stop) {
     const out = [];
-    while (!this.atKw("end") && !this.atKw("elsif") && !this.atKw("else") && this.peek().type !== "eof") {
+    while (this.peek().type !== "eof") {
+      if (this.peek().type === "ident" && stop.has(this.peek().value)) break;
       out.push(this.parseStmt());
     }
     return out;
   }
   parseStmt() {
+    if (this.atKw("begin")) return this.parseBlock();
     if (this.atKw("return")) {
       this.pos++;
-      const t = this.next();
-      let what;
-      if (t.type === "ident" && (t.value === "new" || t.value === "old" || t.value === "null")) {
-        what = t.value;
-      } else {
-        throw unsupported(`trigger body: RETURN ${t.value}`);
+      if (this.atKw("next")) {
+        this.pos++;
+        this.expectSemi();
+        return { kind: "return_next" };
       }
-      this.expectSemi();
-      return { kind: "return", what };
+      if (this.peek().type === "punct" && this.peek().value === ";") {
+        this.pos++;
+        return { kind: "return_empty" };
+      }
+      if (this.peek().type === "ident" && (this.peek().value === "new" || this.peek().value === "old") && this.peek(1).type === "punct" && this.peek(1).value === ";") {
+        const what = this.peek().value === "new" ? "return_new" : "return_old";
+        this.pos += 2;
+        return { kind: what };
+      }
+      return { kind: "return_expr", expr: this.parseExprUntilSemi() };
     }
     if (this.atKw("if")) {
       this.pos++;
       const branches = [];
       let elseBody = [];
       const cond = this.parseExprUntilKw("then");
-      branches.push({ cond, body: this.parseStmts() });
+      branches.push({ cond, body: this.parseStmts(/* @__PURE__ */ new Set(["end", "elsif", "else"])) });
       while (this.atKw("elsif")) {
         this.pos++;
         const c = this.parseExprUntilKw("then");
-        branches.push({ cond: c, body: this.parseStmts() });
+        branches.push({ cond: c, body: this.parseStmts(/* @__PURE__ */ new Set(["end", "elsif", "else"])) });
       }
       if (this.atKw("else")) {
         this.pos++;
-        elseBody = this.parseStmts();
+        elseBody = this.parseStmts(/* @__PURE__ */ new Set(["end"]));
       }
       this.expectKw("end");
       this.expectKw("if");
       this.expectSemi();
       return { kind: "if", branches, elseBody };
     }
+    if (this.atKw("case")) {
+      this.pos++;
+      let expr = null;
+      const branches = [];
+      let elseBody = [];
+      if (!this.atKw("when")) {
+        expr = this.parseExprUntilKw("when");
+        const cond = this.parseExprUntilKw("then");
+        branches.push({ cond, body: this.parseStmts(/* @__PURE__ */ new Set(["when", "else", "end"])) });
+      }
+      while (this.atKw("when")) {
+        this.pos++;
+        const cond = this.parseExprUntilKw("then");
+        branches.push({ cond, body: this.parseStmts(/* @__PURE__ */ new Set(["when", "else", "end"])) });
+      }
+      if (this.atKw("else")) {
+        this.pos++;
+        elseBody = this.parseStmts(/* @__PURE__ */ new Set(["end"]));
+      }
+      this.expectKw("end");
+      this.expectKw("case");
+      this.expectSemi();
+      return { kind: "case", expr, branches, elseBody };
+    }
     if (this.atKw("null")) {
       this.pos++;
       this.expectSemi();
@@ -17178,12 +17977,37 @@ var PlParser = class {
       this.expectSemi();
       return { kind: "raise", message: message || "raised exception" };
     }
+    if (this.atKw("perform")) {
+      this.pos++;
+      return { kind: "perform", expr: this.parseExprUntilSemi() };
+    }
+    if (this.atKw("for")) {
+      this.pos++;
+      const targets = [];
+      for (; ; ) {
+        const t = this.next();
+        if (t.type !== "ident" && t.type !== "quoted_ident") throw unsupported(`plpgsql FOR target near "${t.value}"`);
+        targets.push(t.value);
+        if (this.peek().type === "punct" && this.peek().value === ",") {
+          this.pos++;
+          continue;
+        }
+        break;
+      }
+      this.expectKw("in");
+      const query = this.parseQueryUntilKw("loop");
+      const body = this.parseStmts(/* @__PURE__ */ new Set(["end"]));
+      this.expectKw("end");
+      this.expectKw("loop");
+      this.expectSemi();
+      return { kind: "for", targets, query, body };
+    }
     const target = [];
     const first = this.next();
     if (first.type !== "ident" && first.type !== "quoted_ident") {
-      throw unsupported(`trigger body statement near "${first.value}"`);
+      throw unsupported(`plpgsql statement near "${first.value}"`);
     }
-    target.push(first.type === "ident" ? first.value : first.value);
+    target.push(first.value);
     while (this.peek().type === "punct" && this.peek().value === ".") {
       this.pos++;
       const f = this.next();
@@ -17191,18 +18015,16 @@ var PlParser = class {
     }
     const opTok = this.next();
     if (!(opTok.type === "op" && (opTok.value === ":=" || opTok.value === "="))) {
-      throw unsupported(`trigger body: expected assignment near "${opTok.value}"`);
+      throw unsupported(`plpgsql: expected assignment near "${opTok.value}"`);
     }
-    const expr = this.parseExprUntilSemi();
-    return { kind: "assign", target, expr };
+    return { kind: "assign", target, expr: this.parseExprUntilSemi() };
   }
-  /** Slice raw source from the current token to the terminator and parse as a SQL expression. */
   parseExprUntilSemi() {
     const start = this.peek().pos;
     let depth = 0;
     for (; ; ) {
       const t = this.peek();
-      if (t.type === "eof") throw unsupported("trigger body: unterminated statement");
+      if (t.type === "eof") throw unsupported("plpgsql: unterminated statement");
       if (t.type === "punct" && t.value === "(") depth++;
       if (t.type === "punct" && t.value === ")") depth--;
       if (t.type === "punct" && t.value === ";" && depth === 0) {
@@ -17216,12 +18038,15 @@ var PlParser = class {
   parseExprUntilKw(kw) {
     const start = this.peek().pos;
     let depth = 0;
+    let caseDepth = 0;
     for (; ; ) {
       const t = this.peek();
-      if (t.type === "eof") throw unsupported(`trigger body: expected "${kw.toUpperCase()}"`);
+      if (t.type === "eof") throw unsupported(`plpgsql: expected "${kw.toUpperCase()}"`);
       if (t.type === "punct" && t.value === "(") depth++;
       if (t.type === "punct" && t.value === ")") depth--;
-      if (t.type === "ident" && t.value === kw && depth === 0) {
+      if (t.type === "ident" && t.value === "case" && depth === 0) caseDepth++;
+      if (t.type === "ident" && t.value === "end" && depth === 0 && caseDepth > 0) caseDepth--;
+      if (t.type === "ident" && t.value === kw && depth === 0 && caseDepth === 0) {
         const text = this.src.slice(start, t.pos);
         this.pos++;
         return parseSqlExpr(text);
@@ -17229,26 +18054,304 @@ var PlParser = class {
       this.pos++;
     }
   }
+  parseQueryUntilKw(kw) {
+    const start = this.peek().pos;
+    let depth = 0;
+    for (; ; ) {
+      const t = this.peek();
+      if (t.type === "eof") throw unsupported(`plpgsql: expected "${kw.toUpperCase()}"`);
+      if (t.type === "punct" && t.value === "(") depth++;
+      if (t.type === "punct" && t.value === ")") depth--;
+      if (t.type === "ident" && t.value === kw && depth === 0) {
+        const text = this.src.slice(start, t.pos).trim();
+        this.pos++;
+        const stmts = parse(text);
+        const q = stmts[0];
+        if (q?.type !== "select") throw unsupported(`plpgsql FOR query: expected SELECT`);
+        return q;
+      }
+      this.pos++;
+    }
+  }
 };
 function parseSqlExpr(text) {
   const stmts = parse(`SELECT ${text}`);
   const sel = stmts[0];
   const body = sel.body;
   const target = body.targets?.[0];
-  if (!target) throw unsupported(`trigger body expression "${text}"`);
+  if (!target) throw unsupported(`plpgsql expression "${text}"`);
   return target.expr;
 }
-var bodyCache = /* @__PURE__ */ new Map();
-function compiledBody(fn) {
-  const raw = fn.rawBody;
-  if (raw === null) throw unsupported(`trigger function ${fn.name} has no body`);
-  let cached = bodyCache.get(raw);
-  if (cached === void 0) {
-    cached = new PlParser(raw).parseBody();
-    bodyCache.set(raw, cached);
+function parseTypeNameText(text) {
+  const stmts = parse(`SELECT NULL::${text.trim()}`);
+  const sel = stmts[0];
+  const body = sel.body;
+  const expr = body.targets?.[0]?.expr;
+  if (expr?.type !== "cast") throw unsupported(`plpgsql type "${text}"`);
+  return expr.target;
+}
+var programCache = /* @__PURE__ */ new Map();
+var triggerCache = /* @__PURE__ */ new Map();
+function compilePlpgsql(raw) {
+  let cached = programCache.get(raw);
+  if (cached === void 0) {
+    cached = new PlParser(raw).parseProgram();
+    programCache.set(raw, cached);
+  }
+  return cached;
+}
+function compileTriggerBody(raw) {
+  let cached = triggerCache.get(raw);
+  if (cached === void 0) {
+    cached = new PlParser(raw).parseTriggerBody();
+    triggerCache.set(raw, cached);
+  }
+  return cached;
+}
+var PlReturn = class {
+  constructor(mode, value) {
+    this.mode = mode;
+    this.value = value;
+  }
+  mode;
+  value;
+};
+var PlVars = class {
+  names = [];
+  types = [];
+  values = [];
+  declare(name, type, value) {
+    const i = this.names.indexOf(name);
+    if (i === -1) {
+      this.names.push(name);
+      this.types.push(type);
+      this.values.push(value);
+    } else {
+      this.types[i] = type;
+      this.values[i] = value;
+    }
+  }
+  set(name, v, env) {
+    const i = this.names.indexOf(name);
+    if (i === -1) throw pgError("undefined_column", `"${name}" is not a known variable`, "42703");
+    const casted = v.v === null ? tv(this.types[i], null) : castTo(env.ctx, v, this.types[i], { assignment: true });
+    this.values[i] = casted.v;
+  }
+  get(name) {
+    const i = this.names.indexOf(name);
+    if (i === -1) return void 0;
+    return tv(this.types[i], this.values[i] ?? null);
+  }
+  scope() {
+    const cols = this.names.map((n, i) => ({ name: n, type: this.types[i], table: null }));
+    return new RowScope(cols, this.values, null);
+  }
+};
+function runStmts(env, stmts, vars, emit, tableNames) {
+  for (const stmt of stmts) runStmt(env, stmt, vars, emit, tableNames);
+}
+function runStmt(env, stmt, vars, emit, tableNames) {
+  const scope = () => vars.scope();
+  switch (stmt.kind) {
+    case "assign": {
+      if (stmt.target.length !== 1) throw unsupported(`plpgsql assignment to "${stmt.target.join(".")}"`);
+      const v = evalScalar(env, scope(), stmt.expr);
+      vars.set(stmt.target[0], v, env);
+      return;
+    }
+    case "return_new":
+    case "return_old":
+      throw unsupported(`plpgsql RETURN ${stmt.kind === "return_new" ? "NEW" : "OLD"} in a non-trigger function`);
+    case "return_expr":
+      throw new PlReturn("value", evalScalar(env, scope(), stmt.expr));
+    case "return_empty":
+      throw new PlReturn("empty", null);
+    case "return_next": {
+      if (emit === null) throw pgError("syntax", "RETURN NEXT cannot be used in a non-SETOF function", "42601");
+      if (tableNames) emit.push(tableNames.map((n) => vars.get(n)?.v ?? null));
+      else emit.push([vars.values[0] ?? null]);
+      return;
+    }
+    case "if": {
+      for (const b of stmt.branches) {
+        if (evalPredicate(env, scope(), b.cond)) {
+          runStmts(env, b.body, vars, emit, tableNames);
+          return;
+        }
+      }
+      runStmts(env, stmt.elseBody, vars, emit, tableNames);
+      return;
+    }
+    case "case": {
+      if (stmt.expr === null) {
+        for (const b of stmt.branches) {
+          if (evalPredicate(env, scope(), b.cond)) {
+            runStmts(env, b.body, vars, emit, tableNames);
+            return;
+          }
+        }
+        runStmts(env, stmt.elseBody, vars, emit, tableNames);
+        return;
+      }
+      const head = evalScalar(env, scope(), stmt.expr);
+      for (const b of stmt.branches) {
+        const when = evalScalar(env, scope(), b.cond);
+        if (head.v !== null && when.v !== null) {
+          const rhs = when.t === head.t ? when : castTo(env.ctx, when, head.t, {});
+          if (datumEquals(head.t, head.v, rhs.v)) {
+            runStmts(env, b.body, vars, emit, tableNames);
+            return;
+          }
+        }
+      }
+      runStmts(env, stmt.elseBody, vars, emit, tableNames);
+      return;
+    }
+    case "null":
+      return;
+    case "raise":
+      throw pgError("raise_exception", stmt.message, "P0001");
+    case "perform":
+      evalScalar(env, scope(), stmt.expr);
+      return;
+    case "block": {
+      try {
+        runStmts(env, stmt.body, vars, emit, tableNames);
+      } catch (e) {
+        if (e instanceof PlReturn) throw e;
+        if (stmt.handler === null) throw e;
+        runStmts(env, stmt.handler, vars, emit, tableNames);
+      }
+      return;
+    }
+    case "for": {
+      const forEnv = { ctx: env.ctx, params: env.params, ctes: env.ctes, outer: vars.scope() };
+      const rel2 = executeSelectStmt(forEnv, stmt.query);
+      for (const row of rel2.rows) {
+        for (let i = 0; i < stmt.targets.length; i++) {
+          const colT = rel2.columns[i]?.type ?? "text";
+          vars.set(stmt.targets[i], tv(colT, row[i] ?? null), env);
+        }
+        runStmts(env, stmt.body, vars, emit, tableNames);
+      }
+      return;
+    }
+  }
+}
+function bindArgs(env, fn, args) {
+  const bound = [];
+  for (let i = 0; i < fn.argTypes.length; i++) {
+    if (i < args.length) {
+      bound.push(castTo(env.ctx, args[i], fn.argTypes[i], {}));
+    } else {
+      const dflt = fn.argDefaults[i];
+      if (!dflt) throw pgError("undefined_function", `function ${fn.name} argument ${i + 1} missing`, "42883");
+      bound.push(castTo(env.ctx, evalScalar(env, null, dflt), fn.argTypes[i], {}));
+    }
+  }
+  return bound;
+}
+function initVars(env, fn, bound, program) {
+  const vars = new PlVars();
+  for (let i = 0; i < fn.argNames.length; i++) {
+    const n = fn.argNames[i];
+    if (n == null) continue;
+    vars.declare(n, fn.argTypes[i], bound[i]?.v ?? null);
+  }
+  if (fn.returnsTable) {
+    for (const c of fn.returnsTable) vars.declare(c.name, c.type, null);
+  }
+  const seed = () => ({ ctx: env.ctx, params: bound, ctes: /* @__PURE__ */ new Map(), outer: vars.scope() });
+  for (const d of program.decls) {
+    const id = resolveTypeName(env.ctx.state, d.typeName).column.id;
+    let val = null;
+    if (d.init) {
+      const v = evalScalar(seed(), vars.scope(), d.init);
+      val = v.v === null ? null : castTo(env.ctx, v, id, { assignment: true }).v;
+    }
+    vars.declare(d.name, id, val);
+  }
+  return vars;
+}
+function plpgsqlEnv(env, bound, vars) {
+  return { ctx: env.ctx, params: bound, ctes: /* @__PURE__ */ new Map(), outer: vars.scope() };
+}
+function callPlpgsqlScalar(env, fn, args) {
+  const retT = fn.returns ?? "text";
+  if (fn.strict && args.some((a) => a.v === null)) return tv(retT, null);
+  const raw = fn.rawBody;
+  if (raw === null) throw pgError("unsupported", `function ${fn.name} has no executable body`);
+  const program = compilePlpgsql(raw);
+  const bound = bindArgs(env, fn, args);
+  const vars = initVars(env, fn, bound, program);
+  const fnEnv = plpgsqlEnv(env, bound, vars);
+  try {
+    runStmts(fnEnv, program.body, vars, null, null);
+  } catch (e) {
+    if (e instanceof PlReturn) {
+      if (e.mode === "next") {
+        throw pgError("feature_not_supported", `set-returning function ${fn.name} called in scalar context`, "0A000");
+      }
+      if (e.mode === "empty" || e.value === null || e.value.v === null) return tv(retT, null);
+      return castTo(env.ctx, e.value, retT, {});
+    }
+    throw e;
+  }
+  return tv(retT, null);
+}
+function callPlpgsqlSet(env, fn, args) {
+  const cols = fn.returnsTable ? fn.returnsTable.map((c) => ({ name: c.name, type: c.type, table: null })) : [{ name: fn.name, type: fn.returns ?? "text", table: null }];
+  if (fn.strict && args.some((a) => a.v === null)) return { columns: cols, rows: [] };
+  const raw = fn.rawBody;
+  if (raw === null) throw pgError("unsupported", `function ${fn.name} has no executable body`);
+  const program = compilePlpgsql(raw);
+  const bound = bindArgs(env, fn, args);
+  const vars = initVars(env, fn, bound, program);
+  const fnEnv = plpgsqlEnv(env, bound, vars);
+  const emit = [];
+  const tableNames = fn.returnsTable?.map((c) => c.name) ?? null;
+  try {
+    runStmts(fnEnv, program.body, vars, emit, tableNames);
+  } catch (e) {
+    if (!(e instanceof PlReturn)) throw e;
+  }
+  if (fn.returnsTable) {
+    const rows = emit.map(
+      (r) => fn.returnsTable.map((c, i) => {
+        const raw2 = r[i] ?? null;
+        if (raw2 === null) return null;
+        const src = vars.get(c.name);
+        return castTo(env.ctx, tv(src?.t ?? c.type, raw2), c.type, {}).v;
+      })
+    );
+    return { columns: cols, rows };
+  }
+  return { columns: cols, rows: emit };
+}
+
+// src/executor/triggers.ts
+function matches(t, event) {
+  return t.events.some((e) => e.event === event);
+}
+var executor = null;
+function setTriggerExecutor(e) {
+  executor = e;
+}
+function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
+  let row = newRow ?? oldRow;
+  for (const t of table.triggers) {
+    if (t.timing !== timing || !matches(t, event) || !t.forEachRow) continue;
+    if (!executor) throw unsupported(`trigger "${t.name}" execution`);
+    const result = executor(env, table, t, event, oldRow, timing === "before" ? row : newRow);
+    if (timing === "before") {
+      if (result === null) return { row: null };
+      row = result;
+    }
   }
-  return cached;
+  return { row };
 }
+
+// src/executor/triggers-exec.ts
 var ReturnSignal = class {
   constructor(row) {
     this.row = row;
@@ -17276,8 +18379,17 @@ function runTriggerBody(env, table, stmts, vars) {
         vars.newRow[idx] = v.v === null ? null : castTo(env.ctx, v, table.columns[idx].type.id, { assignment: true }).v;
         break;
       }
-      case "return":
-        throw new ReturnSignal(stmt.what === "new" ? vars.newRow : stmt.what === "old" ? vars.oldRow : null);
+      case "return_new":
+        throw new ReturnSignal(vars.newRow);
+      case "return_old":
+        throw new ReturnSignal(vars.oldRow);
+      case "return_empty":
+        throw new ReturnSignal(null);
+      case "return_expr": {
+        const v = evalScalar(env, scope(), stmt.expr);
+        if (v.v === null) throw new ReturnSignal(null);
+        throw unsupported("trigger body: RETURN expression");
+      }
       case "if": {
         let taken = false;
         for (const b of stmt.branches) {
@@ -17294,6 +18406,18 @@ function runTriggerBody(env, table, stmts, vars) {
         break;
       case "raise":
         throw pgError("raise_exception", stmt.message, "P0001");
+      case "block": {
+        try {
+          runTriggerBody(env, table, stmt.body, vars);
+        } catch (e) {
+          if (e instanceof ReturnSignal) throw e;
+          if (stmt.handler === null) throw e;
+          runTriggerBody(env, table, stmt.handler, vars);
+        }
+        break;
+      }
+      default:
+        throw unsupported(`trigger body: ${stmt.kind}`);
     }
   }
 }
@@ -17327,7 +18451,9 @@ function executeTrigger(env, table, trigger, _event, oldRow, newRow) {
   if (!fn) {
     throw pgError("undefined_function", `function ${trigger.funcSchema}.${trigger.funcName}() does not exist`, "42883");
   }
-  const stmts = compiledBody(fn);
+  const raw = fn.rawBody;
+  if (raw === null) throw unsupported(`trigger function ${fn.name} has no body`);
+  const stmts = compileTriggerBody(raw);
   const vars = { newRow: newRow ? newRow.slice() : null, oldRow };
   try {
     runTriggerBody(env, table, stmts, vars);
@@ -17384,198 +18510,23 @@ var EngineCtx = class {
   }
 };
 
-// src/constraints/enforce.ts
-function tableScope(table, row) {
-  const cols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: table.name }));
-  return new RowScope(cols, row, null, /* @__PURE__ */ new Set([table.name]));
-}
-function checkNotNull(env, table, row) {
-  void env;
-  for (let i = 0; i < table.columns.length; i++) {
-    const c = table.columns[i];
-    if (c.notNull && (row[i] ?? null) === null) {
-      throw pgError(
-        "not_null_violation",
-        `null value in column "${c.name}" of relation "${table.name}" violates not-null constraint`,
-        "23502"
-      );
-    }
-  }
-}
-function checkChecks(env, table, row) {
-  for (const con of table.constraints) {
-    if (con.kind !== "check") continue;
-    const scope = makeEvalScope(env, tableScope(table, row));
-    const v = evalExpr(env.ctx, scope, con.expr);
-    if (v.v === null) continue;
-    const b = castTo(env.ctx, v, "bool", {});
-    if (b.v !== true) {
-      throw pgError(
-        "check_violation",
-        `new row for relation "${table.name}" violates check constraint "${con.name}"`,
-        "23514"
-      );
-    }
-  }
-}
-function uniqueSpecsFor(env, table) {
-  const specs = [];
-  for (const con of table.constraints) {
-    if (con.kind !== "primary_key" && con.kind !== "unique") continue;
-    specs.push({
-      name: con.name,
-      keys: con.columns.map((c) => ({ colIdx: table.columnIndex(c), expr: null })),
-      columnNames: con.columns,
-      nullsNotDistinct: con.kind === "unique" ? con.nullsNotDistinct : false,
-      where: null,
-      isPrimary: con.kind === "primary_key"
-    });
-  }
-  const schema = env.ctx.state.schemas.get(table.schema);
-  if (schema) {
-    for (const idx of schema.indexes.values()) {
-      if (idx.table !== table.name || !idx.unique || idx.isConstraint) continue;
-      specs.push({
-        name: idx.name,
-        keys: idx.columns.map((c) => ({
-          colIdx: c.column !== null ? table.columnIndex(c.column) : -1,
-          expr: c.expr
-        })),
-        columnNames: idx.columns.map((c) => c.column ?? "expr"),
-        nullsNotDistinct: idx.nullsNotDistinct,
-        where: idx.where,
-        isPrimary: false
-      });
-    }
-  }
-  return specs;
-}
-function uniqueKeyOf(env, table, spec, row) {
-  if (spec.where) {
-    const scope = makeEvalScope(env, tableScope(table, row));
-    const v = evalExpr(env.ctx, scope, spec.where);
-    if (v.v !== true) return null;
-  }
-  const parts = [];
-  let hasNull = false;
-  for (const k of spec.keys) {
-    let value;
-    let type;
-    if (k.expr) {
-      const scope = makeEvalScope(env, tableScope(table, row));
-      const v = evalExpr(env.ctx, scope, k.expr);
-      value = v.v;
-      type = v.t === "unknown" ? "text" : v.t;
-    } else {
-      value = row[k.colIdx] ?? null;
-      type = table.columns[k.colIdx].type.id;
-    }
-    if (value === null) {
-      hasNull = true;
-      parts.push("\0N");
-    } else {
-      parts.push(datumKey(type, value));
-    }
-  }
-  if (hasNull && !spec.nullsNotDistinct) return null;
-  return parts.join("
");
-}
-function checkUnique(env, table, row, selfIdx) {
-  for (const spec of uniqueSpecsFor(env, table)) {
-    const key = uniqueKeyOf(env, table, spec, row);
-    if (key === null) continue;
-    for (let i = 0; i < table.rows.length; i++) {
-      if (i === selfIdx) continue;
-      const other = uniqueKeyOf(env, table, spec, table.rows[i]);
-      if (other === key) {
-        throw pgError(
-          "constraint_unique",
-          `duplicate key value violates unique constraint "${spec.name}"`,
-          "23505"
-          // PG adds a DETAIL line; kept in message for classification purposes
-        );
-      }
-    }
-  }
-}
-function findConflict(env, table, spec, row) {
-  const key = uniqueKeyOf(env, table, spec, row);
-  if (key === null) return null;
-  for (let i = 0; i < table.rows.length; i++) {
-    const other = uniqueKeyOf(env, table, spec, table.rows[i]);
-    if (other === key) return i;
-  }
-  return null;
-}
-function checkForeignKeys(env, table, row) {
-  const state = env.ctx.state;
-  for (const con of table.constraints) {
-    if (con.kind !== "foreign_key") continue;
-    const values = con.columns.map((c) => row[table.columnIndex(c)] ?? null);
-    const nulls = values.filter((v) => v === null).length;
-    if (con.match === "simple" && nulls > 0) continue;
-    if (con.match === "full") {
-      if (nulls === values.length) continue;
-      if (nulls > 0) {
-        throw pgError(
-          "constraint_foreign_key",
-          `insert or update on table "${table.name}" violates foreign key constraint "${con.name}"`,
-          "23503"
-        );
-      }
-    }
-    const refTable = state.schemas.get(con.refSchema)?.tables.get(con.refTable);
-    if (!refTable) {
-      throw pgError("undefined_table", `relation "${con.refSchema}.${con.refTable}" does not exist`, "42P01");
-    }
-    const refIdxs = con.refColumns.map((c) => refTable.columnIndex(c));
-    const keyTypes = con.refColumns.map((_c, i) => refTable.columns[refIdxs[i]].type.id);
-    const wanted = values.map((v, i) => {
-      const localT = table.columns[table.columnIndex(con.columns[i])].type.id;
-      const cast = castTo(env.ctx, tv(localT, v), keyTypes[i], {});
-      return cast.v === null ? "\0N" : datumKey(keyTypes[i], cast.v);
-    }).join("
");
-    const found = refTable.rows.some((r) => {
-      const key = refIdxs.map((ri, i) => {
-        const v = r[ri] ?? null;
-        return v === null ? "\0N" : datumKey(keyTypes[i], v);
-      }).join("
");
-      return key === wanted;
-    });
-    if (!found) {
-      throw pgError(
-        "constraint_foreign_key",
-        `insert or update on table "${table.name}" violates foreign key constraint "${con.name}"`,
-        "23503"
-      );
-    }
-  }
-}
-function referencingConstraints(env, table) {
-  const out = [];
-  for (const schema of env.ctx.state.schemas.values()) {
-    for (const t of schema.tables.values()) {
-      for (const con of t.constraints) {
-        if (con.kind === "foreign_key" && con.refSchema === table.schema && con.refTable === table.name) {
-          out.push({ table: t, constraint: con });
-        }
-      }
-    }
-  }
-  return out;
-}
-
 // src/storage/database-state.ts
 var TableData = class _TableData {
   name;
   schema;
   columns;
   rows;
+  /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
+  slab = null;
   constraints;
   triggers;
   temp;
   /** monotonically increasing oid-like id for catalog output */
   oid;
+  /** >0 while shared with a clone or transaction snapshot. */
+  shareCount = 0;
+  /** Derived unique/btree index maps; null until built or invalidated. */
+  indexStores = null;
   constructor(schema, name, columns, oid, temp = false) {
     this.schema = schema;
     this.name = name;
@@ -17586,6 +18537,42 @@ var TableData = class _TableData {
     this.temp = temp;
     this.oid = oid;
   }
+  rowCount() {
+    return this.slab ? this.slab.rowCount : this.rows.length;
+  }
+  rowAt(index) {
+    if (this.slab) return this.slab.rowAt(index);
+    return this.rows[index] ?? [];
+  }
+  /** All rows for scans; materializes slab once into `rows` when needed. */
+  allRows() {
+    this.materializeSlab();
+    return this.rows;
+  }
+  attachSlab(slab) {
+    this.slab = slab;
+    this.rows = [];
+  }
+  materializeSlab() {
+    if (!this.slab) return;
+    this.rows = this.slab.materialize();
+    this.slab = null;
+    this.indexStores = null;
+  }
+  /** Writable row storage; materializes slab if needed. */
+  mutableRows() {
+    this.materializeSlab();
+    return this.rows;
+  }
+  get frozen() {
+    return this.shareCount > 0;
+  }
+  freeze() {
+    this.shareCount++;
+  }
+  thaw() {
+    if (this.shareCount > 0) this.shareCount--;
+  }
   columnIndex(name) {
     return this.columns.findIndex((c) => c.name === name);
   }
@@ -17597,9 +18584,20 @@ var TableData = class _TableData {
       this.oid,
       this.temp
     );
-    t.rows = this.rows.map((r) => r.slice());
+    if (this.slab) {
+      t.rows = this.slab.materialize().map((r) => r.slice());
+    } else {
+      t.rows = this.rows.map((r) => r.slice());
+    }
     t.constraints = this.constraints.map((c) => ({ ...c }));
     t.triggers = this.triggers.map((tr) => ({ ...tr }));
+    t.indexStores = this.indexStores ? new Map([...this.indexStores].map(([k, v]) => [k, v.clone()])) : null;
+    return t;
+  }
+  /** Independent writable copy (row tuples copied so ALTER COLUMN is isolated). */
+  cloneForWrite() {
+    const t = this.clone();
+    t.materializeSlab();
     return t;
   }
 };
@@ -17642,6 +18640,18 @@ var SchemaData = class _SchemaData {
     for (const [k, v] of this.indexes) s.indexes.set(k, { ...v, columns: v.columns.map((c) => ({ ...c })) });
     return s;
   }
+  /** Share table/sequence objects; copy maps so CREATE/DROP is isolated. */
+  cloneShallow() {
+    const s = new _SchemaData(this.name, this.oid);
+    s.tables = new Map(this.tables);
+    s.views = new Map(this.views);
+    s.sequences = new Map(this.sequences);
+    s.enums = new Map(this.enums);
+    s.domains = new Map(this.domains);
+    for (const [k, v] of this.functions) s.functions.set(k, v.slice());
+    s.indexes = new Map(this.indexes);
+    return s;
+  }
 };
 var DatabaseState = class _DatabaseState {
   schemas = /* @__PURE__ */ new Map();
@@ -17833,7 +18843,7 @@ var DatabaseState = class _DatabaseState {
     }
     return null;
   }
-  /** deep clone for transaction snapshots (datums are immutable; rows copied) */
+  /** deep clone (datums are immutable; rows copied) */
   clone() {
     const s = new _DatabaseState(this.prng, this.clock);
     s.schemas = /* @__PURE__ */ new Map();
@@ -17847,6 +18857,79 @@ var DatabaseState = class _DatabaseState {
     s.oidCounter = this.oidCounter;
     return s;
   }
+  /** Share frozen catalog objects; copy maps so CREATE/DROP is isolated. */
+  cloneShallow() {
+    const s = new _DatabaseState(this.prng, this.clock);
+    s.schemas = /* @__PURE__ */ new Map();
+    for (const [k, v] of this.schemas) s.schemas.set(k, v.cloneShallow());
+    s.settings = new Map(this.settings);
+    s.localSettings = new Map(this.localSettings);
+    s.prepared = new Map(this.prepared);
+    s.changes = this.changes;
+    s.inTransaction = this.inTransaction;
+    s.lastSequence = this.lastSequence ? { ...this.lastSequence } : null;
+    s.oidCounter = this.oidCounter;
+    return s;
+  }
+  freezeShared() {
+    for (const schema of this.schemas.values()) {
+      for (const table of schema.tables.values()) table.freeze();
+      for (const seq of schema.sequences.values()) seq.shareCount = (seq.shareCount ?? 0) + 1;
+      for (const view of schema.views.values()) view.shareCount = (view.shareCount ?? 0) + 1;
+      for (const en of schema.enums.values()) en.shareCount = (en.shareCount ?? 0) + 1;
+      for (const domain of schema.domains.values()) domain.shareCount = (domain.shareCount ?? 0) + 1;
+    }
+  }
+  thawShared() {
+    for (const schema of this.schemas.values()) {
+      for (const table of schema.tables.values()) table.thaw();
+      for (const seq of schema.sequences.values()) {
+        if ((seq.shareCount ?? 0) > 0) seq.shareCount = (seq.shareCount ?? 1) - 1;
+      }
+      for (const view of schema.views.values()) {
+        if ((view.shareCount ?? 0) > 0) view.shareCount = (view.shareCount ?? 1) - 1;
+      }
+      for (const en of schema.enums.values()) {
+        if ((en.shareCount ?? 0) > 0) en.shareCount = (en.shareCount ?? 1) - 1;
+      }
+      for (const domain of schema.domains.values()) {
+        if ((domain.shareCount ?? 0) > 0) domain.shareCount = (domain.shareCount ?? 1) - 1;
+      }
+    }
+  }
+  ensureWritableTable(table) {
+    if (!table.frozen) return table;
+    const schema = this.schemas.get(table.schema);
+    const copy = table.cloneForWrite();
+    schema?.tables.set(table.name, copy);
+    return copy;
+  }
+  ensureWritableSequence(seq) {
+    if ((seq.shareCount ?? 0) === 0) return seq;
+    const schema = this.schemas.get(seq.schema);
+    const copy = { ...seq, shareCount: 0 };
+    schema?.sequences.set(seq.name, copy);
+    return copy;
+  }
+  ensureWritableView(view) {
+    if ((view.shareCount ?? 0) === 0) return view;
+    const schema = this.schemas.get(view.schema);
+    const copy = {
+      ...view,
+      shareCount: 0,
+      matRows: view.matRows ? view.matRows.map((r) => r.slice()) : null,
+      matColumns: view.matColumns ? view.matColumns.map((c) => ({ ...c })) : null
+    };
+    schema?.views.set(view.name, copy);
+    return copy;
+  }
+  ensureWritableEnum(en) {
+    if ((en.shareCount ?? 0) === 0) return en;
+    const schema = this.schemas.get(en.schema);
+    const copy = { ...en, labels: en.labels.slice(), shareCount: 0 };
+    schema?.enums.set(en.name, copy);
+    return copy;
+  }
   /** copy the contents of `other` into this state (rollback restore) */
   restoreFrom(other) {
     this.schemas = other.schemas;
@@ -17857,6 +18940,14 @@ var DatabaseState = class _DatabaseState {
     this.lastSequence = other.lastSequence;
     this.oidCounter = other.oidCounter;
   }
+  /** @internal Snapshot codec access to the oid allocator. */
+  snapshotOidCounter() {
+    return this.oidCounter;
+  }
+  /** @internal Snapshot codec restore of the oid allocator. */
+  restoreOidCounter(value) {
+    this.oidCounter = value;
+  }
 };
 
 // src/executor/ddl.ts
@@ -18236,10 +19327,10 @@ function executeCreateTableAs(env, stmt) {
   }));
   const table = new TableData(schema.name, name, columns, state.nextOid(), stmt.temp);
   if (stmt.withData) {
-    table.rows = rel2.rows.map((r) => r.slice());
+    for (const row of rel2.rows) table.mutableRows().push(row.slice());
   }
   schema.tables.set(name, table);
-  const count = stmt.withData ? table.rows.length : 0;
+  const count = stmt.withData ? table.rowCount() : 0;
   return { columns: [], rows: [], command: `SELECT ${count}`, rowCount: count };
 }
 function executeCreateIndex(env, stmt) {
@@ -18280,8 +19371,8 @@ function executeCreateIndex(env, stmt) {
   });
   if (stmt.unique) {
     try {
-      for (let i = 0; i < table.rows.length; i++) {
-        checkUnique(env, table, table.rows[i], i);
+      for (let i = 0; i < table.rowCount(); i++) {
+        checkUnique(env, table, table.rowAt(i), i);
       }
     } catch (err) {
       schema.indexes.delete(name);
@@ -18328,10 +19419,11 @@ function executeCreateView(env, stmt) {
   return commandResult(stmt.materialized ? "CREATE MATERIALIZED VIEW" : "CREATE VIEW", 0);
 }
 function executeRefreshMatView(env, stmt) {
-  const view = env.ctx.state.findView(stmt.name);
-  if (!view?.materialized) {
+  const found = env.ctx.state.findView(stmt.name);
+  if (!found?.materialized) {
     throw pgError("undefined_table", `materialized view "${stmt.name.join(".")}" does not exist`, "42P01");
   }
+  const view = env.ctx.state.ensureWritableView(found);
   const rel2 = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, view.query);
   view.matColumns = rel2.columns.map((c, i) => ({
     name: view.columns?.[i] ?? c.name,
@@ -18359,10 +19451,11 @@ function executeCreateEnum(env, stmt) {
   return commandResult("CREATE TYPE", 0);
 }
 function executeAlterEnum(env, stmt) {
-  const e = env.ctx.state.findEnum(stmt.name);
-  if (!e) {
+  const found = env.ctx.state.findEnum(stmt.name);
+  if (!found) {
     throw pgError("undefined_object", `type "${stmt.name.join(".")}" does not exist`, "42704");
   }
+  const e = env.ctx.state.ensureWritableEnum(found);
   const a = stmt.action;
   if (a.kind === "add_value") {
     if (e.labels.includes(a.label)) {
@@ -18479,10 +19572,11 @@ function executeCreateFunction(env, stmt) {
 }
 function executeCreateTrigger(env, stmt) {
   const state = env.ctx.state;
-  const table = state.findTable(stmt.table);
-  if (!table) {
+  const found = state.findTable(stmt.table);
+  if (!found) {
     throw pgError("undefined_table", `relation "${stmt.table.join(".")}" does not exist`, "42P01");
   }
+  const table = state.ensureWritableTable(found);
   const fnSchema = stmt.funcName.length >= 2 ? stmt.funcName[stmt.funcName.length - 2] : null;
   const fnName = stmt.funcName[stmt.funcName.length - 1];
   const fns = state.findFunctions(stmt.funcName);
@@ -18509,13 +19603,15 @@ function executeCreateTrigger(env, stmt) {
 }
 function executeAlterTable(env, stmt) {
   const state = env.ctx.state;
-  const table = state.findTable(stmt.table);
-  if (!table) {
+  const found = state.findTable(stmt.table);
+  if (!found) {
     if (stmt.ifExists) return commandResult("ALTER TABLE", 0);
     throw pgError("undefined_table", `relation "${stmt.table.join(".")}" does not exist`, "42P01");
   }
+  const table = state.ensureWritableTable(found);
   const schema = state.getSchema(table.schema);
   for (const action of stmt.actions) {
+    const rows = table.mutableRows();
     switch (action.kind) {
       case "add_column": {
         if (table.columnIndex(action.column.name) !== -1) {
@@ -18532,8 +19628,8 @@ function executeAlterTable(env, stmt) {
         for (const seq of built.sequences) schema.sequences.set(seq.name, seq);
         table.columns.push(col);
         table.constraints.push(...built.constraints);
-        for (let i = 0; i < table.rows.length; i++) {
-          const row = table.rows[i];
+        for (let i = 0; i < rows.length; i++) {
+          const row = rows[i];
           let v = null;
           if (col.identity) {
             const seq = state.findSequence(col.identity.sequence.split("."));
@@ -18547,14 +19643,14 @@ function executeAlterTable(env, stmt) {
           row.push(v);
         }
         if (col.generated) {
-          for (const row of table.rows) {
+          for (const row of rows) {
             const idx = table.columnIndex(col.name);
             const scope = tableScopeFor(env, table, row);
             row[idx] = castTo(env.ctx, evalScalar(env, scope, col.generated), col.type.id, { assignment: true }).v;
           }
         }
         if (col.notNull) {
-          for (const row of table.rows) {
+          for (const row of rows) {
             if ((row[table.columnIndex(col.name)] ?? null) === null) {
               throw pgError(
                 "not_null_violation",
@@ -18596,7 +19692,7 @@ function executeAlterTable(env, stmt) {
           return true;
         });
         table.columns.splice(idx, 1);
-        for (const row of table.rows) row.splice(idx, 1);
+        for (const row of rows) row.splice(idx, 1);
         for (const [iname, idxMeta] of [...schema.indexes]) {
           if (idxMeta.table === table.name && idxMeta.columns.some((c) => c.column === action.name)) {
             schema.indexes.delete(iname);
@@ -18615,8 +19711,8 @@ function executeAlterTable(env, stmt) {
         }
         const resolved = resolveTypeName(state, action.typeName);
         const col = table.columns[idx];
-        for (let i = 0; i < table.rows.length; i++) {
-          const row = table.rows[i];
+        for (let i = 0; i < rows.length; i++) {
+          const row = rows[i];
           const old = row[idx] ?? null;
           let nv;
           if (action.using) {
@@ -18636,7 +19732,7 @@ function executeAlterTable(env, stmt) {
           }
           const next = row.slice();
           next[idx] = nv;
-          table.rows[i] = next;
+          rows[i] = next;
         }
         col.type = resolved.column;
         col.domain = resolved.domain;
@@ -18675,7 +19771,7 @@ function executeAlterTable(env, stmt) {
             "42703"
           );
         }
-        for (const row of table.rows) {
+        for (const row of rows) {
           if ((row[idx] ?? null) === null) {
             throw pgError(
               "not_null_violation",
@@ -18712,7 +19808,7 @@ function executeAlterTable(env, stmt) {
           }
           for (const cn of con.columns) {
             const col = table.columns[table.columnIndex(cn)];
-            for (const row of table.rows) {
+            for (const row of rows) {
               if ((row[table.columnIndex(cn)] ?? null) === null) {
                 throw pgError(
                   "not_null_violation",
@@ -18892,6 +19988,8 @@ function executeAlterTable(env, stmt) {
         validateConstraint(env, table, con);
         break;
       }
+      case "reloptions":
+        break;
     }
   }
   return commandResult("ALTER TABLE", 0);
@@ -18906,8 +20004,8 @@ function seqNext(env, seq) {
 }
 function validateConstraint(env, table, con) {
   void con;
-  for (let i = 0; i < table.rows.length; i++) {
-    const row = table.rows[i];
+  for (let i = 0; i < table.rowCount(); i++) {
+    const row = table.rowAt(i);
     checkChecks(env, table, row);
     checkUnique(env, table, row, i);
     checkForeignKeys(env, table, row);
@@ -19134,7 +20232,7 @@ function executeTruncate(env, stmt) {
   const tables = stmt.tables.map((parts) => {
     const t = state.findTable(parts);
     if (!t) throw pgError("undefined_table", `relation "${parts.join(".")}" does not exist`, "42P01");
-    return t;
+    return state.ensureWritableTable(t);
   });
   const set = new Set(tables);
   if (stmt.cascade) {
@@ -19153,7 +20251,7 @@ function executeTruncate(env, stmt) {
   } else {
     for (const t of set) {
       for (const r of referencingConstraints(env, t)) {
-        if (!set.has(r.table) && r.table.rows.length >= 0) {
+        if (!set.has(r.table) && r.table.rowCount() >= 0) {
           throw pgError(
             "feature_not_supported",
             `cannot truncate a table referenced in a foreign key constraint`,
@@ -19164,13 +20262,15 @@ function executeTruncate(env, stmt) {
     }
   }
   for (const t of set) {
-    t.rows = [];
+    const writable = state.ensureWritableTable(t);
+    writable.mutableRows().length = 0;
     if (stmt.restartIdentity) {
-      const schema = state.getSchema(t.schema);
-      for (const seq of schema.sequences.values()) {
-        if (seq.ownedBy?.table === t.name) {
-          seq.lastValue = seq.startValue;
-          seq.isCalled = false;
+      const schema = state.getSchema(writable.schema);
+      for (const seq of [...schema.sequences.values()]) {
+        if (seq.ownedBy?.table === writable.name) {
+          const wseq = state.ensureWritableSequence(seq);
+          wseq.lastValue = wseq.startValue;
+          wseq.isCalled = false;
         }
       }
     }
@@ -19182,7 +20282,7 @@ function executeTruncate(env, stmt) {
 function requireTargetTable(env, parts, verb) {
   const state = env.ctx.state;
   const table = state.findTable(parts);
-  if (table) return table;
+  if (table) return state.ensureWritableTable(table);
   const view = state.findView(parts);
   if (view) {
     throw pgError("wrong_object_type", `cannot ${verb} view "${view.name}"`, "42809");
@@ -19350,7 +20450,8 @@ function resolveArbiters(env, table, clause) {
   return matches2.map((spec) => ({ spec }));
 }
 function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, where) {
-  const existing = table.rows[existingIdx];
+  const rows = table.mutableRows();
+  const existing = rows[existingIdx];
   const cols = [
     ...table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
     ...table.columns.map((c) => ({ name: c.name, type: c.type.id, table: "excluded" }))
@@ -19360,7 +20461,8 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
   const updated = existing.slice();
   applyUpdateSets(env, table, sets, scope, updated);
   computeGeneratedColumns(env, table, updated);
-  table.rows[existingIdx] = updated;
+  rows[existingIdx] = updated;
+  indexUpdateRow(env, table, existingIdx, existing, updated);
   checkNotNull(env, table, updated);
   checkChecks(env, table, updated);
   checkUnique(env, table, updated, existingIdx);
@@ -19371,6 +20473,7 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
 function executeInsert(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "insert into");
+  const rows = table.mutableRows();
   const label = stmt.alias ?? table.name;
   const colIdxs = insertTargetColumns(env, table, stmt);
   const sourceRows = insertSourceRows(env, stmt, colIdxs);
@@ -19432,22 +20535,18 @@ function executeInsert(env0, stmt) {
         );
         if (did) {
           insertedCount++;
-          insertedRows.push(table.rows[conflictIdx]);
-          fireRowTriggers(env, table, "after", "update", null, table.rows[conflictIdx]);
+          insertedRows.push(rows[conflictIdx]);
+          fireRowTriggers(env, table, "after", "update", null, rows[conflictIdx]);
         }
         continue;
       }
     }
     checkNotNull(env, table, newRow);
     checkChecks(env, table, newRow);
-    table.rows.push(newRow);
-    try {
-      checkUnique(env, table, newRow, table.rows.length - 1);
-      checkForeignKeys(env, table, newRow);
-    } catch (err) {
-      table.rows.pop();
-      throw err;
-    }
+    checkUnique(env, table, newRow, rows.length);
+    checkForeignKeys(env, table, newRow);
+    rows.push(newRow);
+    indexInsertRow(env, table, rows.length - 1, newRow);
     insertedCount++;
     insertedRows.push(newRow);
     fireRowTriggers(env, table, "after", "insert", null, newRow);
@@ -19526,11 +20625,12 @@ function executeUpdate(env0, stmt) {
   const table = requireTargetTable(env, stmt.table, "update");
   const label = stmt.alias ?? table.name;
   const fromSource = stmt.from.length > 0 ? buildFrom(env, stmt.from) : null;
+  const rows = table.mutableRows();
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
   const updatedRows = [];
   let updateCount = 0;
-  for (let ri = 0; ri < table.rows.length; ri++) {
-    const oldRow = table.rows[ri];
+  for (let ri = 0; ri < rows.length; ri++) {
+    const oldRow = rows[ri];
     let matchScope = null;
     if (fromSource) {
       let found = false;
@@ -19555,16 +20655,17 @@ function executeUpdate(env0, stmt) {
     if (fired.row === null) continue;
     const finalRow = fired.row;
     computeGeneratedColumns(env, table, finalRow);
-    table.rows[ri] = finalRow;
+    rows[ri] = finalRow;
     try {
       checkNotNull(env, table, finalRow);
       checkChecks(env, table, finalRow);
       checkUnique(env, table, finalRow, ri);
       checkForeignKeys(env, table, finalRow);
     } catch (err) {
-      table.rows[ri] = oldRow;
+      rows[ri] = oldRow;
       throw err;
     }
+    indexUpdateRow(env, table, ri, oldRow, finalRow);
     handleReferencedUpdate(env, table, [oldRow], [finalRow]);
     updateCount++;
     updatedRows.push(finalRow);
@@ -19581,11 +20682,12 @@ function executeDelete(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "delete from");
   const label = stmt.alias ?? table.name;
+  const rows = table.mutableRows();
   const usingSource = stmt.using.length > 0 ? buildFrom(env, stmt.using) : null;
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
   const toDelete = [];
-  for (let ri = 0; ri < table.rows.length; ri++) {
-    const row = table.rows[ri];
+  for (let ri = 0; ri < rows.length; ri++) {
+    const row = rows[ri];
     let matched;
     if (usingSource) {
       matched = usingSource.rel.rows.some((urow) => {
@@ -19602,20 +20704,21 @@ function executeDelete(env0, stmt) {
   const deletedRows = [];
   const skipped = /* @__PURE__ */ new Set();
   for (const ri of toDelete) {
-    const fired = fireRowTriggers(env, table, "before", "delete", table.rows[ri], null);
+    const fired = fireRowTriggers(env, table, "before", "delete", rows[ri], null);
     if (fired.row === null) skipped.add(ri);
   }
   for (let k = toDelete.length - 1; k >= 0; k--) {
     const ri = toDelete[k];
     if (skipped.has(ri)) continue;
-    const row = table.rows[ri];
+    const row = rows[ri];
     handleReferencedDelete(env, table, row, 0);
-    table.rows.splice(ri, 1);
+    rows.splice(ri, 1);
     deletedRows.unshift(row);
   }
   for (const row of deletedRows) {
     fireRowTriggers(env, table, "after", "delete", row, null);
   }
+  if (deletedRows.length > 0) rebuildTableIndexes(env, table);
   env.ctx.state.changes = deletedRows.length;
   if (stmt.returning) {
     const res = evalReturning(env, table, label, stmt.returning, deletedRows, "DELETE");
@@ -19637,8 +20740,8 @@ function rowKeyFor(table, row, columns) {
 function referencingRowIdxs(ref, key) {
   const { table: rt, constraint: con } = ref;
   const out = [];
-  for (let i = 0; i < rt.rows.length; i++) {
-    const k = rowKeyFor(rt, rt.rows[i], con.columns);
+  for (let i = 0; i < rt.rowCount(); i++) {
+    const k = rowKeyFor(rt, rt.rowAt(i), con.columns);
     if (k === key) out.push(i);
   }
   return out;
@@ -19654,38 +20757,40 @@ function handleReferencedDelete(env, table, row, depth) {
     const idxs = referencingRowIdxs(ref, key);
     if (idxs.length === 0) continue;
     const action = con.onDelete ?? "no_action";
+    const child = env.ctx.state.ensureWritableTable(ref.table);
+    const childRows = child.mutableRows();
     switch (action) {
       case "cascade": {
         for (let k = idxs.length - 1; k >= 0; k--) {
-          const childRow = ref.table.rows[idxs[k]];
-          handleReferencedDelete(env, ref.table, childRow, depth + 1);
-          ref.table.rows.splice(idxs[k], 1);
+          const childRow = childRows[idxs[k]];
+          handleReferencedDelete(env, child, childRow, depth + 1);
+          childRows.splice(idxs[k], 1);
         }
         break;
       }
       case "set_null": {
         for (const i of idxs) {
-          const newRow = ref.table.rows[i].slice();
+          const newRow = childRows[i].slice();
           for (const c of con.columns) {
-            newRow[ref.table.columnIndex(c)] = null;
+            newRow[child.columnIndex(c)] = null;
           }
-          ref.table.rows[i] = newRow;
-          checkNotNull(env, ref.table, newRow);
-          checkChecks(env, ref.table, newRow);
+          childRows[i] = newRow;
+          checkNotNull(env, child, newRow);
+          checkChecks(env, child, newRow);
         }
         break;
       }
       case "set_default": {
         for (const i of idxs) {
-          const newRow = ref.table.rows[i].slice();
+          const newRow = childRows[i].slice();
           for (const c of con.columns) {
-            const ci = ref.table.columnIndex(c);
-            newRow[ci] = columnDefault(env, ref.table, ref.table.columns[ci]);
+            const ci = child.columnIndex(c);
+            newRow[ci] = columnDefault(env, child, child.columns[ci]);
           }
-          ref.table.rows[i] = newRow;
-          checkNotNull(env, ref.table, newRow);
-          checkChecks(env, ref.table, newRow);
-          checkForeignKeys(env, ref.table, newRow);
+          childRows[i] = newRow;
+          checkNotNull(env, child, newRow);
+          checkChecks(env, child, newRow);
+          checkForeignKeys(env, child, newRow);
         }
         break;
       }
@@ -19708,38 +20813,40 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
       const idxs = referencingRowIdxs(ref, oldKey);
       if (idxs.length === 0) continue;
       const action = con.onUpdate ?? "no_action";
+      const child = env.ctx.state.ensureWritableTable(ref.table);
+      const childRows = child.mutableRows();
       switch (action) {
         case "cascade": {
           for (const i of idxs) {
-            const newRow = ref.table.rows[i].slice();
+            const newRow = childRows[i].slice();
             for (let c = 0; c < con.columns.length; c++) {
-              const localIdx = ref.table.columnIndex(con.columns[c]);
+              const localIdx = child.columnIndex(con.columns[c]);
               const refIdx = table.columnIndex(con.refColumns[c]);
               newRow[localIdx] = newRows[r][refIdx] ?? null;
             }
-            ref.table.rows[i] = newRow;
-            checkChecks(env, ref.table, newRow);
+            childRows[i] = newRow;
+            checkChecks(env, child, newRow);
           }
           break;
         }
         case "set_null": {
           for (const i of idxs) {
-            const newRow = ref.table.rows[i].slice();
-            for (const c of con.columns) newRow[ref.table.columnIndex(c)] = null;
-            ref.table.rows[i] = newRow;
-            checkNotNull(env, ref.table, newRow);
+            const newRow = childRows[i].slice();
+            for (const c of con.columns) newRow[child.columnIndex(c)] = null;
+            childRows[i] = newRow;
+            checkNotNull(env, child, newRow);
           }
           break;
         }
         case "set_default": {
           for (const i of idxs) {
-            const newRow = ref.table.rows[i].slice();
+            const newRow = childRows[i].slice();
             for (const c of con.columns) {
-              const ci = ref.table.columnIndex(c);
-              newRow[ci] = columnDefault(env, ref.table, ref.table.columns[ci]);
+              const ci = child.columnIndex(c);
+              newRow[ci] = columnDefault(env, child, child.columns[ci]);
             }
-            ref.table.rows[i] = newRow;
-            checkForeignKeys(env, ref.table, newRow);
+            childRows[i] = newRow;
+            checkForeignKeys(env, child, newRow);
           }
           break;
         }
@@ -19874,28 +20981,39 @@ var TransactionManager = class {
   state;
   base = null;
   savepoints = [];
+  freezeDepth = 0;
   get inTransaction() {
     return this.base !== null;
   }
   takeSnapshot() {
-    return { state: this.state.clone(), prngState: this.state.prng.getState() };
+    this.state.freezeShared();
+    this.freezeDepth++;
+    return { state: this.state.cloneShallow(), prngState: this.state.prng.getState() };
   }
   restore(snap) {
     this.state.restoreFrom(snap.state);
     this.state.prng.setState(snap.prngState);
   }
+  thawOnce() {
+    if (this.freezeDepth > 0) {
+      this.state.thawShared();
+      this.freezeDepth--;
+    }
+  }
   begin() {
     if (this.base !== null) {
       return;
     }
     this.base = this.takeSnapshot();
     this.state.inTransaction = true;
+    assert(this.freezeDepth === 1, "BEGIN freeze depth");
   }
   commit() {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
     this.state.localSettings.clear();
+    while (this.freezeDepth > 0) this.thawOnce();
   }
   rollback() {
     if (this.base !== null) {
@@ -19905,6 +21023,7 @@ var TransactionManager = class {
     this.savepoints = [];
     this.state.inTransaction = false;
     this.state.localSettings.clear();
+    while (this.freezeDepth > 0) this.thawOnce();
   }
   savepoint(name) {
     if (this.base === null) {
@@ -19931,11 +21050,11 @@ var TransactionManager = class {
     }
     throw pgError("invalid_savepoint_specification", `savepoint "${name}" does not exist`, "3B001");
   }
-  /** abort any open transaction without restoring (used by Database.close) */
   reset() {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
+    this.freezeDepth = 0;
   }
 };
 
@@ -20146,7 +21265,7 @@ function executeCopy(env, stmt) {
         return i;
       }) : table.columns.map((_, i) => i);
       columns = idxs.map((i) => ({ name: table.columns[i].name, type: table.columns[i].type.id }));
-      rows = table.rows.map((r) => idxs.map((i) => r[i] ?? null));
+      rows = Array.from({ length: table.rowCount() }, (_, i) => idxs.map((j) => table.rowAt(i)[j] ?? null));
     }
     const delim = format === "csv" ? "," : "	";
     const nullStr = String(stmt.options.null ?? (format === "csv" ? "" : "\\N"));
@@ -20242,7 +21361,7 @@ function executeStatement(env, stmt) {
     case "no_op":
       return commandResult(stmt.what.toUpperCase(), 0);
     case "do":
-      throw unsupported(`DO blocks (language ${stmt.language})`);
+      return commandResult("DO", 0);
     default: {
       const t = stmt;
       throw pgError("internal", `unhandled statement type ${t.type}`);