@crvouga/mockingbird-service-postgres 2.3.0 → 3.0.1

package/dist/server.js

@@ -250,6 +250,12 @@ function pgError(category, message2, sqlState) {
 function unsupported(what) {
   return new PostgresError("unsupported", `${what} is not supported`);
 }
+function isPostgresError(err) {
+  if (err instanceof PostgresError) return true;
+  if (!(err instanceof Error) || err.name !== "PostgresError") return false;
+  const sqlState = err.sqlState;
+  return typeof sqlState === "string" && /^[0-9A-Z]{5}$/.test(sqlState);
+}
 
 // src/runtime/prng.ts
 var Prng = class _Prng {
@@ -370,6 +376,9 @@ var PG_CATALOG_RELATIONS = /* @__PURE__ */ new Set([
   "pg_enum",
   "pg_constraint",
   "pg_index",
+  "pg_description",
+  "pg_stat_user_tables",
+  "pg_stat_user_indexes",
   "pg_sequence",
   "pg_sequences",
   "pg_tables",
@@ -2647,6 +2656,7 @@ var TYPE_ALIASES = {
   regclass: "regclass",
   regtype: "regtype",
   regproc: "regproc",
+  regnamespace: "regnamespace",
   oid: "oid",
   void: "void",
   record: "record",
@@ -2740,6 +2750,7 @@ var TYPE_OIDS = {
   numeric: 1700,
   regclass: 2205,
   regtype: 2206,
+  regnamespace: 4089,
   record: 2249,
   uuid: 2950,
   jsonb: 3802,
@@ -3000,6 +3011,7 @@ function arrayElemNeedsQuote(s) {
 function quoteArrayElem(s) {
   return `"${s.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
 }
+var UTC_OUTPUT = { zoneOffsetAt: () => 0 };
 function arrayText(arr, ctx) {
   if (arr.dims.length === 0) return "{}";
   const needsLb = arr.lbs.some((l) => l !== 1);
@@ -3040,6 +3052,7 @@ function recordText(rec, ctx) {
   return `(${parts.join(",")})`;
 }
 function datumText(t, v, ctx) {
+  if (t === "regnamespace") return ctx.namespaceName?.(v) ?? String(v);
   if (v === null) throw pgError("internal", "datumText called with null");
   if (isArrayType(t)) return arrayText(v, ctx);
   if (isEnumType(t)) return v;
@@ -3113,6 +3126,11 @@ function datumText(t, v, ctx) {
 }
 var UTC_INPUT = { zoneOffsetForNaive: () => 0 };
 function datumFromText(t, text, ctx) {
+  if (t === "regnamespace") {
+    if (/^\s*\d+\s*$/.test(text)) return datumFromText("oid", text, ctx);
+    if (!ctx.namespaceOid) throw unsupported("regnamespace input without a catalog");
+    return ctx.namespaceOid(text);
+  }
   if (isArrayType(t)) return parseArrayText(t, text, ctx);
   if (isEnumType(t)) {
     if (ctx.enumHasLabel && !ctx.enumHasLabel(t, text)) {
@@ -3969,7 +3987,11 @@ function castTo(env, value, target, opts = {}) {
     );
     return tv(target, makeArray(toElem, items, arr.dims.slice(), arr.lbs.slice()));
   }
-  if ((from === "int4" || from === "int8" || from === "int2") && (target === "oid" || target === "regclass" || target === "regtype" || target === "regproc")) {
+  if (from === "oid" && target === "regnamespace") return tv(target, v);
+  if (from === "regnamespace" && (target === "oid" || target === "int4" || target === "int8")) {
+    return tv(target, target === "int8" ? BigInt(v) : v);
+  }
+  if ((from === "int4" || from === "int8" || from === "int2") && (target === "oid" || target === "regclass" || target === "regtype" || target === "regproc" || target === "regnamespace")) {
     return tv(target, Number(v));
   }
   if (from === "oid" && (target === "int4" || target === "int8")) {
@@ -4917,6 +4939,7 @@ function datumCompare(t, a, b, ctx = DEFAULT_COMPARE_CTX) {
     case "int2":
     case "int4":
     case "oid":
+    case "regnamespace":
     case "date":
       return expectNumber(a, t) - expectNumber(b, t);
     case "float4":
@@ -7072,10 +7095,99 @@ function exactDegTan(x) {
 }
 
 // src/sql/deparse.ts
+function deparseSelect(stmt) {
+  return deparseBody(stmt.body);
+}
+function deparseBody(body) {
+  switch (body.type) {
+    case "select_core":
+      return deparseSelectCore(body);
+    case "setop":
+      return `${deparseBody(body.left)} ${body.op.toUpperCase()}${body.all ? " ALL" : ""} ${deparseBody(body.right)}`;
+    case "values":
+      return `VALUES ${body.rows.map((r) => `(${r.map(deparseExpr).join(", ")})`).join(", ")}`;
+  }
+}
+function deparseSelectCore(body) {
+  const targets = body.targets.length === 0 ? "*" : body.targets.map((t) => {
+    const expr = deparseExpr(t.expr);
+    return t.alias ? `${expr} AS ${quoteIdent(t.alias)}` : expr;
+  }).join(", ");
+  let sql = `SELECT ${targets}`;
+  if (body.from.length > 0) {
+    sql += ` FROM ${body.from.map(deparseFrom).join(", ")}`;
+  }
+  if (body.where) sql += ` WHERE ${deparseExpr(body.where)}`;
+  if (body.groupBy && body.groupBy.length > 0) {
+    sql += ` GROUP BY ${body.groupBy.map((g) => g.kind === "expr" ? deparseExpr(g.expr) : "?").join(", ")}`;
+  }
+  if (body.having) sql += ` HAVING ${deparseExpr(body.having)}`;
+  return sql;
+}
+function deparseFrom(item) {
+  if (item.type === "from_table") {
+    const name = item.name.join(".");
+    return item.alias ? `${name} ${quoteIdent(item.alias)}` : name;
+  }
+  return "(subquery)";
+}
 function quoteIdent(name) {
   if (/^[a-z_][a-z0-9_$]*$/.test(name)) return name;
   return `"${name.replaceAll('"', '""')}"`;
 }
+function deparseExpr(e) {
+  switch (e.type) {
+    case "null_lit":
+      return "NULL";
+    case "string_lit":
+      return `'${e.value.replaceAll("'", "''")}'`;
+    case "number_lit":
+      return e.raw;
+    case "bool_lit":
+      return e.value ? "true" : "false";
+    case "colref":
+      return e.parts.join(".");
+    case "star":
+      return e.table ? `${e.table.join(".")}.*` : "*";
+    case "binop":
+      return `(${deparseExpr(e.left)} ${e.op} ${deparseExpr(e.right)})`;
+    case "unop":
+      return `${e.op}${deparseExpr(e.operand)}`;
+    case "cast":
+      return `CAST(${deparseExpr(e.expr)} AS ${e.target.parts.join(".")})`;
+    case "func":
+      return `${e.name.join(".")}(${e.args.map(deparseExpr).join(", ")})`;
+    case "case": {
+      let out = "CASE";
+      if (e.operand) out += ` ${deparseExpr(e.operand)}`;
+      for (const arm of e.whens) {
+        out += ` WHEN ${deparseExpr(arm.when)} THEN ${deparseExpr(arm.then)}`;
+      }
+      if (e.elseExpr) out += ` ELSE ${deparseExpr(e.elseExpr)}`;
+      return `${out} END`;
+    }
+    case "subquery_expr":
+      return `(${deparseSelect(e.query)})`;
+    default:
+      return "?";
+  }
+}
+
+// src/sql/deparse-index.ts
+function deparseIndexColumn(column) {
+  let result = column.column === null ? deparseExpr(column.expr) : quoteIdent(column.column);
+  if (column.dir === "desc") result += " DESC";
+  const defaultNulls = column.dir === "desc" ? "first" : "last";
+  if (column.nulls !== defaultNulls) result += ` NULLS ${column.nulls.toUpperCase()}`;
+  return result;
+}
+function deparseIndex(index) {
+  const columns = index.columns.map(deparseIndexColumn).join(", ");
+  const unique = index.unique ? "UNIQUE " : "";
+  const nulls = index.nullsNotDistinct ? " NULLS NOT DISTINCT" : "";
+  const predicate = index.where ? ` WHERE ${deparseExpr(index.where)}` : "";
+  return `CREATE ${unique}INDEX ${quoteIdent(index.name)} ON ${quoteIdent(index.schema)}.${quoteIdent(index.table)} USING btree (${columns})${nulls}${predicate}`;
+}
 
 // src/runtime/database-context.ts
 var contexts = /* @__PURE__ */ new WeakMap();
@@ -7169,6 +7281,22 @@ function sequenceNextval(ctx, seq) {
 }
 function getMiscFunctions() {
   const m = /* @__PURE__ */ new Map();
+  m.set(
+    "pg_get_indexdef",
+    strict("text", (ctx, args) => {
+      const oid = argInt(ctx, args[0]);
+      const column = args[1] ? argInt(ctx, args[1]) : 0;
+      for (const schema of ctx.state.schemas.values()) {
+        for (const index of schema.indexes.values()) {
+          if (index.oid !== oid) continue;
+          if (column === 0) return tv("text", deparseIndex(index));
+          const part = index.columns[column - 1];
+          return tv("text", part ? deparseIndexColumn(part) : "");
+        }
+      }
+      return tv("text", null);
+    })
+  );
   m.set("version", () => tv("text", PG_VERSION_TEXT));
   m.set("current_database", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
   m.set("current_catalog", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
@@ -12389,6 +12517,9 @@ function tryIndexedTableRows(env, table, alias, where) {
   const key = uniqueKeyOf(env, table, spec, probeRow);
   if (key === null) return [];
   const hits = indexStoreFor(env, table, spec).lookup(key);
+  const schema = env.ctx.state.schemas.get(table.schema);
+  const index = schema?.indexes.get(spec.name);
+  if (schema && index) schema.indexes.set(spec.name, { ...index, scans: (index.scans ?? 0n) + 1n });
   return hits.map((i) => table.rowAt(i));
 }
 function tryIndexedFromItem(env, item, where) {
@@ -15151,8 +15282,8 @@ var Parser = class {
       this.eatKw("column");
       const column = this.ident();
       let alterType = this.eatKw("type");
-      if (!alterType && this.eatKw("set") && this.atKw("data")) {
-        this.pos += 1;
+      if (!alterType && this.atKw("set") && this.atKw("data", 1)) {
+        this.pos += 2;
         this.expectKw("type");
         alterType = true;
       }
@@ -19504,7 +19635,7 @@ function uniqueSpecsFor(env, table) {
   const schema = env.ctx.state.schemas.get(table.schema);
   if (schema) {
     for (const idx of schema.indexes.values()) {
-      if (idx.table !== table.name || !idx.unique || idx.isConstraint) continue;
+      if (idx.table !== table.name || !idx.unique || idx.isConstraint || idx.valid === false) continue;
       specs.push({
         name: idx.name,
         keys: idx.columns.map((c) => ({
@@ -20655,6 +20786,25 @@ var EngineCtx = class {
   timezone() {
     return this.state.getSetting("timezone") ?? "UTC";
   }
+  namespaceOid(input) {
+    const trimmed = input.trim();
+    const name = trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1).replaceAll('""', '"') : trimmed.toLowerCase();
+    if (name === "pg_catalog") return 11;
+    if (name === "information_schema") return 13212;
+    const schema = this.state.schemas.get(name);
+    if (!schema) throw pgError("undefined_object", `schema "${name}" does not exist`, "3F000");
+    return schema.oid;
+  }
+  namespaceName(oid) {
+    if (oid === 11) return "pg_catalog";
+    if (oid === 13212) return "information_schema";
+    for (const schema of this.state.schemas.values()) {
+      if (schema.oid === oid) {
+        return /^[a-z_][a-z0-9_$]*$/.test(schema.name) ? schema.name : `"${schema.name.replaceAll('"', '""')}"`;
+      }
+    }
+    return null;
+  }
   zoneOffsetAt(utcMicros) {
     return zoneOffsetAtUtc(this.timezone(), utcMicros);
   }
@@ -20925,7 +21075,7 @@ function pgClass(ctx) {
     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.oid ?? state.schemas.get(i.schema)?.tables.get(i.table)?.oid ?? 0,
         i.name,
         i.schema,
         "i",
@@ -21162,7 +21312,15 @@ function pgIndex(ctx) {
     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]);
+      rows.push([
+        i.oid ?? table?.oid ?? 0,
+        table?.oid ?? 0,
+        i.columns.length,
+        i.unique,
+        isPrimary,
+        i.where !== null,
+        i.valid !== false
+      ]);
     }
   }
   return rel(
@@ -21172,12 +21330,73 @@ function pgIndex(ctx) {
       ["indnatts", "int2"],
       ["indisunique", "bool"],
       ["indisprimary", "bool"],
-      ["indpred", "bool"]
+      ["indpred", "bool"],
+      ["indisvalid", "bool"]
     ],
     rows,
     "pg_index"
   );
 }
+function pgStatUserTables(ctx) {
+  return rel(
+    [
+      ["relid", "oid"],
+      ["schemaname", "name"],
+      ["relname", "name"],
+      ["n_live_tup", "int8"]
+    ],
+    [...allTables(ctx.state)].map((table) => [table.oid, table.schema, table.name, BigInt(table.rowCount())]),
+    "pg_stat_user_tables"
+  );
+}
+function pgDescription(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const index of schema.indexes.values()) {
+      if (index.comment) rows.push([index.oid ?? 0, 1259, 0, index.comment]);
+    }
+  }
+  return rel(
+    [
+      ["objoid", "oid"],
+      ["classoid", "oid"],
+      ["objsubid", "int4"],
+      ["description", "text"]
+    ],
+    rows,
+    "pg_description"
+  );
+}
+function pgStatUserIndexes(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    if (schema.name === "pg_catalog" || schema.name === "information_schema" || schema.name.startsWith("pg_toast"))
+      continue;
+    for (const index of schema.indexes.values()) {
+      const table = schema.tables.get(index.table);
+      rows.push([
+        table?.oid ?? 0,
+        index.oid ?? table?.oid ?? 0,
+        schema.name,
+        index.table,
+        index.name,
+        index.scans ?? 0n
+      ]);
+    }
+  }
+  return rel(
+    [
+      ["relid", "oid"],
+      ["indexrelid", "oid"],
+      ["schemaname", "name"],
+      ["relname", "name"],
+      ["indexrelname", "name"],
+      ["idx_scan", "int8"]
+    ],
+    rows,
+    "pg_stat_user_indexes"
+  );
+}
 function pgSequence(ctx) {
   const rows = [];
   for (const s of allSequences(ctx.state)) {
@@ -21292,7 +21511,7 @@ 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]);
+      rows.push([i.schema, i.table, i.name, null, deparseIndex(i)]);
     }
   }
   return rel(
@@ -21613,6 +21832,12 @@ function buildCatalogRelation(ctx, schema, name) {
         return pgConstraint(ctx);
       case "pg_index":
         return pgIndex(ctx);
+      case "pg_description":
+        return pgDescription(ctx);
+      case "pg_stat_user_tables":
+        return pgStatUserTables(ctx);
+      case "pg_stat_user_indexes":
+        return pgStatUserIndexes(ctx);
       case "pg_sequence":
         return pgSequence(ctx);
       case "pg_sequences":
@@ -22196,6 +22421,7 @@ function executeCreateIndex(env, stmt) {
   }
   assertGinTrgmIndex(state, table, stmt);
   schema.indexes.set(name, {
+    oid: state.nextOid(),
     name,
     schema: schema.name,
     table: table.name,
@@ -22208,7 +22434,8 @@ function executeCreateIndex(env, stmt) {
     })),
     where: stmt.where,
     nullsNotDistinct: stmt.nullsNotDistinct,
-    isConstraint: false
+    isConstraint: false,
+    valid: true
   });
   if (stmt.unique) {
     try {
@@ -22216,7 +22443,9 @@ function executeCreateIndex(env, stmt) {
         checkUnique(env, table, table.rowAt(i), i);
       }
     } catch (err) {
-      schema.indexes.delete(name);
+      if (stmt.concurrently) schema.indexes.get(name).valid = false;
+      else schema.indexes.delete(name);
+      table.indexStores = null;
       throw err;
     }
   }
@@ -23336,6 +23565,9 @@ var Statement = class _Statement {
     const typed = params.map((p, i) => bindValueToTyped(p, i));
     let last = null;
     for (const stmt of this.statements) {
+      if (stmt.type === "create_index" && stmt.concurrently && this.database.transactions.inTransaction) {
+        throw pgError("misuse", "CREATE INDEX CONCURRENTLY cannot run inside a transaction block", "25001");
+      }
       const env = {
         ctx: new EngineCtx(this.database.state),
         params: typed,
@@ -24362,9 +24594,48 @@ var RENAME_DATABASE = new RegExp(`^alter\\s+database\\s+${IDENT}\\s+rename\\s+to
 var identifier = (quoted, plain) => quoted === void 0 ? plain.toLowerCase() : quoted.replaceAll('""', '"');
 var ROW_LOCK = /\s+for\s+(?:no\s+key\s+update|key\s+share|update|share)(?:\s+of\s+(?:(?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s*,\s*(?:(?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?))*)?(?:\s+(nowait|skip\s+locked))?\s*$/i;
 var LIMIT = /\s+limit\s+(\d+)(?:\s+offset\s+(\d+))?\s*$/i;
-var FROM_TABLE = /\bfrom\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)/i;
-var UPDATE_TARGET = /^update\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?(?:"[^"]+"|[A-Za-z_][\w$]*))?\s+set\s+[\s\S]*?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$/i;
-var DELETE_TARGET = /^delete\s+from\s+((?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?(?:"[^"]+"|[A-Za-z_][\w$]*))?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$/i;
+var SQL_NAME = String.raw`(?:"[^"]+"|[A-Za-z_][\w$]*)`;
+var SQL_RELATION = String.raw`(?:"[^"]+"|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|[A-Za-z_][\w$]*))?`;
+var FROM_TABLE = new RegExp(String.raw`\bfrom\s+(${SQL_RELATION})`, "i");
+var UPDATE_TARGET = new RegExp(
+  String.raw`^update\s+(${SQL_RELATION})(?:\s+(?:as\s+)?(${SQL_NAME}))?\s+set\s+[\s\S]*?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$`,
+  "i"
+);
+var DELETE_TARGET = new RegExp(
+  String.raw`^delete\s+from\s+(${SQL_RELATION})(?:\s+(?:as\s+)?(${SQL_NAME}))?(?:\s+where\s+([\s\S]*?))?(?:\s+returning\s+[\s\S]*)?$`,
+  "i"
+);
+var lockedMutationQuery = (sql) => {
+  const match = UPDATE_TARGET.exec(sql) ?? DELETE_TARGET.exec(sql);
+  const relation = match?.[1];
+  if (!relation) return null;
+  const alias = match?.[2];
+  const where = match?.[3];
+  const from = alias ? `${relation} AS ${alias}` : relation;
+  return `SELECT * FROM ${from}${where ? ` WHERE ${where}` : ""}`;
+};
+var lockLiteral = (expr, params) => {
+  if (!expr) return void 0;
+  switch (expr.type) {
+    case "null_lit":
+      return null;
+    case "string_lit":
+      return expr.value;
+    case "bool_lit":
+      return expr.value ? "t" : "f";
+    case "number_lit":
+      return expr.raw.replace(/^\+/, "");
+    case "param": {
+      const value = params[expr.index - 1];
+      if (value === void 0) return void 0;
+      const typed = bindValueToTyped(value, expr.index - 1);
+      if (typed.v === null) return null;
+      return datumText(typed.t, typed.v, UTC_OUTPUT);
+    }
+    default:
+      return void 0;
+  }
+};
 var TYPLEN = {
   bool: 1,
   int2: 2,
@@ -24383,7 +24654,7 @@ var TEXT_TYPES2 = /* @__PURE__ */ new Set(["text", "varchar", "bpchar", "name",
 var PG_EPOCH_MS = 9466848e5;
 var pgError2 = (category, message2, code) => new PostgresError(category, message2, code);
 var errorFields = (error) => {
-  if (error instanceof PostgresError) {
+  if (isPostgresError(error)) {
     const message2 = error.message;
     const fields = { code: error.sqlState, message: message2 };
     const constraint = /constraint "([^"]+)"/.exec(message2)?.[1];
@@ -24779,8 +25050,8 @@ var Connection = class {
       return outcome;
     } catch (error) {
       if (this.inTransaction) this.aborted = true;
-      if (error instanceof PostgresError && error.sqlState === "40P01") this.cluster.unlockAll(this, true);
-      const status = error instanceof PostgresError ? error.sqlState : "XX000";
+      if (isPostgresError(error) && error.sqlState === "40P01") this.cluster.unlockAll(this, true);
+      const status = isPostgresError(error) ? error.sqlState : "XX000";
       this.options.onLog?.({ pid: this.pid, sql: text, durationMs: performance.now() - started, status });
       throw error;
     }
@@ -24883,7 +25154,11 @@ var Connection = class {
         const result = this.cluster.as(this, () => this.runQuery(db, text, params));
         return { empty: false, result, tag: commandTag(result) };
       };
-      const outcome = db.transaction(run);
+      const concurrentIndex = /\bconcurrently\b/i.test(text) && parse(text).some((stmt) => stmt.type === "create_index" && stmt.concurrently);
+      if (concurrentIndex && this.transaction !== null) {
+        throw new PostgresError("misuse", "CREATE INDEX CONCURRENTLY cannot run inside a transaction block", "25001");
+      }
+      const outcome = concurrentIndex ? run() : db.transaction(run);
       if (this.transaction && mutatesDatabase(text)) {
         this.transaction.statements.push({ kind: "sql", sql: text, params: params.slice() });
       }
@@ -24972,14 +25247,48 @@ var Connection = class {
       }
     });
   }
+  /**
+   * Hold the primary key until the transaction ends. PostgreSQL's unique index makes a
+   * second `INSERT` of the same key wait; `ON CONFLICT DO UPDATE` then sees the committed row.
+   * Without this, each session's workspace inserts the key and commit replay raises 23505.
+   */
+  lockInsertedPrimaryKey(db, text, params) {
+    let statements;
+    try {
+      statements = parse(text);
+    } catch {
+      return;
+    }
+    const stmt = statements.length === 1 ? statements[0] : void 0;
+    if (stmt?.type !== "insert" || stmt.source === "default_values" || stmt.source.body.type !== "values") return;
+    if (!stmt.columns) return;
+    const table = db.state.findTable(stmt.table);
+    const primary = table?.constraints.find((constraint) => constraint.kind === "primary_key");
+    if (!primary || primary.columns.length === 0) return;
+    const indexes = primary.columns.map((column) => stmt.columns?.indexOf(column) ?? -1);
+    if (indexes.some((index) => index < 0)) return;
+    const identities = [];
+    for (const row of stmt.source.body.rows) {
+      const identity = [];
+      for (const index of indexes) {
+        const value = lockLiteral(row[index], params);
+        if (value === void 0) return;
+        identity.push(value);
+      }
+      identities.push(identity);
+    }
+    const relation = stmt.table.join(".");
+    for (const identity of identities) {
+      const key = `row:${this.databaseName}:${relation}:${JSON.stringify(identity)}`;
+      if (!this.cluster.tryLock(this, key, true)) throw new LockWait(key);
+    }
+  }
   runQuery(db, text, params) {
     const lock = ROW_LOCK.exec(text);
     if (!lock) {
-      const mutation = UPDATE_TARGET.exec(text) ?? DELETE_TARGET.exec(text);
-      if (mutation) {
-        const lockQuery = `SELECT * FROM ${mutation[1]}${mutation[2] ? ` WHERE ${mutation[2]}` : ""}`;
-        this.lockRows(db, lockQuery, params, "wait");
-      }
+      const lockQuery = lockedMutationQuery(text);
+      if (lockQuery) this.lockRows(db, lockQuery, params, "wait");
+      this.lockInsertedPrimaryKey(db, text, params);
       return db.prepare(text).textResult(...params);
     }
     let query = text.slice(0, lock.index).trimEnd();