@crvouga/mockingbird-service-postgres 3.6.0 → 3.8.0

package/dist/index.js

@@ -2800,6 +2800,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 = [];
@@ -2835,8 +2841,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 "-";
@@ -2909,6 +2915,7 @@ var TYPE_ALIASES = {
   regtype: "regtype",
   regproc: "regproc",
   regnamespace: "regnamespace",
+  xid: "xid",
   oid: "oid",
   void: "void",
   record: "record",
@@ -2985,6 +2992,7 @@ var TYPE_OIDS = {
   regproc: 24,
   text: 25,
   oid: 26,
+  xid: 28,
   json: 114,
   float4: 700,
   float8: 701,
@@ -3303,6 +3311,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);
@@ -3313,6 +3322,7 @@ function datumText(t, v, ctx) {
     case "int2":
     case "int4":
     case "oid":
+    case "xid":
       return String(v);
     case "int8":
       return String(v);
@@ -3377,6 +3387,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;
@@ -3398,6 +3414,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"));
@@ -3554,6 +3571,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;
@@ -3596,6 +3615,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;
   }
@@ -3629,6 +3653,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 }));
@@ -3714,6 +3742,14 @@ 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 = [];
@@ -3927,6 +3963,8 @@ var DatabaseState = class _DatabaseState {
     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;
   }
@@ -3946,6 +3984,8 @@ var DatabaseState = class _DatabaseState {
     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;
   }
@@ -4021,6 +4061,8 @@ var DatabaseState = class _DatabaseState {
     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() {
@@ -4097,6 +4139,11 @@ function zoneOffsetForNaive(zone, naiveMicros) {
 // src/expressions/context.ts
 var EngineCtx = class {
   state;
+  writeXid = null;
+  rowVersionXid() {
+    if (this.state.inTransaction) return this.state.transactionXid ??= this.state.allocateXid();
+    return this.writeXid ??= this.state.allocateXid();
+  }
   /** transaction timestamp (now(), current_timestamp) — UTC micros since PG epoch */
   txNow;
   /** statement timestamp */
@@ -4111,6 +4158,23 @@ var EngineCtx = class {
   timezone() {
     return this.state.getSetting("timezone") ?? "UTC";
   }
+  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;
+  }
+  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(".");
+      }
+    }
+    return null;
+  }
   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");
@@ -4411,7 +4475,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")) {
@@ -5112,6 +5176,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);
@@ -5231,6 +5297,8 @@ function datumKey(t, v) {
     case "int2":
     case "int4":
     case "oid":
+    case "regclass":
+    case "xid":
     case "date":
       return `i${v}`;
     case "float4":
@@ -8136,7 +8204,7 @@ function databaseCatalogContext(state) {
 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");
   }
@@ -8360,14 +8428,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) => {
@@ -9885,7 +9955,7 @@ function evalTrgmWordSimilar(ctx, left, right) {
   const score = wordSimilarity(a.v, b.v);
   return tv("bool", score >= WORD_SIMILARITY_THRESHOLD);
 }
-function assertGinTrgmIndex(state, table, stmt) {
+function assertGinTrgmIndex(state, table, stmt, expressionType) {
   const trgmCols = stmt.columns.filter((col2) => isGinTrgmOpclass(col2.opclass));
   if (trgmCols.length === 0) return;
   if (trgmCols.length !== stmt.columns.length || stmt.columns.length !== 1) {
@@ -9905,11 +9975,7 @@ function assertGinTrgmIndex(state, table, stmt) {
   if (stmt.unique) {
     throw pgError("feature_not_supported", `access method "gin" does not support unique indexes`, "0A000");
   }
-  if (col.expr.type !== "colref" || col.expr.parts.length !== 1) {
-    throw unsupported("expression gin_trgm_ops");
-  }
-  const index = table.columnIndex(col.expr.parts[0]);
-  const typeId = table.columns[index].type.id;
+  const typeId = col.expr.type === "colref" && col.expr.parts.length === 1 ? table.columns[table.columnIndex(col.expr.parts[0])].type.id : expressionType(col.expr);
   if (!GIN_TRGM_TYPES.has(typeId)) {
     throw pgError(
       "datatype_mismatch",
@@ -13311,7 +13377,7 @@ var RowScope = class {
       let count2 = 0;
       for (let i = 0; i < this.columns.length; i++) {
         const c = this.columns[i];
-        if (c.name === name2 && !c.hidden) {
+        if (c.name === name2 && (!c.hidden || c.system)) {
           count2++;
           if (count2 > 1) {
             throw pgError("ambiguous_column", `column reference "${name2}" is ambiguous`);
@@ -13349,7 +13415,7 @@ var RowScope = class {
     const names = [];
     for (let i = 0; i < this.columns.length; i++) {
       const c = this.columns[i];
-      if (c.table === rangeVar) {
+      if (c.table === rangeVar && !c.system) {
         types.push(c.type);
         values.push(this.row[i] ?? null);
         names.push(c.name);
@@ -13547,6 +13613,17 @@ 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 expressionTypeOf(env, table, expr) {
+  const scope = makeEvalScope(
+    env,
+    tableScope(
+      table,
+      table.columns.map(() => null)
+    )
+  );
+  const v = evalExpr(env.ctx, scope, expr);
+  return v.t === "unknown" ? "text" : v.t;
+}
 function checkNotNull(env, table, row) {
   void env;
   for (let i = 0; i < table.columns.length; i++) {
@@ -13792,7 +13869,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 = [];
@@ -16282,6 +16359,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);
@@ -16339,8 +16417,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");
@@ -16420,7 +16513,8 @@ var Parser = class {
       body,
       sqlBody,
       volatility,
-      strict: strict2
+      strict: strict2,
+      settings
     };
   }
   parseCreateTrigger(orReplace, constraint) {
@@ -16452,7 +16546,6 @@ var Parser = class {
     } while (this.eatKw("or"));
     this.expectKw("on");
     const table = this.qualifiedName();
-    if (this.eatKw("referencing")) throw unsupported("trigger transition tables");
     let deferrable = false;
     let initiallyDeferred = false;
     if (this.eatKw("not")) this.expectKw("deferrable");
@@ -16465,6 +16558,23 @@ var Parser = class {
       this.errorAt(this.peek(), "only constraint triggers can be deferred");
     if (initiallyDeferred && !deferrable)
       this.errorAt(this.peek(), "constraint declared INITIALLY DEFERRED must be DEFERRABLE");
+    const transitions = [];
+    if (!constraint && this.eatKw("referencing")) {
+      do {
+        const isNew = this.eatKw("new");
+        if (!isNew) this.expectKw("old");
+        if (this.eatKw("row")) {
+          throw pgError(
+            "feature_not_supported",
+            "ROW variable naming in the REFERENCING clause is not supported",
+            "0A000"
+          );
+        }
+        this.expectKw("table");
+        this.eatKw("as");
+        transitions.push({ isNew, name: this.ident() });
+      } while (this.atKw("new") || this.atKw("old"));
+    }
     let forEachRow = false;
     if (this.eatKw("for")) {
       this.eatKw("each");
@@ -16502,7 +16612,8 @@ var Parser = class {
       forEachRow,
       when,
       funcName,
-      funcArgs
+      funcArgs,
+      ...transitions.length > 0 ? { transitions } : {}
     };
   }
   // --- ALTER --------------------------------------------------------------------
@@ -16529,8 +16640,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))) {
@@ -19106,7 +19217,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);
@@ -19136,6 +19260,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);
   }
@@ -19290,15 +19417,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
   }));
@@ -19319,8 +19448,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]) };
       }
@@ -19950,7 +20082,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;
       }
@@ -20534,7 +20666,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 });
           }
@@ -21027,6 +21159,29 @@ function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
   }
   return { row };
 }
+function transitionRelation(table, name, rows) {
+  return {
+    columns: table.columns.map((c) => ({ name: c.name, type: c.type.id, table: name })),
+    rows
+  };
+}
+function fireStatementTriggers(env, table, timing, event, transitions) {
+  const fired = table.triggers.filter((t) => !t.forEachRow && t.timing === timing && matches(t, event)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  for (const t of fired) {
+    if (!executor) throw unsupported(`trigger "${t.name}" execution`);
+    const ctes = /* @__PURE__ */ new Map();
+    if (t.oldTable !== void 0)
+      ctes.set(t.oldTable, transitionRelation(table, t.oldTable, transitions?.oldRows ?? []));
+    if (t.newTable !== void 0)
+      ctes.set(t.newTable, transitionRelation(table, t.newTable, transitions?.newRows ?? []));
+    const changes = env.ctx.state.changes;
+    try {
+      executor({ ctx: env.ctx, params: null, ctes, outer: null }, table, t, event, null, null);
+    } finally {
+      env.ctx.state.changes = changes;
+    }
+  }
+}
 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 };
@@ -21139,6 +21294,7 @@ var TransactionManager = class {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
+    this.state.transactionXid = null;
     this.state.localSettings.clear();
     this.state.pendingTriggers = [];
     this.state.constraintModes.clear();
@@ -21151,6 +21307,7 @@ var TransactionManager = class {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
+    this.state.transactionXid = null;
     this.state.localSettings.clear();
     this.state.pendingTriggers = [];
     this.state.constraintModes.clear();
@@ -21185,6 +21342,7 @@ var TransactionManager = class {
     this.base = null;
     this.savepoints = [];
     this.state.inTransaction = false;
+    this.state.transactionXid = null;
     this.freezeDepth = 0;
   }
 };
@@ -21388,6 +21546,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);
@@ -21406,7 +21565,13 @@ function executeInsert(env0, stmt) {
   const sourceRows = insertSourceRows(env, stmt, colIdxs);
   const insertedRows = [];
   let insertedCount = 0;
+  const addedRows = [];
+  const conflictOldRows = [];
+  const conflictNewRows = [];
+  const updatesOnConflict = stmt.onConflict !== null && stmt.onConflict.action !== "nothing";
   return withStatementRollback(env, () => {
+    fireStatementTriggers(env, table, "before", "insert");
+    if (updatesOnConflict) fireStatementTriggers(env, table, "before", "update");
     for (const srcRow of sourceRows) {
       const row = table.columns.map(() => null);
       const provided = /* @__PURE__ */ new Set();
@@ -21452,6 +21617,7 @@ function executeInsert(env0, stmt) {
         }
         if (conflictIdx !== null && conflictWhereOk) {
           if (stmt.onConflict.action === "nothing") continue;
+          const replaced = rows[conflictIdx];
           const did = applyOnConflictUpdate(
             env,
             table,
@@ -21464,6 +21630,8 @@ function executeInsert(env0, stmt) {
           if (did) {
             insertedCount++;
             insertedRows.push(rows[conflictIdx]);
+            conflictOldRows.push(replaced);
+            conflictNewRows.push(rows[conflictIdx]);
             fireRowTriggers(env, table, "after", "update", null, rows[conflictIdx]);
           }
           continue;
@@ -21473,12 +21641,18 @@ 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++;
       insertedRows.push(newRow);
+      addedRows.push(newRow);
       fireRowTriggers(env, table, "after", "insert", null, newRow);
     }
+    fireStatementTriggers(env, table, "after", "insert", { oldRows: [], newRows: addedRows });
+    if (updatesOnConflict) {
+      fireStatementTriggers(env, table, "after", "update", { oldRows: conflictOldRows, newRows: conflictNewRows });
+    }
     env.ctx.state.changes = insertedCount;
     if (stmt.returning) {
       const res = evalReturning(env, table, label, stmt.returning, insertedRows, "INSERT");
@@ -21559,10 +21733,12 @@ function executeUpdate(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "update");
   const label = stmt.alias ?? table.name;
+  fireStatementTriggers(env, table, "before", "update");
   const fromSource = stmt.from.length > 0 ? buildFrom(env, stmt.from) : null;
   const rows = table.mutableRows();
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
   const updatedRows = [];
+  const replacedRows = [];
   let updateCount = 0;
   for (let ri = 0; ri < rows.length; ri++) {
     const oldRow = rows[ri];
@@ -21590,6 +21766,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);
@@ -21604,8 +21781,10 @@ function executeUpdate(env0, stmt) {
     handleReferencedUpdate(env, table, [oldRow], [finalRow]);
     updateCount++;
     updatedRows.push(finalRow);
+    replacedRows.push(oldRow);
     fireRowTriggers(env, table, "after", "update", oldRow, finalRow);
   }
+  fireStatementTriggers(env, table, "after", "update", { oldRows: replacedRows, newRows: updatedRows });
   env.ctx.state.changes = updateCount;
   if (stmt.returning) {
     const res = evalReturning(env, table, label, stmt.returning, updatedRows, "UPDATE");
@@ -21617,6 +21796,7 @@ function executeDelete(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "delete from");
   const label = stmt.alias ?? table.name;
+  fireStatementTriggers(env, table, "before", "delete");
   const rows = table.mutableRows();
   const usingSource = stmt.using.length > 0 ? buildFrom(env, stmt.using) : null;
   const targetCols = table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label }));
@@ -21654,6 +21834,7 @@ function executeDelete(env0, stmt) {
     fireRowTriggers(env, table, "after", "delete", row, null);
   }
   if (deletedRows.length > 0) rebuildTableIndexes(env, table);
+  fireStatementTriggers(env, table, "after", "delete", { oldRows: deletedRows, newRows: [] });
   env.ctx.state.changes = deletedRows.length;
   if (stmt.returning) {
     const res = evalReturning(env, table, label, stmt.returning, deletedRows, "DELETE");
@@ -21709,6 +21890,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);
@@ -21722,6 +21904,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);
@@ -21759,6 +21942,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);
           }
@@ -21768,6 +21952,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);
           }
@@ -21780,6 +21965,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);
           }
@@ -23791,7 +23977,7 @@ function pgTrigger(ctx) {
   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]);
+      rows.push([oid++, tr.name, t.oid, !tr.forEachRow, tr.oldTable ?? null, tr.newTable ?? null]);
     }
   }
   return rel2(
@@ -23799,7 +23985,9 @@ function pgTrigger(ctx) {
       ["oid", "oid"],
       ["tgname", "name"],
       ["tgrelid", "oid"],
-      ["tgisinternal", "bool"]
+      ["tgisinternal", "bool"],
+      ["tgoldtable", "name"],
+      ["tgnewtable", "name"]
     ],
     rows,
     "pg_trigger"
@@ -24824,13 +25012,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);
@@ -24888,7 +25126,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) {
@@ -25141,7 +25379,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;
@@ -25169,7 +25411,7 @@ function executeCreateIndex(env, stmt) {
       }
     }
   }
-  assertGinTrgmIndex(state, table, stmt);
+  assertGinTrgmIndex(state, table, stmt, (expr) => expressionTypeOf(env, table, expr));
   const method = stmt.using ?? "btree";
   if (!ACCESS_METHODS.has(method) || method === "heap") {
     throw pgError("undefined_object", `access method "${method}" does not exist`, "42704");
@@ -25410,6 +25652,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()
   };
@@ -25418,6 +25666,50 @@ function executeCreateFunction(env, stmt) {
   schema.functions.set(name, existing);
   return commandResult("CREATE FUNCTION", 0);
 }
+function validateTransitionTables(stmt) {
+  const transitions = stmt.transitions ?? [];
+  if (transitions.length === 0) return {};
+  const invalid = (message) => pgError("invalid_table_definition", message, "42P17");
+  const unsupportedClause = (message) => pgError("feature_not_supported", message, "0A000");
+  if (stmt.timing !== "after") throw invalid("transition table name can only be specified for an AFTER trigger");
+  if (stmt.events.some((e) => e.event === "truncate")) {
+    throw unsupportedClause("TRUNCATE triggers with transition tables are not supported");
+  }
+  if (stmt.events.some((e) => e.columns !== null)) {
+    throw unsupportedClause("transition tables cannot be specified for triggers with column lists");
+  }
+  if (stmt.events.length > 1) {
+    throw unsupportedClause("transition tables cannot be specified for triggers with more than one event");
+  }
+  const event = stmt.events[0].event;
+  let oldTable;
+  let newTable;
+  for (const transition of transitions) {
+    if (transition.isNew) {
+      if (event !== "insert" && event !== "update") {
+        throw invalid("NEW TABLE can only be specified for an INSERT or UPDATE trigger");
+      }
+      if (newTable !== void 0) throw invalid("NEW TABLE cannot be specified multiple times");
+      newTable = transition.name;
+    } else {
+      if (event !== "delete" && event !== "update") {
+        throw invalid("OLD TABLE can only be specified for a DELETE or UPDATE trigger");
+      }
+      if (oldTable !== void 0) throw invalid("OLD TABLE cannot be specified multiple times");
+      oldTable = transition.name;
+    }
+  }
+  if (oldTable !== void 0 && oldTable === newTable) {
+    throw invalid("OLD TABLE name and NEW TABLE name cannot be the same");
+  }
+  if (stmt.forEachRow) {
+    throw pgError("unsupported", "transition tables on FOR EACH ROW triggers are not supported", "0A000");
+  }
+  return {
+    ...oldTable !== void 0 ? { oldTable } : {},
+    ...newTable !== void 0 ? { newTable } : {}
+  };
+}
 function executeCreateTrigger(env, stmt) {
   if (stmt.constraint && (stmt.timing !== "after" || !stmt.forEachRow))
     throw pgError("syntax", "constraint triggers must be AFTER ROW triggers", "42601");
@@ -25427,6 +25719,7 @@ function executeCreateTrigger(env, stmt) {
     throw pgError("undefined_table", `relation "${stmt.table.join(".")}" does not exist`, "42P01");
   }
   const table = state.ensureWritableTable(found);
+  const transitionTables = validateTransitionTables(stmt);
   const fnSchema = stmt.funcName.length >= 2 ? stmt.funcName[stmt.funcName.length - 2] : null;
   const fnName = stmt.funcName[stmt.funcName.length - 1];
   const fns = state.findFunctions(stmt.funcName);
@@ -25445,6 +25738,7 @@ function executeCreateTrigger(env, stmt) {
     timing: stmt.timing,
     events: stmt.events,
     forEachRow: stmt.forEachRow,
+    ...transitionTables,
     when: stmt.when,
     funcSchema: fnSchema ?? fns[0].schema,
     funcName: fnName,
@@ -25594,6 +25888,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;
@@ -25695,6 +25990,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);
@@ -25731,6 +26031,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);
@@ -27320,6 +27625,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,
@@ -27417,8 +27723,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));
@@ -27862,6 +28174,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();
@@ -27955,6 +28269,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,
@@ -28032,10 +28347,188 @@ function forceBjvStrings(pool, value) {
   }
 }
 registerCodec({ encodeDatabaseState, decodeDatabaseState });
+
+// src/api/schema-report.ts
+var bounded = (value, fallback2, max) => {
+  if (value === void 0) return fallback2;
+  if (!Number.isSafeInteger(value) || value < 1 || value > max)
+    throw new RangeError(`limit must be an integer between 1 and ${max}`);
+  return value;
+};
+function analyzeSchema(sql, options = {}) {
+  const inputLimit = bounded(options.maxInputBytes, 1024 * 1024, 4 * 1024 * 1024);
+  const statementLimit = bounded(options.maxStatements, 1e3, 1e4);
+  const diagnosticLimit = bounded(options.maxDiagnostics, 100, 1e3);
+  const report = {
+    engine: "mockingbird-postgres",
+    version: true ? "3.8.0" : "source-tree",
+    statements: 0,
+    accepted: 0,
+    compatible: null,
+    truncated: false,
+    diagnostics: []
+  };
+  const add = (diagnostic) => {
+    if (report.diagnostics.length >= diagnosticLimit) {
+      report.truncated = true;
+      return false;
+    }
+    report.diagnostics.push({
+      ...diagnostic,
+      ...diagnostic.object ? { object: diagnostic.object.slice(0, 200) } : {}
+    });
+    if (diagnostic.category !== "unknown") report.compatible = false;
+    return true;
+  };
+  const location = (offset) => {
+    const prefix = sql.slice(0, offset);
+    return { offset, line: prefix.split("\n").length, column: offset - prefix.lastIndexOf("\n") };
+  };
+  if (sql.length > inputLimit || new TextEncoder().encode(sql).length > inputLimit) {
+    add({
+      statement: 0,
+      ...location(0),
+      sqlstate: null,
+      category: "limit",
+      message: `Input exceeds ${inputLimit} bytes`
+    });
+    report.truncated = true;
+    return report;
+  }
+  let tokens;
+  try {
+    tokens = tokenize(sql);
+  } catch (error) {
+    add({
+      statement: 1,
+      ...location(0),
+      sqlstate: isPostgresError(error) ? error.code : null,
+      category: "syntax",
+      message: error instanceof Error ? error.message.slice(0, 500) : "Cannot tokenize input"
+    });
+    return report;
+  }
+  const db = new Database();
+  const failed = /* @__PURE__ */ new Map();
+  let start = 0;
+  let tokenStart = 0;
+  let atomicDepth = 0;
+  const run = (end, tokenEnd) => {
+    const statementTokens = tokens.slice(tokenStart, tokenEnd);
+    tokenStart = tokenEnd + 1;
+    const offset = statementTokens[0]?.pos;
+    const statementSql = sql.slice(start, end);
+    start = end + 1;
+    if (offset === void 0) return;
+    if (report.statements >= statementLimit) {
+      report.truncated = true;
+      add({
+        statement: report.statements + 1,
+        ...location(offset),
+        sqlstate: null,
+        category: "limit",
+        message: `Statement limit ${statementLimit} reached`
+      });
+      return;
+    }
+    report.statements++;
+    let object;
+    const candidate = statementTokens.findIndex(
+      (token) => ["table", "view", "function", "sequence", "schema", "type", "index"].includes(token.value)
+    );
+    if (candidate >= 0) {
+      const name = statementTokens[candidate + 1];
+      if (name?.type === "ident" || name?.type === "quoted_ident") object = name.value;
+    }
+    try {
+      const ast = parse(statementSql);
+      const statement = ast[0];
+      if (statement && "name" in statement && Array.isArray(statement.name)) object = statement.name.join(".");
+      if (statement && !/^(create_|alter_|comment|grant|revoke|set|reset)/.test(statement.type)) {
+        add({
+          statement: report.statements,
+          ...location(offset),
+          object,
+          sqlstate: null,
+          category: "unknown",
+          message: "Only schema statements are analyzed; data, queries and dynamic commands are unknown"
+        });
+        return;
+      }
+      const references = statementTokens.flatMap((token, index) => {
+        if (!["from", "join", "references"].includes(token.value)) return [];
+        const parts = [];
+        for (let at = index + 1; at < statementTokens.length; at += 2) {
+          const part = statementTokens[at];
+          if (!part || part.type !== "ident" && part.type !== "quoted_ident") break;
+          parts.push(part.value);
+          if (statementTokens[at + 1]?.value !== ".") break;
+        }
+        return parts.length ? [parts.join(".")] : [];
+      });
+      const missing = [...failed].find(
+        ([name]) => references.some(
+          (reference) => reference === name || !reference.includes(".") && reference === name.split(".").at(-1) || !name.includes(".") && name === reference.split(".").at(-1)
+        )
+      );
+      if (missing) {
+        add({
+          statement: report.statements,
+          ...location(offset),
+          object,
+          sqlstate: "42P01",
+          category: "prerequisite",
+          message: `Prerequisite ${missing[0]} was not created`,
+          prerequisiteStatement: missing[1]
+        });
+        if (object) failed.set(object, report.statements);
+        return;
+      }
+      db.exec(statementSql);
+      report.accepted++;
+      add({
+        statement: report.statements,
+        ...location(offset),
+        object,
+        sqlstate: null,
+        category: "unknown",
+        message: "Accepted by the ephemeral engine; semantics, function bodies and dynamic SQL require oracle verification"
+      });
+    } catch (error) {
+      const code = isPostgresError(error) ? error.code : null;
+      const message = error instanceof Error ? error.message.slice(0, 500) : "Schema analysis failed";
+      const prerequisite = code?.startsWith("42") ? [...failed].find(([name]) => message.includes(`"${name}"`) || message.includes(`"${name.split(".").at(-1)}"`)) : void 0;
+      add({
+        statement: report.statements,
+        ...location(offset),
+        object,
+        sqlstate: code,
+        category: prerequisite ? "prerequisite" : code === "0A000" ? "unsupported" : code?.startsWith("426") ? "syntax" : "execution",
+        message,
+        ...prerequisite ? { prerequisiteStatement: prerequisite[1] } : {}
+      });
+      if (object) failed.set(object, report.statements);
+    }
+  };
+  try {
+    for (let index = 0; index < tokens.length; index++) {
+      const token = tokens[index];
+      if (token.value === "begin" && tokens[index + 1]?.value === "atomic") atomicDepth++;
+      if (token.value === "end" && atomicDepth > 0) atomicDepth--;
+      if (token.type === "punct" && token.value === ";" && atomicDepth === 0 || token.type === "eof")
+        run(token.pos, index);
+      if (report.truncated) break;
+    }
+  } finally {
+    db.close();
+  }
+  return report;
+}
 export {
   Database,
   PostgresError,
   Snapshot,
-  Statement
+  Statement,
+  analyzeSchema
 };
 //# sourceMappingURL=index.js.map