@crvouga/mockingbird-service-postgres 3.7.0 → 3.8.0

package/dist/storage/database-state.d.ts

@@ -90,6 +90,10 @@ export interface TriggerMeta {
     timing: "before" | "after" | "instead_of";
     events: CreateTriggerStmt["events"];
     forEachRow: boolean;
+    /** `REFERENCING OLD TABLE AS …` name; only on AFTER statement triggers for UPDATE or DELETE */
+    oldTable?: string;
+    /** `REFERENCING NEW TABLE AS …` name; only on AFTER statement triggers for INSERT or UPDATE */
+    newTable?: string;
     when: Expr | null;
     funcSchema: string;
     funcName: string;

package/dist/unstable.js

@@ -9693,7 +9693,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) {
@@ -9713,11 +9713,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",
@@ -13355,6 +13351,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++) {
@@ -16277,7 +16284,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");
@@ -16290,6 +16296,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");
@@ -16327,7 +16350,8 @@ var Parser = class {
       forEachRow,
       when,
       funcName,
-      funcArgs
+      funcArgs,
+      ...transitions.length > 0 ? { transitions } : {}
     };
   }
   // --- ALTER --------------------------------------------------------------------
@@ -20883,6 +20907,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 };
@@ -22425,7 +22472,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(
@@ -22433,7 +22480,9 @@ function pgTrigger(ctx) {
       ["oid", "oid"],
       ["tgname", "name"],
       ["tgrelid", "oid"],
-      ["tgisinternal", "bool"]
+      ["tgisinternal", "bool"],
+      ["tgoldtable", "name"],
+      ["tgnewtable", "name"]
     ],
     rows,
     "pg_trigger"
@@ -23857,7 +23906,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");
@@ -24112,6 +24161,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");
@@ -24121,6 +24214,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);
@@ -24139,6 +24233,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,
@@ -25093,7 +25188,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();
@@ -25139,6 +25240,7 @@ function executeInsert(env0, stmt) {
         }
         if (conflictIdx !== null && conflictWhereOk) {
           if (stmt.onConflict.action === "nothing") continue;
+          const replaced = rows[conflictIdx];
           const did = applyOnConflictUpdate(
             env,
             table,
@@ -25151,6 +25253,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;
@@ -25165,8 +25269,13 @@ function executeInsert(env0, stmt) {
       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");
@@ -25247,10 +25356,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];
@@ -25293,8 +25404,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");
@@ -25306,6 +25419,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 }));
@@ -25343,6 +25457,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");