@crvouga/mockingbird-service-postgres 3.5.0 → 3.7.0

package/dist/server.js

@@ -257,6 +257,13 @@ function isPostgresError(err) {
   return typeof sqlState === "string" && /^[0-9A-Z]{5}$/.test(sqlState);
 }
 
+// src/storage/guc.ts
+function validateStorageSetting(name, value) {
+  if (name === "default_table_access_method" && value !== "heap" || name === "default_tablespace" && value !== "" && value !== "pg_default") {
+    throw pgError("invalid_parameter_value", `invalid value for parameter "${name}": "${value}"`, "22023");
+  }
+}
+
 // src/runtime/prng.ts
 var Prng = class _Prng {
   state;
@@ -2796,6 +2803,12 @@ var invalidName = () => {
   throw pgError("syntax", "invalid name syntax", "42602");
 };
 function parseNamespaceInput(text) {
+  const parsed = parseRelationInput(text);
+  if ("oid" in parsed) return parsed;
+  if (parsed.parts.length !== 1) invalidName();
+  return { name: parsed.parts[0] };
+}
+function parseRelationInput(text) {
   if (text === "-") return { oid: 0 };
   if (/^\d+$/.test(text)) return { oid: parseOidText(text) };
   const names = [];
@@ -2831,8 +2844,8 @@ function parseNamespaceInput(text) {
     skipSpace();
     if (at === text.length) invalidName();
   }
-  if (names.length !== 1) invalidName();
-  return { name: names[0] };
+  if (names.length === 0 || names.length > 3) invalidName();
+  return { parts: names };
 }
 function namespaceText(oid, name) {
   if (oid === 0) return "-";
@@ -2905,6 +2918,7 @@ var TYPE_ALIASES = {
   regtype: "regtype",
   regproc: "regproc",
   regnamespace: "regnamespace",
+  xid: "xid",
   oid: "oid",
   void: "void",
   record: "record",
@@ -2981,6 +2995,7 @@ var TYPE_OIDS = {
   regproc: 24,
   text: 25,
   oid: 26,
+  xid: 28,
   json: 114,
   float4: 700,
   float8: 701,
@@ -3300,6 +3315,7 @@ function recordText(rec, ctx) {
   return `(${parts.join(",")})`;
 }
 function datumText(t, v, ctx) {
+  if (t === "regclass") return v === 0 ? "-" : ctx.relationName?.(v) ?? String(v);
   if (t === "regnamespace") return namespaceText(v, ctx.namespaceName?.(v));
   if (v === null) throw pgError("internal", "datumText called with null");
   if (isArrayType(t)) return arrayText(v, ctx);
@@ -3310,6 +3326,7 @@ function datumText(t, v, ctx) {
     case "int2":
     case "int4":
     case "oid":
+    case "xid":
       return String(v);
     case "int8":
       return String(v);
@@ -3374,6 +3391,12 @@ function datumText(t, v, ctx) {
 }
 var UTC_INPUT = { zoneOffsetForNaive: () => 0 };
 function datumFromText(t, text, ctx) {
+  if (t === "regclass") {
+    const parsed = parseRelationInput(text);
+    if ("oid" in parsed) return parsed.oid;
+    if (!ctx.relationOid) throw unsupported("regclass input without a catalog");
+    return ctx.relationOid(parsed.parts);
+  }
   if (t === "regnamespace") {
     const parsed = parseNamespaceInput(text);
     if ("oid" in parsed) return parsed.oid;
@@ -3395,6 +3418,7 @@ function datumFromText(t, text, ctx) {
     case "int8":
       return parseIntegerText(text, t);
     case "oid":
+    case "xid":
       return parseOidText(text);
     case "float4":
       return Math.fround(parseFloatText(text, "float4"));
@@ -3551,6 +3575,8 @@ var TableData = class _TableData {
   schema;
   columns;
   rows;
+  rowXmins = /* @__PURE__ */ new WeakMap();
+  slabXmins = null;
   /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
   slab = null;
   constraints;
@@ -3593,6 +3619,11 @@ var TableData = class _TableData {
   materializeSlab() {
     if (!this.slab) return;
     this.rows = this.slab.materialize();
+    if (this.slabXmins)
+      this.rows.forEach((row, index) => {
+        this.rowXmins.set(row, this.slabXmins[index] ?? 2);
+      });
+    this.slabXmins = null;
     this.slab = null;
     this.indexStores = null;
   }
@@ -3626,6 +3657,10 @@ var TableData = class _TableData {
     } else {
       t.rows = this.rows.map((r) => r.slice());
     }
+    t.rows.forEach((row, index) => {
+      const xmin = this.slabXmins?.[index] ?? this.rowXmins.get(this.rows[index]);
+      if (xmin !== void 0) t.rowXmins.set(row, xmin);
+    });
     t.unlogged = this.unlogged;
     t.constraints = this.constraints.map((c) => ({ ...c }));
     t.triggers = this.triggers.map((tr) => ({ ...tr }));
@@ -3711,7 +3746,18 @@ var DatabaseState = class _DatabaseState {
   clock;
   changes = 0;
   oidCounter = 16384;
+  /** Local monotonic xid allocator; 2 denotes a row from a legacy snapshot without metadata. */
+  xidCounter = 3;
+  transactionXid = null;
+  allocateXid() {
+    if (this.xidCounter > 4294967295)
+      throw pgError("program_limit_exceeded", "transaction ID space exhausted; xid wraparound is not modeled", "54000");
+    return this.xidCounter++;
+  }
   inTransaction = false;
+  /** Transaction-only events: included in rollback clones, never in exported snapshots. */
+  pendingTriggers = [];
+  constraintModes = /* @__PURE__ */ new Map();
   /** most recent sequence touched by nextval/setval, for lastval() */
   lastSequence = null;
   /** Session currval per sequence; absent entry means currval is undefined. */
@@ -3754,6 +3800,8 @@ var DatabaseState = class _DatabaseState {
     this.settings.set("row_security", "on");
     this.settings.set("array_nulls", "on");
     this.settings.set("backslash_quote", "safe_encoding");
+    this.settings.set("default_tablespace", "");
+    this.settings.set("default_table_access_method", "heap");
   }
   nextOid() {
     return this.oidCounter++;
@@ -3913,10 +3961,14 @@ var DatabaseState = class _DatabaseState {
     s.prepared = new Map(this.prepared);
     s.changes = this.changes;
     s.inTransaction = this.inTransaction;
+    s.pendingTriggers = this.pendingTriggers.slice();
+    s.constraintModes = new Map(this.constraintModes);
     s.lastSequence = this.lastSequence ? { ...this.lastSequence } : null;
     s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.tableStats = new Map(this.tableStats);
     s.oidCounter = this.oidCounter;
+    s.xidCounter = this.xidCounter;
+    s.transactionXid = this.transactionXid;
     for (const [name, overloads] of this.systemFunctions) s.systemFunctions.set(name, overloads.slice());
     return s;
   }
@@ -3930,10 +3982,14 @@ var DatabaseState = class _DatabaseState {
     s.prepared = new Map(this.prepared);
     s.changes = this.changes;
     s.inTransaction = this.inTransaction;
+    s.pendingTriggers = this.pendingTriggers.slice();
+    s.constraintModes = new Map(this.constraintModes);
     s.lastSequence = this.lastSequence ? { ...this.lastSequence } : null;
     s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.tableStats = new Map(this.tableStats);
     s.oidCounter = this.oidCounter;
+    s.xidCounter = this.xidCounter;
+    s.transactionXid = this.transactionXid;
     for (const [name, overloads] of this.systemFunctions) s.systemFunctions.set(name, overloads.slice());
     return s;
   }
@@ -4002,11 +4058,15 @@ var DatabaseState = class _DatabaseState {
     this.settings = other.settings;
     this.localSettings = other.localSettings;
     this.prepared = other.prepared;
+    this.pendingTriggers = other.pendingTriggers.slice();
+    this.constraintModes = new Map(other.constraintModes);
     this.changes = other.changes;
     this.lastSequence = other.lastSequence;
     this.sequenceCurrval = other.sequenceCurrval;
     this.tableStats = other.tableStats;
     this.oidCounter = other.oidCounter;
+    this.xidCounter = Math.max(this.xidCounter, other.xidCounter);
+    this.transactionXid = other.transactionXid;
   }
   /** @internal Snapshot codec access to the oid allocator. */
   snapshotOidCounter() {
@@ -4018,91 +4078,215 @@ var DatabaseState = class _DatabaseState {
   }
 };
 
-// src/transactions/manager.ts
-var TransactionManager = class {
-  constructor(state) {
-    this.state = state;
+// src/types/timezone.ts
+var intlCache = /* @__PURE__ */ new Map();
+function intlFor(zone) {
+  const cached = intlCache.get(zone);
+  if (cached) return cached;
+  try {
+    const fmt = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      timeZoneName: "longOffset",
+      year: "numeric"
+    });
+    intlCache.set(zone, fmt);
+    return fmt;
+  } catch {
+    return null;
+  }
+}
+function parseFixedOffset(zone) {
+  const m = /^([+-]?)(\d{1,2})(?::(\d{2}))?(?::(\d{2}))?$/.exec(zone.trim());
+  if (!m) return null;
+  const sign = m[1] === "-" ? -1 : 1;
+  return sign * (Number(m[2]) * 3600 + Number(m[3] ?? 0) * 60 + Number(m[4] ?? 0));
+}
+function parsePosixOffset(zone) {
+  const m = /^(?:utc|gmt)([+-])(\d{1,2})(?::(\d{2}))?$/i.exec(zone.trim());
+  if (!m) return null;
+  const sign = m[1] === "-" ? 1 : -1;
+  return sign * (Number(m[2]) * 3600 + Number(m[3] ?? 0) * 60);
+}
+function pgMicrosToUnixMs(utcMicros) {
+  return Number((utcMicros - UNIX_EPOCH_MICROS_FROM_PG) / 1000n);
+}
+function zoneOffsetAtUtc(zone, utcMicros) {
+  const z = zone.trim();
+  const lower = z.toLowerCase();
+  if (lower === "utc" || lower === "gmt" || lower === "z" || lower === "zulu" || lower === "universal") return 0;
+  const posix = parsePosixOffset(z);
+  if (posix !== null) return posix;
+  const fixed = parseFixedOffset(z);
+  if (fixed !== null) return fixed;
+  const fmt = intlFor(z);
+  if (fmt) {
+    const ms = clampDateMs(pgMicrosToUnixMs(utcMicros));
+    const parts = fmt.formatToParts(new Date(ms));
+    const tzName = parts.find((p) => p.type === "timeZoneName")?.value ?? "GMT";
+    const m = /GMT([+-])(\d{2}):(\d{2})(?::(\d{2}))?/.exec(tzName);
+    if (!m) return 0;
+    const sign = m[1] === "-" ? -1 : 1;
+    return sign * (Number(m[2]) * 3600 + Number(m[3]) * 60 + Number(m[4] ?? 0));
   }
+  throw pgError("invalid_parameter_value", `time zone "${zone}" not recognized`);
+}
+function clampDateMs(ms) {
+  const MAX = 864e13;
+  return Math.max(-MAX, Math.min(MAX, ms));
+}
+function zoneOffsetForNaive(zone, naiveMicros) {
+  const first = zoneOffsetAtUtc(zone, naiveMicros);
+  const second = zoneOffsetAtUtc(zone, naiveMicros - BigInt(first) * 1000000n);
+  return second;
+}
+function validateZone(zone) {
+  zoneOffsetAtUtc(zone, 0n);
+}
+
+// src/expressions/context.ts
+var EngineCtx = class {
   state;
-  base = null;
-  savepoints = [];
-  freezeDepth = 0;
-  get inTransaction() {
-    return this.base !== null;
+  writeXid = null;
+  rowVersionXid() {
+    if (this.state.inTransaction) return this.state.transactionXid ??= this.state.allocateXid();
+    return this.writeXid ??= this.state.allocateXid();
   }
-  takeSnapshot() {
-    this.state.freezeShared();
-    this.freezeDepth++;
-    return { state: this.state.cloneShallow(), prngState: this.state.prng.getState() };
+  /** transaction timestamp (now(), current_timestamp) — UTC micros since PG epoch */
+  txNow;
+  /** statement timestamp */
+  stmtNow;
+  constructor(state, txNow) {
+    this.state = state;
+    const nowMs = state.clock().getTime();
+    const nowMicros = BigInt(Math.round(nowMs)) * 1000n + UNIX_EPOCH_MICROS_FROM_PG;
+    this.txNow = txNow ?? nowMicros;
+    this.stmtNow = nowMicros;
   }
-  restore(snap) {
-    this.state.restoreFrom(snap.state);
-    this.state.prng.setState(snap.prngState);
+  timezone() {
+    return this.state.getSetting("timezone") ?? "UTC";
   }
-  thawOnce() {
-    if (this.freezeDepth > 0) {
-      this.state.thawShared();
-      this.freezeDepth--;
-    }
+  relationOid(parts) {
+    const target = this.state.resolveRelationSchema(parts);
+    const schema = target ? this.state.schemas.get(target.schema) : void 0;
+    const relation = target ? schema?.sequences.get(target.name) ?? schema?.tables.get(target.name) ?? schema?.views.get(target.name) : void 0;
+    if (!relation) throw pgError("undefined_table", `relation "${parts.join(".")}" does not exist`, "42P01");
+    return relation.oid;
   }
-  begin() {
-    if (this.base !== null) {
-      return;
+  relationName(oid) {
+    for (const schema of this.state.schemas.values()) {
+      for (const relation of [...schema.tables.values(), ...schema.sequences.values(), ...schema.views.values()]) {
+        if (relation.oid !== oid) continue;
+        const visible = this.state.resolveRelationSchema([relation.name])?.schema === schema.name;
+        return (visible ? [relation.name] : [schema.name, relation.name]).map(quoteIdentifier).join(".");
+      }
     }
-    this.base = this.takeSnapshot();
-    this.state.inTransaction = true;
-    assert(this.freezeDepth === 1, "BEGIN freeze depth");
+    return null;
   }
-  commit() {
-    this.base = null;
-    this.savepoints = [];
-    this.state.inTransaction = false;
-    this.state.localSettings.clear();
-    while (this.freezeDepth > 0) this.thawOnce();
+  namespaceOid(name) {
+    const oid = builtinNamespaceOid(name) ?? this.state.schemas.get(name)?.oid;
+    if (oid === void 0) throw pgError("undefined_object", `schema "${name}" does not exist`, "3F000");
+    return oid;
   }
-  rollback() {
-    if (this.base !== null) {
-      this.restore(this.base);
+  namespaceName(oid) {
+    const builtin = builtinNamespaceName(oid);
+    if (builtin !== void 0) return builtin;
+    for (const schema of this.state.schemas.values()) {
+      if (schema.oid === oid) return schema.name;
     }
-    this.base = null;
-    this.savepoints = [];
-    this.state.inTransaction = false;
-    this.state.localSettings.clear();
-    while (this.freezeDepth > 0) this.thawOnce();
+    return null;
   }
-  savepoint(name) {
-    if (this.base === null) {
-      throw pgError("transaction_state", "SAVEPOINT can only be used in transaction blocks", "25P01");
-    }
-    this.savepoints.push({ name, snap: this.takeSnapshot() });
+  zoneOffsetAt(utcMicros) {
+    return zoneOffsetAtUtc(this.timezone(), utcMicros);
   }
-  releaseSavepoint(name) {
-    const idx = this.findSavepoint(name);
-    this.savepoints.splice(idx);
+  zoneOffsetForNaive(naiveMicros) {
+    return zoneOffsetForNaive(this.timezone(), naiveMicros);
   }
-  rollbackToSavepoint(name) {
-    const idx = this.findSavepoint(name);
-    const sp = this.savepoints[idx];
-    this.restore(sp.snap);
-    this.savepoints.splice(idx + 1);
+  enumLabels(enumType) {
+    if (!isEnumType(enumType)) return null;
+    const e = this.state.findEnumByKey(enumType.slice(5));
+    return e?.labels ?? null;
   }
-  findSavepoint(name) {
-    if (this.base === null) {
-      throw pgError("transaction_state", `SAVEPOINT can only be used in transaction blocks`, "25P01");
-    }
-    for (let i = this.savepoints.length - 1; i >= 0; i--) {
-      if (this.savepoints[i].name === name) return i;
-    }
-    throw pgError("invalid_savepoint_specification", `savepoint "${name}" does not exist`, "3B001");
+  enumHasLabel(enumType, label) {
+    const labels = this.enumLabels(enumType);
+    return labels === null ? true : labels.includes(label);
   }
-  reset() {
-    this.base = null;
-    this.savepoints = [];
-    this.state.inTransaction = false;
-    this.freezeDepth = 0;
+  enumOrder(enumType, label) {
+    const labels = this.enumLabels(enumType);
+    if (!labels) return 0;
+    const idx = labels.indexOf(label);
+    return idx === -1 ? labels.length : idx;
+  }
+  requireEnum(enumType) {
+    const labels = this.enumLabels(enumType);
+    if (!labels) throw pgError("undefined_object", `type "${enumType.slice(5)}" does not exist`);
+    return labels;
   }
 };
 
+// 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/types/cast.ts
 var UTC_CAST_ENV = {
   zoneOffsetAt: () => 0,
@@ -4298,7 +4482,7 @@ function castTo(env, value, target, opts = {}) {
     return tv(target, makeArray(toElem, items, arr.dims.slice(), arr.lbs.slice()));
   }
   if (from === "oid" && target === "regnamespace") return tv(target, v);
-  if (from === "regnamespace" && (target === "oid" || target === "int4" || target === "int8")) {
+  if ((from === "regnamespace" || from === "regclass") && (target === "oid" || target === "int4" || target === "int8")) {
     return tv(target, target === "int8" ? BigInt(v) : v);
   }
   if ((from === "int4" || from === "int8" || from === "int2") && (target === "oid" || target === "regnamespace")) {
@@ -4579,259 +4763,6 @@ function unifyTypes(a, b) {
   return null;
 }
 
-// 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()) {
-    this.columns = columns;
-    this.row = row;
-    this.parent = parent;
-    this.rangeVars = rangeVars;
-  }
-  columns;
-  row;
-  parent;
-  rangeVars;
-  /** Resolve a (possibly qualified) column reference. undefined = not found. */
-  lookup(parts) {
-    if (parts.length === 1) {
-      const name2 = parts[0];
-      let found2;
-      let count2 = 0;
-      for (let i = 0; i < this.columns.length; i++) {
-        const c = this.columns[i];
-        if (c.name === name2 && !c.hidden) {
-          count2++;
-          if (count2 > 1) {
-            throw pgError("ambiguous_column", `column reference "${name2}" is ambiguous`);
-          }
-          found2 = tv(c.type, this.row[i] ?? null);
-        }
-      }
-      if (found2 !== void 0) return found2;
-      if (this.rangeVars.has(name2)) {
-        return this.wholeRow(name2);
-      }
-      return this.parent?.lookup(parts);
-    }
-    const table = parts[parts.length - 2];
-    const name = parts[parts.length - 1];
-    let found;
-    let count = 0;
-    for (let i = 0; i < this.columns.length; i++) {
-      const c = this.columns[i];
-      if (c.table === table && c.name === name) {
-        count++;
-        if (count > 1) {
-          throw pgError("ambiguous_column", `column reference "${name}" is ambiguous`);
-        }
-        found = tv(c.type, this.row[i] ?? null);
-      }
-    }
-    if (found !== void 0) return found;
-    return this.parent?.lookup(parts);
-  }
-  /** Build a record value from all columns belonging to a range variable. */
-  wholeRow(rangeVar) {
-    const types = [];
-    const values = [];
-    const names = [];
-    for (let i = 0; i < this.columns.length; i++) {
-      const c = this.columns[i];
-      if (c.table === rangeVar) {
-        types.push(c.type);
-        values.push(this.row[i] ?? null);
-        names.push(c.name);
-      }
-    }
-    if (types.length === 0) return void 0;
-    return tv("record", { kind: "pgrecord", types, values, names });
-  }
-  hasRangeVar(name) {
-    if (this.rangeVars.has(name)) return true;
-    return this.parent?.hasRangeVar(name) ?? false;
-  }
-};
-function childEnv(env, outer) {
-  return {
-    ctx: env.ctx,
-    params: env.params,
-    ctes: env.ctes,
-    outer,
-    allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
-  };
-}
-function relationResult(rel3, command2) {
-  const visible = rel3.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
-  return {
-    columns: visible.map(({ c }) => ({ name: c.name, type: c.type })),
-    rows: rel3.rows.map((r) => visible.map(({ i }) => r[i] ?? null)),
-    command: command2,
-    rowCount: rel3.rows.length
-  };
-}
-function commandResult(command2, rowCount) {
-  return { columns: [], rows: [], command: command2, rowCount };
-}
-function inferColumnName(e) {
-  switch (e.type) {
-    case "colref":
-      return e.parts[e.parts.length - 1];
-    case "func":
-      return e.name[e.name.length - 1];
-    case "cast": {
-      const inner = inferColumnName(e.expr);
-      if (inner !== "?column?") return inner;
-      return e.target.parts[e.target.parts.length - 1];
-    }
-    case "collate":
-      return inferColumnName(e.expr);
-    case "case":
-      return "case";
-    case "array_ctor":
-    case "array_query":
-      return "array";
-    case "row":
-      return "row";
-    case "subquery_expr":
-      return e.kind === "exists" ? "exists" : "?column?";
-    case "bool_lit":
-      return "bool";
-    case "extract":
-      return "extract";
-    case "position":
-      return "position";
-    case "substring_sql":
-      return "substring";
-    case "overlay":
-      return "overlay";
-    case "trim":
-      return e.side === "leading" ? "ltrim" : e.side === "trailing" ? "rtrim" : "btrim";
-    case "field_select":
-      return e.field === "*" ? "?column?" : e.field;
-    case "at_time_zone":
-      return "timezone";
-    case "grouping_func":
-      return "grouping";
-    case "subscript":
-      return inferColumnName(e.base);
-    default:
-      return "?column?";
-  }
-}
-
-// 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/functions/datetime-fns.ts
 function extractDatePart(ctx, field0, src0, asNumeric) {
   const field = field0.toLowerCase();
@@ -5252,6 +5183,8 @@ function datumCompare(t, a, b, ctx = DEFAULT_COMPARE_CTX) {
     case "int2":
     case "int4":
     case "oid":
+    case "regclass":
+    case "xid":
     case "regnamespace":
     case "date":
       return expectNumber(a, t) - expectNumber(b, t);
@@ -5371,6 +5304,8 @@ function datumKey(t, v) {
     case "int2":
     case "int4":
     case "oid":
+    case "regclass":
+    case "xid":
     case "date":
       return `i${v}`;
     case "float4":
@@ -5746,71 +5681,6 @@ function getArrayFunctions() {
   return m;
 }
 
-// src/types/timezone.ts
-var intlCache = /* @__PURE__ */ new Map();
-function intlFor(zone) {
-  const cached = intlCache.get(zone);
-  if (cached) return cached;
-  try {
-    const fmt = new Intl.DateTimeFormat("en-US", {
-      timeZone: zone,
-      timeZoneName: "longOffset",
-      year: "numeric"
-    });
-    intlCache.set(zone, fmt);
-    return fmt;
-  } catch {
-    return null;
-  }
-}
-function parseFixedOffset(zone) {
-  const m = /^([+-]?)(\d{1,2})(?::(\d{2}))?(?::(\d{2}))?$/.exec(zone.trim());
-  if (!m) return null;
-  const sign = m[1] === "-" ? -1 : 1;
-  return sign * (Number(m[2]) * 3600 + Number(m[3] ?? 0) * 60 + Number(m[4] ?? 0));
-}
-function parsePosixOffset(zone) {
-  const m = /^(?:utc|gmt)([+-])(\d{1,2})(?::(\d{2}))?$/i.exec(zone.trim());
-  if (!m) return null;
-  const sign = m[1] === "-" ? 1 : -1;
-  return sign * (Number(m[2]) * 3600 + Number(m[3] ?? 0) * 60);
-}
-function pgMicrosToUnixMs(utcMicros) {
-  return Number((utcMicros - UNIX_EPOCH_MICROS_FROM_PG) / 1000n);
-}
-function zoneOffsetAtUtc(zone, utcMicros) {
-  const z = zone.trim();
-  const lower = z.toLowerCase();
-  if (lower === "utc" || lower === "gmt" || lower === "z" || lower === "zulu" || lower === "universal") return 0;
-  const posix = parsePosixOffset(z);
-  if (posix !== null) return posix;
-  const fixed = parseFixedOffset(z);
-  if (fixed !== null) return fixed;
-  const fmt = intlFor(z);
-  if (fmt) {
-    const ms = clampDateMs(pgMicrosToUnixMs(utcMicros));
-    const parts = fmt.formatToParts(new Date(ms));
-    const tzName = parts.find((p) => p.type === "timeZoneName")?.value ?? "GMT";
-    const m = /GMT([+-])(\d{2}):(\d{2})(?::(\d{2}))?/.exec(tzName);
-    if (!m) return 0;
-    const sign = m[1] === "-" ? -1 : 1;
-    return sign * (Number(m[2]) * 3600 + Number(m[3]) * 60 + Number(m[4] ?? 0));
-  }
-  throw pgError("invalid_parameter_value", `time zone "${zone}" not recognized`);
-}
-function clampDateMs(ms) {
-  const MAX = 864e13;
-  return Math.max(-MAX, Math.min(MAX, ms));
-}
-function zoneOffsetForNaive(zone, naiveMicros) {
-  const first = zoneOffsetAtUtc(zone, naiveMicros);
-  const second = zoneOffsetAtUtc(zone, naiveMicros - BigInt(first) * 1000000n);
-  return second;
-}
-function validateZone(zone) {
-  zoneOffsetAtUtc(zone, 0n);
-}
-
 // src/functions/datetime-registry.ts
 function getDatetimeFunctions() {
   const m = /* @__PURE__ */ new Map();
@@ -7410,6 +7280,28 @@ function exactDegTan(x) {
   return Math.tan(x * Math.PI / 180);
 }
 
+// src/storage/indexable-relation.ts
+function materializedTable(view) {
+  const table = new TableData(
+    view.schema,
+    view.name,
+    (view.matColumns ?? []).map((c) => ({
+      name: c.name,
+      type: { id: c.type, mod: null },
+      notNull: false,
+      defaultExpr: null,
+      identity: null,
+      generated: null,
+      collate: null,
+      domain: null
+    })),
+    view.oid,
+    view.temp
+  );
+  table.rows = view.matRows ?? [];
+  return table;
+}
+
 // src/schema/index-catalog.ts
 var isKeyConstraint = (constraint) => constraint.kind === "primary_key" || constraint.kind === "unique";
 var ACCESS_METHODS = /* @__PURE__ */ new Map([
@@ -7438,6 +7330,8 @@ function syncIndexCatalog(state) {
   const tables = /* @__PURE__ */ new Map();
   for (const schema of state.schemas.values()) {
     for (const table of schema.tables.values()) tables.set(table.oid, { schema, table });
+    for (const view of schema.views.values())
+      if (view.materialized) tables.set(view.oid, { schema, table: materializedTable(view) });
   }
   const backing = /* @__PURE__ */ new Map();
   for (const { table } of tables.values()) {
@@ -7635,6 +7529,55 @@ function deparseExpr(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/sql/ruleutils.ts
 var BOOL = "bool";
 var TEXT = "text";
@@ -8271,7 +8214,7 @@ function setDatabaseCatalogContext(state, context) {
 var PG_VERSION_TEXT = "PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine";
 function findSequenceForCall(ctx, name) {
   const parts = parseQualifiedName(name);
-  const seq = ctx.state.findSequence(parts);
+  const seq = /^\d+$/.test(name) ? [...ctx.state.schemas.values()].flatMap((schema) => [...schema.sequences.values()]).find((sequence) => sequence.oid === Number(name)) : ctx.state.findSequence(parts);
   if (!seq) {
     throw pgError("undefined_table", `relation "${name}" does not exist`, "42P01");
   }
@@ -8432,7 +8375,11 @@ function getMiscFunctions() {
     }
     const name = argText(ctx, args[0]).toLowerCase();
     const value = args[1].v === null ? "" : argText(ctx, args[1]);
-    ctx.state.settings.set(name, value);
+    if (!ctx.state.settings.has(name) && !name.includes("."))
+      throw pgError("undefined_object", `unrecognized configuration parameter "${name}"`, "42704");
+    validateStorageSetting(name, value);
+    const local = args[2]?.v === true;
+    if (!local || ctx.state.inTransaction) (local ? ctx.state.localSettings : ctx.state.settings).set(name, value);
     return tv("text", value);
   });
   m.set(
@@ -8491,17 +8438,16 @@ function getMiscFunctions() {
     "pg_get_serial_sequence",
     strict("text", (ctx, args) => {
       const tableName2 = argText(ctx, args[0]);
-      const column = argText(ctx, args[1]).toLowerCase();
+      const column = argText(ctx, args[1]);
       const table = ctx.state.findTable(parseQualifiedName(tableName2));
       if (!table) throw pgError("undefined_table", `relation "${tableName2}" does not exist`, "42P01");
       const col = table.columns.find((c) => c.name === column);
       if (!col)
         throw pgError("undefined_column", `column "${column}" of relation "${table.name}" does not exist`, "42703");
-      if (!col.identity) return tv("text", null);
-      return tv(
-        "text",
-        col.identity.sequence.split(".").map(quoteIdent).join(".")
+      const seq = [...ctx.state.schemas.get(table.schema)?.sequences.values() ?? []].find(
+        (candidate) => candidate.ownedBy?.table === table.name && candidate.ownedBy.column === column
       );
+      return tv("text", seq ? [seq.schema, seq.name].map(quoteIdent).join(".") : null);
     })
   );
   m.set("format_type", (ctx, args) => {
@@ -13425,6 +13371,146 @@ function isSrfName(name) {
   return SRFS.has(name);
 }
 
+// src/executor/relation.ts
+var RowScope = class {
+  constructor(columns, row, parent = null, rangeVars = /* @__PURE__ */ new Set()) {
+    this.columns = columns;
+    this.row = row;
+    this.parent = parent;
+    this.rangeVars = rangeVars;
+  }
+  columns;
+  row;
+  parent;
+  rangeVars;
+  /** Resolve a (possibly qualified) column reference. undefined = not found. */
+  lookup(parts) {
+    if (parts.length === 1) {
+      const name2 = parts[0];
+      let found2;
+      let count2 = 0;
+      for (let i = 0; i < this.columns.length; i++) {
+        const c = this.columns[i];
+        if (c.name === name2 && (!c.hidden || c.system)) {
+          count2++;
+          if (count2 > 1) {
+            throw pgError("ambiguous_column", `column reference "${name2}" is ambiguous`);
+          }
+          found2 = tv(c.type, this.row[i] ?? null);
+        }
+      }
+      if (found2 !== void 0) return found2;
+      if (this.rangeVars.has(name2)) {
+        return this.wholeRow(name2);
+      }
+      return this.parent?.lookup(parts);
+    }
+    const table = parts[parts.length - 2];
+    const name = parts[parts.length - 1];
+    let found;
+    let count = 0;
+    for (let i = 0; i < this.columns.length; i++) {
+      const c = this.columns[i];
+      if (c.table === table && c.name === name) {
+        count++;
+        if (count > 1) {
+          throw pgError("ambiguous_column", `column reference "${name}" is ambiguous`);
+        }
+        found = tv(c.type, this.row[i] ?? null);
+      }
+    }
+    if (found !== void 0) return found;
+    return this.parent?.lookup(parts);
+  }
+  /** Build a record value from all columns belonging to a range variable. */
+  wholeRow(rangeVar) {
+    const types = [];
+    const values = [];
+    const names = [];
+    for (let i = 0; i < this.columns.length; i++) {
+      const c = this.columns[i];
+      if (c.table === rangeVar && !c.system) {
+        types.push(c.type);
+        values.push(this.row[i] ?? null);
+        names.push(c.name);
+      }
+    }
+    if (types.length === 0) return void 0;
+    return tv("record", { kind: "pgrecord", types, values, names });
+  }
+  hasRangeVar(name) {
+    if (this.rangeVars.has(name)) return true;
+    return this.parent?.hasRangeVar(name) ?? false;
+  }
+};
+function childEnv(env, outer) {
+  return {
+    ctx: env.ctx,
+    params: env.params,
+    ctes: env.ctes,
+    outer,
+    allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+  };
+}
+function relationResult(rel3, command2) {
+  const visible = rel3.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
+  return {
+    columns: visible.map(({ c }) => ({ name: c.name, type: c.type })),
+    rows: rel3.rows.map((r) => visible.map(({ i }) => r[i] ?? null)),
+    command: command2,
+    rowCount: rel3.rows.length
+  };
+}
+function commandResult(command2, rowCount) {
+  return { columns: [], rows: [], command: command2, rowCount };
+}
+function inferColumnName(e) {
+  switch (e.type) {
+    case "colref":
+      return e.parts[e.parts.length - 1];
+    case "func":
+      return e.name[e.name.length - 1];
+    case "cast": {
+      const inner = inferColumnName(e.expr);
+      if (inner !== "?column?") return inner;
+      return e.target.parts[e.target.parts.length - 1];
+    }
+    case "collate":
+      return inferColumnName(e.expr);
+    case "case":
+      return "case";
+    case "array_ctor":
+    case "array_query":
+      return "array";
+    case "row":
+      return "row";
+    case "subquery_expr":
+      return e.kind === "exists" ? "exists" : "?column?";
+    case "bool_lit":
+      return "bool";
+    case "extract":
+      return "extract";
+    case "position":
+      return "position";
+    case "substring_sql":
+      return "substring";
+    case "overlay":
+      return "overlay";
+    case "trim":
+      return e.side === "leading" ? "ltrim" : e.side === "trailing" ? "rtrim" : "btrim";
+    case "field_select":
+      return e.field === "*" ? "?column?" : e.field;
+    case "at_time_zone":
+      return "timezone";
+    case "grouping_func":
+      return "grouping";
+    case "subscript":
+      return inferColumnName(e.base);
+    default:
+      return "?column?";
+  }
+}
+
 // src/indexes/index.ts
 var IndexStore = class _IndexStore {
   name;
@@ -13487,53 +13573,228 @@ function ensureIndexStores(env, table) {
       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));
+    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/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 || idx.valid === false) continue;
+      specs.push(uniqueSpecOfIndex(table, idx));
+    }
+  }
+  return specs;
+}
+function uniqueSpecOfIndex(table, idx) {
+  return {
+    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
+  };
+}
+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"
+      );
     }
   }
-  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);
+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 });
+        }
+      }
     }
-    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);
+  return out;
 }
 
 // src/planner/access.ts
@@ -13611,7 +13872,7 @@ function tryIndexedFromItem(env, item, where) {
   if (!table) return null;
   const alias = item.alias ?? item.name[item.name.length - 1];
   table.materializeSlab();
-  return tryIndexedTableRows(env, table, alias, where);
+  return tryIndexedTableRows(env, table, alias, where)?.map((row) => [...row, table.rowXmins.get(row) ?? 2]) ?? null;
 }
 function joinKeyFromRow(row, colIdxs, srcTypes, unifiedTypes, ctx) {
   const parts = [];
@@ -15419,10 +15680,9 @@ var Parser = class {
       return this.parseCreateFunction(orReplace);
     }
     if (this.atKw("trigger") || this.atKw("constraint") && this.atKw("trigger", 1)) {
-      if (this.eatKw("constraint")) {
-      }
+      const constraint = this.eatKw("constraint");
       this.expectKw("trigger");
-      return this.parseCreateTrigger(orReplace);
+      return this.parseCreateTrigger(orReplace, constraint);
     }
     if (this.atKw("extension")) {
       this.pos++;
@@ -16102,6 +16362,7 @@ var Parser = class {
     let sqlBody = null;
     let volatility = null;
     let strict2 = false;
+    const settings = {};
     for (; ; ) {
       if (this.eatKw("language")) {
         language = this.peek().type === "string" ? this.next().value : this.ident(true);
@@ -16159,8 +16420,23 @@ var Parser = class {
         continue;
       }
       if (this.eatKw("set")) {
-        this.ident(true);
-        if (this.eatOp("=") || this.eatKw("to")) this.next();
+        const key = this.ident(true).toLowerCase();
+        if (this.eatKw("from")) {
+          this.expectKw("current");
+          settings[key] = "__from_current__";
+        } else {
+          if (!this.eatOp("=")) this.expectKw("to");
+          const values = [];
+          do {
+            const value = this.next();
+            if (!["string", "ident", "quoted_ident", "number"].includes(value.type))
+              this.errorAt(value, "expected setting value");
+            values.push(
+              key === "search_path" && /[^a-z0-9_]/.test(value.value) ? `"${value.value.replaceAll('"', '""')}"` : value.value
+            );
+          } while (this.eatPunct(","));
+          settings[key] = values.join(", ");
+        }
         continue;
       }
       if (this.eatKw("window")) throw unsupported("window functions via CREATE FUNCTION");
@@ -16240,10 +16516,11 @@ var Parser = class {
       body,
       sqlBody,
       volatility,
-      strict: strict2
+      strict: strict2,
+      settings
     };
   }
-  parseCreateTrigger(orReplace) {
+  parseCreateTrigger(orReplace, constraint) {
     const name = this.ident();
     let timing;
     if (this.eatKw("before")) timing = "before";
@@ -16273,9 +16550,18 @@ var Parser = class {
     this.expectKw("on");
     const table = this.qualifiedName();
     if (this.eatKw("referencing")) throw unsupported("trigger transition tables");
-    while (this.atKw("not") || this.atKw("deferrable") || this.atKw("initially")) {
-      this.pos++;
-    }
+    let deferrable = false;
+    let initiallyDeferred = false;
+    if (this.eatKw("not")) this.expectKw("deferrable");
+    else if (this.eatKw("deferrable")) deferrable = true;
+    if (this.eatKw("initially")) {
+      if (this.eatKw("deferred")) initiallyDeferred = true;
+      else this.expectKw("immediate");
+    }
+    if ((deferrable || initiallyDeferred) && !constraint)
+      this.errorAt(this.peek(), "only constraint triggers can be deferred");
+    if (initiallyDeferred && !deferrable)
+      this.errorAt(this.peek(), "constraint declared INITIALLY DEFERRED must be DEFERRABLE");
     let forEachRow = false;
     if (this.eatKw("for")) {
       this.eatKw("each");
@@ -16300,7 +16586,21 @@ var Parser = class {
       } while (this.eatPunct(","));
     }
     this.expectPunct(")");
-    return { type: "create_trigger", orReplace, name, timing, events, table, forEachRow, when, funcName, funcArgs };
+    return {
+      type: "create_trigger",
+      constraint,
+      deferrable,
+      initiallyDeferred,
+      orReplace,
+      name,
+      timing,
+      events,
+      table,
+      forEachRow,
+      when,
+      funcName,
+      funcArgs
+    };
   }
   // --- ALTER --------------------------------------------------------------------
   parseAlter() {
@@ -16326,8 +16626,8 @@ var Parser = class {
           type: "alter_sequence",
           name,
           ifExists,
-          options: { ownedBy: void 0 },
-          ...{ renameTo: to }
+          options: {},
+          renameTo: to
         };
       }
       if (this.atKw("set") && (this.atKw("logged", 1) || this.atKw("unlogged", 1))) {
@@ -16645,9 +16945,15 @@ var Parser = class {
       this.skipToStatementEnd();
       return { type: "no_op", what: "SET TRANSACTION" };
     }
-    if (this.atKw("constraints")) {
-      this.skipToStatementEnd();
-      return { type: "no_op", what: "SET CONSTRAINTS" };
+    if (this.eatKw("constraints")) {
+      const names = this.eatKw("all") ? null : [];
+      if (names)
+        do {
+          names.push(this.qualifiedName());
+        } while (this.eatPunct(","));
+      const deferred = this.eatKw("deferred");
+      if (!deferred) this.expectKw("immediate");
+      return { type: "set_constraints", names, deferred };
     }
     if (this.atKw("role") || this.atKw("session", 0) && this.atKw("authorization", 1)) {
       this.skipToStatementEnd();
@@ -18897,7 +19203,20 @@ function runFunctionBody(env, fn, args) {
   }
   return last;
 }
+function withFunctionSettings(env, fn, run) {
+  const state = env.ctx.state;
+  const saved = new Map(state.localSettings);
+  for (const [name, value] of Object.entries(fn.settings ?? {})) state.localSettings.set(name, value);
+  try {
+    return run();
+  } finally {
+    state.localSettings = saved;
+  }
+}
 function callSqlFunctionScalar(env, fn, args) {
+  return withFunctionSettings(env, fn, () => callSqlFunctionScalarBody(env, fn, args));
+}
+function callSqlFunctionScalarBody(env, fn, args) {
   const retT = fn.returns ?? "text";
   if (fn.language === "plpgsql") {
     return callPlpgsqlScalar(env, fn, args);
@@ -18927,6 +19246,9 @@ function callSqlFunctionScalar(env, fn, args) {
   return castTo(env.ctx, tv(rawT, raw), retT, {});
 }
 function callSqlFunctionSet(env, fn, args) {
+  return withFunctionSettings(env, fn, () => callSqlFunctionSetBody(env, fn, args));
+}
+function callSqlFunctionSetBody(env, fn, args) {
   if (fn.language === "plpgsql") {
     return callPlpgsqlSet(env, fn, args);
   }
@@ -19022,12 +19344,12 @@ function executeRecursiveCte(env, cte, query) {
     table: null
   }));
   const seen = /* @__PURE__ */ new Set();
-  const keyOf = (row) => row.map((v, i) => v === null ? "\0N" : datumKey(columns[i].type, v)).join("
");
+  const keyOf2 = (row) => row.map((v, i) => v === null ? "\0N" : datumKey(columns[i].type, v)).join("
");
   let result = [];
   let working = [];
   for (const row of base.rows) {
     if (!body.all) {
-      const k = keyOf(row);
+      const k = keyOf2(row);
       if (seen.has(k)) continue;
       seen.add(k);
     }
@@ -19060,7 +19382,7 @@ function executeRecursiveCte(env, cte, query) {
         return castTo(env.ctx, tv(srcT === UNKNOWN ? "text" : srcT, v), columns[i].type, {}).v;
       });
       if (!body.all) {
-        const k = keyOf(row);
+        const k = keyOf2(row);
         if (seen.has(k)) continue;
         seen.add(k);
       }
@@ -19081,15 +19403,17 @@ function executeRecursiveCte(env, cte, query) {
   return rel3;
 }
 function renameWithAliases(rel3, label, colAliases, what) {
-  if (colAliases && colAliases.length > rel3.columns.length) {
+  const visibleWidth = rel3.columns.filter((column) => !column.system).length;
+  if (colAliases && colAliases.length > visibleWidth) {
     throw pgError(
       "invalid_column_reference",
-      `table "${what}" has ${rel3.columns.length} columns available but ${colAliases.length} columns specified`,
+      `table "${what}" has ${visibleWidth} columns available but ${colAliases.length} columns specified`,
       "42P10"
     );
   }
   const columns = rel3.columns.map((c, i) => ({
-    name: colAliases?.[i] ?? c.name,
+    ...c,
+    name: c.system ? c.name : colAliases?.[i] ?? c.name,
     type: c.type === UNKNOWN ? "text" : c.type,
     table: label
   }));
@@ -19110,8 +19434,11 @@ function materializeItem(env, item, scope) {
       if (table) {
         table.materializeSlab();
         const rel3 = {
-          columns: table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
-          rows: table.rows
+          columns: [
+            ...table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
+            { name: "xmin", type: "xid", table: label, hidden: true, system: true }
+          ],
+          rows: table.rows.map((row) => [...row, table.rowXmins.get(row) ?? 2])
         };
         return { rel: renameWithAliases(rel3, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
@@ -19741,7 +20068,7 @@ function resolveColIdx(columns, parts) {
     let found = -1;
     for (let i = 0; i < columns.length; i++) {
       const c = columns[i];
-      if (!c.hidden && c.name === name2) {
+      if ((!c.hidden || c.system) && c.name === name2) {
         if (found !== -1) return null;
         found = i;
       }
@@ -20240,7 +20567,7 @@ function setOpRelation(env, op) {
   );
   const lrows = normalize2(left);
   const rrows = normalize2(right);
-  const keyOf = (row) => row.map((v, i) => v === null ? "\0N" : datumKey(types[i], v)).join("
");
+  const keyOf2 = (row) => row.map((v, i) => v === null ? "\0N" : datumKey(types[i], v)).join("
");
   let rows;
   switch (op.op) {
     case "union": {
@@ -20248,7 +20575,7 @@ function setOpRelation(env, op) {
       if (!op.all) {
         const seen = /* @__PURE__ */ new Set();
         rows = rows.filter((r) => {
-          const k = keyOf(r);
+          const k = keyOf2(r);
           if (seen.has(k)) return false;
           seen.add(k);
           return true;
@@ -20259,13 +20586,13 @@ function setOpRelation(env, op) {
     case "intersect": {
       const rightCounts = /* @__PURE__ */ new Map();
       for (const r of rrows) {
-        const k = keyOf(r);
+        const k = keyOf2(r);
         rightCounts.set(k, (rightCounts.get(k) ?? 0) + 1);
       }
       rows = [];
       const emitted = /* @__PURE__ */ new Set();
       for (const r of lrows) {
-        const k = keyOf(r);
+        const k = keyOf2(r);
         const avail = rightCounts.get(k) ?? 0;
         if (avail <= 0) continue;
         if (op.all) {
@@ -20281,13 +20608,13 @@ function setOpRelation(env, op) {
     case "except": {
       const rightCounts = /* @__PURE__ */ new Map();
       for (const r of rrows) {
-        const k = keyOf(r);
+        const k = keyOf2(r);
         rightCounts.set(k, (rightCounts.get(k) ?? 0) + 1);
       }
       rows = [];
       const emitted = /* @__PURE__ */ new Set();
       for (const r of lrows) {
-        const k = keyOf(r);
+        const k = keyOf2(r);
         if (op.all) {
           const avail = rightCounts.get(k) ?? 0;
           if (avail > 0) {
@@ -20325,7 +20652,7 @@ function expandTargets(core, columns) {
         let any = false;
         for (let i = 0; i < columns.length; i++) {
           const c = columns[i];
-          if (c.table === label) {
+          if (c.table === label && !c.system) {
             any = true;
             items.push({ name: c.name, kind: "col", colIdx: i, expr: null, hidden: false });
           }
@@ -20763,179 +21090,26 @@ function executeSelectStmt(env0, stmt) {
   return applyLimitOffset(env, rel3, stmt.limit, stmt.offset);
 }
 
-// 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 || idx.valid === false) continue;
-      specs.push(uniqueSpecOfIndex(table, idx));
-    }
-  }
-  return specs;
-}
-function uniqueSpecOfIndex(table, idx) {
-  return {
-    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
-  };
-}
-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"
-      );
+// src/executor/triggers-scope.ts
+function triggerScope(table, newRow, oldRow) {
+  const cols = [];
+  const row = [];
+  const rangeVars = /* @__PURE__ */ new Set();
+  if (newRow) {
+    rangeVars.add("new");
+    for (let i = 0; i < table.columns.length; i++) {
+      cols.push({ name: table.columns[i].name, type: table.columns[i].type.id, table: "new" });
+      row.push(newRow[i] ?? null);
     }
   }
-}
-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 });
-        }
-      }
+  if (oldRow) {
+    rangeVars.add("old");
+    for (let i = 0; i < table.columns.length; i++) {
+      cols.push({ name: table.columns[i].name, type: table.columns[i].type.id, table: "old" });
+      row.push(oldRow[i] ?? null);
     }
   }
-  return out;
+  return new RowScope(cols, row, null, rangeVars);
 }
 
 // src/executor/triggers.ts
@@ -20951,6 +21125,18 @@ function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
   for (const t of table.triggers) {
     if (t.timing !== timing || !matches(t, event) || !t.forEachRow) continue;
     if (!executor) throw unsupported(`trigger "${t.name}" execution`);
+    if (t.constraint && timing === "after") {
+      if (t.when && !evalPredicate(env, triggerScope(table, newRow, oldRow), t.when)) continue;
+      env.ctx.state.pendingTriggers.push({
+        schema: table.schema,
+        table: table.name,
+        trigger: t.name,
+        event,
+        oldRow: oldRow?.slice() ?? null,
+        newRow: newRow?.slice() ?? null
+      });
+      continue;
+    }
     const result = executor(env, table, t, event, oldRow, timing === "before" ? row : newRow);
     if (timing === "before") {
       if (result === null) return { row: null };
@@ -20959,6 +21145,170 @@ function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
   }
   return { row };
 }
+var keyOf = (schema, name) => JSON.stringify([schema, name]);
+function flushConstraintTriggers(state, all = false) {
+  const env = { ctx: new EngineCtx(state), params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
+  for (let i = 0; i < state.pendingTriggers.length; ) {
+    const pending = state.pendingTriggers[i];
+    const table = state.schemas.get(pending.schema)?.tables.get(pending.table);
+    const trigger = table?.triggers.find((t) => t.name === pending.trigger);
+    if (!table || !trigger) {
+      state.pendingTriggers.splice(i, 1);
+      continue;
+    }
+    const deferred = trigger.deferrable && (state.constraintModes.get(keyOf(table.schema, trigger.name)) ?? trigger.initiallyDeferred);
+    if (!all && state.inTransaction && deferred) {
+      i++;
+      continue;
+    }
+    if (!executor) throw unsupported(`trigger "${trigger.name}" execution`);
+    state.pendingTriggers.splice(i, 1);
+    const changes = state.changes;
+    try {
+      executor(env, table, { ...trigger, when: null }, pending.event, pending.oldRow, pending.newRow);
+    } catch (error) {
+      state.pendingTriggers.splice(i, 0, pending);
+      throw error;
+    } finally {
+      state.changes = changes;
+    }
+  }
+}
+function setConstraints(state, stmt) {
+  if (!state.inTransaction) return;
+  const matches2 = [];
+  if (stmt.names) {
+    for (const name of stmt.names) {
+      const schemas = name.length > 1 ? [name[name.length - 2]] : state.effectiveSearchPath();
+      let found = false;
+      for (const schema of schemas) {
+        const items = [...state.schemas.get(schema)?.tables.values() ?? []].flatMap(
+          (table) => table.triggers.filter((t) => t.constraint && t.name === name[name.length - 1])
+        );
+        if (items.length) {
+          for (const trigger of items) matches2.push({ schema, trigger });
+          found = true;
+          break;
+        }
+      }
+      if (!found) throw pgError("undefined_object", `constraint "${name.join(".")}" does not exist`, "42704");
+    }
+  } else {
+    for (const schema of state.schemas.values())
+      for (const table of schema.tables.values())
+        for (const trigger of table.triggers)
+          if (trigger.constraint && trigger.deferrable) matches2.push({ schema: schema.name, trigger });
+  }
+  for (const { trigger } of matches2)
+    if (stmt.deferred && !trigger.deferrable)
+      throw pgError("misuse", `constraint "${trigger.name}" is not deferrable`, "55000");
+  const previous = new Map(state.constraintModes);
+  for (const { schema, trigger } of matches2) state.constraintModes.set(keyOf(schema, trigger.name), stmt.deferred);
+  try {
+    if (!stmt.deferred) flushConstraintTriggers(state);
+  } catch (error) {
+    state.constraintModes = previous;
+    throw error;
+  }
+}
+
+// src/transactions/manager.ts
+var TransactionManager = class {
+  constructor(state) {
+    this.state = state;
+  }
+  state;
+  base = null;
+  savepoints = [];
+  freezeDepth = 0;
+  get inTransaction() {
+    return this.base !== null;
+  }
+  takeSnapshot() {
+    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() {
+    try {
+      flushConstraintTriggers(this.state, true);
+    } catch (error) {
+      this.rollback();
+      throw error;
+    }
+    this.base = null;
+    this.savepoints = [];
+    this.state.inTransaction = false;
+    this.state.transactionXid = null;
+    this.state.localSettings.clear();
+    this.state.pendingTriggers = [];
+    this.state.constraintModes.clear();
+    while (this.freezeDepth > 0) this.thawOnce();
+  }
+  rollback() {
+    if (this.base !== null) {
+      this.restore(this.base);
+    }
+    this.base = null;
+    this.savepoints = [];
+    this.state.inTransaction = false;
+    this.state.transactionXid = null;
+    this.state.localSettings.clear();
+    this.state.pendingTriggers = [];
+    this.state.constraintModes.clear();
+    while (this.freezeDepth > 0) this.thawOnce();
+  }
+  savepoint(name) {
+    if (this.base === null) {
+      throw pgError("transaction_state", "SAVEPOINT can only be used in transaction blocks", "25P01");
+    }
+    this.savepoints.push({ name, snap: this.takeSnapshot() });
+  }
+  releaseSavepoint(name) {
+    const idx = this.findSavepoint(name);
+    this.savepoints.splice(idx);
+  }
+  rollbackToSavepoint(name) {
+    const idx = this.findSavepoint(name);
+    const sp = this.savepoints[idx];
+    this.restore(sp.snap);
+    this.savepoints.splice(idx + 1);
+  }
+  findSavepoint(name) {
+    if (this.base === null) {
+      throw pgError("transaction_state", `SAVEPOINT can only be used in transaction blocks`, "25P01");
+    }
+    for (let i = this.savepoints.length - 1; i >= 0; i--) {
+      if (this.savepoints[i].name === name) return i;
+    }
+    throw pgError("invalid_savepoint_specification", `savepoint "${name}" does not exist`, "3B001");
+  }
+  reset() {
+    this.base = null;
+    this.savepoints = [];
+    this.state.inTransaction = false;
+    this.state.transactionXid = null;
+    this.freezeDepth = 0;
+  }
+};
 
 // src/executor/dml.ts
 function withStatementRollback(env, fn) {
@@ -21159,6 +21509,7 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
   const updated = existing.slice();
   applyUpdateSets(env, table, sets, scope, updated);
   computeGeneratedColumns(env, table, updated);
+  table.rowXmins.set(updated, env.ctx.rowVersionXid());
   rows[existingIdx] = updated;
   indexUpdateRow(env, table, existingIdx, existing, updated);
   checkNotNull(env, table, updated);
@@ -21244,6 +21595,7 @@ function executeInsert(env0, stmt) {
       checkChecks(env, table, newRow);
       checkUnique(env, table, newRow, rows.length);
       checkForeignKeys(env, table, newRow);
+      table.rowXmins.set(newRow, env.ctx.rowVersionXid());
       rows.push(newRow);
       indexInsertRow(env, table, rows.length - 1, newRow);
       insertedCount++;
@@ -21361,6 +21713,7 @@ function executeUpdate(env0, stmt) {
     if (fired.row === null) continue;
     const finalRow = fired.row;
     computeGeneratedColumns(env, table, finalRow);
+    table.rowXmins.set(finalRow, env.ctx.rowVersionXid());
     rows[ri] = finalRow;
     try {
       checkNotNull(env, table, finalRow);
@@ -21480,6 +21833,7 @@ function handleReferencedDelete(env, table, row, depth) {
           for (const c of con.columns) {
             newRow[child.columnIndex(c)] = null;
           }
+          child.rowXmins.set(newRow, env.ctx.rowVersionXid());
           childRows[i] = newRow;
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
@@ -21493,6 +21847,7 @@ function handleReferencedDelete(env, table, row, depth) {
             const ci = child.columnIndex(c);
             newRow[ci] = columnDefault(env, child, child.columns[ci]);
           }
+          child.rowXmins.set(newRow, env.ctx.rowVersionXid());
           childRows[i] = newRow;
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
@@ -21530,6 +21885,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               const refIdx = table.columnIndex(con.refColumns[c]);
               newRow[localIdx] = newRows[r][refIdx] ?? null;
             }
+            child.rowXmins.set(newRow, env.ctx.rowVersionXid());
             childRows[i] = newRow;
             checkChecks(env, child, newRow);
           }
@@ -21539,6 +21895,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
           for (const i of idxs) {
             const newRow = childRows[i].slice();
             for (const c of con.columns) newRow[child.columnIndex(c)] = null;
+            child.rowXmins.set(newRow, env.ctx.rowVersionXid());
             childRows[i] = newRow;
             checkNotNull(env, child, newRow);
           }
@@ -21551,6 +21908,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               const ci = child.columnIndex(c);
               newRow[ci] = columnDefault(env, child, child.columns[ci]);
             }
+            child.rowXmins.set(newRow, env.ctx.rowVersionXid());
             childRows[i] = newRow;
             checkForeignKeys(env, child, newRow);
           }
@@ -21648,6 +22006,7 @@ function executeSet(env, stmt) {
     else target.delete(name);
     return commandResult("SET", 0);
   }
+  validateStorageSetting(name, stmt.value);
   target.set(name, stmt.value);
   return commandResult("SET", 0);
 }
@@ -21953,64 +22312,6 @@ function executeCopyFromData(env, stmt, data) {
   };
 }
 
-// src/expressions/context.ts
-var EngineCtx = class {
-  state;
-  /** transaction timestamp (now(), current_timestamp) — UTC micros since PG epoch */
-  txNow;
-  /** statement timestamp */
-  stmtNow;
-  constructor(state, txNow) {
-    this.state = state;
-    const nowMs = state.clock().getTime();
-    const nowMicros = BigInt(Math.round(nowMs)) * 1000n + UNIX_EPOCH_MICROS_FROM_PG;
-    this.txNow = txNow ?? nowMicros;
-    this.stmtNow = nowMicros;
-  }
-  timezone() {
-    return this.state.getSetting("timezone") ?? "UTC";
-  }
-  namespaceOid(name) {
-    const oid = builtinNamespaceOid(name) ?? this.state.schemas.get(name)?.oid;
-    if (oid === void 0) throw pgError("undefined_object", `schema "${name}" does not exist`, "3F000");
-    return oid;
-  }
-  namespaceName(oid) {
-    const builtin = builtinNamespaceName(oid);
-    if (builtin !== void 0) return builtin;
-    for (const schema of this.state.schemas.values()) {
-      if (schema.oid === oid) return schema.name;
-    }
-    return null;
-  }
-  zoneOffsetAt(utcMicros) {
-    return zoneOffsetAtUtc(this.timezone(), utcMicros);
-  }
-  zoneOffsetForNaive(naiveMicros) {
-    return zoneOffsetForNaive(this.timezone(), naiveMicros);
-  }
-  enumLabels(enumType) {
-    if (!isEnumType(enumType)) return null;
-    const e = this.state.findEnumByKey(enumType.slice(5));
-    return e?.labels ?? null;
-  }
-  enumHasLabel(enumType, label) {
-    const labels = this.enumLabels(enumType);
-    return labels === null ? true : labels.includes(label);
-  }
-  enumOrder(enumType, label) {
-    const labels = this.enumLabels(enumType);
-    if (!labels) return 0;
-    const idx = labels.indexOf(label);
-    return idx === -1 ? labels.length : idx;
-  }
-  requireEnum(enumType) {
-    const labels = this.enumLabels(enumType);
-    if (!labels) throw pgError("undefined_object", `type "${enumType.slice(5)}" does not exist`);
-    return labels;
-  }
-};
-
 // src/runtime/clock.ts
 var DEFAULT_NOW = /* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z");
 function fixedClock(instant = DEFAULT_NOW) {
@@ -22978,7 +23279,7 @@ function pgClass(ctx) {
         v.materialized ? "m" : "v",
         v.columns?.length ?? 0,
         v.matRows?.length ?? 0,
-        false,
+        v.materialized && [...schemaData.indexes.values()].some((i) => i.tableOid === v.oid),
         !v.materialized || v.matRows !== null,
         relPersistence(v)
       );
@@ -23244,7 +23545,7 @@ function pgIndex(ctx) {
       const valid = i.valid !== false;
       rows.push([
         i.oid ?? 0,
-        table?.oid ?? 0,
+        table?.oid ?? i.tableOid ?? 0,
         indexAttributeCount(i),
         i.columns.length,
         i.unique,
@@ -23416,7 +23717,7 @@ function pgStatUserIndexes(ctx) {
     for (const index of schema.indexes.values()) {
       const table = schema.tables.get(index.table);
       rows.push([
-        table?.oid ?? 0,
+        table?.oid ?? index.tableOid ?? 0,
         index.oid ?? 0,
         schema.name,
         index.table,
@@ -24011,26 +24312,6 @@ function runTriggerBody(env, table, stmts, vars) {
     }
   }
 }
-function triggerScope(table, newRow, oldRow) {
-  const cols = [];
-  const row = [];
-  const rangeVars = /* @__PURE__ */ new Set();
-  if (newRow) {
-    rangeVars.add("new");
-    for (let i = 0; i < table.columns.length; i++) {
-      cols.push({ name: table.columns[i].name, type: table.columns[i].type.id, table: "new" });
-      row.push(newRow[i] ?? null);
-    }
-  }
-  if (oldRow) {
-    rangeVars.add("old");
-    for (let i = 0; i < table.columns.length; i++) {
-      cols.push({ name: table.columns[i].name, type: table.columns[i].type.id, table: "old" });
-      row.push(oldRow[i] ?? null);
-    }
-  }
-  return new RowScope(cols, row, null, rangeVars);
-}
 function executeTrigger(env, table, trigger, _event, oldRow, newRow) {
   const state = env.ctx.state;
   if (trigger.when !== null && !evalPredicate(env, triggerScope(table, newRow, oldRow), trigger.when)) {
@@ -24675,13 +24956,63 @@ function executeCreateSequence(env, stmt) {
   schema.sequences.set(name, seq);
   return commandResult("CREATE SEQUENCE", 0);
 }
+function renameSequenceReferences(env, seq, newName) {
+  const state = env.ctx.state;
+  const matches2 = (value) => {
+    try {
+      const input = parseRelationInput(value);
+      if ("oid" in input) return input.oid === seq.oid;
+      return state.findSequence(input.parts)?.oid === seq.oid;
+    } catch {
+      return false;
+    }
+  };
+  const rewrite = (value) => {
+    if (Array.isArray(value)) return value.map(rewrite);
+    if (value === null || typeof value !== "object") return value;
+    const node = value;
+    const updated = Object.fromEntries(Object.entries(node).map(([key, child]) => [key, rewrite(child)]));
+    const rewriteLiteral = (literal2) => {
+      if (literal2 && typeof literal2 === "object" && "type" in literal2 && literal2.type === "string_lit" && "value" in literal2 && typeof literal2.value === "string" && matches2(literal2.value)) {
+        return { ...literal2, value: [seq.schema, newName].map(quoteIdent).join(".") };
+      }
+      return literal2;
+    };
+    if (node.type === "func" && Array.isArray(node.name) && ["nextval", "currval", "setval"].includes(String(node.name.at(-1))) && Array.isArray(updated.args))
+      updated.args[0] = rewriteLiteral(updated.args[0]);
+    if (node.type === "cast" && node.target && typeof node.target === "object" && "parts" in node.target && Array.isArray(node.target.parts) && node.target.parts.at(-1) === "regclass")
+      updated.expr = rewriteLiteral(updated.expr);
+    return updated;
+  };
+  for (const schema of state.schemas.values()) {
+    for (const table of [...schema.tables.values()]) {
+      const writable = state.ensureWritableTable(table);
+      for (const column of writable.columns) {
+        if (column.defaultExpr) column.defaultExpr = rewrite(column.defaultExpr);
+        if (column.identity?.sequence === `${seq.schema}.${seq.name}`)
+          column.identity = { ...column.identity, sequence: `${seq.schema}.${newName}` };
+      }
+    }
+  }
+}
 function executeAlterSequence(env, stmt) {
   const state = env.ctx.state;
-  const seq = state.findSequence(stmt.name);
-  if (!seq) {
+  const foundSequence = state.findSequence(stmt.name);
+  if (!foundSequence) {
     if (stmt.ifExists) return commandResult("ALTER SEQUENCE", 0);
     throw pgError("undefined_table", `relation "${stmt.name.join(".")}" does not exist`, "42P01");
   }
+  const seq = state.ensureWritableSequence(foundSequence);
+  if (stmt.renameTo) {
+    const schema = state.getSchema(seq.schema);
+    if (schema.hasRelation(stmt.renameTo))
+      throw pgError("duplicate_table", `relation "${stmt.renameTo}" already exists`, "42P07");
+    renameSequenceReferences(env, seq, stmt.renameTo);
+    schema.sequences.delete(seq.name);
+    seq.name = stmt.renameTo;
+    schema.sequences.set(seq.name, seq);
+    return commandResult("ALTER SEQUENCE", 0);
+  }
   const o = stmt.options;
   if (o.logged !== void 0) {
     setSequenceLogged(state, seq, o.logged);
@@ -24739,7 +25070,7 @@ function buildColumn(env, schema, tableName2, def, out, taken) {
     col.defaultExpr = {
       type: "func",
       name: ["nextval"],
-      args: [{ type: "string_lit", value: `${schema.name}.${seqName}` }]
+      args: [{ type: "string_lit", value: [schema.name, seqName].map(quoteIdent).join(".") }]
     };
   }
   for (const c of def.constraints) {
@@ -24992,7 +25323,11 @@ function executeCreateTableAs(env, stmt) {
   const table = new TableData(schema.name, name, columns, state.nextOid(), stmt.temp);
   table.unlogged = stmt.unlogged === true;
   if (stmt.withData) {
-    for (const row of rel3.rows) table.mutableRows().push(row.slice());
+    for (const row of rel3.rows) {
+      const stored = row.slice();
+      table.rowXmins.set(stored, env.ctx.rowVersionXid());
+      table.mutableRows().push(stored);
+    }
   }
   schema.tables.set(name, table);
   const count = stmt.withData ? table.rowCount() : 0;
@@ -25000,7 +25335,8 @@ function executeCreateTableAs(env, stmt) {
 }
 function executeCreateIndex(env, stmt) {
   const state = env.ctx.state;
-  const table = state.findTable(stmt.table);
+  const view = state.findView(stmt.table);
+  const table = state.findTable(stmt.table) ?? (view?.materialized ? materializedTable(view) : void 0);
   if (!table) {
     throw pgError("undefined_table", `relation "${stmt.table.join(".")}" does not exist`, "42P01");
   }
@@ -25112,13 +25448,22 @@ function executeRefreshMatView(env, stmt) {
   if (!found?.materialized) {
     throw pgError("undefined_table", `materialized view "${stmt.name.join(".")}" does not exist`, "42P01");
   }
+  const rel3 = executeSelectStmt(matviewQueryEnv(env, !stmt.withData), found.query);
+  const next = {
+    ...found,
+    matColumns: rel3.columns.map((c, i) => ({
+      name: found.columns?.[i] ?? c.name,
+      type: c.type === UNKNOWN ? "text" : c.type
+    })),
+    matRows: stmt.withData ? rel3.rows : null
+  };
+  const table = materializedTable(next);
+  for (const index of env.ctx.state.getSchema(found.schema).indexes.values()) {
+    if (index.tableOid === found.oid && index.valid !== false) assertUniqueIndexBuildable(env, table, index);
+  }
   const view = env.ctx.state.ensureWritableView(found);
-  const rel3 = executeSelectStmt(matviewQueryEnv(env, !stmt.withData), view.query);
-  view.matColumns = rel3.columns.map((c, i) => ({
-    name: view.columns?.[i] ?? c.name,
-    type: c.type === UNKNOWN ? "text" : c.type
-  }));
-  view.matRows = stmt.withData ? rel3.rows : null;
+  view.matColumns = next.matColumns;
+  view.matRows = next.matRows;
   return commandResult("REFRESH MATERIALIZED VIEW", 0);
 }
 function executeCreateSchema(env, stmt) {
@@ -25251,6 +25596,12 @@ function executeCreateFunction(env, stmt) {
     language: lang,
     body,
     rawBody: stmt.body,
+    settings: Object.fromEntries(
+      Object.entries(stmt.settings ?? {}).map(([key, value]) => [
+        key,
+        value === "__from_current__" ? state.getSetting(key) ?? "" : value
+      ])
+    ),
     strict: stmt.strict,
     oid: state.nextOid()
   };
@@ -25260,6 +25611,8 @@ function executeCreateFunction(env, stmt) {
   return commandResult("CREATE FUNCTION", 0);
 }
 function executeCreateTrigger(env, stmt) {
+  if (stmt.constraint && (stmt.timing !== "after" || !stmt.forEachRow))
+    throw pgError("syntax", "constraint triggers must be AFTER ROW triggers", "42601");
   const state = env.ctx.state;
   const found = state.findTable(stmt.table);
   if (!found) {
@@ -25278,6 +25631,9 @@ function executeCreateTrigger(env, stmt) {
   }
   const meta = {
     name: stmt.name,
+    constraint: stmt.constraint,
+    deferrable: stmt.deferrable,
+    initiallyDeferred: stmt.initiallyDeferred,
     timing: stmt.timing,
     events: stmt.events,
     forEachRow: stmt.forEachRow,
@@ -25430,6 +25786,7 @@ function executeAlterTable(env, stmt) {
           }
           const next = row.slice();
           next[idx] = nv;
+          table.rowXmins.set(next, table.rowXmins.get(rows[i]) ?? 2);
           rows[i] = next;
         }
         col.type = resolved.column;
@@ -25531,6 +25888,11 @@ function executeAlterTable(env, stmt) {
           );
         }
         table.columns[idx].name = action.to;
+        for (const seq of [...schema.sequences.values()]) {
+          if (seq.ownedBy?.table === table.name && seq.ownedBy.column === action.from) {
+            state.ensureWritableSequence(seq).ownedBy = { table: table.name, column: action.to };
+          }
+        }
         for (const con of table.constraints) {
           if (con.kind === "primary_key" || con.kind === "unique" || con.kind === "foreign_key") {
             con.columns = con.columns.map((c) => c === action.from ? action.to : c);
@@ -25567,6 +25929,11 @@ function executeAlterTable(env, stmt) {
           throw pgError("duplicate_table", `relation "${action.to}" already exists`, "42P07");
         }
         const oldName = table.name;
+        for (const seq of [...schema.sequences.values()]) {
+          if (seq.ownedBy?.table === oldName) {
+            state.ensureWritableSequence(seq).ownedBy = { ...seq.ownedBy, table: action.to };
+          }
+        }
         schema.tables.delete(table.name);
         table.name = action.to;
         schema.tables.set(action.to, table);
@@ -26046,7 +26413,16 @@ function alterTableIsSelfContained(stmt) {
   return stmt.actions.length === 1 && action !== void 0 && SELF_CONTAINED_ALTER_ACTIONS.has(action.kind);
 }
 function executeStatement(env, stmt) {
-  if (!RESHAPES_TABLES.has(stmt.type)) return dispatchStatement(env, stmt);
+  if (!RESHAPES_TABLES.has(stmt.type)) {
+    if ((stmt.type === "insert" || stmt.type === "update" || stmt.type === "delete") && (env.ctx.state.pendingTriggers.length > 0 || env.ctx.state.findTable(stmt.table)?.triggers.some((t) => t.constraint))) {
+      return withStatementRollback(env, () => {
+        const result = dispatchStatement(env, stmt);
+        flushConstraintTriggers(env.ctx.state);
+        return result;
+      });
+    }
+    return dispatchStatement(env, stmt);
+  }
   try {
     return dispatchStatement(env, stmt);
   } finally {
@@ -26105,6 +26481,9 @@ function dispatchStatement(env, stmt) {
       return executeRefreshMatView(env, stmt);
     case "transaction":
       return executeTransaction(env, stmt);
+    case "set_constraints":
+      setConstraints(env.ctx.state, stmt);
+      return commandResult("SET CONSTRAINTS", 0);
     case "set":
       return executeSet(env, stmt);
     case "show":
@@ -27428,6 +27807,7 @@ function encodeDatabaseState(state, runtime) {
       writeBjv(
         w,
         {
+          xmins: table.allRows().map((row) => table.rowXmins.get(row) ?? 2),
           name: table.name,
           schema: table.schema,
           columns: table.columns,
@@ -27525,8 +27905,14 @@ function decodeInner(snapshot, prng, clock) {
       table.constraints = meta.constraints;
       table.triggers = meta.triggers;
       table.unlogged = meta.unlogged === true;
+      table.slabXmins = meta.xmins ?? null;
+      state.xidCounter = Math.max(
+        state.xidCounter,
+        (meta.xmins ?? []).reduce((max, xid) => Math.max(max, xid + 1), 3)
+      );
       if (meta.stats) state.tableStats.set(table.oid, meta.stats);
       const rowCount = readVarintU32(r);
+      if (meta.xmins && meta.xmins.length !== rowCount) throw snapshotError();
       const slabColumns = [];
       for (let c = 0; c < meta.columns.length; c++)
         slabColumns.push(readPackedColumn(r, rowCount, intern, meta.columns[c].type.id));
@@ -27970,6 +28356,8 @@ function validateTableMetaBjv(value) {
   if (!isRecord(value) || typeof value.name !== "string" || typeof value.schema !== "string") throw snapshotError();
   if (!Array.isArray(value.columns)) throw snapshotError();
   for (const col of value.columns) validateColumnMeta(col);
+  if (value.xmins !== void 0 && (!Array.isArray(value.xmins) || value.xmins.some((xid) => !Number.isInteger(xid) || xid < 2 || xid > 4294967295)))
+    throw snapshotError();
 }
 function validateViewMetaBjv(value) {
   if (!isRecord(value) || typeof value.name !== "string" || typeof value.schema !== "string") throw snapshotError();
@@ -28063,6 +28451,7 @@ function forceSchemaIntern(pool, state, schemas) {
       pool.forceId(table.name);
       pool.forceId(table.schema);
       forceBjvStrings(pool, {
+        xmins: table.allRows().map((row) => table.rowXmins.get(row) ?? 2),
         name: table.name,
         schema: table.schema,
         columns: table.columns,
@@ -28543,11 +28932,13 @@ var ScramServer = class {
 var splitStatements = (script) => {
   const out = [];
   let start2 = 0;
+  let hasSql = false;
   let i = 0;
   const n = script.length;
   const push = (end) => {
     const text = script.slice(start2, end).trim();
-    if (text.length > 0) out.push(text);
+    if (hasSql) out.push(text);
+    hasSql = false;
   };
   while (i < n) {
     const c = script[i];
@@ -28569,9 +28960,11 @@ var splitStatements = (script) => {
           i += 2;
         } else i++;
       }
+      if (depth > 0) hasSql = true;
       continue;
     }
     if (c === "'" || c === '"') {
+      hasSql = true;
       const escaped = c === "'" && /[eE]/.test(script[i - 1] ?? "") && !/[\w$]/.test(script[i - 2] ?? "");
       i++;
       while (i < n) {
@@ -28594,6 +28987,7 @@ var splitStatements = (script) => {
     if (c === "$") {
       const m = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(script.slice(i, i + 64));
       if (m) {
+        hasSql = true;
         const tag = m[0];
         const end = script.indexOf(tag, i + tag.length);
         i = end === -1 ? n : end + tag.length;
@@ -28604,6 +28998,7 @@ var splitStatements = (script) => {
       push(i);
       start2 = i + 1;
     }
+    if (c !== ";" && !/\s/.test(c)) hasSql = true;
     i++;
   }
   push(n);
@@ -29036,7 +29431,16 @@ var binaryValue = (type, text) => {
   }
 };
 var binaryEncodable = (type) => TEXT_TYPES2.has(type) || ["bool", "int2", "int4", "oid", "int8", "float4", "float8", "bytea", "uuid"].includes(type);
-var mutatesDatabase = (sql) => parse(sql).some((stmt) => !["select", "show", "explain", "transaction", "no_op"].includes(stmt.type));
+var setsSessionConfig = (node) => {
+  if (Array.isArray(node)) return node.some(setsSessionConfig);
+  if (typeof node !== "object" || node === null) return false;
+  const call = node;
+  if (call.type === "func" && call.name?.at(-1) === "set_config") return true;
+  return Object.values(node).some(setsSessionConfig);
+};
+var mutatesDatabase = (sql) => parse(sql).some(
+  (stmt) => !["select", "show", "explain", "transaction", "no_op"].includes(stmt.type) || stmt.type === "select" && setsSessionConfig(stmt)
+);
 var NEVER_WRITES = /* @__PURE__ */ new Set(["show", "set", "reset", "transaction", "no_op", "prepare", "deallocate"]);
 var WRITE_NODES = /* @__PURE__ */ new Set(["insert", "update", "delete"]);
 var containsWrite = (db, node) => {
@@ -29661,6 +30065,7 @@ var Connection = class {
       }
       return outcome;
     } finally {
+      workspace?.transactions.rollback();
       workspace?.close();
     }
   }
@@ -29677,7 +30082,7 @@ var Connection = class {
     if (stmt?.type !== "transaction") throw pgError2("syntax", "invalid transaction command", "42601");
     switch (stmt.action) {
       case "begin":
-        this.transaction ??= { statements: [], savepoints: [] };
+        this.transaction ??= { statements: [], savepoints: [], xid: this.database.state.allocateXid() };
         return command("BEGIN");
       case "commit": {
         const transaction = this.transaction;
@@ -29686,6 +30091,7 @@ var Connection = class {
           this.inSession(
             this.database,
             () => this.database.transaction(() => {
+              this.database.state.transactionXid = transaction.xid;
               for (const logged of transaction.statements) this.replay(this.database, logged);
             })
           );
@@ -29735,8 +30141,10 @@ var Connection = class {
     });
     workspace.state.settings = new Map(this.settings);
     workspace.state.settingDefaults = this.settingDefaults;
+    workspace.transactions.begin();
+    workspace.state.transactionXid = this.transaction?.xid ?? null;
     for (const logged of this.transaction?.statements ?? []) {
-      workspace.transaction(() => this.replay(workspace, logged));
+      this.replay(workspace, logged);
     }
     return workspace;
   }