@crvouga/mockingbird-service-postgres 3.11.0 → 3.12.1

package/dist/unstable.js

@@ -8566,6 +8566,252 @@ function validateStorageSetting(name, value) {
   }
 }
 
+// ../../core/dist/fork-map.js
+var ForkMap = class _ForkMap {
+  owner = {};
+  index = { owner: this.owner, groups: [] };
+  order = { owner: this.owner, cells: [] };
+  shift = 0;
+  length = 0;
+  count = 0;
+  nextSequence = 0;
+  layout = 0;
+  cleared = 0;
+  version = 0;
+  constructor(entries) {
+    if (entries)
+      for (const [key, value] of entries)
+        this.set(key, value);
+  }
+  get size() {
+    return this.count;
+  }
+  get [Symbol.toStringTag]() {
+    return "Map";
+  }
+  fork() {
+    const copy = new _ForkMap();
+    copy.index = this.index;
+    copy.order = this.order;
+    copy.shift = this.shift;
+    copy.length = this.length;
+    copy.count = this.count;
+    copy.nextSequence = this.nextSequence;
+    this.owner = {};
+    return copy;
+  }
+  /** Visit changed hash buckets only. Values must be replaced, rather than mutated in place. */
+  *changes(previous) {
+    if (previous?.index === this.index)
+      return;
+    for (let group = 0; group < 32; group++) {
+      const currentGroup = this.index.groups[group];
+      const oldGroup = previous?.index.groups[group];
+      if (currentGroup === oldGroup)
+        continue;
+      for (let bucket = 0; bucket < 32; bucket++) {
+        const current = currentGroup?.buckets[bucket]?.data;
+        const old = oldGroup?.buckets[bucket]?.data;
+        if (current === old)
+          continue;
+        if (current)
+          for (const [key, entry] of current) {
+            const before = old?.get(key);
+            if (!before || !Object.is(before.value, entry.value) || before.sequence !== entry.sequence)
+              yield { key, value: entry.value, deleted: false };
+          }
+        if (old) {
+          for (const key of old.keys())
+            if (!current?.has(key))
+              yield { key, deleted: true };
+        }
+      }
+    }
+  }
+  get(key) {
+    return this.find(key)?.value;
+  }
+  has(key) {
+    return this.find(key) !== void 0;
+  }
+  set(key, value) {
+    if (typeof key === "number" && key === 0)
+      key = 0;
+    const hash = hashKey(key);
+    const existing = this.bucket(hash)?.get(key);
+    if (existing && Object.is(existing.value, value))
+      return this;
+    const entry = existing ? { ...existing, value } : { key, value, position: this.length++, sequence: this.nextSequence++ };
+    this.writableBucket(hash).set(key, entry);
+    this.writeOrder(entry.position, entry);
+    if (!existing)
+      this.count++;
+    this.version++;
+    return this;
+  }
+  delete(key) {
+    const hash = hashKey(key);
+    const entry = this.bucket(hash)?.get(key);
+    if (!entry)
+      return false;
+    this.writableBucket(hash).delete(key);
+    this.writeOrder(entry.position, void 0);
+    this.count--;
+    this.version++;
+    if (this.length > 1024 && this.length > this.count * 2)
+      this.compact();
+    return true;
+  }
+  clear() {
+    this.index = { owner: this.owner, groups: [] };
+    this.order = { owner: this.owner, cells: [] };
+    this.shift = this.length = this.count = this.nextSequence = 0;
+    this.layout++;
+    this.cleared++;
+    this.version++;
+  }
+  entries() {
+    return this.iterate(0);
+  }
+  keys() {
+    return this.iterate(1);
+  }
+  values() {
+    return this.iterate(2);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(callback, thisArg) {
+    for (const [key, value] of this)
+      callback.call(thisArg, value, key, this);
+  }
+  find(key) {
+    return this.bucket(hashKey(key))?.get(key);
+  }
+  bucket(hash) {
+    return this.index.groups[hash >>> 5 & 31]?.buckets[hash & 31]?.data;
+  }
+  writableBucket(hash) {
+    if (this.index.owner !== this.owner)
+      this.index = { owner: this.owner, groups: this.index.groups.slice() };
+    const groupIndex = hash >>> 5 & 31;
+    let group = this.index.groups[groupIndex];
+    if (!group || group.owner !== this.owner) {
+      group = { owner: this.owner, buckets: group?.buckets.slice() ?? [] };
+      this.index.groups[groupIndex] = group;
+    }
+    const at = hash & 31;
+    let bucket = group.buckets[at];
+    if (!bucket || bucket.owner !== this.owner) {
+      bucket = { owner: this.owner, data: bucket ? this.copyBucket(bucket.data) : /* @__PURE__ */ new Map() };
+      group.buckets[at] = bucket;
+    }
+    return bucket.data;
+  }
+  copyBucket(bucket) {
+    return new Map(bucket);
+  }
+  leaf(position) {
+    let node = this.order;
+    for (let shift = this.shift; shift > 0; shift -= 5)
+      node = node.cells[Math.floor(position / 2 ** shift) & 31];
+    return node;
+  }
+  writeOrder(position, entry) {
+    while (position >= 2 ** (this.shift + 5)) {
+      this.order = { owner: this.owner, cells: [this.order] };
+      this.shift += 5;
+    }
+    if (this.order.owner !== this.owner)
+      this.order = { owner: this.owner, cells: this.order.cells.slice() };
+    let node = this.order;
+    for (let shift = this.shift; shift > 0; shift -= 5) {
+      const at = Math.floor(position / 2 ** shift) & 31;
+      let child = node.cells[at];
+      if (!child || child.owner !== this.owner) {
+        child = { owner: this.owner, cells: child?.cells.slice() ?? [] };
+        node.cells[at] = child;
+      }
+      node = child;
+    }
+    node.cells[position & 31] = entry;
+  }
+  compact() {
+    const entries = [];
+    for (let position = 0; position < this.length; position++) {
+      const entry = this.leaf(position).cells[position & 31];
+      if (entry)
+        entries.push(entry);
+    }
+    this.index = { owner: this.owner, groups: [] };
+    this.order = { owner: this.owner, cells: [] };
+    this.shift = this.length = this.count = 0;
+    for (const original of entries) {
+      const entry = { ...original, position: this.length++ };
+      this.writableBucket(hashKey(entry.key)).set(entry.key, entry);
+      this.writeOrder(entry.position, entry);
+      this.count++;
+    }
+    this.layout++;
+  }
+  *iterate(kind) {
+    let position = 0;
+    let layout = this.layout;
+    let cleared = this.cleared;
+    let lastSequence = -1;
+    let version = -1;
+    let leaf;
+    let page = -1;
+    for (; ; ) {
+      if (cleared !== this.cleared) {
+        position = 0;
+        lastSequence = -1;
+        cleared = this.cleared;
+      }
+      if (layout !== this.layout) {
+        position = 0;
+        while (position < this.length) {
+          const entry2 = this.leaf(position).cells[position & 31];
+          if (entry2 && entry2.sequence > lastSequence)
+            break;
+          position++;
+        }
+        layout = this.layout;
+      }
+      if (position >= this.length)
+        return;
+      const nextPage = Math.floor(position / 32);
+      if (page !== nextPage || version !== this.version) {
+        leaf = this.leaf(position);
+        page = nextPage;
+        version = this.version;
+      }
+      const entry = leaf?.cells[position++ & 31];
+      if (!entry)
+        continue;
+      lastSequence = entry.sequence;
+      yield kind === 0 ? [entry.key, entry.value] : kind === 1 ? entry.key : entry.value;
+    }
+  }
+};
+function hashKey(key) {
+  if (typeof key === "number" && Number.isInteger(key))
+    return mix2((key | 0) ^ (key / 4294967296 | 0));
+  if (typeof key === "bigint")
+    return mix2(Number(BigInt.asIntN(32, key ^ key >> 32n)));
+  const text = String(key);
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++)
+    hash = Math.imul(hash ^ text.charCodeAt(i), 16777619);
+  return hash;
+}
+function mix2(value) {
+  value = Math.imul(value ^ value >>> 16, 73244475);
+  value = Math.imul(value ^ value >>> 16, 73244475);
+  return value ^ value >>> 16;
+}
+
 // src/schema/catalog.ts
 var builder = null;
 function setCatalogBuilder(b) {
@@ -8614,10 +8860,81 @@ var PG_CATALOG_RELATIONS = /* @__PURE__ */ new Set([
 
 // src/storage/database-state.ts
 var TableData = class _TableData {
+  /** @internal Optional physical row journal; IDs remain stable across heap splices. */
+  durableChanges = null;
+  durableNextId = 0;
+  durableEpoch;
+  durableUnsafe = false;
+  durableIds;
+  enableDurabilityTracking(ids, nextId) {
+    if (this.durableChanges && !this.durableUnsafe && !ids) return;
+    this.materializeSlab();
+    this.durableIds = /* @__PURE__ */ new WeakMap();
+    this.durableChanges = new ForkMap();
+    this.durableNextId = nextId ?? this.#rows.length;
+    for (let i = 0; i < this.#rows.length; i++) this.durableIds.set(this.#rows[i], ids?.[i] ?? i);
+    this.durableEpoch = {};
+    this.durableUnsafe = false;
+  }
+  durableRowId(row) {
+    const id = this.durableIds?.get(row);
+    if (id === void 0) throw new Error("Untracked durable row");
+    return id;
+  }
+  disableDurabilityTracking() {
+    this.durableChanges = null;
+    this.durableIds = void 0;
+    this.durableEpoch = void 0;
+    this.durableUnsafe = false;
+  }
+  recordDurableRow(row, previous) {
+    if (!this.durableChanges) return;
+    const id = (previous && this.durableIds?.get(previous)) ?? this.durableIds?.get(row) ?? this.durableNextId++;
+    this.durableIds.set(row, id);
+    this.durableChanges.set(id, { row, xmin: this.rowXmins.get(row) ?? 2 });
+  }
+  recordDurableDelete(row) {
+    if (this.durableChanges) this.durableChanges.set(this.durableRowId(row), { row: null, xmin: 0 });
+  }
+  /** @internal Metadata twin with no visits/copies of existing rows or index entries. */
+  emptyForDurability() {
+    const copy = new _TableData(this.schema, this.name, this.columns, this.oid, this.temp);
+    copy.constraints = this.constraints;
+    copy.triggers = this.triggers;
+    copy.unlogged = this.unlogged;
+    return copy;
+  }
+  /** @internal Serialization/SQL scans must not count as public native-array exposure. */
+  serializationRows() {
+    this.materializeSlab();
+    return this.materializedRows();
+  }
+  /** @internal Internal mutable array access, with ordinary public mutableRows kept intact. */
+  writeRows() {
+    return this.serializationRows();
+  }
+  /** @internal Ordinary snapshot branches must not inherit a persistence journal. */
+  untrackedFork() {
+    const copy = this.emptyForDurability();
+    copy.rowXmins = this.rowXmins;
+    copy.slabXmins = this.slabXmins;
+    if (this.slab) copy.slab = this.slab;
+    else {
+      copy.#rows = this.#rows;
+      copy.#rowPatches = this.#rowPatches?.fork() ?? null;
+      copy.#rowsShared = this.#rowsShared = true;
+      copy.tuplesShared = this.tuplesShared = true;
+    }
+    copy.indexStores = this.indexStores ? new Map([...this.indexStores].map(([name, store]) => [name, store.clone()])) : null;
+    return copy;
+  }
   name;
   schema;
   columns;
-  rows;
+  #rows = [];
+  #rowPatches = null;
+  #rowsShared = false;
+  #rowsExposed = false;
   rowXmins = /* @__PURE__ */ new WeakMap();
   slabXmins = null;
   /** Frozen columnar storage after snapshot hydrate; `rows` stays empty until materialized. */
@@ -8633,22 +8950,54 @@ var TableData = class _TableData {
   shareCount = 0;
   /** Derived unique/btree index maps; null until built or invalidated. */
   indexStores = null;
+  /** DML replaces tuples; DDL must detach them before changing cells in place. */
+  tuplesShared = false;
   constructor(schema, name, columns, oid, temp = false) {
     this.schema = schema;
     this.name = name;
     this.columns = columns;
-    this.rows = [];
+    Object.defineProperty(this, "rows", {
+      enumerable: true,
+      configurable: true,
+      get: this.nativeRows,
+      set: this.setNativeRows
+    });
     this.constraints = [];
     this.triggers = [];
     this.temp = temp;
     this.oid = oid;
   }
   rowCount() {
-    return this.slab ? this.slab.rowCount : this.rows.length;
+    return this.slab ? this.slab.rowCount : this.#rows.length;
   }
   rowAt(index) {
     if (this.slab) return this.slab.rowAt(index);
-    return this.rows[index] ?? [];
+    return this.#rowPatches?.get(index) ?? this.#rows[index] ?? [];
+  }
+  /** Replace an existing tuple without copying the array of unchanged row references. */
+  replaceRow(index, row) {
+    if (this.durableChanges) this.recordDurableRow(row, this.rowAt(index));
+    if (this.#rowPatches) this.#rowPatches.set(index, row);
+    else this.#rows[index] = row;
+  }
+  materializedRows() {
+    if (this.#rowsShared) this.#rows = this.#rows.slice();
+    if (this.#rowPatches) for (const [index, row] of this.#rowPatches) this.#rows[index] = row;
+    this.#rowPatches = null;
+    this.#rowsShared = false;
+    return this.#rows;
+  }
+  nativeRows() {
+    if (this.durableChanges) this.durableUnsafe = true;
+    this.#rowsExposed = true;
+    return this.materializedRows();
+  }
+  setNativeRows(rows) {
+    if (this.durableChanges) this.durableUnsafe = true;
+    this.#rows = rows;
+    this.#rowPatches = null;
+    this.#rowsShared = false;
+    this.#rowsExposed = true;
   }
   /** All rows for scans; materializes slab once into `rows` when needed. */
   allRows() {
@@ -8657,13 +9006,15 @@ var TableData = class _TableData {
   }
   attachSlab(slab) {
     this.slab = slab;
-    this.rows = [];
+    this.#rows = [];
+    this.#rowPatches = null;
+    this.#rowsShared = false;
   }
   materializeSlab() {
     if (!this.slab) return;
-    this.rows = this.slab.materialize();
+    this.#rows = this.slab.materialize();
     if (this.slabXmins)
-      this.rows.forEach((row, index) => {
+      this.#rows.forEach((row, index) => {
         this.rowXmins.set(row, this.slabXmins[index] ?? 2);
       });
     this.slabXmins = null;
@@ -8687,7 +9038,7 @@ var TableData = class _TableData {
   columnIndex(name) {
     return this.columns.findIndex((c) => c.name === name);
   }
-  clone() {
+  cloneMetadata() {
     const t = new _TableData(
       this.schema,
       this.name,
@@ -8695,21 +9046,68 @@ var TableData = class _TableData {
       this.oid,
       this.temp
     );
+    t.unlogged = this.unlogged;
+    t.durableChanges = this.durableChanges?.fork() ?? null;
+    t.durableIds = this.durableIds;
+    t.durableNextId = this.durableNextId;
+    t.durableEpoch = this.durableEpoch;
+    t.durableUnsafe = this.durableUnsafe;
+    t.constraints = this.constraints.map((c) => ({ ...c }));
+    t.triggers = this.triggers.map((tr) => ({ ...tr }));
+    t.indexStores = this.indexStores ? new Map([...this.indexStores].map(([k, v]) => [k, v.clone()])) : null;
+    return t;
+  }
+  clone() {
+    const t = this.cloneMetadata();
+    if (t.durableChanges) t.durableUnsafe = true;
     if (this.slab) {
-      t.rows = this.slab.materialize().map((r) => r.slice());
+      t.#rows = this.slab.materialize().map((r) => r.slice());
     } else {
-      t.rows = this.rows.map((r) => r.slice());
+      t.#rows = this.materializedRows().map((r) => r.slice());
     }
-    t.rows.forEach((row, index) => {
-      const xmin = this.slabXmins?.[index] ?? this.rowXmins.get(this.rows[index]);
+    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 }));
-    t.indexStores = this.indexStores ? new Map([...this.indexStores].map(([k, v]) => [k, v.clone()])) : null;
     return t;
   }
+  /** DML creates new tuple arrays; retain existing tuples and xmin bindings until DDL. */
+  cloneForDml() {
+    if (this.triggers.length > 0) return this.cloneForWrite();
+    const t = this.cloneMetadata();
+    t.rowXmins = this.rowXmins;
+    if (this.slab) {
+      t.#rows = this.slab.materialize();
+      if (this.slabXmins) {
+        for (let index = 0; index < t.#rows.length; index++)
+          t.rowXmins.set(t.#rows[index], this.slabXmins[index] ?? 2);
+      }
+    } else {
+      if (this.#rows.length >= 4096 && !this.#rowsExposed) {
+        this.#rowPatches ??= new ForkMap();
+        t.#rowPatches = this.#rowPatches.fork();
+        t.#rows = this.#rows;
+        t.#rowsShared = this.#rowsShared = true;
+      } else t.#rows = this.materializedRows().slice();
+      this.tuplesShared = true;
+    }
+    t.tuplesShared = true;
+    return t;
+  }
+  /** A live DML fork can be unfrozen while its unchanged tuples still belong to history. */
+  ownTuples() {
+    if (this.durableChanges) this.durableUnsafe = true;
+    if (!this.tuplesShared) return;
+    const xmins = /* @__PURE__ */ new WeakMap();
+    this.rows = this.rows.map((row) => {
+      const copy = row.slice();
+      const xmin = this.rowXmins.get(row);
+      if (xmin !== void 0) xmins.set(copy, xmin);
+      return copy;
+    });
+    this.rowXmins = xmins;
+    this.tuplesShared = false;
+  }
   /** Independent writable copy (row tuples copied so ALTER COLUMN is isolated). */
   cloneForWrite() {
     const t = this.clone();
@@ -9063,12 +9461,21 @@ var DatabaseState = class _DatabaseState {
     }
   }
   ensureWritableTable(table) {
-    if (!table.frozen) return table;
+    if (!table.frozen) {
+      table.ownTuples();
+      return table;
+    }
     const schema = this.schemas.get(table.schema);
     const copy = table.cloneForWrite();
     schema?.tables.set(table.name, copy);
     return copy;
   }
+  ensureWritableTableForDml(table) {
+    if (!table.frozen) return table;
+    const copy = table.cloneForDml();
+    this.schemas.get(table.schema)?.tables.set(table.name, copy);
+    return copy;
+  }
   ensureWritableSequence(seq) {
     if ((seq.shareCount ?? 0) === 0) return seq;
     const schema = this.schemas.get(seq.schema);
@@ -14716,6 +15123,21 @@ var IndexStore = class _IndexStore {
   name;
   unique;
   entries = /* @__PURE__ */ new Map();
+  integerKeys = null;
+  shared = false;
+  ownedBuckets = /* @__PURE__ */ new WeakSet();
+  writableBucket(key, bucket) {
+    if (this.ownedBuckets.has(bucket)) return bucket;
+    const copy = bucket.slice();
+    this.entries.set(key, copy);
+    this.ownedBuckets.add(copy);
+    return copy;
+  }
+  detach() {
+    if (!this.shared) return;
+    if (!(this.entries instanceof ForkMap)) this.entries = new Map(this.entries);
+    this.shared = false;
+  }
   constructor(name, unique = false) {
     this.name = name;
     this.unique = unique;
@@ -14734,36 +15156,78 @@ var IndexStore = class _IndexStore {
   }
   insert(key, rowIdx) {
     if (this.unique) this.checkUnique(key, rowIdx);
+    this.detach();
+    this.integerKeys = null;
     const existing = this.entries.get(key);
     if (!existing) {
-      this.entries.set(key, [rowIdx]);
+      const bucket = [rowIdx];
+      this.ownedBuckets.add(bucket);
+      this.entries.set(key, bucket);
       return;
     }
     if (existing.includes(rowIdx)) return;
-    existing.push(rowIdx);
+    this.writableBucket(key, existing).push(rowIdx);
   }
   remove(key, rowIdx) {
     const existing = this.entries.get(key);
     if (!existing) return;
     const at = existing.indexOf(rowIdx);
     if (at < 0) return;
-    existing.splice(at, 1);
-    if (existing.length === 0) this.entries.delete(key);
+    this.detach();
+    this.integerKeys = null;
+    if (existing.length === 1) this.entries.delete(key);
+    else {
+      const remaining = this.writableBucket(key, existing);
+      remaining.splice(at, 1);
+      this.entries.set(key, remaining);
+    }
   }
   lookup(key) {
     return this.entries.get(key) ?? [];
   }
+  /** Ordered access for a single int2/int4 key (the planner validates the key type). */
+  integerRange(lower, upper, includeLower, includeUpper) {
+    const keys = this.integerKeys ??= [...this.entries].map(([key, rows]) => ({ value: Number(key.slice(1)), rows })).sort((a, b) => a.value - b.value);
+    let lo = 0;
+    let hi = keys.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const value = keys[mid].value;
+      if (value < lower || !includeLower && value === lower) lo = mid + 1;
+      else hi = mid;
+    }
+    const result = [];
+    for (let i = lo; i < keys.length; i++) {
+      const key = keys[i];
+      if (key.value > upper || !includeUpper && key.value === upper) break;
+      result.push(...key.rows);
+    }
+    return result.sort((a, b) => a - b);
+  }
   clear() {
-    this.entries.clear();
+    this.entries = /* @__PURE__ */ new Map();
+    this.shared = false;
+    this.integerKeys = null;
   }
   clone() {
     const copy = new _IndexStore(this.name, this.unique);
-    for (const [key, rowids] of this.entries) copy.entries.set(key, [...rowids]);
+    if (this.entries.size >= 4096 && !(this.entries instanceof ForkMap)) this.entries = new ForkMap(this.entries);
+    copy.entries = this.entries instanceof ForkMap ? this.entries.fork() : this.entries;
+    copy.integerKeys = this.integerKeys;
+    copy.shared = true;
+    this.shared = true;
+    this.ownedBuckets = /* @__PURE__ */ new WeakSet();
     return copy;
   }
 };
 
 // src/indexes/maintain.ts
+function prepareDmlIndexStores(env, table) {
+  if (table.indexStores || !table.frozen || table.triggers.length > 0) return;
+  const specs = uniqueSpecsFor(env, table);
+  if (specs.some((spec) => spec.where || spec.keys.some((key) => key.expr))) return;
+  ensureIndexStores(env, table);
+}
 function ensureIndexStores(env, table) {
   if (table.indexStores) return table.indexStores;
   const stores = /* @__PURE__ */ new Map();
@@ -14814,8 +15278,19 @@ function indexRemoveRow(env, table, rowIdx, row) {
   }
 }
 function indexUpdateRow(env, table, rowIdx, oldRow, newRow) {
-  indexRemoveRow(env, table, rowIdx, oldRow);
-  indexInsertRow(env, table, rowIdx, newRow);
+  const specs = uniqueSpecsFor(env, table);
+  if (specs.some((spec) => spec.where || spec.keys.some((key) => key.expr))) {
+    indexRemoveRow(env, table, rowIdx, oldRow);
+    indexInsertRow(env, table, rowIdx, newRow);
+    return;
+  }
+  for (const spec of specs) {
+    const before = uniqueKeyOf(env, table, spec, oldRow);
+    const after = uniqueKeyOf(env, table, spec, newRow);
+    if (before === after) continue;
+    if (before !== null) table.indexStores?.get(spec.name)?.remove(before, rowIdx);
+    if (after !== null) indexStoreFor(env, table, spec).insert(after, rowIdx);
+  }
 }
 function rebuildTableIndexes(env, table) {
   table.indexStores = null;
@@ -15032,6 +15507,82 @@ function conjunctions(expr) {
   }
   return [expr];
 }
+function tryPointRowIndices(env, table, alias, where) {
+  const eqs = [];
+  for (const part of conjunctions(where)) {
+    const eq = equalityAgainstConst(part);
+    if (!eq || !["param", "number_lit", "string_lit", "bool_lit", "null_lit"].includes(eq.valueExpr.type)) return null;
+    if (part.type !== "binop") return null;
+    const column = part.left.type === "colref" ? part.left : part.right;
+    if (column.type !== "colref") return null;
+    if (column.parts.length > 1 && column.parts[column.parts.length - 2] !== alias) return null;
+    eqs.push(eq);
+  }
+  for (const spec of uniqueSpecsFor(env, table)) {
+    if (spec.where || spec.keys.length !== eqs.length || spec.keys.some((key2) => key2.expr) || !eqs.every((eq, index) => eq.column === spec.columnNames[index]))
+      continue;
+    const values = table.columns.map(() => null);
+    let matches2 = true;
+    for (let index = 0; index < spec.keys.length; index++) {
+      const key2 = spec.keys[index];
+      const column = table.columns[key2.colIdx];
+      const eq = eqs[index];
+      if (!column || !eq || column.domain) {
+        matches2 = false;
+        break;
+      }
+      const value = evalExpr(env.ctx, makeEvalScope(env, null), eq.valueExpr);
+      if (value.t !== column.type.id && !(column.type.id === "text" && value.t === "unknown" && typeof value.v === "string")) {
+        matches2 = false;
+        break;
+      }
+      values[key2.colIdx] = value.v;
+    }
+    if (!matches2) continue;
+    const key = uniqueKeyOf(env, table, spec, values);
+    return { indices: key === null ? [] : indexStoreFor(env, table, spec).lookup(key), indexName: spec.name };
+  }
+  return null;
+}
+function recordIndexScan(env, table, name) {
+  const schema = env.ctx.state.schemas.get(table.schema);
+  const index = schema?.indexes.get(name);
+  if (schema && index) {
+    const lastScan = env.ctx.state.clock().getTime();
+    schema.indexes.set(name, { ...index, scans: (index.scans ?? 0n) + 1n, lastScan });
+  }
+}
+function tryRangeRowIndices(env, table, alias, where) {
+  const parts = conjunctions(where);
+  if (parts.length !== 2) return null;
+  const bounds = [];
+  for (const part of parts) {
+    if (part.type !== "binop" || ![">", ">=", "<", "<="].includes(part.op)) return null;
+    const column2 = part.left.type === "colref" ? part.left : part.right;
+    const value = part.left.type === "colref" ? part.right : part.left;
+    if (column2.type !== "colref" || column2.parts.length > 2 || column2.parts.length === 2 && column2.parts[0] !== alias || !["param", "number_lit"].includes(value.type))
+      return null;
+    const op = part.left === column2 ? part.op : { ">": "<", ">=": "<=", "<": ">", "<=": ">=" }[part.op];
+    bounds.push({ column: column2.parts.at(-1), op, value });
+  }
+  const lower = bounds.find((bound) => bound.op === ">" || bound.op === ">=");
+  const upper = bounds.find((bound) => bound.op === "<" || bound.op === "<=");
+  if (!lower || !upper || lower.column !== upper.column) return null;
+  const column = table.columns.find((column2) => column2.name === lower.column);
+  if (!column || column.domain || !["int2", "int4"].includes(column.type.id)) return null;
+  for (const spec of uniqueSpecsFor(env, table)) {
+    if (spec.where || spec.keys.length !== 1 || spec.keys[0].expr || spec.columnNames[0] !== lower.column) continue;
+    const low = evalExpr(env.ctx, makeEvalScope(env, null), lower.value);
+    const high = evalExpr(env.ctx, makeEvalScope(env, null), upper.value);
+    if (low.t !== column.type.id || high.t !== column.type.id || typeof low.v !== "number" || typeof high.v !== "number")
+      return null;
+    return {
+      indices: indexStoreFor(env, table, spec).integerRange(low.v, high.v, lower.op === ">=", upper.op === "<="),
+      indexName: spec.name
+    };
+  }
+  return null;
+}
 function tryIndexedTableRows(env, table, alias, where) {
   const parts = conjunctions(where);
   const eqs = [];
@@ -15068,12 +15619,7 @@ 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) {
-    const lastScan = env.ctx.state.clock().getTime();
-    schema.indexes.set(spec.name, { ...index, scans: (index.scans ?? 0n) + 1n, lastScan });
-  }
+  recordIndexScan(env, table, spec.name);
   return hits.map((i) => table.rowAt(i));
 }
 function tryIndexedFromItem(env, item, where) {
@@ -21059,7 +21605,7 @@ function renameWithAliases(rel4, label, colAliases, what) {
   }));
   return { columns, rows: rel4.rows };
 }
-function materializeItem(env, item, scope) {
+function materializeItem(env, item, scope, shapeOnly = false) {
   switch (item.type) {
     case "from_table": {
       const label = item.alias ?? item.name[item.name.length - 1];
@@ -21078,7 +21624,7 @@ function materializeItem(env, item, scope) {
             ...table.columns.map((c) => ({ name: c.name, type: c.type.id, mod: c.type.mod, table: label })),
             { name: "xmin", type: "xid", table: label, hidden: true, system: true }
           ],
-          rows: table.rows.map((row) => [...row, table.rowXmins.get(row) ?? 2])
+          rows: shapeOnly ? [] : table.serializationRows().map((row) => [...row, table.rowXmins.get(row) ?? 2])
         };
         return { rel: renameWithAliases(rel4, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
@@ -22351,14 +22897,30 @@ function checkPredicateType(env, columns, rangeVars, e, kind, extras) {
 function executeCore(env0, core, orderBy, opts) {
   const env = env0;
   const ctx = env.ctx;
-  const source = buildFrom(env, core.from, core.where);
+  const item = core.from.length === 1 ? core.from[0] : null;
+  const pointTable = item?.type === "from_table" && !item.colAliases?.length && !(item.name.length === 1 && env.ctes.has(item.name[0])) ? env.ctx.state.findTable(item.name) : null;
+  const point = pointTable && core.where && item?.type === "from_table" ? tryPointRowIndices(env, pointTable, item.alias ?? item.name[item.name.length - 1], core.where) : null;
+  const range = !point && pointTable && core.where && item?.type === "from_table" ? tryRangeRowIndices(env, pointTable, item.alias ?? item.name[item.name.length - 1], core.where) : null;
+  const access = point ?? range;
+  const source = access && item ? materializeItem(env, item, env.outer, true) : buildFrom(env, core.from, core.where);
   const srcCols = source.rel.columns;
   const rangeVars = source.rangeVars;
   const rowScope = (row) => new RowScope(srcCols, row, env.outer, rangeVars);
   let srcRows = source.rel.rows;
   if (core.where) {
     checkPredicateType(env, srcCols, rangeVars, core.where, "WHERE");
-    if (core.from.length === 1) {
+    if (access && pointTable) {
+      pointTable.materializeSlab();
+      srcRows = access.indices.map((index) => {
+        const row = pointTable.rowAt(index);
+        return [...row, pointTable.rowXmins.get(row) ?? 2];
+      });
+      if (range) {
+        const where = core.where;
+        srcRows = srcRows.filter((row) => evalPredicate2(env, rowScope(row), where));
+      }
+      recordIndexScan(env, pointTable, access.indexName);
+    } else if (core.from.length === 1) {
       const indexed = tryIndexedFromItem(env, core.from[0], core.where);
       if (indexed !== null) {
         srcRows = indexed;
@@ -22539,11 +23101,11 @@ function executeCore(env0, core, orderBy, opts) {
         }
       }
     }
-    const item = { name: `__ord${orderExprs.length}`, kind: "expr", colIdx: -1, expr: ob.expr, hidden: true };
+    const item2 = { name: `__ord${orderExprs.length}`, kind: "expr", colIdx: -1, expr: ob.expr, hidden: true };
     const spec = { colIdx: projItems.length, dir, nullsFirst };
-    projItems.push(item);
+    projItems.push(item2);
     sortSpecs.push(spec);
-    orderExprs.push({ item, spec });
+    orderExprs.push({ item: item2, spec });
   }
   if (core.distinct && !core.distinct.on && sortSpecs.length > 0 && !opts?.hasLimit) {
     const used = new Set(sortSpecs.map((s) => s.colIdx));
@@ -27437,7 +27999,10 @@ function withStatementRollback(env, fn) {
 function requireTargetTable(env, parts, verb) {
   const state = env.ctx.state;
   const table = state.findTable(parts);
-  if (table) return state.ensureWritableTable(table);
+  if (table) {
+    prepareDmlIndexStores(env, table);
+    return state.ensureWritableTableForDml(table);
+  }
   const view = state.findView(parts);
   if (view) {
     throw pgError("wrong_object_type", `cannot ${verb} view "${view.name}"`, "42809");
@@ -27605,7 +28170,7 @@ function resolveArbiters(env, table, clause) {
   return matches2.map((spec) => ({ spec }));
 }
 function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, where) {
-  const rows = table.mutableRows();
+  const rows = table.writeRows();
   const existing = rows[existingIdx];
   const cols = [
     ...table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
@@ -27617,7 +28182,7 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
   applyUpdateSets(env, table, sets, scope, updated);
   computeGeneratedColumns(env, table, updated);
   table.rowXmins.set(updated, env.ctx.rowVersionXid());
-  rows[existingIdx] = updated;
+  table.replaceRow(existingIdx, updated);
   indexUpdateRow(env, table, existingIdx, existing, updated);
   checkNotNull(env, table, updated);
   checkChecks(env, table, updated);
@@ -27629,7 +28194,7 @@ function applyOnConflictUpdate(env, table, label, existingIdx, newRow, sets, whe
 function executeInsert(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   const table = requireTargetTable(env, stmt.table, "insert into");
-  const rows = table.mutableRows();
+  const rows = table.writeRows();
   const label = stmt.alias ?? table.name;
   const colIdxs = insertTargetColumns(env, table, stmt);
   const sourceRows = insertSourceRows(env, stmt, colIdxs);
@@ -27713,6 +28278,7 @@ function executeInsert(env0, stmt) {
       checkForeignKeys(env, table, newRow);
       table.rowXmins.set(newRow, env.ctx.rowVersionXid());
       rows.push(newRow);
+      table.recordDurableRow(newRow);
       indexInsertRow(env, table, rows.length - 1, newRow);
       insertedCount++;
       insertedRows.push(newRow);
@@ -27805,13 +28371,17 @@ function executeUpdate(env0, stmt) {
   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];
+  const point = !fromSource && stmt.where && table.triggers.length === 0 && !table.columns.some((column) => column.generated || column.domain) && !table.constraints.some((constraint) => constraint.kind === "check") && stmt.sets.every(
+    (set) => set.columns.every((column) => column.subscripts === null && column.fields.length === 0) && "type" in set.value && isPureUpdateValue(set.value)
+  ) && referencingConstraints(env, table).length === 0 ? tryPointRowIndices(env, table, label, stmt.where) : null;
+  const rows = point ? null : table.writeRows();
+  for (let candidate = 0; candidate < (point ? point.indices.length : rows.length); candidate++) {
+    const ri = point ? point.indices[candidate] : candidate;
+    const oldRow = point ? table.rowAt(ri) : rows[ri];
     let matchScope = null;
     if (fromSource) {
       let found = false;
@@ -27837,14 +28407,14 @@ function executeUpdate(env0, stmt) {
     const finalRow = fired.row;
     computeGeneratedColumns(env, table, finalRow);
     table.rowXmins.set(finalRow, env.ctx.rowVersionXid());
-    rows[ri] = finalRow;
+    table.replaceRow(ri, finalRow);
     try {
       checkNotNull(env, table, finalRow);
       checkChecks(env, table, finalRow);
       checkUnique(env, table, finalRow, ri);
       checkForeignKeys(env, table, finalRow);
     } catch (err) {
-      rows[ri] = oldRow;
+      table.replaceRow(ri, oldRow);
       throw err;
     }
     indexUpdateRow(env, table, ri, oldRow, finalRow);
@@ -27862,12 +28432,29 @@ function executeUpdate(env0, stmt) {
   }
   return commandResult("UPDATE", updateCount);
 }
+function isPureUpdateValue(expr) {
+  switch (expr.type) {
+    case "param":
+    case "number_lit":
+    case "string_lit":
+    case "bool_lit":
+    case "null_lit":
+    case "colref":
+      return true;
+    case "binop":
+      return isPureUpdateValue(expr.left) && isPureUpdateValue(expr.right);
+    case "unop":
+      return isPureUpdateValue(expr.operand);
+    default:
+      return false;
+  }
+}
 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 rows = table.writeRows();
   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 }));
   const toDelete = [];
@@ -27897,6 +28484,7 @@ function executeDelete(env0, stmt) {
     if (skipped.has(ri)) continue;
     const row = rows[ri];
     handleReferencedDelete(env, table, row, 0);
+    table.recordDurableDelete(row);
     rows.splice(ri, 1);
     deletedRows.unshift(row);
   }
@@ -27943,13 +28531,14 @@ function handleReferencedDelete(env, table, row, depth) {
     const idxs = referencingRowIdxs(ref, key);
     if (idxs.length === 0) continue;
     const action = con.onDelete ?? "no_action";
-    const child = env.ctx.state.ensureWritableTable(ref.table);
-    const childRows = child.mutableRows();
+    const child = env.ctx.state.ensureWritableTableForDml(ref.table);
+    const childRows = child.writeRows();
     switch (action) {
       case "cascade": {
         for (let k = idxs.length - 1; k >= 0; k--) {
           const childRow = childRows[idxs[k]];
           handleReferencedDelete(env, child, childRow, depth + 1);
+          child.recordDurableDelete(childRow);
           childRows.splice(idxs[k], 1);
         }
         break;
@@ -27961,7 +28550,7 @@ function handleReferencedDelete(env, table, row, depth) {
             newRow[child.columnIndex(c)] = null;
           }
           child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-          childRows[i] = newRow;
+          child.replaceRow(i, newRow);
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
         }
@@ -27975,7 +28564,7 @@ function handleReferencedDelete(env, table, row, depth) {
             newRow[ci] = columnDefault(env, child, child.columns[ci]);
           }
           child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-          childRows[i] = newRow;
+          child.replaceRow(i, newRow);
           checkNotNull(env, child, newRow);
           checkChecks(env, child, newRow);
           checkForeignKeys(env, child, newRow);
@@ -28001,8 +28590,8 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
       const idxs = referencingRowIdxs(ref, oldKey);
       if (idxs.length === 0) continue;
       const action = con.onUpdate ?? "no_action";
-      const child = env.ctx.state.ensureWritableTable(ref.table);
-      const childRows = child.mutableRows();
+      const child = env.ctx.state.ensureWritableTableForDml(ref.table);
+      const childRows = child.writeRows();
       switch (action) {
         case "cascade": {
           for (const i of idxs) {
@@ -28013,7 +28602,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               newRow[localIdx] = newRows[r][refIdx] ?? null;
             }
             child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-            childRows[i] = newRow;
+            child.replaceRow(i, newRow);
             checkChecks(env, child, newRow);
           }
           break;
@@ -28023,7 +28612,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
             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;
+            child.replaceRow(i, newRow);
             checkNotNull(env, child, newRow);
           }
           break;
@@ -28036,7 +28625,7 @@ function handleReferencedUpdate(env, table, oldRows, newRows) {
               newRow[ci] = columnDefault(env, child, child.columns[ci]);
             }
             child.rowXmins.set(newRow, env.ctx.rowVersionXid());
-            childRows[i] = newRow;
+            child.replaceRow(i, newRow);
             checkForeignKeys(env, child, newRow);
           }
           break;
@@ -28199,7 +28788,7 @@ var TransactionManager = class {
     return { state: this.state.cloneShallow(), prngState: this.state.prng.getState() };
   }
   restore(snap) {
-    this.state.restoreFrom(snap.state);
+    this.state.restoreFrom(snap.state.cloneShallow());
     this.state.prng.setState(snap.prngState);
   }
   thawOnce() {