@crvouga/postgres-mem 0.1.0 → 1.0.0

package/dist/index.js

@@ -190,6 +190,9 @@ var OsEntropy = class _OsEntropy extends Prng {
 
 // src/schema/catalog.ts
 var builder = null;
+function setCatalogBuilder(b) {
+  builder = b;
+}
 function catalogRelation(ctx, schema, name) {
   if (schema !== "pg_catalog" && schema !== "information_schema") return null;
   return builder ? builder(ctx, schema, name) : null;
@@ -2490,6 +2493,36 @@ var TYPE_OIDS = {
   void: 2278,
   unknown: 705
 };
+var ARRAY_OIDS = {
+  bool: 1e3,
+  bytea: 1001,
+  name: 1003,
+  int8: 1016,
+  int2: 1005,
+  int4: 1007,
+  text: 1009,
+  oid: 1028,
+  json: 199,
+  float4: 1021,
+  float8: 1022,
+  money: 791,
+  bpchar: 1014,
+  varchar: 1015,
+  date: 1182,
+  time: 1183,
+  timestamp: 1115,
+  timestamptz: 1185,
+  interval: 1187,
+  timetz: 1270,
+  numeric: 1231,
+  record: 2287,
+  uuid: 2951,
+  jsonb: 3807
+};
+function typeOid(t) {
+  if (isArrayType(t)) return ARRAY_OIDS[arrayElemType(t)] ?? 2277;
+  return TYPE_OIDS[t] ?? 705;
+}
 function shortestParts(v) {
   const s = Math.abs(v).toString();
   if (s.includes("e") || s.includes("E")) {
@@ -3906,13 +3939,13 @@ var RowScope = class {
 function childEnv(env, outer) {
   return { ctx: env.ctx, params: env.params, ctes: env.ctes, outer };
 }
-function relationResult(rel, command) {
-  const visible = rel.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
+function relationResult(rel2, command) {
+  const visible = rel2.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
   return {
     columns: visible.map(({ c }) => ({ name: c.name, type: c.type })),
-    rows: rel.rows.map((r) => visible.map(({ i }) => r[i] ?? null)),
+    rows: rel2.rows.map((r) => visible.map(({ i }) => r[i] ?? null)),
     command,
-    rowCount: rel.rows.length
+    rowCount: rel2.rows.length
   };
 }
 function commandResult(command, rowCount) {
@@ -10391,6 +10424,9 @@ var FACTORIES = /* @__PURE__ */ new Map([
   ["regr_syy", () => new CorrAcc("regr_syy")],
   ["regr_sxy", () => new CorrAcc("regr_sxy")]
 ]);
+function getAggregateFactories() {
+  return FACTORIES;
+}
 function isAggregateName(name) {
   return FACTORIES.has(name);
 }
@@ -11109,31 +11145,31 @@ function makeEvalScope(env, scope, extras) {
       return p;
     },
     execScalarSubquery(q) {
-      const rel = executeSelectStmt(childEnv(env, scope), q);
-      if (rel.columns.length !== 1) {
+      const rel2 = executeSelectStmt(childEnv(env, scope), q);
+      if (rel2.columns.length !== 1) {
         throw pgError("cardinality_violation", "subquery must return only one column", "42601");
       }
-      if (rel.rows.length > 1) {
+      if (rel2.rows.length > 1) {
         throw pgError(
           "cardinality_violation",
           "more than one row returned by a subquery used as an expression",
           "21000"
         );
       }
-      const t = rel.columns[0].type;
-      return tv(t === UNKNOWN ? "text" : t, rel.rows[0]?.[0] ?? null);
+      const t = rel2.columns[0].type;
+      return tv(t === UNKNOWN ? "text" : t, rel2.rows[0]?.[0] ?? null);
     },
     execExistsSubquery(q) {
-      const rel = executeSelectStmt(childEnv(env, scope), q);
-      return rel.rows.length > 0;
+      const rel2 = executeSelectStmt(childEnv(env, scope), q);
+      return rel2.rows.length > 0;
     },
     execColumnSubquery(q) {
-      const rel = executeSelectStmt(childEnv(env, scope), q);
-      if (rel.columns.length !== 1) {
+      const rel2 = executeSelectStmt(childEnv(env, scope), q);
+      if (rel2.columns.length !== 1) {
         throw pgError("cardinality_violation", "subquery has too many columns", "42601");
       }
-      const t = rel.columns[0].type;
-      return { type: t === UNKNOWN ? "text" : t, values: rel.rows.map((r) => r[0] ?? null) };
+      const t = rel2.columns[0].type;
+      return { type: t === UNKNOWN ? "text" : t, values: rel2.rows.map((r) => r[0] ?? null) };
     },
     aggValue(node) {
       return extras?.aggMap?.get(node);
@@ -11249,39 +11285,39 @@ function referencesRelation(node, name) {
   }
   return false;
 }
-function applyCteColumnNames(rel, cte) {
-  const columns = rel.columns.map((c, i) => ({
+function applyCteColumnNames(rel2, cte) {
+  const columns = rel2.columns.map((c, i) => ({
     name: cte.columns?.[i] ?? c.name,
     type: c.type,
     table: null
   }));
-  if (cte.columns && cte.columns.length > rel.columns.length) {
+  if (cte.columns && cte.columns.length > rel2.columns.length) {
     throw pgError(
       "syntax",
-      `WITH query "${cte.name}" has ${rel.columns.length} columns available but ${cte.columns.length} columns specified`,
+      `WITH query "${cte.name}" has ${rel2.columns.length} columns available but ${cte.columns.length} columns specified`,
       "42P10"
     );
   }
-  return { columns, rows: rel.rows };
+  return { columns, rows: rel2.rows };
 }
 function applyWith(env, w) {
   if (!w) return env;
   const ctes = new Map(env.ctes);
   for (const cte of w.ctes) {
     const scopedEnv = { ctx: env.ctx, params: env.params, ctes, outer: env.outer };
-    let rel;
+    let rel2;
     if (w.recursive && cte.query.type === "select" && cte.query.body.type === "setop" && cte.query.body.op === "union" && referencesRelation(cte.query.body.right, cte.name)) {
-      rel = executeRecursiveCte(scopedEnv, cte, cte.query);
+      rel2 = executeRecursiveCte(scopedEnv, cte, cte.query);
     } else if (cte.query.type === "select") {
-      rel = executeSelectStmt(scopedEnv, cte.query);
+      rel2 = executeSelectStmt(scopedEnv, cte.query);
     } else {
       const res = runStatement(scopedEnv, cte.query);
-      rel = {
+      rel2 = {
         columns: res.columns.map((c) => ({ name: c.name, type: c.type, table: null })),
         rows: res.rows
       };
     }
-    ctes.set(cte.name, applyCteColumnNames(rel, cte));
+    ctes.set(cte.name, applyCteColumnNames(rel2, cte));
   }
   return { ctx: env.ctx, params: env.params, ctes, outer: env.outer };
 }
@@ -11340,28 +11376,28 @@ function executeRecursiveCte(env, cte, query) {
     }
     working = next;
   }
-  let rel = { columns, rows: result };
+  let rel2 = { columns, rows: result };
   if (query.orderBy.length > 0 || query.limit || query.offset) {
-    const sortSpecs = outputOrderSpecs(env, rel, query.orderBy);
-    if (sortSpecs.length > 0) sortRows(env, rel, sortSpecs);
-    rel = applyLimitOffset(env, rel, query.limit, query.offset);
+    const sortSpecs = outputOrderSpecs(env, rel2, query.orderBy);
+    if (sortSpecs.length > 0) sortRows(env, rel2, sortSpecs);
+    rel2 = applyLimitOffset(env, rel2, query.limit, query.offset);
   }
-  return rel;
+  return rel2;
 }
-function renameWithAliases(rel, label, colAliases, what) {
-  if (colAliases && colAliases.length > rel.columns.length) {
+function renameWithAliases(rel2, label, colAliases, what) {
+  if (colAliases && colAliases.length > rel2.columns.length) {
     throw pgError(
       "invalid_column_reference",
-      `table "${what}" has ${rel.columns.length} columns available but ${colAliases.length} columns specified`,
+      `table "${what}" has ${rel2.columns.length} columns available but ${colAliases.length} columns specified`,
       "42P10"
     );
   }
-  const columns = rel.columns.map((c, i) => ({
+  const columns = rel2.columns.map((c, i) => ({
     name: colAliases?.[i] ?? c.name,
     type: c.type === UNKNOWN ? "text" : c.type,
     table: label
   }));
-  return { columns, rows: rel.rows };
+  return { columns, rows: rel2.rows };
 }
 function materializeItem(env, item, scope) {
   switch (item.type) {
@@ -11376,15 +11412,15 @@ function materializeItem(env, item, scope) {
       const state = env.ctx.state;
       const table = state.findTable(item.name);
       if (table) {
-        const rel = {
+        const rel2 = {
           columns: table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
           rows: table.rows
         };
-        return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+        return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
       const view = state.findView(item.name);
       if (view) {
-        let rel;
+        let rel2;
         if (view.materialized) {
           if (view.matRows === null || view.matColumns === null) {
             throw pgError(
@@ -11393,23 +11429,23 @@ function materializeItem(env, item, scope) {
               "55000"
             );
           }
-          rel = {
+          rel2 = {
             columns: view.matColumns.map((c) => ({ name: c.name, type: c.type, table: label })),
             rows: view.matRows
           };
         } else {
           const viewEnv = { ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
-          rel = executeSelectStmt(viewEnv, view.query);
-          rel = {
-            columns: rel.columns.map((c, i) => ({
+          rel2 = executeSelectStmt(viewEnv, view.query);
+          rel2 = {
+            columns: rel2.columns.map((c, i) => ({
               name: view.columns?.[i] ?? c.name,
               type: c.type,
               table: label
             })),
-            rows: rel.rows
+            rows: rel2.rows
           };
         }
-        return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+        return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
       const resolved = state.resolveRelationSchema(item.name);
       if (resolved) {
@@ -11422,9 +11458,9 @@ function materializeItem(env, item, scope) {
     }
     case "from_subquery": {
       const subEnv = childEnv(env, item.lateral ? scope : env.outer);
-      const rel = executeSelectStmt(subEnv, item.query);
+      const rel2 = executeSelectStmt(subEnv, item.query);
       const label = item.alias ?? "unnamed_subquery";
-      return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+      return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
     }
     case "from_func":
       return materializeFunc(env, item, scope);
@@ -11461,7 +11497,7 @@ function srfCallRelation(env, call, scope, alias) {
 }
 function materializeFunc(env, item, scope) {
   const effScope = scope ?? env.outer;
-  let rel;
+  let rel2;
   if (item.rowsFrom) {
     const parts = item.rowsFrom.map((c) => srfCallRelation(env, c, effScope, null));
     const maxLen = Math.max(0, ...parts.map((p) => p.rows.length));
@@ -11476,18 +11512,18 @@ function materializeFunc(env, item, scope) {
       }
       rows.push(row);
     }
-    rel = { columns, rows };
+    rel2 = { columns, rows };
   } else {
-    rel = srfCallRelation(env, item.call, effScope, item.alias);
+    rel2 = srfCallRelation(env, item.call, effScope, item.alias);
   }
   if (item.withOrdinality) {
-    rel = {
-      columns: [...rel.columns, { name: "ordinality", type: "int8", table: null }],
-      rows: rel.rows.map((r, i) => [...r, BigInt(i + 1)])
+    rel2 = {
+      columns: [...rel2.columns, { name: "ordinality", type: "int8", table: null }],
+      rows: rel2.rows.map((r, i) => [...r, BigInt(i + 1)])
     };
   }
   const label = item.alias ?? (item.call.type === "func" ? item.call.name[item.call.name.length - 1] : "unnamed_function");
-  return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+  return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
 }
 function isLateralItem(item) {
   switch (item.type) {
@@ -12016,9 +12052,9 @@ function computeAggregate(env, call, rows) {
   for (const t of effective) acc.step(t.args);
   return acc.result();
 }
-function sortRows(env, rel, specs) {
+function sortRows(env, rel2, specs) {
   const ctx = env.ctx;
-  const indexed = rel.rows.map((row, i) => ({ row, i }));
+  const indexed = rel2.rows.map((row, i) => ({ row, i }));
   indexed.sort((a, b) => {
     for (const s of specs) {
       const av = a.row[s.colIdx] ?? null;
@@ -12030,14 +12066,14 @@ function sortRows(env, rel, specs) {
         if (c2 !== 0) return c2;
         continue;
       }
-      const t = rel.columns[s.colIdx].type;
+      const t = rel2.columns[s.colIdx].type;
       let c = datumCompare(t === UNKNOWN ? "text" : t, av, bv, ctx);
       if (s.dir === "desc") c = -c;
       if (c !== 0) return c;
     }
     return a.i - b.i;
   });
-  rel.rows = indexed.map((x) => x.row);
+  rel2.rows = indexed.map((x) => x.row);
 }
 function orderDirection(ob) {
   let dir = ob.dir ?? "asc";
@@ -12046,30 +12082,30 @@ function orderDirection(ob) {
   const nullsFirst = ob.nulls ? ob.nulls === "first" : dir === "desc";
   return { dir, nullsFirst };
 }
-function outputOrderSpecs(env, rel, orderBy) {
+function outputOrderSpecs(env, rel2, orderBy) {
   if (orderBy.length === 0) return [];
   const specs = [];
   const extraCols = [];
   const extraExprs = [];
   for (const ob of orderBy) {
     const { dir, nullsFirst } = orderDirection(ob);
-    const pos = orderPosition(ob.expr, rel);
+    const pos = orderPosition(ob.expr, rel2);
     if (pos !== null) {
       specs.push({ colIdx: pos, dir, nullsFirst });
       continue;
     }
-    specs.push({ colIdx: rel.columns.length + extraCols.length, dir, nullsFirst });
+    specs.push({ colIdx: rel2.columns.length + extraCols.length, dir, nullsFirst });
     extraCols.push({ name: `__ord${extraCols.length}`, type: UNKNOWN, table: null, hidden: true });
     extraExprs.push(ob.expr);
   }
   if (extraExprs.length > 0) {
-    const baseCols = rel.columns.slice();
-    rel.columns = [...rel.columns, ...extraCols];
-    rel.rows = rel.rows.map((row) => {
+    const baseCols = rel2.columns.slice();
+    rel2.columns = [...rel2.columns, ...extraCols];
+    rel2.rows = rel2.rows.map((row) => {
       const scope = new RowScope(baseCols, row, env.outer);
       const extras = extraExprs.map((e) => evalScalar(env, scope, e));
       for (let k = 0; k < extras.length; k++) {
-        const col = rel.columns[baseCols.length + k];
+        const col = rel2.columns[baseCols.length + k];
         col.type = unifyAggType(col.type, extras[k].t);
       }
       return [...row, ...extras.map((x) => x.v)];
@@ -12077,8 +12113,8 @@ function outputOrderSpecs(env, rel, orderBy) {
   }
   return specs;
 }
-function orderPosition(e, rel) {
-  const visible = rel.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
+function orderPosition(e, rel2) {
+  const visible = rel2.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
   if (e.type === "number_lit" && /^\d+$/.test(e.raw)) {
     const k = Number(e.raw);
     const v = visible[k - 1];
@@ -12097,16 +12133,16 @@ function orderPosition(e, rel) {
   }
   return null;
 }
-function stripHidden(rel) {
-  if (!rel.columns.some((c) => c.hidden)) return rel;
-  const keep = rel.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
+function stripHidden(rel2) {
+  if (!rel2.columns.some((c) => c.hidden)) return rel2;
+  const keep = rel2.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
   return {
     columns: keep.map(({ c }) => c),
-    rows: rel.rows.map((row) => keep.map(({ i }) => row[i] ?? null))
+    rows: rel2.rows.map((row) => keep.map(({ i }) => row[i] ?? null))
   };
 }
-function applyLimitOffset(env, rel, limit, offset, tieSpecs) {
-  let rows = rel.rows;
+function applyLimitOffset(env, rel2, limit, offset, tieSpecs) {
+  let rows = rel2.rows;
   if (offset) {
     const v = evalScalar(env, env.outer, offset);
     if (v.v !== null) {
@@ -12123,14 +12159,14 @@ function applyLimitOffset(env, rel, limit, offset, tieSpecs) {
       let end = Math.min(n, rows.length);
       if (tieSpecs && end > 0 && end < rows.length) {
         const boundary = rows[end - 1];
-        while (end < rows.length && sortKeysEqual(env, rel, tieSpecs, boundary, rows[end])) end++;
+        while (end < rows.length && sortKeysEqual(env, rel2, tieSpecs, boundary, rows[end])) end++;
       }
       rows = rows.slice(0, end);
     }
   }
-  return { columns: rel.columns, rows };
+  return { columns: rel2.columns, rows };
 }
-function sortKeysEqual(env, rel, specs, a, b) {
+function sortKeysEqual(env, rel2, specs, a, b) {
   for (const s of specs) {
     const av = a[s.colIdx] ?? null;
     const bv = b[s.colIdx] ?? null;
@@ -12138,7 +12174,7 @@ function sortKeysEqual(env, rel, specs, a, b) {
       if (av !== bv) return false;
       continue;
     }
-    const t = rel.columns[s.colIdx].type;
+    const t = rel2.columns[s.colIdx].type;
     if (datumCompare(t === UNKNOWN ? "text" : t, av, bv, env.ctx) !== 0) return false;
   }
   return true;
@@ -12197,10 +12233,10 @@ function setOpRelation(env, op) {
     return t === UNKNOWN ? "text" : t;
   });
   const columns = left.columns.map((c, i) => ({ name: c.name, type: types[i], table: null }));
-  const normalize = (rel) => rel.rows.map(
+  const normalize = (rel2) => rel2.rows.map(
     (row) => row.map((v, i) => {
       if (v === null) return null;
-      const srcT = rel.columns[i].type;
+      const srcT = rel2.columns[i].type;
       if (srcT === types[i]) return v;
       return castTo(ctx, tv(srcT === UNKNOWN ? "text" : srcT, v), types[i], {}).v;
     })
@@ -12628,26 +12664,26 @@ function executeCore(env0, core, orderBy) {
       outRows[r][k] = castTo(ctx, tv(cellT, v), finalT, { explicit: true }).v;
     }
   }
-  let rel = { columns: outColumns, rows: outRows };
+  let rel2 = { columns: outColumns, rows: outRows };
   if (sortSpecs.length > 0) {
-    sortRows(env, rel, sortSpecs);
+    sortRows(env, rel2, sortSpecs);
   }
   if (core.distinct) {
     if (core.distinct.on) {
       const seen = /* @__PURE__ */ new Set();
-      rel.rows = rel.rows.filter((row) => {
+      rel2.rows = rel2.rows.filter((row) => {
         const k = distinctOnIdx.map((ci) => {
           const v = row[ci] ?? null;
-          return v === null ? "\0N" : datumKey(rel.columns[ci].type, v);
+          return v === null ? "\0N" : datumKey(rel2.columns[ci].type, v);
         }).join("
");
         if (seen.has(k)) return false;
         seen.add(k);
         return true;
       });
     } else {
-      const visible = rel.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
+      const visible = rel2.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
       const seen = /* @__PURE__ */ new Set();
-      rel.rows = rel.rows.filter((row) => {
+      rel2.rows = rel2.rows.filter((row) => {
         const k = visible.map(({ c, i }) => {
           const v = row[i] ?? null;
           return v === null ? "\0N" : datumKey(c.type, v);
@@ -12658,28 +12694,28 @@ function executeCore(env0, core, orderBy) {
       });
     }
   }
-  rel = stripHidden(rel);
-  return rel;
+  rel2 = stripHidden(rel2);
+  return rel2;
 }
 function executeSelectStmt(env0, stmt) {
   const env = applyWith(env0, stmt.with);
-  let rel;
+  let rel2;
   if (stmt.body.type === "select_core") {
-    rel = executeCore(env, stmt.body, stmt.orderBy);
+    rel2 = executeCore(env, stmt.body, stmt.orderBy);
   } else {
-    rel = executeBody(env, stmt.body);
-    const specs = outputOrderSpecs(env, rel, stmt.orderBy);
-    if (specs.length > 0) sortRows(env, rel, specs);
-    rel = stripHidden(rel);
+    rel2 = executeBody(env, stmt.body);
+    const specs = outputOrderSpecs(env, rel2, stmt.orderBy);
+    if (specs.length > 0) sortRows(env, rel2, specs);
+    rel2 = stripHidden(rel2);
   }
   if (stmt.limitWithTies) {
     if (stmt.orderBy.length === 0) {
       throw pgError("syntax", "WITH TIES cannot be specified without ORDER BY clause", "42601");
     }
-    const tieSpecs = outputOrderSpecs(env, rel, stmt.orderBy);
-    return stripHidden(applyLimitOffset(env, rel, stmt.limit, stmt.offset, tieSpecs));
+    const tieSpecs = outputOrderSpecs(env, rel2, stmt.orderBy);
+    return stripHidden(applyLimitOffset(env, rel2, stmt.limit, stmt.offset, tieSpecs));
   }
-  return applyLimitOffset(env, rel, stmt.limit, stmt.offset);
+  return applyLimitOffset(env, rel2, stmt.limit, stmt.offset);
 }
 
 // src/constraints/enforce.ts
@@ -12868,6 +12904,9 @@ function matches(t, event) {
   return t.events.some((e) => e.event === event);
 }
 var executor = null;
+function setTriggerExecutor(e) {
+  executor = e;
+}
 function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
   let row = newRow ?? oldRow;
   for (const t of table.triggers) {
@@ -13010,13 +13049,13 @@ function insertSourceRows(env, stmt, colIdxs) {
     }
     return rows;
   }
-  const rel = executeSelectStmt(env, src);
-  if (rel.columns.length > colIdxs.length) {
+  const rel2 = executeSelectStmt(env, src);
+  if (rel2.columns.length > colIdxs.length) {
     throw pgError("syntax", "INSERT has more expressions than target columns", "42601");
   }
-  return rel.rows.map(
+  return rel2.rows.map(
     (r) => r.map((v, i) => {
-      const t = rel.columns[i].type;
+      const t = rel2.columns[i].type;
       return tv(t === UNKNOWN ? "text" : t, v);
     })
   );
@@ -13179,21 +13218,21 @@ function applyUpdateSets(env, table, sets, scope, row) {
       return i;
     });
     if (typeof set.value === "object" && "kind" in set.value && set.value.kind === "row_subquery") {
-      const rel = executeSelectStmt(
+      const rel2 = executeSelectStmt(
         { ctx: env.ctx, params: env.params, ctes: env.ctes, outer: scope },
         set.value.query
       );
-      if (rel.rows.length > 1) {
+      if (rel2.rows.length > 1) {
         throw pgError(
           "cardinality_violation",
           "more than one row returned by a subquery used as an expression",
           "21000"
         );
       }
-      const srcRow = rel.rows[0] ?? null;
+      const srcRow = rel2.rows[0] ?? null;
       for (let k = 0; k < colIdxs.length; k++) {
         const col2 = table.columns[colIdxs[k]];
-        const v = srcRow === null ? tv(col2.type.id, null) : tv(rel.columns[k]?.type ?? "text", srcRow[k] ?? null);
+        const v = srcRow === null ? tv(col2.type.id, null) : tv(rel2.columns[k]?.type ?? "text", srcRow[k] ?? null);
         row[colIdxs[k]] = coerceToColumn(env, v.t === UNKNOWN ? tv("text", v.v) : v, col2);
       }
       continue;
@@ -17851,6 +17890,1097 @@ function resolveClock(now) {
 // src/runtime/options.ts
 var DEFAULT_DATABASE_SEED = 1;
 
+// src/schema/catalog-tables.ts
+function rel(specs, rows, table) {
+  const columns = specs.map(([name, type]) => ({ name, type, table }));
+  return { columns, rows };
+}
+var OWNER = "postgres";
+function* allTables(state) {
+  for (const schema of state.schemas.values()) {
+    for (const t of schema.tables.values()) yield t;
+  }
+}
+function* allSequences(state) {
+  for (const schema of state.schemas.values()) {
+    for (const s of schema.sequences.values()) yield s;
+  }
+}
+var NS_PG_CATALOG = 11;
+var NS_INFORMATION_SCHEMA = 13212;
+function namespaceOid(state, name) {
+  if (name === "pg_catalog") return NS_PG_CATALOG;
+  if (name === "information_schema") return NS_INFORMATION_SCHEMA;
+  return state.schemas.get(name)?.oid ?? 0;
+}
+function attTypmod(mod, type) {
+  if (!mod || mod.a === void 0) return -1;
+  if (type === "numeric") return (mod.a << 16 | (mod.b ?? 0)) + 4;
+  if (type === "varchar" || type === "bpchar") return mod.a + 4;
+  return mod.a;
+}
+function enumOid(ctx, t) {
+  if (!isEnumType(t)) return typeOid(t);
+  const e = ctx.state.findEnumByKey(t.slice(5));
+  return e ? e.oid : 0;
+}
+function pgNamespace(state) {
+  const rows = [
+    [NS_PG_CATALOG, "pg_catalog", 10, null],
+    [NS_INFORMATION_SCHEMA, "information_schema", 10, null]
+  ];
+  for (const s of state.schemas.values()) rows.push([s.oid, s.name, 10, null]);
+  return rel(
+    [
+      ["oid", "oid"],
+      ["nspname", "name"],
+      ["nspowner", "oid"],
+      ["nspacl", "text[]"]
+    ],
+    rows,
+    "pg_namespace"
+  );
+}
+function pgClass(ctx) {
+  const state = ctx.state;
+  const rows = [];
+  const push = (oid, name, schema, kind, natts, tuples, hasindex, populated, temp) => {
+    rows.push([
+      oid,
+      name,
+      namespaceOid(state, schema),
+      0,
+      10,
+      kind === "i" ? 403 : kind === "S" || kind === "v" ? 0 : 2,
+      oid,
+      0,
+      0,
+      tuples,
+      0,
+      0,
+      hasindex,
+      false,
+      temp ? "t" : "p",
+      kind,
+      natts,
+      0,
+      false,
+      false,
+      false,
+      false,
+      false,
+      populated,
+      kind === "r" ? "d" : "n",
+      false,
+      0,
+      null,
+      null,
+      null
+    ]);
+  };
+  for (const schemaData of state.schemas.values()) {
+    for (const t of schemaData.tables.values()) {
+      const hasIndex = t.constraints.some((c) => c.kind === "primary_key" || c.kind === "unique") || [...schemaData.indexes.values()].some((i) => i.table === t.name);
+      push(t.oid, t.name, t.schema, "r", t.columns.length, t.rows.length, hasIndex, true, t.temp);
+    }
+    for (const v of schemaData.views.values()) {
+      push(
+        v.oid,
+        v.name,
+        v.schema,
+        v.materialized ? "m" : "v",
+        v.columns?.length ?? 0,
+        v.matRows?.length ?? 0,
+        false,
+        !v.materialized || v.matRows !== null,
+        v.temp
+      );
+    }
+    for (const s of schemaData.sequences.values()) push(s.oid, s.name, s.schema, "S", 3, 1, false, true, s.temp);
+    for (const i of schemaData.indexes.values()) {
+      push(
+        state.schemas.get(i.schema)?.tables.get(i.table)?.oid ?? 0,
+        i.name,
+        i.schema,
+        "i",
+        i.columns.length,
+        0,
+        false,
+        true,
+        false
+      );
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["relname", "name"],
+      ["relnamespace", "oid"],
+      ["reltype", "oid"],
+      ["relowner", "oid"],
+      ["relam", "oid"],
+      ["relfilenode", "oid"],
+      ["reltablespace", "oid"],
+      ["relpages", "int4"],
+      ["reltuples", "float4"],
+      ["relallvisible", "int4"],
+      ["reltoastrelid", "oid"],
+      ["relhasindex", "bool"],
+      ["relisshared", "bool"],
+      ["relpersistence", "bpchar"],
+      ["relkind", "bpchar"],
+      ["relnatts", "int2"],
+      ["relchecks", "int2"],
+      ["relhasrules", "bool"],
+      ["relhastriggers", "bool"],
+      ["relhassubclass", "bool"],
+      ["relrowsecurity", "bool"],
+      ["relforcerowsecurity", "bool"],
+      ["relispopulated", "bool"],
+      ["relreplident", "bpchar"],
+      ["relispartition", "bool"],
+      ["relrewrite", "oid"],
+      ["relacl", "text[]"],
+      ["reloptions", "text[]"],
+      ["relpartbound", "text"]
+    ],
+    rows,
+    "pg_class"
+  );
+}
+function pgAttribute(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    t.columns.forEach((c, i) => {
+      rows.push([
+        t.oid,
+        c.name,
+        enumOid(ctx, c.type.id),
+        i + 1,
+        attTypmod(c.type.mod, c.type.id),
+        -1,
+        c.notNull,
+        c.defaultExpr !== null || c.identity !== null,
+        false,
+        c.identity ? c.identity.always ? "a" : "d" : "",
+        c.generated ? "s" : "",
+        isArrayType(c.type.id) ? 1 : 0
+      ]);
+    });
+  }
+  return rel(
+    [
+      ["attrelid", "oid"],
+      ["attname", "name"],
+      ["atttypid", "oid"],
+      ["attnum", "int2"],
+      ["atttypmod", "int4"],
+      ["attlen", "int2"],
+      ["attnotnull", "bool"],
+      ["atthasdef", "bool"],
+      ["attisdropped", "bool"],
+      ["attidentity", "bpchar"],
+      ["attgenerated", "bpchar"],
+      ["attndims", "int2"]
+    ],
+    rows,
+    "pg_attribute"
+  );
+}
+function pgType(ctx) {
+  const rows = [];
+  for (const [name, oid] of Object.entries(TYPE_OIDS)) {
+    const isArr = name.startsWith("_");
+    rows.push([
+      oid,
+      name,
+      NS_PG_CATALOG,
+      "b",
+      isArr ? "A" : "U",
+      isArr ? TYPE_OIDS[name.slice(1)] ?? 0 : 0,
+      isArr ? 0 : TYPE_OIDS[`_${name}`] ?? 0,
+      0,
+      0,
+      -1
+    ]);
+  }
+  for (const schema of ctx.state.schemas.values()) {
+    for (const e of schema.enums.values()) {
+      rows.push([e.oid, e.name, namespaceOid(ctx.state, e.schema), "e", "E", 0, 0, 0, 0, 4]);
+    }
+    for (const d of schema.domains.values()) {
+      rows.push([d.oid, d.name, namespaceOid(ctx.state, d.schema), "d", "S", 0, 0, typeOid(d.baseType.id), 0, -1]);
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["typname", "name"],
+      ["typnamespace", "oid"],
+      ["typtype", "bpchar"],
+      ["typcategory", "bpchar"],
+      ["typelem", "oid"],
+      ["typarray", "oid"],
+      ["typbasetype", "oid"],
+      ["typrelid", "oid"],
+      ["typlen", "int2"]
+    ],
+    rows,
+    "pg_type"
+  );
+}
+function pgProc(ctx) {
+  const rows = [];
+  let oid = 1e3;
+  const seen = /* @__PURE__ */ new Set();
+  const push = (name, ns, kind, retset, nargs, realOid) => {
+    rows.push([realOid ?? oid++, name, ns, kind, retset, nargs]);
+  };
+  for (const name of getScalarFunctions().keys()) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      push(name, NS_PG_CATALOG, "f", false, -1);
+    }
+  }
+  for (const name of Object.keys(getAggregateFactories())) {
+    if (!seen.has(`agg:${name}`)) {
+      seen.add(`agg:${name}`);
+      push(name, NS_PG_CATALOG, "a", false, -1);
+    }
+  }
+  for (const name of WINDOW_FUNCTION_NAMES) push(name, NS_PG_CATALOG, "w", false, -1);
+  for (const name of getSrfFunctions().keys()) push(name, NS_PG_CATALOG, "f", true, -1);
+  for (const schema of ctx.state.schemas.values()) {
+    for (const fns of schema.functions.values()) {
+      for (const f of fns) {
+        push(f.name, namespaceOid(ctx.state, f.schema), "f", f.returnsSet, f.argTypes.length, f.oid);
+      }
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["proname", "name"],
+      ["pronamespace", "oid"],
+      ["prokind", "bpchar"],
+      ["proretset", "bool"],
+      ["pronargs", "int2"]
+    ],
+    rows,
+    "pg_proc"
+  );
+}
+function pgEnum(ctx) {
+  const rows = [];
+  let oid = 2e4;
+  for (const schema of ctx.state.schemas.values()) {
+    for (const e of schema.enums.values()) {
+      e.labels.forEach((label, i) => {
+        rows.push([oid++, e.oid, i + 1, label]);
+      });
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["enumtypid", "oid"],
+      ["enumsortorder", "float4"],
+      ["enumlabel", "name"]
+    ],
+    rows,
+    "pg_enum"
+  );
+}
+function pgConstraint(ctx) {
+  const rows = [];
+  let oid = 3e4;
+  for (const t of allTables(ctx.state)) {
+    for (const c of t.constraints) {
+      const contype = c.kind === "primary_key" ? "p" : c.kind === "unique" ? "u" : c.kind === "check" ? "c" : "f";
+      const refTable = c.kind === "foreign_key" ? ctx.state.schemas.get(c.refSchema)?.tables.get(c.refTable) : void 0;
+      rows.push([oid++, c.name, namespaceOid(ctx.state, t.schema), contype, false, false, t.oid, refTable?.oid ?? 0]);
+    }
+    for (const col of t.columns) {
+      if (col.notNull) {
+        rows.push([
+          oid++,
+          `${t.name}_${col.name}_not_null`,
+          namespaceOid(ctx.state, t.schema),
+          "n",
+          false,
+          false,
+          t.oid,
+          0
+        ]);
+      }
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["conname", "name"],
+      ["connamespace", "oid"],
+      ["contype", "bpchar"],
+      ["condeferrable", "bool"],
+      ["condeferred", "bool"],
+      ["conrelid", "oid"],
+      ["confrelid", "oid"]
+    ],
+    rows,
+    "pg_constraint"
+  );
+}
+function pgIndex(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const i of schema.indexes.values()) {
+      const table = schema.tables.get(i.table);
+      const isPrimary = i.isConstraint && table?.constraints.some((c) => c.kind === "primary_key" && c.name === i.name) === true;
+      rows.push([table?.oid ?? 0, table?.oid ?? 0, i.columns.length, i.unique, isPrimary, i.where !== null]);
+    }
+  }
+  return rel(
+    [
+      ["indexrelid", "oid"],
+      ["indrelid", "oid"],
+      ["indnatts", "int2"],
+      ["indisunique", "bool"],
+      ["indisprimary", "bool"],
+      ["indpred", "bool"]
+    ],
+    rows,
+    "pg_index"
+  );
+}
+function pgSequence(ctx) {
+  const rows = [];
+  for (const s of allSequences(ctx.state)) {
+    rows.push([s.oid, typeOid(s.dataType), s.startValue, s.increment, s.maxValue, s.minValue, s.cache, s.cycle]);
+  }
+  return rel(
+    [
+      ["seqrelid", "oid"],
+      ["seqtypid", "oid"],
+      ["seqstart", "int8"],
+      ["seqincrement", "int8"],
+      ["seqmax", "int8"],
+      ["seqmin", "int8"],
+      ["seqcache", "int8"],
+      ["seqcycle", "bool"]
+    ],
+    rows,
+    "pg_sequence"
+  );
+}
+function pgSequencesView(ctx) {
+  const rows = [];
+  for (const s of allSequences(ctx.state)) {
+    rows.push([
+      s.schema,
+      s.name,
+      OWNER,
+      typeDisplayName(s.dataType),
+      s.startValue,
+      s.minValue,
+      s.maxValue,
+      s.increment,
+      s.cycle,
+      s.cache,
+      s.isCalled ? s.lastValue : null
+    ]);
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["sequencename", "name"],
+      ["sequenceowner", "name"],
+      ["data_type", "text"],
+      ["start_value", "int8"],
+      ["min_value", "int8"],
+      ["max_value", "int8"],
+      ["increment_by", "int8"],
+      ["cycle", "bool"],
+      ["cache_size", "int8"],
+      ["last_value", "int8"]
+    ],
+    rows,
+    "pg_sequences"
+  );
+}
+function pgTables(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    const hasIndexes = t.constraints.some((c) => c.kind === "primary_key" || c.kind === "unique") || [...ctx.state.schemas.get(t.schema)?.indexes.values() ?? []].some((i) => i.table === t.name);
+    rows.push([t.schema, t.name, OWNER, null, hasIndexes, false, t.triggers.length > 0, false]);
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["tablename", "name"],
+      ["tableowner", "name"],
+      ["tablespace", "name"],
+      ["hasindexes", "bool"],
+      ["hasrules", "bool"],
+      ["hastriggers", "bool"],
+      ["rowsecurity", "bool"]
+    ],
+    rows,
+    "pg_tables"
+  );
+}
+function pgViews(ctx, materialized) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const v of schema.views.values()) {
+      if (v.materialized !== materialized) continue;
+      if (materialized) rows.push([v.schema, v.name, OWNER, null, v.matRows !== null, null]);
+      else rows.push([v.schema, v.name, OWNER, null]);
+    }
+  }
+  if (materialized) {
+    return rel(
+      [
+        ["schemaname", "name"],
+        ["matviewname", "name"],
+        ["matviewowner", "name"],
+        ["tablespace", "name"],
+        ["ispopulated", "bool"],
+        ["definition", "text"]
+      ],
+      rows,
+      "pg_matviews"
+    );
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["viewname", "name"],
+      ["viewowner", "name"],
+      ["definition", "text"]
+    ],
+    rows,
+    "pg_views"
+  );
+}
+function pgIndexesView(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const i of schema.indexes.values()) {
+      rows.push([i.schema, i.table, i.name, null, null]);
+    }
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["tablename", "name"],
+      ["indexname", "name"],
+      ["tablespace", "name"],
+      ["indexdef", "text"]
+    ],
+    rows,
+    "pg_indexes"
+  );
+}
+function pgSettings(ctx) {
+  const rows = [];
+  const keys = /* @__PURE__ */ new Set([...ctx.state.settings.keys(), ...ctx.state.localSettings.keys()]);
+  for (const name of [...keys].sort()) {
+    rows.push([name, ctx.state.getSetting(name) ?? null]);
+  }
+  return rel(
+    [
+      ["name", "text"],
+      ["setting", "text"]
+    ],
+    rows,
+    "pg_settings"
+  );
+}
+function pgDatabase() {
+  return rel(
+    [
+      ["oid", "oid"],
+      ["datname", "name"],
+      ["encoding", "int4"],
+      ["datistemplate", "bool"],
+      ["datallowconn", "bool"]
+    ],
+    [[5, "postgres", 6, false, true]],
+    "pg_database"
+  );
+}
+function pgRoles() {
+  return rel(
+    [
+      ["oid", "oid"],
+      ["rolname", "name"],
+      ["rolsuper", "bool"],
+      ["rolcanlogin", "bool"]
+    ],
+    [[10, OWNER, true, true]],
+    "pg_roles"
+  );
+}
+function pgTrigger(ctx) {
+  const rows = [];
+  let oid = 4e4;
+  for (const t of allTables(ctx.state)) {
+    for (const tr of t.triggers) {
+      rows.push([oid++, tr.name, t.oid, !tr.forEachRow]);
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["tgname", "name"],
+      ["tgrelid", "oid"],
+      ["tgisinternal", "bool"]
+    ],
+    rows,
+    "pg_trigger"
+  );
+}
+var CATALOG_NAME = "postgres";
+function infoSchemata(state) {
+  const rows = [
+    [CATALOG_NAME, "pg_catalog", OWNER],
+    [CATALOG_NAME, "information_schema", OWNER]
+  ];
+  for (const s of state.schemas.values()) rows.push([CATALOG_NAME, s.name, OWNER]);
+  return rel(
+    [
+      ["catalog_name", "name"],
+      ["schema_name", "name"],
+      ["schema_owner", "name"]
+    ],
+    rows,
+    "schemata"
+  );
+}
+function infoTables(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const t of schema.tables.values()) {
+      rows.push([CATALOG_NAME, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
+    }
+    for (const v of schema.views.values()) {
+      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, "VIEW", "NO"]);
+    }
+  }
+  return rel(
+    [
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["table_type", "text"],
+      ["is_insertable_into", "text"]
+    ],
+    rows,
+    "tables"
+  );
+}
+function infoColumns(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    t.columns.forEach((c, i) => {
+      const id = c.type.id;
+      const isNumeric2 = id === "numeric";
+      const isIntish = id === "int2" || id === "int4" || id === "int8";
+      const charMax = (id === "varchar" || id === "bpchar") && c.type.mod?.a !== void 0 ? c.type.mod.a : null;
+      const dataType = isArrayType(id) ? "ARRAY" : isEnumType(id) ? "USER-DEFINED" : typeDisplayName(id);
+      const udt = isArrayType(id) ? `_${arrayUdt(id)}` : isEnumType(id) ? id.slice(5).split(".").pop() : id;
+      rows.push([
+        CATALOG_NAME,
+        t.schema,
+        t.name,
+        c.name,
+        i + 1,
+        null,
+        c.notNull ? "NO" : "YES",
+        dataType,
+        charMax,
+        isNumeric2 ? c.type.mod?.a ?? null : isIntish ? id === "int2" ? 16 : id === "int4" ? 32 : 64 : null,
+        isNumeric2 ? c.type.mod?.b ?? null : isIntish ? 0 : null,
+        udt,
+        c.identity ? "YES" : "NO",
+        c.generated ? "ALWAYS" : "NEVER",
+        "YES"
+      ]);
+    });
+  }
+  return rel(
+    [
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["column_name", "name"],
+      ["ordinal_position", "int4"],
+      ["column_default", "text"],
+      ["is_nullable", "text"],
+      ["data_type", "text"],
+      ["character_maximum_length", "int4"],
+      ["numeric_precision", "int4"],
+      ["numeric_scale", "int4"],
+      ["udt_name", "name"],
+      ["is_identity", "text"],
+      ["is_generated", "text"],
+      ["is_updatable", "text"]
+    ],
+    rows,
+    "columns"
+  );
+}
+function arrayUdt(t) {
+  const elem = t.slice(0, -2);
+  return isEnumType(elem) ? elem.slice(5).split(".").pop() : elem;
+}
+function infoViews(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const v of schema.views.values()) {
+      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, null]);
+    }
+  }
+  return rel(
+    [
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["view_definition", "text"]
+    ],
+    rows,
+    "views"
+  );
+}
+function infoSequences(ctx) {
+  const rows = [];
+  for (const s of allSequences(ctx.state)) {
+    rows.push([
+      CATALOG_NAME,
+      s.schema,
+      s.name,
+      typeDisplayName(s.dataType),
+      String(s.startValue),
+      String(s.minValue),
+      String(s.maxValue),
+      String(s.increment),
+      s.cycle ? "YES" : "NO"
+    ]);
+  }
+  return rel(
+    [
+      ["sequence_catalog", "name"],
+      ["sequence_schema", "name"],
+      ["sequence_name", "name"],
+      ["data_type", "text"],
+      ["start_value", "text"],
+      ["minimum_value", "text"],
+      ["maximum_value", "text"],
+      ["increment", "text"],
+      ["cycle_option", "text"]
+    ],
+    rows,
+    "sequences"
+  );
+}
+function infoTableConstraints(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    for (const c of t.constraints) {
+      const type = c.kind === "primary_key" ? "PRIMARY KEY" : c.kind === "unique" ? "UNIQUE" : c.kind === "check" ? "CHECK" : "FOREIGN KEY";
+      rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, type]);
+    }
+  }
+  return rel(
+    [
+      ["constraint_catalog", "name"],
+      ["constraint_schema", "name"],
+      ["constraint_name", "name"],
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["constraint_type", "text"]
+    ],
+    rows,
+    "table_constraints"
+  );
+}
+function infoKeyColumnUsage(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    for (const c of t.constraints) {
+      if (c.kind !== "primary_key" && c.kind !== "unique" && c.kind !== "foreign_key") continue;
+      c.columns.forEach((col, i) => {
+        rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, col, i + 1]);
+      });
+    }
+  }
+  return rel(
+    [
+      ["constraint_catalog", "name"],
+      ["constraint_schema", "name"],
+      ["constraint_name", "name"],
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["column_name", "name"],
+      ["ordinal_position", "int4"]
+    ],
+    rows,
+    "key_column_usage"
+  );
+}
+function infoRoutines(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const fns of schema.functions.values()) {
+      for (const f of fns) {
+        rows.push([
+          CATALOG_NAME,
+          f.schema,
+          f.name,
+          "FUNCTION",
+          f.returns ? typeDisplayName(f.returns) : null,
+          f.language.toUpperCase()
+        ]);
+      }
+    }
+  }
+  return rel(
+    [
+      ["routine_catalog", "name"],
+      ["routine_schema", "name"],
+      ["routine_name", "name"],
+      ["routine_type", "text"],
+      ["data_type", "text"],
+      ["external_language", "text"]
+    ],
+    rows,
+    "routines"
+  );
+}
+function buildCatalogRelation(ctx, schema, name) {
+  if (schema === "pg_catalog") {
+    switch (name) {
+      case "pg_namespace":
+        return pgNamespace(ctx.state);
+      case "pg_class":
+        return pgClass(ctx);
+      case "pg_attribute":
+        return pgAttribute(ctx);
+      case "pg_type":
+        return pgType(ctx);
+      case "pg_proc":
+        return pgProc(ctx);
+      case "pg_enum":
+        return pgEnum(ctx);
+      case "pg_constraint":
+        return pgConstraint(ctx);
+      case "pg_index":
+        return pgIndex(ctx);
+      case "pg_sequence":
+        return pgSequence(ctx);
+      case "pg_sequences":
+        return pgSequencesView(ctx);
+      case "pg_tables":
+        return pgTables(ctx);
+      case "pg_views":
+        return pgViews(ctx, false);
+      case "pg_matviews":
+        return pgViews(ctx, true);
+      case "pg_indexes":
+        return pgIndexesView(ctx);
+      case "pg_settings":
+        return pgSettings(ctx);
+      case "pg_database":
+        return pgDatabase();
+      case "pg_roles":
+      case "pg_user":
+        return pgRoles();
+      case "pg_trigger":
+        return pgTrigger(ctx);
+      default:
+        return null;
+    }
+  }
+  switch (name) {
+    case "schemata":
+      return infoSchemata(ctx.state);
+    case "tables":
+      return infoTables(ctx);
+    case "columns":
+      return infoColumns(ctx);
+    case "views":
+      return infoViews(ctx);
+    case "sequences":
+      return infoSequences(ctx);
+    case "table_constraints":
+      return infoTableConstraints(ctx);
+    case "key_column_usage":
+      return infoKeyColumnUsage(ctx);
+    case "routines":
+      return infoRoutines(ctx);
+    default:
+      return null;
+  }
+}
+setCatalogBuilder(buildCatalogRelation);
+
+// src/executor/triggers-exec.ts
+var PlParser = class {
+  constructor(src) {
+    this.src = src;
+    this.tokens = tokenize(src);
+  }
+  src;
+  tokens;
+  pos = 0;
+  peek(offset = 0) {
+    return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
+  }
+  next() {
+    const t = this.peek();
+    if (t.type !== "eof") this.pos++;
+    return t;
+  }
+  atKw(kw) {
+    const t = this.peek();
+    return t.type === "ident" && t.value === kw;
+  }
+  expectKw(kw) {
+    if (!this.atKw(kw)) throw unsupported(`trigger body: expected "${kw.toUpperCase()}" near "${this.peek().value}"`);
+    this.pos++;
+  }
+  expectSemi() {
+    const t = this.next();
+    if (t.type !== "punct" || t.value !== ";") throw unsupported(`trigger body: expected ";" near "${t.value}"`);
+  }
+  parseBody() {
+    if (this.atKw("declare")) throw unsupported("trigger body: DECLARE section");
+    this.expectKw("begin");
+    const stmts = this.parseStmts();
+    this.expectKw("end");
+    if (this.peek().type === "punct" && this.peek().value === ";") this.pos++;
+    if (this.peek().type !== "eof") throw unsupported(`trigger body: trailing content near "${this.peek().value}"`);
+    return stmts;
+  }
+  parseStmts() {
+    const out = [];
+    while (!this.atKw("end") && !this.atKw("elsif") && !this.atKw("else") && this.peek().type !== "eof") {
+      out.push(this.parseStmt());
+    }
+    return out;
+  }
+  parseStmt() {
+    if (this.atKw("return")) {
+      this.pos++;
+      const t = this.next();
+      let what;
+      if (t.type === "ident" && (t.value === "new" || t.value === "old" || t.value === "null")) {
+        what = t.value;
+      } else {
+        throw unsupported(`trigger body: RETURN ${t.value}`);
+      }
+      this.expectSemi();
+      return { kind: "return", what };
+    }
+    if (this.atKw("if")) {
+      this.pos++;
+      const branches = [];
+      let elseBody = [];
+      const cond = this.parseExprUntilKw("then");
+      branches.push({ cond, body: this.parseStmts() });
+      while (this.atKw("elsif")) {
+        this.pos++;
+        const c = this.parseExprUntilKw("then");
+        branches.push({ cond: c, body: this.parseStmts() });
+      }
+      if (this.atKw("else")) {
+        this.pos++;
+        elseBody = this.parseStmts();
+      }
+      this.expectKw("end");
+      this.expectKw("if");
+      this.expectSemi();
+      return { kind: "if", branches, elseBody };
+    }
+    if (this.atKw("null")) {
+      this.pos++;
+      this.expectSemi();
+      return { kind: "null" };
+    }
+    if (this.atKw("raise")) {
+      this.pos++;
+      if (this.peek().type === "ident") this.pos++;
+      let message = "";
+      while (!(this.peek().type === "punct" && this.peek().value === ";") && this.peek().type !== "eof") {
+        const t = this.next();
+        if (t.type === "string" && message === "") message = t.value;
+      }
+      this.expectSemi();
+      return { kind: "raise", message: message || "raised exception" };
+    }
+    const target = [];
+    const first = this.next();
+    if (first.type !== "ident" && first.type !== "quoted_ident") {
+      throw unsupported(`trigger body statement near "${first.value}"`);
+    }
+    target.push(first.type === "ident" ? first.value : first.value);
+    while (this.peek().type === "punct" && this.peek().value === ".") {
+      this.pos++;
+      const f = this.next();
+      target.push(f.value);
+    }
+    const opTok = this.next();
+    if (!(opTok.type === "op" && (opTok.value === ":=" || opTok.value === "="))) {
+      throw unsupported(`trigger body: expected assignment near "${opTok.value}"`);
+    }
+    const expr = this.parseExprUntilSemi();
+    return { kind: "assign", target, expr };
+  }
+  /** Slice raw source from the current token to the terminator and parse as a SQL expression. */
+  parseExprUntilSemi() {
+    const start = this.peek().pos;
+    let depth = 0;
+    for (; ; ) {
+      const t = this.peek();
+      if (t.type === "eof") throw unsupported("trigger body: unterminated statement");
+      if (t.type === "punct" && t.value === "(") depth++;
+      if (t.type === "punct" && t.value === ")") depth--;
+      if (t.type === "punct" && t.value === ";" && depth === 0) {
+        const text = this.src.slice(start, t.pos);
+        this.pos++;
+        return parseSqlExpr(text);
+      }
+      this.pos++;
+    }
+  }
+  parseExprUntilKw(kw) {
+    const start = this.peek().pos;
+    let depth = 0;
+    for (; ; ) {
+      const t = this.peek();
+      if (t.type === "eof") throw unsupported(`trigger body: expected "${kw.toUpperCase()}"`);
+      if (t.type === "punct" && t.value === "(") depth++;
+      if (t.type === "punct" && t.value === ")") depth--;
+      if (t.type === "ident" && t.value === kw && depth === 0) {
+        const text = this.src.slice(start, t.pos);
+        this.pos++;
+        return parseSqlExpr(text);
+      }
+      this.pos++;
+    }
+  }
+};
+function parseSqlExpr(text) {
+  const stmts = parse(`SELECT ${text}`);
+  const sel = stmts[0];
+  const body = sel.body;
+  const target = body.targets?.[0];
+  if (!target) throw unsupported(`trigger body expression "${text}"`);
+  return target.expr;
+}
+var bodyCache = /* @__PURE__ */ new Map();
+function compiledBody(fn) {
+  const raw = fn.rawBody;
+  if (raw === null) throw unsupported(`trigger function ${fn.name} has no body`);
+  let cached = bodyCache.get(raw);
+  if (cached === void 0) {
+    cached = new PlParser(raw).parseBody();
+    bodyCache.set(raw, cached);
+  }
+  return cached;
+}
+var ReturnSignal = class {
+  constructor(row) {
+    this.row = row;
+  }
+  row;
+};
+function runTriggerBody(env, table, stmts, vars) {
+  const scope = () => triggerScope(table, vars.newRow, vars.oldRow);
+  for (const stmt of stmts) {
+    switch (stmt.kind) {
+      case "assign": {
+        if (stmt.target.length !== 2 || stmt.target[0] !== "new") {
+          throw unsupported(`trigger body: assignment to "${stmt.target.join(".")}"`);
+        }
+        if (vars.newRow === null) {
+          throw pgError("object_not_in_prerequisite_state", `record "new" is not assigned yet`, "55000");
+        }
+        const colName = stmt.target[1];
+        const idx = table.columns.findIndex((c) => c.name === colName);
+        if (idx === -1) {
+          throw pgError("undefined_column", `record "new" has no field "${colName}"`, "42703");
+        }
+        const v = evalScalar(env, scope(), stmt.expr);
+        vars.newRow = vars.newRow.slice();
+        vars.newRow[idx] = v.v === null ? null : castTo(env.ctx, v, table.columns[idx].type.id, { assignment: true }).v;
+        break;
+      }
+      case "return":
+        throw new ReturnSignal(stmt.what === "new" ? vars.newRow : stmt.what === "old" ? vars.oldRow : null);
+      case "if": {
+        let taken = false;
+        for (const b of stmt.branches) {
+          if (evalPredicate(env, scope(), b.cond)) {
+            runTriggerBody(env, table, b.body, vars);
+            taken = true;
+            break;
+          }
+        }
+        if (!taken) runTriggerBody(env, table, stmt.elseBody, vars);
+        break;
+      }
+      case "null":
+        break;
+      case "raise":
+        throw pgError("raise_exception", stmt.message, "P0001");
+    }
+  }
+}
+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)) {
+    return newRow;
+  }
+  const fns = state.schemas.get(trigger.funcSchema)?.functions.get(trigger.funcName);
+  const fn = fns?.[0];
+  if (!fn) {
+    throw pgError("undefined_function", `function ${trigger.funcSchema}.${trigger.funcName}() does not exist`, "42883");
+  }
+  const stmts = compiledBody(fn);
+  const vars = { newRow: newRow ? newRow.slice() : null, oldRow };
+  try {
+    runTriggerBody(env, table, stmts, vars);
+  } catch (e) {
+    if (e instanceof ReturnSignal) return e.row;
+    throw e;
+  }
+  throw pgError("invalid_function_definition", `control reached end of trigger procedure without RETURN`, "2F005");
+}
+setTriggerExecutor(executeTrigger);
+
 // src/executor/ddl.ts
 function targetSchema(env, parts) {
   const state = env.ctx.state;
@@ -18215,8 +19345,8 @@ function executeCreateTableAs(env, stmt) {
     if (stmt.ifNotExists) return commandResult("CREATE TABLE AS", 0);
     throw pgError("duplicate_table", `relation "${name}" already exists`, "42P07");
   }
-  const rel = executeSelectStmt(env, stmt.query);
-  const columns = rel.columns.map((c, i) => ({
+  const rel2 = executeSelectStmt(env, stmt.query);
+  const columns = rel2.columns.map((c, i) => ({
     name: stmt.columns?.[i] ?? c.name,
     type: { id: c.type === UNKNOWN ? "text" : c.type, mod: null },
     notNull: false,
@@ -18228,7 +19358,7 @@ function executeCreateTableAs(env, stmt) {
   }));
   const table = new TableData(schema.name, name, columns, state.nextOid(), stmt.temp);
   if (stmt.withData) {
-    table.rows = rel.rows.map((r) => r.slice());
+    table.rows = rel2.rows.map((r) => r.slice());
   }
   schema.tables.set(name, table);
   const count = stmt.withData ? table.rows.length : 0;
@@ -18299,12 +19429,12 @@ function executeCreateView(env, stmt) {
   let matRows = null;
   let matColumns = null;
   if (stmt.materialized) {
-    const rel = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, stmt.query);
-    matColumns = rel.columns.map((c, i) => ({
+    const rel2 = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, stmt.query);
+    matColumns = rel2.columns.map((c, i) => ({
       name: stmt.columns?.[i] ?? c.name,
       type: c.type === UNKNOWN ? "text" : c.type
     }));
-    matRows = stmt.withData ? rel.rows : null;
+    matRows = stmt.withData ? rel2.rows : null;
   }
   schema.views.set(name, {
     name,
@@ -18324,12 +19454,12 @@ function executeRefreshMatView(env, stmt) {
   if (!view?.materialized) {
     throw pgError("undefined_table", `materialized view "${stmt.name.join(".")}" does not exist`, "42P01");
   }
-  const rel = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, view.query);
-  view.matColumns = rel.columns.map((c, i) => ({
+  const rel2 = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, view.query);
+  view.matColumns = rel2.columns.map((c, i) => ({
     name: view.columns?.[i] ?? c.name,
     type: c.type === UNKNOWN ? "text" : c.type
   }));
-  view.matRows = stmt.withData ? rel.rows : null;
+  view.matRows = stmt.withData ? rel2.rows : null;
   return commandResult("REFRESH MATERIALIZED VIEW", 0);
 }
 function executeCreateSchema(env, stmt) {
@@ -19494,8 +20624,8 @@ var Database = class {
    */
   snapshot() {
     this.assertOpen();
-    const { encodeDatabaseState } = requireCodec();
-    return encodeDatabaseState(this.state, {
+    const { encodeDatabaseState: encodeDatabaseState2 } = requireCodec();
+    return encodeDatabaseState2(this.state, {
       prngState: this.prng.getState(),
       nowMs: this.now().getTime()
     });
@@ -19506,8 +20636,8 @@ var Database = class {
     if (this.transactions.inTransaction) {
       throw pgError("transaction_state", "cannot restore during a transaction", "25P01");
     }
-    const { decodeDatabaseState } = requireCodec();
-    const decoded = decodeDatabaseState(snapshot, this.prng, () => this.now());
+    const { decodeDatabaseState: decodeDatabaseState2 } = requireCodec();
+    const decoded = decodeDatabaseState2(snapshot, this.prng, () => this.now());
     this.state.restoreFrom(decoded.state);
     if (decoded.runtime) {
       this.prng.setState(decoded.runtime.prngState);
@@ -19567,6 +20697,9 @@ var Database = class {
   }
 };
 var codec = null;
+function registerCodec(m) {
+  codec = m;
+}
 function requireCodec() {
   if (!codec) {
     throw new PostgresError("unsupported", "snapshot codec not loaded");
@@ -19583,6 +20716,483 @@ if (typeof disposeKey === "symbol") {
     configurable: true
   });
 }
+
+// src/serialization/codec.ts
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder();
+var utf8Encode = (s) => TEXT_ENCODER.encode(s);
+var utf8Decode = (b) => TEXT_DECODER.decode(b);
+var MAGIC = utf8Encode("PGMM");
+var VERSION = 1;
+var Writer = class {
+  buf = new Uint8Array(1024);
+  len = 0;
+  ensure(needed) {
+    if (this.len + needed <= this.buf.length) return;
+    let cap = this.buf.length;
+    while (cap < this.len + needed) cap *= 2;
+    const next = new Uint8Array(cap);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+  }
+  u8(value) {
+    this.ensure(1);
+    this.buf[this.len++] = value & 255;
+  }
+  u32(value) {
+    this.ensure(4);
+    this.buf[this.len++] = value & 255;
+    this.buf[this.len++] = value >>> 8 & 255;
+    this.buf[this.len++] = value >>> 16 & 255;
+    this.buf[this.len++] = value >>> 24 & 255;
+  }
+  i32(value) {
+    this.u32(value | 0);
+  }
+  u64(value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigUint64(0, BigInt.asUintN(64, value), true);
+    this.raw(bytes);
+  }
+  i64(value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigInt64(0, value, true);
+    this.raw(bytes);
+  }
+  f64(value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    this.raw(bytes);
+  }
+  raw(value) {
+    this.ensure(value.length);
+    this.buf.set(value, this.len);
+    this.len += value.length;
+  }
+  text(value) {
+    const bytes = utf8Encode(value);
+    this.u32(bytes.length);
+    this.raw(bytes);
+  }
+  json(value) {
+    this.text(JSON.stringify(value, jsonReplacer) ?? "null");
+  }
+  datum(value) {
+    if (value === null) {
+      this.u8(0);
+      return;
+    }
+    if (typeof value === "boolean") {
+      this.u8(1);
+      this.u8(value ? 1 : 0);
+      return;
+    }
+    if (typeof value === "number") {
+      this.u8(2);
+      this.f64(value);
+      return;
+    }
+    if (typeof value === "bigint") {
+      this.u8(3);
+      this.i64(value);
+      return;
+    }
+    if (typeof value === "string") {
+      this.u8(4);
+      this.text(value);
+      return;
+    }
+    if (value instanceof Uint8Array) {
+      this.u8(5);
+      this.u32(value.length);
+      this.raw(value);
+      return;
+    }
+    switch (value.kind) {
+      case "numeric": {
+        this.u8(6);
+        this.text(value.coef.toString());
+        this.u32(value.dscale);
+        this.u8(value.special === null ? 0 : value.special === "nan" ? 1 : value.special === "inf" ? 2 : 3);
+        return;
+      }
+      case "interval": {
+        this.u8(7);
+        this.i32(value.months);
+        this.i32(value.days);
+        this.i64(value.micros);
+        return;
+      }
+      case "pgarray": {
+        this.u8(8);
+        this.text(value.elem);
+        this.u32(value.dims.length);
+        for (const d of value.dims) this.i32(d);
+        for (const l of value.lbs) this.i32(l);
+        this.u32(value.items.length);
+        for (const item of value.items) this.datum(item);
+        return;
+      }
+      case "pgrecord": {
+        this.u8(9);
+        this.json(value.types);
+        this.json(value.names ?? null);
+        this.u32(value.values.length);
+        for (const item of value.values) this.datum(item);
+        return;
+      }
+      case "jsonb": {
+        this.u8(10);
+        this.text(jsonbText(value.value));
+        return;
+      }
+      default: {
+        const tz = value;
+        if (typeof tz.micros === "bigint" && typeof tz.offsetSec === "number") {
+          this.u8(11);
+          this.i64(tz.micros);
+          this.i32(tz.offsetSec);
+          return;
+        }
+        throw snapshotError();
+      }
+    }
+  }
+  finish() {
+    if (this.len === this.buf.length) return this.buf;
+    return this.buf.slice(0, this.len);
+  }
+};
+var Reader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+  }
+  bytes;
+  offset = 0;
+  u8() {
+    if (this.offset >= this.bytes.length) this.fail();
+    return this.bytes[this.offset++];
+  }
+  u32() {
+    if (this.offset + 4 > this.bytes.length) this.fail();
+    const value = new DataView(this.bytes.buffer, this.bytes.byteOffset + this.offset, 4).getUint32(0, true);
+    this.offset += 4;
+    return value;
+  }
+  i32() {
+    return this.u32() | 0;
+  }
+  u64() {
+    const bytes = this.raw(8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getBigUint64(0, true);
+  }
+  i64() {
+    const bytes = this.raw(8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getBigInt64(0, true);
+  }
+  f64() {
+    const bytes = this.raw(8);
+    return new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, true);
+  }
+  raw(length) {
+    if (length < 0 || this.offset + length > this.bytes.length) this.fail();
+    const value = this.bytes.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return value;
+  }
+  text() {
+    return utf8Decode(this.raw(this.u32()));
+  }
+  json() {
+    try {
+      return JSON.parse(this.text(), jsonReviver);
+    } catch {
+      throw snapshotError();
+    }
+  }
+  datum() {
+    const tag = this.u8();
+    switch (tag) {
+      case 0:
+        return null;
+      case 1:
+        return this.u8() !== 0;
+      case 2:
+        return this.f64();
+      case 3:
+        return this.i64();
+      case 4:
+        return this.text();
+      case 5:
+        return this.raw(this.u32());
+      case 6: {
+        const coef = BigInt(this.text());
+        const dscale = this.u32();
+        const specialTag = this.u8();
+        const special = specialTag === 0 ? null : specialTag === 1 ? "nan" : specialTag === 2 ? "inf" : "-inf";
+        return { kind: "numeric", coef, dscale, special };
+      }
+      case 7: {
+        const months = this.i32();
+        const days = this.i32();
+        const micros = this.i64();
+        return { kind: "interval", months, days, micros };
+      }
+      case 8: {
+        const elem = this.text();
+        const ndims = this.u32();
+        const dims = [];
+        for (let i = 0; i < ndims; i++) dims.push(this.i32());
+        const lbs = [];
+        for (let i = 0; i < ndims; i++) lbs.push(this.i32());
+        const count = this.u32();
+        const items = [];
+        for (let i = 0; i < count; i++) items.push(this.datum());
+        return { kind: "pgarray", elem, dims, lbs, items };
+      }
+      case 9: {
+        const types = this.json();
+        const names = this.json();
+        const count = this.u32();
+        const values = [];
+        for (let i = 0; i < count; i++) values.push(this.datum());
+        const rec = names ? { kind: "pgrecord", types, values, names } : { kind: "pgrecord", types, values };
+        return rec;
+      }
+      case 10:
+        return { kind: "jsonb", value: parseJsonText(this.text()) };
+      case 11: {
+        const micros = this.i64();
+        const offsetSec = this.i32();
+        return { micros, offsetSec };
+      }
+      default:
+        this.fail();
+    }
+  }
+  remaining() {
+    return this.bytes.length - this.offset;
+  }
+  done() {
+    return this.offset === this.bytes.length;
+  }
+  fail() {
+    throw snapshotError();
+  }
+};
+function encodeDatabaseState(state, runtime) {
+  const w = new Writer();
+  w.raw(MAGIC);
+  w.u32(VERSION);
+  w.u32(state.oidCounter);
+  w.u32(state.changes);
+  const settings = [...state.settings.entries()].sort((a, b) => compareNames(a[0], b[0]));
+  w.u32(settings.length);
+  for (const [k, v] of settings) {
+    w.text(k);
+    w.text(v);
+  }
+  const schemas = [...state.schemas.values()].sort((a, b) => compareNames(a.name, b.name));
+  w.u32(schemas.length);
+  for (const schema of schemas) {
+    w.text(schema.name);
+    w.u32(schema.oid);
+    const tables = sortedValues(schema.tables);
+    w.u32(tables.length);
+    for (const t of tables) {
+      w.json({
+        name: t.name,
+        schema: t.schema,
+        columns: t.columns,
+        constraints: t.constraints,
+        triggers: t.triggers,
+        temp: t.temp,
+        oid: t.oid
+      });
+      w.u32(t.rows.length);
+      for (const row of t.rows) {
+        w.u32(row.length);
+        for (const d of row) w.datum(d);
+      }
+    }
+    const views = sortedValues(schema.views);
+    w.u32(views.length);
+    for (const v of views) {
+      w.json({
+        name: v.name,
+        schema: v.schema,
+        query: v.query,
+        columns: v.columns,
+        materialized: v.materialized,
+        matColumns: v.matColumns,
+        temp: v.temp,
+        oid: v.oid
+      });
+      if (v.matRows === null) {
+        w.u8(0);
+      } else {
+        w.u8(1);
+        w.u32(v.matRows.length);
+        for (const row of v.matRows) {
+          w.u32(row.length);
+          for (const d of row) w.datum(d);
+        }
+      }
+    }
+    const sequences = sortedValues(schema.sequences);
+    w.u32(sequences.length);
+    for (const s of sequences) w.json(s);
+    const enums = sortedValues(schema.enums);
+    w.u32(enums.length);
+    for (const e of enums) w.json(e);
+    const domains = sortedValues(schema.domains);
+    w.u32(domains.length);
+    for (const d of domains) w.json(d);
+    const functionKeys = [...schema.functions.keys()].sort(compareNames);
+    w.u32(functionKeys.length);
+    for (const key of functionKeys) {
+      w.text(key);
+      const overloads = schema.functions.get(key);
+      w.u32(overloads.length);
+      for (const f of overloads) w.json(f);
+    }
+    const indexes = sortedValues(schema.indexes);
+    w.u32(indexes.length);
+    for (const idx of indexes) w.json(idx);
+  }
+  if (state.lastSequence === null) {
+    w.u8(0);
+  } else {
+    w.u8(1);
+    w.text(state.lastSequence.schema);
+    w.text(state.lastSequence.name);
+  }
+  w.u64(runtime.prngState);
+  w.i64(BigInt(Math.trunc(runtime.nowMs)));
+  return w.finish();
+}
+function decodeDatabaseState(snapshot, prng, clock) {
+  try {
+    return decodeInner(snapshot, prng, clock);
+  } catch (error) {
+    if (error instanceof PostgresError) throw error;
+    throw snapshotError();
+  }
+}
+function decodeInner(snapshot, prng, clock) {
+  const r = new Reader(snapshot);
+  const magic = r.raw(4);
+  if (!magic.every((byte, index) => byte === MAGIC[index])) {
+    throw new PostgresError("snapshot_format", "invalid postgres-mem snapshot magic", "XX000");
+  }
+  const version = r.u32();
+  if (version !== VERSION) {
+    throw new PostgresError("snapshot_version", `unsupported postgres-mem snapshot version: ${version}`, "XX000");
+  }
+  const state = new DatabaseState(prng, clock);
+  state.oidCounter = r.u32();
+  state.changes = r.u32();
+  state.settings = /* @__PURE__ */ new Map();
+  const settingCount = r.u32();
+  for (let i = 0; i < settingCount; i++) {
+    const k = r.text();
+    state.settings.set(k, r.text());
+  }
+  state.schemas = /* @__PURE__ */ new Map();
+  const schemaCount = r.u32();
+  for (let si = 0; si < schemaCount; si++) {
+    const schema = new SchemaData(r.text(), r.u32());
+    const tableCount = r.u32();
+    for (let i = 0; i < tableCount; i++) {
+      const meta = r.json();
+      const table = new TableData(meta.schema, meta.name, meta.columns, meta.oid, meta.temp);
+      table.constraints = meta.constraints;
+      table.triggers = meta.triggers;
+      const rowCount = r.u32();
+      for (let ri = 0; ri < rowCount; ri++) {
+        const width = r.u32();
+        if (width !== meta.columns.length) throw snapshotError();
+        const row = [];
+        for (let ci = 0; ci < width; ci++) row.push(r.datum());
+        table.rows.push(row);
+      }
+      schema.tables.set(table.name, table);
+    }
+    const viewCount = r.u32();
+    for (let i = 0; i < viewCount; i++) {
+      const meta = r.json();
+      let matRows = null;
+      if (r.u8() === 1) {
+        matRows = [];
+        const rowCount = r.u32();
+        for (let ri = 0; ri < rowCount; ri++) {
+          const width = r.u32();
+          const row = [];
+          for (let ci = 0; ci < width; ci++) row.push(r.datum());
+          matRows.push(row);
+        }
+      }
+      const view = { ...meta, matRows };
+      schema.views.set(view.name, view);
+    }
+    const seqCount = r.u32();
+    for (let i = 0; i < seqCount; i++) {
+      const seq = r.json();
+      schema.sequences.set(seq.name, seq);
+    }
+    const enumCount = r.u32();
+    for (let i = 0; i < enumCount; i++) {
+      const e = r.json();
+      schema.enums.set(e.name, e);
+    }
+    const domainCount = r.u32();
+    for (let i = 0; i < domainCount; i++) {
+      const d = r.json();
+      schema.domains.set(d.name, d);
+    }
+    const fnCount = r.u32();
+    for (let i = 0; i < fnCount; i++) {
+      const key = r.text();
+      const overloadCount = r.u32();
+      const overloads = [];
+      for (let oi = 0; oi < overloadCount; oi++) overloads.push(r.json());
+      schema.functions.set(key, overloads);
+    }
+    const indexCount = r.u32();
+    for (let i = 0; i < indexCount; i++) {
+      const idx = r.json();
+      schema.indexes.set(idx.name, idx);
+    }
+    state.schemas.set(schema.name, schema);
+  }
+  state.lastSequence = r.u8() === 1 ? { schema: r.text(), name: r.text() } : null;
+  if (r.remaining() < 16) throw snapshotError();
+  const runtime = { prngState: r.u64(), nowMs: Number(r.i64()) };
+  if (!r.done()) throw new PostgresError("snapshot_format", "snapshot has trailing data", "XX000");
+  return { state, runtime };
+}
+function snapshotError() {
+  return new PostgresError("snapshot_format", "invalid or truncated postgres-mem snapshot", "XX000");
+}
+function compareNames(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function sortedValues(map) {
+  return [...map.values()].sort((a, b) => compareNames(a.name, b.name));
+}
+function jsonReplacer(_key, value) {
+  if (typeof value === "bigint") return { $pgmm: "bigint", value: value.toString() };
+  if (value instanceof Uint8Array) return { $pgmm: "bytes", value: Array.from(value) };
+  return value;
+}
+function jsonReviver(_key, value) {
+  if (!value || typeof value !== "object" || !("$pgmm" in value)) return value;
+  const tagged = value;
+  if (tagged.$pgmm === "bigint") return BigInt(tagged.value);
+  if (tagged.$pgmm === "bytes") return Uint8Array.from(tagged.value);
+  return value;
+}
+registerCodec({ encodeDatabaseState, decodeDatabaseState });
 export {
   Database,
   PostgresError,