@crvouga/mockingbird-service-postgres 1.3.1 → 1.5.0

package/dist/wire/index.js

@@ -1,6 +1,167 @@
 // src/wire/index.ts
 import { createServer } from "node:net";
 
+// ../../core/dist/timeline.js
+var BRANCH_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+var Timeline = class {
+  maxCheckpoints;
+  now;
+  makeId;
+  nodes = /* @__PURE__ */ new Map();
+  heads = /* @__PURE__ */ new Map();
+  /** Unreferenced nodes in the exact order they became collectible. */
+  evictable = /* @__PURE__ */ new Set();
+  /** Branch heads plus explicit retainers. Absent means zero. */
+  references = /* @__PURE__ */ new Map();
+  explicitPins = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options = {}) {
+    const max = options.maxCheckpoints ?? 1e3;
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("maxCheckpoints must be a positive integer");
+    this.maxCheckpoints = max;
+    this.now = options.now ?? (() => this.sequence);
+    this.makeId = options.id ?? ((sequence) => `cp_${sequence.toString(36).padStart(8, "0")}`);
+  }
+  /** Capture a new immutable value and move `branch` to it. */
+  commit(value, options = {}) {
+    const branch = options.branch ?? "main";
+    this.assertBranch(branch);
+    const parent = options.parent === void 0 ? this.heads.get(branch) ?? null : options.parent;
+    if (parent !== null && !this.nodes.has(parent))
+      throw new RangeError(`no checkpoint ${parent}`);
+    const id = this.makeId(++this.sequence);
+    if (this.nodes.has(id))
+      throw new RangeError(`duplicate checkpoint id ${id}`);
+    const checkpoint = Object.freeze({ id, branch, parent, at: this.now(), value });
+    this.nodes.set(id, checkpoint);
+    this.moveHead(branch, id);
+    this.collect(this.maxCheckpoints);
+    return checkpoint;
+  }
+  /** Create a branch pointer without copying its checkpoint value. */
+  fork(branch, options = {}) {
+    this.assertBranch(branch);
+    if (this.heads.has(branch))
+      throw new RangeError(`branch already exists: ${branch}`);
+    const from = options.from ?? this.heads.get("main");
+    if (from === void 0)
+      return void 0;
+    const checkpoint = this.get(from);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  /** Move a branch pointer to an existing checkpoint. */
+  checkout(branch, id) {
+    this.assertBranch(branch);
+    const checkpoint = this.get(id);
+    this.moveHead(branch, checkpoint.id);
+    return checkpoint;
+  }
+  get(id) {
+    const checkpoint = this.nodes.get(id);
+    if (!checkpoint)
+      throw new RangeError(`no checkpoint ${id}`);
+    return checkpoint;
+  }
+  head(branch = "main") {
+    const id = this.heads.get(branch);
+    return id === void 0 ? void 0 : this.get(id);
+  }
+  hasBranch(branch) {
+    return this.heads.has(branch);
+  }
+  branches() {
+    return Object.freeze(Object.fromEntries([...this.heads].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
+  }
+  checkpoints() {
+    return [...this.nodes.values()];
+  }
+  /** Number of retained checkpoints without allocating an array. */
+  get size() {
+    return this.nodes.size;
+  }
+  /** Pin a checkpoint independently of branch heads (used by compatibility snapshot handles). */
+  retain(id) {
+    const checkpoint = this.get(id);
+    this.explicitPins.set(id, (this.explicitPins.get(id) ?? 0) + 1);
+    this.addReference(id);
+    return checkpoint;
+  }
+  /** Release one explicit pin. Branch heads remain pinned until moved or deleted. */
+  release(id) {
+    if (!this.nodes.has(id))
+      return false;
+    const pins = this.explicitPins.get(id) ?? 0;
+    if (pins === 0)
+      return false;
+    if (pins === 1)
+      this.explicitPins.delete(id);
+    else
+      this.explicitPins.set(id, pins - 1);
+    this.removeReference(id);
+    this.collect(this.maxCheckpoints);
+    return true;
+  }
+  deleteBranch(branch) {
+    if (branch === "main")
+      throw new RangeError("cannot delete main branch");
+    const previous = this.heads.get(branch);
+    const deleted = this.heads.delete(branch);
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.collect(this.maxCheckpoints);
+    return deleted;
+  }
+  /**
+   * Deterministically discard oldest unpinned checkpoints. Collection is O(number removed):
+   * commits never scan pinned nodes or the retained history. Parents are metadata rather than a
+   * storage dependency, so a retained node remains usable after pruning.
+   */
+  gc(max = this.maxCheckpoints) {
+    if (!Number.isSafeInteger(max) || max < 1)
+      throw new RangeError("max must be a positive integer");
+    const removed = [];
+    this.collect(max, removed);
+    return removed;
+  }
+  collect(max, removed) {
+    while (this.nodes.size > max && this.evictable.size > 0) {
+      const id = this.evictable.values().next().value;
+      this.evictable.delete(id);
+      this.nodes.delete(id);
+      removed?.push(id);
+    }
+  }
+  moveHead(branch, id) {
+    const previous = this.heads.get(branch);
+    if (previous === id)
+      return;
+    if (previous !== void 0)
+      this.removeReference(previous);
+    this.heads.set(branch, id);
+    this.addReference(id);
+  }
+  addReference(id) {
+    this.references.set(id, (this.references.get(id) ?? 0) + 1);
+    this.evictable.delete(id);
+  }
+  removeReference(id) {
+    const next = (this.references.get(id) ?? 0) - 1;
+    if (next > 0)
+      this.references.set(id, next);
+    else {
+      this.references.delete(id);
+      if (this.nodes.has(id))
+        this.evictable.add(id);
+    }
+  }
+  assertBranch(branch) {
+    if (!BRANCH_PATTERN.test(branch))
+      throw new RangeError(`branch must match ${BRANCH_PATTERN}`);
+  }
+};
+
 // src/errors/error.ts
 var CATEGORY_TO_SQLSTATE = {
   syntax: "42601",
@@ -4199,7 +4360,13 @@ var RowScope = class {
   }
 };
 function childEnv(env, outer) {
-  return { ctx: env.ctx, params: env.params, ctes: env.ctes, outer };
+  return {
+    ctx: env.ctx,
+    params: env.params,
+    ctes: env.ctes,
+    outer,
+    allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+  };
 }
 function relationResult(rel2, command2) {
   const visible = rel2.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
@@ -8539,6 +8706,234 @@ function callScalarFunction(ctx, name, args) {
   return fn(ctx, args);
 }
 
+// src/functions/pgtrgm.ts
+var PGTRGM_BODY = "pg_trgm";
+var WORD_SIMILARITY_THRESHOLD = Math.fround(0.6);
+var GIN_TRGM_TYPES = /* @__PURE__ */ new Set(["text", "varchar"]);
+var WORD_CHAR = /[\p{L}\p{N}]+/gu;
+function pgTrgmSchema(state) {
+  for (const schema of state.schemas.values()) {
+    for (const fns of schema.functions.values()) {
+      if (fns.some((fn) => fn.language === "internal" && fn.rawBody === PGTRGM_BODY)) return schema.name;
+    }
+  }
+  return null;
+}
+function pgTrgmInstalled(state) {
+  return pgTrgmSchema(state) !== null;
+}
+function installPgTrgm(state, schemaName) {
+  const schema = state.getSchema(schemaName);
+  const existing = schema.functions.get("similarity") ?? [];
+  const fn = {
+    name: "similarity",
+    schema: schema.name,
+    argNames: [null, null],
+    argTypes: ["text", "text"],
+    argDefaults: [null, null],
+    returns: "float4",
+    returnsSet: false,
+    returnsTable: null,
+    language: "internal",
+    body: null,
+    rawBody: PGTRGM_BODY,
+    strict: true,
+    oid: state.nextOid()
+  };
+  existing.push(fn);
+  schema.functions.set("similarity", existing);
+}
+function uninstallPgTrgm(state) {
+  let removed = false;
+  for (const schema of state.schemas.values()) {
+    for (const [name, fns] of [...schema.functions.entries()]) {
+      const keep = fns.filter((fn) => fn.language !== "internal" || fn.rawBody !== PGTRGM_BODY);
+      if (keep.length === fns.length) continue;
+      removed = true;
+      if (keep.length === 0) schema.functions.delete(name);
+      else schema.functions.set(name, keep);
+    }
+  }
+  return removed;
+}
+function evalPgTrgmFunction(ctx, fn, args) {
+  const ret = fn.returns ?? "float4";
+  if (fn.strict && args.some((arg) => arg.v === null)) return tv(ret, null);
+  if (fn.name !== "similarity" || args.length !== 2) {
+    throw pgError("undefined_function", `function ${fn.schema}.${fn.name} is not implemented`, "42883");
+  }
+  const left = castTo(ctx, args[0], "text");
+  const right = castTo(ctx, args[1], "text");
+  if (left.v === null || right.v === null) return tv("float4", null);
+  return tv("float4", trigramSimilarity(left.v, right.v));
+}
+function evalTrgmWordSimilar(ctx, left, right) {
+  const missing = () => {
+    throw pgError(
+      "undefined_function",
+      `operator does not exist: ${typeDisplayName(left.t)} <% ${typeDisplayName(right.t)}`
+    );
+  };
+  if (!pgTrgmInstalled(ctx.state)) missing();
+  if (!canImplicitCast(left.t, "text") || !canImplicitCast(right.t, "text")) missing();
+  const a = castTo(ctx, left, "text");
+  const b = castTo(ctx, right, "text");
+  if (a.v === null || b.v === null) return tv("bool", null);
+  const score = wordSimilarity(a.v, b.v);
+  return tv("bool", score >= WORD_SIMILARITY_THRESHOLD);
+}
+function assertGinTrgmIndex(state, table, stmt) {
+  const trgmCols = stmt.columns.filter((col2) => isGinTrgmOpclass(col2.opclass));
+  if (trgmCols.length === 0) return;
+  if (trgmCols.length !== stmt.columns.length || stmt.columns.length !== 1) {
+    throw unsupported("multicolumn gin_trgm_ops");
+  }
+  const method = stmt.using ?? "btree";
+  const col = trgmCols[0];
+  const opclass = col.opclass;
+  const label = opclass.join(".");
+  if (method !== "gin" || !opclassVisible(state, opclass)) {
+    throw pgError(
+      "undefined_object",
+      `operator class "${label}" does not exist for access method "${method}"`,
+      "42704"
+    );
+  }
+  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;
+  if (!GIN_TRGM_TYPES.has(typeId)) {
+    throw pgError(
+      "datatype_mismatch",
+      `operator class "${label}" does not accept data type ${typeDisplayName(typeId)}`,
+      "42804"
+    );
+  }
+}
+function isGinTrgmOpclass(opclass) {
+  return opclass !== null && opclass[opclass.length - 1] === "gin_trgm_ops";
+}
+function opclassVisible(state, opclass) {
+  const schema = pgTrgmSchema(state);
+  if (schema === null || opclass[opclass.length - 1] !== "gin_trgm_ops") return false;
+  if (opclass.length === 1) return state.effectiveSearchPath().includes(schema);
+  if (opclass.length === 2) return opclass[0] === schema;
+  return false;
+}
+function trigramSimilarity(left, right) {
+  const a = uniqueSorted(orderedTrigrams(left));
+  const b = uniqueSorted(orderedTrigrams(right));
+  if (a.length === 0 || b.length === 0) return 0;
+  let i = 0;
+  let j = 0;
+  let count = 0;
+  while (i < a.length && j < b.length) {
+    const cmp = a[i] < b[j] ? -1 : a[i] > b[j] ? 1 : 0;
+    if (cmp < 0) i++;
+    else if (cmp > 0) j++;
+    else {
+      count++;
+      i++;
+      j++;
+    }
+  }
+  return calcSml(count, a.length, b.length);
+}
+function wordSimilarity(pattern, haystack) {
+  const trg1 = orderedTrigrams(pattern);
+  const trg2 = orderedTrigrams(haystack);
+  const len1 = trg1.length;
+  const len2 = trg2.length;
+  if (len1 === 0 || len2 === 0) return 0;
+  const positional = [];
+  for (let i = 0; i < len1; i++) positional.push({ trg: trg1[i], index: -1 });
+  for (let i = 0; i < len2; i++) positional.push({ trg: trg2[i], index: i });
+  positional.sort((x, y) => x.trg < y.trg ? -1 : x.trg > y.trg ? 1 : x.index - y.index);
+  const len = len1 + len2;
+  const trg2indexes = new Array(len2);
+  const found = new Array(len).fill(false);
+  let ulen1 = 0;
+  let group = 0;
+  for (let i = 0; i < len; i++) {
+    if (i > 0 && positional[i - 1].trg !== positional[i].trg) {
+      if (found[group]) ulen1++;
+      group++;
+    }
+    const index = positional[i].index;
+    if (index >= 0) trg2indexes[index] = group;
+    else found[group] = true;
+  }
+  if (found[group]) ulen1++;
+  return iterateWordSimilarity(trg2indexes, found, ulen1, len2);
+}
+function orderedTrigrams(input) {
+  const out = [];
+  for (const match of input.matchAll(WORD_CHAR)) {
+    const padded = `  ${match[0].toLowerCase()} `;
+    for (let i = 0; i + 3 <= padded.length; i++) out.push(padded.slice(i, i + 3));
+  }
+  return out;
+}
+function uniqueSorted(trigrams) {
+  return [...new Set(trigrams)].sort();
+}
+function calcSml(count, len1, len2) {
+  const denom = len1 + len2 - count;
+  if (denom <= 0) return 0;
+  return Math.fround(count / denom);
+}
+function iterateWordSimilarity(trg2indexes, found, ulen1, len2) {
+  const lastpos = new Array(found.length).fill(-1);
+  let ulen2 = 0;
+  let count = 0;
+  let lower = -1;
+  let smlrMax = 0;
+  for (let i = 0; i < len2; i++) {
+    const trgindex = trg2indexes[i];
+    if (lower >= 0 || found[trgindex]) {
+      if (lastpos[trgindex] < 0) {
+        ulen2++;
+        if (found[trgindex]) count++;
+      }
+      lastpos[trgindex] = i;
+    }
+    if (!found[trgindex]) continue;
+    if (lower === -1) {
+      lower = i;
+      ulen2 = 1;
+    }
+    let smlrCur = calcSml(count, ulen1, ulen2);
+    let tmpCount = count;
+    let tmpUlen2 = ulen2;
+    const prevLower = lower;
+    for (let tmpLower = lower; tmpLower <= i; tmpLower++) {
+      const smlrTmp = calcSml(tmpCount, ulen1, tmpUlen2);
+      if (smlrTmp > smlrCur) {
+        smlrCur = smlrTmp;
+        ulen2 = tmpUlen2;
+        lower = tmpLower;
+        count = tmpCount;
+      }
+      const tmpTrgindex = trg2indexes[tmpLower];
+      if (lastpos[tmpTrgindex] === tmpLower) {
+        tmpUlen2--;
+        if (found[tmpTrgindex]) tmpCount--;
+      }
+    }
+    if (smlrCur > smlrMax) smlrMax = smlrCur;
+    for (let tmpLower = prevLower; tmpLower < lower; tmpLower++) {
+      const tmpTrgindex = trg2indexes[tmpLower];
+      if (lastpos[tmpTrgindex] === tmpLower) lastpos[tmpTrgindex] = -1;
+    }
+  }
+  return smlrMax;
+}
+
 // src/expressions/operators.ts
 var NUM_LADDER = ["int2", "int4", "int8", "numeric", "float4", "float8"];
 function opNotExist(op, l, r) {
@@ -8682,6 +9077,8 @@ function evalBinary(ctx, op, l0, r0) {
       return evalJsonbDeletePath(ctx, l, r);
     case "@@":
       return evalTextSearchMatch(ctx, l, r);
+    case "<%":
+      return evalTrgmWordSimilar(ctx, l, r);
     default:
       opNotExist(op, l.t, r.t);
   }
@@ -10902,6 +11299,634 @@ function unifyAggType(a, b) {
   return unifyTypes(a, b) ?? a;
 }
 
+// src/functions/pgcrypto.ts
+var PGCRYPTO_BODY = "pgcrypto";
+var utf82 = new TextEncoder();
+var MD5_S = [
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21
+];
+var MD5_K = new Uint32Array([
+  3614090360,
+  3905402710,
+  606105819,
+  3250441966,
+  4118548399,
+  1200080426,
+  2821735955,
+  4249261313,
+  1770035416,
+  2336552879,
+  4294925233,
+  2304563134,
+  1804603682,
+  4254626195,
+  2792965006,
+  1236535329,
+  4129170786,
+  3225465664,
+  643717713,
+  3921069994,
+  3593408605,
+  38016083,
+  3634488961,
+  3889429448,
+  568446438,
+  3275163606,
+  4107603335,
+  1163531501,
+  2850285829,
+  4243563512,
+  1735328473,
+  2368359562,
+  4294588738,
+  2272392833,
+  1839030562,
+  4259657740,
+  2763975236,
+  1272893353,
+  4139469664,
+  3200236656,
+  681279174,
+  3936430074,
+  3572445317,
+  76029189,
+  3654602809,
+  3873151461,
+  530742520,
+  3299628645,
+  4096336452,
+  1126891415,
+  2878612391,
+  4237533241,
+  1700485571,
+  2399980690,
+  4293915773,
+  2240044497,
+  1873313359,
+  4264355552,
+  2734768916,
+  1309151649,
+  4149444226,
+  3174756917,
+  718787259,
+  3951481745
+]);
+var SHA256_K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA512_K = [
+  0x428a2f98d728ae22n,
+  0x7137449123ef65cdn,
+  0xb5c0fbcfec4d3b2fn,
+  0xe9b5dba58189dbbcn,
+  0x3956c25bf348b538n,
+  0x59f111f1b605d019n,
+  0x923f82a4af194f9bn,
+  0xab1c5ed5da6d8118n,
+  0xd807aa98a3030242n,
+  0x12835b0145706fben,
+  0x243185be4ee4b28cn,
+  0x550c7dc3d5ffb4e2n,
+  0x72be5d74f27b896fn,
+  0x80deb1fe3b1696b1n,
+  0x9bdc06a725c71235n,
+  0xc19bf174cf692694n,
+  0xe49b69c19ef14ad2n,
+  0xefbe4786384f25e3n,
+  0x0fc19dc68b8cd5b5n,
+  0x240ca1cc77ac9c65n,
+  0x2de92c6f592b0275n,
+  0x4a7484aa6ea6e483n,
+  0x5cb0a9dcbd41fbd4n,
+  0x76f988da831153b5n,
+  0x983e5152ee66dfabn,
+  0xa831c66d2db43210n,
+  0xb00327c898fb213fn,
+  0xbf597fc7beef0ee4n,
+  0xc6e00bf33da88fc2n,
+  0xd5a79147930aa725n,
+  0x06ca6351e003826fn,
+  0x142929670a0e6e70n,
+  0x27b70a8546d22ffcn,
+  0x2e1b21385c26c926n,
+  0x4d2c6dfc5ac42aedn,
+  0x53380d139d95b3dfn,
+  0x650a73548baf63den,
+  0x766a0abb3c77b2a8n,
+  0x81c2c92e47edaee6n,
+  0x92722c851482353bn,
+  0xa2bfe8a14cf10364n,
+  0xa81a664bbc423001n,
+  0xc24b8b70d0f89791n,
+  0xc76c51a30654be30n,
+  0xd192e819d6ef5218n,
+  0xd69906245565a910n,
+  0xf40e35855771202an,
+  0x106aa07032bbd1b8n,
+  0x19a4c116b8d2d0c8n,
+  0x1e376c085141ab53n,
+  0x2748774cdf8eeb99n,
+  0x34b0bcb5e19b48a8n,
+  0x391c0cb3c5c95a63n,
+  0x4ed8aa4ae3418acbn,
+  0x5b9cca4f7763e373n,
+  0x682e6ff3d6b2b8a3n,
+  0x748f82ee5defb2fcn,
+  0x78a5636f43172f60n,
+  0x84c87814a1f0ab72n,
+  0x8cc702081a6439ecn,
+  0x90befffa23631e28n,
+  0xa4506cebde82bde9n,
+  0xbef9a3f7b2c67915n,
+  0xc67178f2e372532bn,
+  0xca273eceea26619cn,
+  0xd186b8c721c0c207n,
+  0xeada7dd6cde0eb1en,
+  0xf57d4f7fee6ed178n,
+  0x06f067aa72176fban,
+  0x0a637dc5a2c898a6n,
+  0x113f9804bef90daen,
+  0x1b710b35131c471bn,
+  0x28db77f523047d84n,
+  0x32caab7b40c72493n,
+  0x3c9ebe0a15c9bebcn,
+  0x431d67c49c100d4cn,
+  0x4cc5d4becb3e42b6n,
+  0x597f299cfc657e2an,
+  0x5fcb6fab3ad6faecn,
+  0x6c44198c4a475817n
+];
+var MASK64 = (1n << 64n) - 1n;
+function rotl32(x, n) {
+  return (x << n | x >>> 32 - n) >>> 0;
+}
+function rotr32(x, n) {
+  return (x >>> n | x << 32 - n) >>> 0;
+}
+function rotr64(x, n) {
+  return (x >> n | x << 64n - n) & MASK64;
+}
+function padBe(data, block, lengthBytes) {
+  const bitLen = BigInt(data.length) * 8n;
+  let len = data.length + 1 + lengthBytes;
+  const rem = len % block;
+  if (rem !== 0) len += block - rem;
+  const out = new Uint8Array(len);
+  out.set(data);
+  out[data.length] = 128;
+  const view = new DataView(out.buffer);
+  view.setUint32(out.length - 8, Number(bitLen >> 32n & 0xffffffffn), false);
+  view.setUint32(out.length - 4, Number(bitLen & 0xffffffffn), false);
+  return out;
+}
+function padMd5(data) {
+  const bitLen = BigInt(data.length) * 8n;
+  let len = data.length + 1 + 8;
+  const rem = len % 64;
+  if (rem !== 0) len += 64 - rem;
+  const out = new Uint8Array(len);
+  out.set(data);
+  out[data.length] = 128;
+  const view = new DataView(out.buffer);
+  view.setUint32(out.length - 8, Number(bitLen & 0xffffffffn), true);
+  view.setUint32(out.length - 4, Number(bitLen >> 32n & 0xffffffffn), true);
+  return out;
+}
+function md5(data) {
+  const bytes = padMd5(data);
+  const view = new DataView(bytes.buffer);
+  let a0 = 1732584193;
+  let b0 = 4023233417;
+  let c0 = 2562383102;
+  let d0 = 271733878;
+  const m = new Uint32Array(16);
+  for (let off = 0; off < bytes.length; off += 64) {
+    for (let i = 0; i < 16; i++) m[i] = view.getUint32(off + i * 4, true);
+    let a = a0;
+    let b = b0;
+    let c = c0;
+    let d = d0;
+    for (let i = 0; i < 64; i++) {
+      let f;
+      let g;
+      if (i < 16) {
+        f = b & c | ~b & d;
+        g = i;
+      } else if (i < 32) {
+        f = d & b | ~d & c;
+        g = (5 * i + 1) % 16;
+      } else if (i < 48) {
+        f = b ^ c ^ d;
+        g = (3 * i + 5) % 16;
+      } else {
+        f = c ^ (b | ~d);
+        g = 7 * i % 16;
+      }
+      const sum = f + a + MD5_K[i] + m[g] >>> 0;
+      a = d;
+      d = c;
+      c = b;
+      b = b + rotl32(sum, MD5_S[i]) >>> 0;
+    }
+    a0 = a0 + a >>> 0;
+    b0 = b0 + b >>> 0;
+    c0 = c0 + c >>> 0;
+    d0 = d0 + d >>> 0;
+  }
+  const out = new Uint8Array(16);
+  const ov = new DataView(out.buffer);
+  ov.setUint32(0, a0, true);
+  ov.setUint32(4, b0, true);
+  ov.setUint32(8, c0, true);
+  ov.setUint32(12, d0, true);
+  return out;
+}
+function sha1(data) {
+  const bytes = padBe(data, 64, 8);
+  const view = new DataView(bytes.buffer);
+  let h0 = 1732584193;
+  let h1 = 4023233417;
+  let h2 = 2562383102;
+  let h3 = 271733878;
+  let h4 = 3285377520;
+  const w = new Uint32Array(80);
+  for (let off = 0; off < bytes.length; off += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(off + t * 4, false);
+    for (let t = 16; t < 80; t++) w[t] = rotl32(w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16], 1);
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    for (let t = 0; t < 80; t++) {
+      let f;
+      let k;
+      if (t < 20) {
+        f = b & c | ~b & d;
+        k = 1518500249;
+      } else if (t < 40) {
+        f = b ^ c ^ d;
+        k = 1859775393;
+      } else if (t < 60) {
+        f = b & c | b & d | c & d;
+        k = 2400959708;
+      } else {
+        f = b ^ c ^ d;
+        k = 3395469782;
+      }
+      const temp = rotl32(a, 5) + f + e + k + w[t] >>> 0;
+      e = d;
+      d = c;
+      c = rotl32(b, 30);
+      b = a;
+      a = temp;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+  }
+  const out = new Uint8Array(20);
+  const ov = new DataView(out.buffer);
+  ov.setUint32(0, h0, false);
+  ov.setUint32(4, h1, false);
+  ov.setUint32(8, h2, false);
+  ov.setUint32(12, h3, false);
+  ov.setUint32(16, h4, false);
+  return out;
+}
+function sha256(data, sha224) {
+  const bytes = padBe(data, 64, 8);
+  const view = new DataView(bytes.buffer);
+  let h0 = sha224 ? 3238371032 : 1779033703;
+  let h1 = sha224 ? 914150663 : 3144134277;
+  let h2 = sha224 ? 812702999 : 1013904242;
+  let h3 = sha224 ? 4144912697 : 2773480762;
+  let h4 = sha224 ? 4290775857 : 1359893119;
+  let h5 = sha224 ? 1750603025 : 2600822924;
+  let h6 = sha224 ? 1694076839 : 528734635;
+  let h7 = sha224 ? 3204075428 : 1541459225;
+  const w = new Uint32Array(64);
+  for (let off = 0; off < bytes.length; off += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(off + t * 4, false);
+    for (let t = 16; t < 64; t++) {
+      const x15 = w[t - 15];
+      const x2 = w[t - 2];
+      const s0 = rotr32(x15, 7) ^ rotr32(x15, 18) ^ x15 >>> 3;
+      const s1 = rotr32(x2, 17) ^ rotr32(x2, 19) ^ x2 >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let t = 0; t < 64; t++) {
+      const s1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
+      const ch = e & f ^ ~e & g;
+      const t1 = h + s1 + ch + SHA256_K[t] + w[t] >>> 0;
+      const s0 = rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  const words = sha224 ? 7 : 8;
+  const out = new Uint8Array(words * 4);
+  const ov = new DataView(out.buffer);
+  const hs = [h0, h1, h2, h3, h4, h5, h6, h7];
+  for (let i = 0; i < words; i++) ov.setUint32(i * 4, hs[i], false);
+  return out;
+}
+function readUint64BE(view, offset) {
+  return BigInt(view.getUint32(offset, false)) << 32n | BigInt(view.getUint32(offset + 4, false));
+}
+function sha512(data, sha384) {
+  const bytes = padBe(data, 128, 16);
+  const view = new DataView(bytes.buffer);
+  let h0 = sha384 ? 0xcbbb9d5dc1059ed8n : 0x6a09e667f3bcc908n;
+  let h1 = sha384 ? 0x629a292a367cd507n : 0xbb67ae8584caa73bn;
+  let h2 = sha384 ? 0x9159015a3070dd17n : 0x3c6ef372fe94f82bn;
+  let h3 = sha384 ? 0x152fecd8f70e5939n : 0xa54ff53a5f1d36f1n;
+  let h4 = sha384 ? 0x67332667ffc00b31n : 0x510e527fade682d1n;
+  let h5 = sha384 ? 0x8eb44a8768581511n : 0x9b05688c2b3e6c1fn;
+  let h6 = sha384 ? 0xdb0c2e0d64f98fa7n : 0x1f83d9abfb41bd6bn;
+  let h7 = sha384 ? 0x47b5481dbefa4fa4n : 0x5be0cd19137e2179n;
+  const w = new Array(80);
+  for (let off = 0; off < bytes.length; off += 128) {
+    for (let t = 0; t < 16; t++) w[t] = readUint64BE(view, off + t * 8);
+    for (let t = 16; t < 80; t++) {
+      const x15 = w[t - 15];
+      const x2 = w[t - 2];
+      const s0 = rotr64(x15, 1n) ^ rotr64(x15, 8n) ^ x15 >> 7n;
+      const s1 = rotr64(x2, 19n) ^ rotr64(x2, 61n) ^ x2 >> 6n;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 & MASK64;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let t = 0; t < 80; t++) {
+      const s1 = rotr64(e, 14n) ^ rotr64(e, 18n) ^ rotr64(e, 41n);
+      const ch = e & f ^ ~e & g & MASK64;
+      const t1 = h + s1 + ch + SHA512_K[t] + w[t] & MASK64;
+      const s0 = rotr64(a, 28n) ^ rotr64(a, 34n) ^ rotr64(a, 39n);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = s0 + maj & MASK64;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 & MASK64;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 & MASK64;
+    }
+    h0 = h0 + a & MASK64;
+    h1 = h1 + b & MASK64;
+    h2 = h2 + c & MASK64;
+    h3 = h3 + d & MASK64;
+    h4 = h4 + e & MASK64;
+    h5 = h5 + f & MASK64;
+    h6 = h6 + g & MASK64;
+    h7 = h7 + h & MASK64;
+  }
+  const words = sha384 ? 6 : 8;
+  const out = new Uint8Array(words * 8);
+  const ov = new DataView(out.buffer);
+  const hs = [h0, h1, h2, h3, h4, h5, h6, h7];
+  for (let i = 0; i < words; i++) {
+    const word = hs[i];
+    ov.setUint32(i * 8, Number(word >> 32n & 0xffffffffn), false);
+    ov.setUint32(i * 8 + 4, Number(word & 0xffffffffn), false);
+  }
+  return out;
+}
+function digestBytes(data, algorithm) {
+  switch (algorithm.toLowerCase().replaceAll("-", "")) {
+    case "md5":
+      return md5(data);
+    case "sha1":
+      return sha1(data);
+    case "sha224":
+      return sha256(data, true);
+    case "sha256":
+      return sha256(data, false);
+    case "sha384":
+      return sha512(data, true);
+    case "sha512":
+      return sha512(data, false);
+    default:
+      throw pgError("invalid_parameter_value", `Cannot use "${algorithm}": No such hash algorithm`, "22023");
+  }
+}
+function pgcryptoInstalled(state) {
+  for (const schema of state.schemas.values()) {
+    for (const fns of schema.functions.values()) {
+      if (fns.some((fn) => fn.language === "internal" && fn.rawBody === PGCRYPTO_BODY)) return true;
+    }
+  }
+  return false;
+}
+function installPgcrypto(state, schemaName) {
+  const schema = state.getSchema(schemaName);
+  const existing = schema.functions.get("digest") ?? [];
+  const arg0Types = ["text", "bytea"];
+  for (const arg0 of arg0Types) {
+    const fn = {
+      name: "digest",
+      schema: schema.name,
+      argNames: [null, null],
+      argTypes: [arg0, "text"],
+      argDefaults: [null, null],
+      returns: "bytea",
+      returnsSet: false,
+      returnsTable: null,
+      language: "internal",
+      body: null,
+      rawBody: PGCRYPTO_BODY,
+      strict: true,
+      oid: state.nextOid()
+    };
+    existing.push(fn);
+  }
+  schema.functions.set("digest", existing);
+}
+function uninstallPgcrypto(state) {
+  let removed = false;
+  for (const schema of state.schemas.values()) {
+    for (const [name, fns] of [...schema.functions.entries()]) {
+      const keep = fns.filter((fn) => fn.language !== "internal" || fn.rawBody !== PGCRYPTO_BODY);
+      if (keep.length === fns.length) continue;
+      removed = true;
+      if (keep.length === 0) schema.functions.delete(name);
+      else schema.functions.set(name, keep);
+    }
+  }
+  return removed;
+}
+function evalPgcryptoFunction(ctx, fn, args) {
+  const ret = fn.returns ?? "bytea";
+  if (fn.strict && args.some((arg) => arg.v === null)) return tv(ret, null);
+  if (fn.name !== "digest" || args.length !== 2) {
+    throw pgError("undefined_function", `function ${fn.schema}.${fn.name} is not implemented`, "42883");
+  }
+  const data = castTo(ctx, args[0], fn.argTypes[0] ?? "bytea", {});
+  const algorithm = castTo(ctx, args[1], "text", {});
+  if (data.v === null || algorithm.v === null) return tv("bytea", null);
+  const bytes = fn.argTypes[0] === "bytea" ? data.v : utf82.encode(data.v);
+  return tv("bytea", digestBytes(bytes, algorithm.v));
+}
+
 // src/functions/srf.ts
 function jsonInput(ctx, a) {
   void ctx;
@@ -13095,10 +14120,32 @@ var Parser = class {
     }
     if (this.atKw("extension")) {
       this.pos++;
-      this.parseIfNotExists();
+      const ifNotExists = this.parseIfNotExists();
       const name = this.ident(true);
-      while (!this.atPunct(";") && this.peek().type !== "eof") this.pos++;
-      throw unsupported(`extension "${name}"`);
+      let schema = null;
+      let version = null;
+      let cascade = false;
+      this.eatKw("with");
+      while (!this.atPunct(";") && this.peek().type !== "eof") {
+        if (this.eatKw("schema")) {
+          schema = this.ident(true);
+          continue;
+        }
+        if (this.eatKw("version")) {
+          const token = this.next();
+          if (token.type !== "string" && token.type !== "ident" && token.type !== "quoted_ident") {
+            this.errorAt(token, "expected extension version");
+          }
+          version = token.value;
+          continue;
+        }
+        if (this.eatKw("cascade")) {
+          cascade = true;
+          continue;
+        }
+        throw unsupported("CREATE EXTENSION option");
+      }
+      return { type: "create_extension", name, ifNotExists, schema, version, cascade };
     }
     if (this.atKw("database")) throw unsupported("CREATE DATABASE");
     if (this.atKw("role") || this.atKw("user") || this.atKw("group")) throw unsupported("roles");
@@ -13575,7 +14622,11 @@ var Parser = class {
       let opclass = null;
       const t = this.peek();
       if (t.type === "ident" && !RESERVED.has(t.value) && !["asc", "desc", "nulls", "with", "where", "include"].includes(t.value)) {
-        opclass = this.ident();
+        opclass = [this.ident()];
+        while (this.atPunct(".")) {
+          this.pos++;
+          opclass.push(this.ident(true));
+        }
       }
       let dir = null;
       if (this.eatKw("asc")) dir = "asc";
@@ -15811,7 +16862,13 @@ function runStmt(env, stmt, vars, emit, tableNames) {
       return;
     }
     case "for": {
-      const forEnv = { ctx: env.ctx, params: env.params, ctes: env.ctes, outer: vars.scope() };
+      const forEnv = {
+        ctx: env.ctx,
+        params: env.params,
+        ctes: env.ctes,
+        outer: vars.scope(),
+        allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+      };
       const rel2 = executeSelectStmt(forEnv, stmt.query);
       for (const row of rel2.rows) {
         for (let i = 0; i < stmt.targets.length; i++) {
@@ -15853,7 +16910,13 @@ function initVars(env, fn, bound, program) {
   if (fn.returnsTable) {
     for (const c of fn.returnsTable) vars.declare(c.name, c.type, null);
   }
-  const seed = () => ({ ctx: env.ctx, params: bound, ctes: /* @__PURE__ */ new Map(), outer: vars.scope() });
+  const seed = () => ({
+    ctx: env.ctx,
+    params: bound,
+    ctes: /* @__PURE__ */ new Map(),
+    outer: vars.scope(),
+    allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+  });
   for (const d of program.decls) {
     const id = resolveTypeName(env.ctx.state, d.typeName).column.id;
     let val = null;
@@ -15866,7 +16929,13 @@ function initVars(env, fn, bound, program) {
   return vars;
 }
 function plpgsqlEnv(env, bound, vars) {
-  return { ctx: env.ctx, params: bound, ctes: /* @__PURE__ */ new Map(), outer: vars.scope() };
+  return {
+    ctx: env.ctx,
+    params: bound,
+    ctes: /* @__PURE__ */ new Map(),
+    outer: vars.scope(),
+    allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+  };
 }
 function callPlpgsqlScalar(env, fn, args) {
   const retT = fn.returns ?? "text";
@@ -16465,7 +17534,13 @@ function functionEnv(env, fn, args) {
       bound.push(castTo(env.ctx, evalScalar(env, null, dflt), fn.argTypes[i], {}));
     }
   }
-  const fnEnv = { ctx: env.ctx, params: bound, ctes: /* @__PURE__ */ new Map(), outer: null };
+  const fnEnv = {
+    ctx: env.ctx,
+    params: bound,
+    ctes: /* @__PURE__ */ new Map(),
+    outer: null,
+    allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+  };
   const namedCols = fn.argNames.map((n, i) => ({ n, i })).filter((x) => x.n !== null);
   if (namedCols.length > 0) {
     const cols = namedCols.map(({ n, i }) => ({ name: n, type: fn.argTypes[i] ?? "text", table: null }));
@@ -16491,6 +17566,10 @@ function callSqlFunctionScalar(env, fn, args) {
   if (fn.language === "plpgsql") {
     return callPlpgsqlScalar(env, fn, args);
   }
+  if (fn.language === "internal") {
+    if (fn.rawBody === "pg_trgm") return evalPgTrgmFunction(env.ctx, fn, args);
+    return evalPgcryptoFunction(env.ctx, fn, args);
+  }
   if (fn.language === "js") {
     if (!fn.jsImpl) {
       throw pgError("undefined_function", `JavaScript function ${fn.name} is not registered`, "42883");
@@ -16567,7 +17646,13 @@ function applyWith(env, w) {
   if (!w) return env;
   const ctes = new Map(env.ctes);
   for (const cte of w.ctes) {
-    const scopedEnv = { ctx: env.ctx, params: env.params, ctes, outer: env.outer };
+    const scopedEnv = {
+      ctx: env.ctx,
+      params: env.params,
+      ctes,
+      outer: env.outer,
+      allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+    };
     let rel2;
     if (w.recursive && cte.query.type === "select" && cte.query.body.type === "setop" && cte.query.body.op === "union" && referencesRelation(cte.query.body.right, cte.name)) {
       rel2 = executeRecursiveCte(scopedEnv, cte, cte.query);
@@ -16582,7 +17667,13 @@ function applyWith(env, w) {
     }
     ctes.set(cte.name, applyCteColumnNames(rel2, cte));
   }
-  return { ctx: env.ctx, params: env.params, ctes, outer: env.outer };
+  return {
+    ctx: env.ctx,
+    params: env.params,
+    ctes,
+    outer: env.outer,
+    allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+  };
 }
 var MAX_RECURSION_ITERATIONS = 2e5;
 var MAX_RECURSION_ROWS = 5e6;
@@ -16614,7 +17705,13 @@ function executeRecursiveCte(env, cte, query) {
     }
     const iterCtes = new Map(env.ctes);
     iterCtes.set(cte.name, { columns, rows: working });
-    const iterEnv = { ctx: env.ctx, params: env.params, ctes: iterCtes, outer: env.outer };
+    const iterEnv = {
+      ctx: env.ctx,
+      params: env.params,
+      ctes: iterCtes,
+      outer: env.outer,
+      allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+    };
     const step = executeBody(iterEnv, body.right);
     if (step.columns.length !== columns.length) {
       throw pgError("syntax", "each UNION query must have the same number of columns", "42601");
@@ -16686,7 +17783,7 @@ function materializeItem(env, item, scope) {
       if (view) {
         let rel2;
         if (view.materialized) {
-          if (view.matRows === null || view.matColumns === null) {
+          if (view.matColumns === null || view.matRows === null && !env.allowUnpopulatedMatviews) {
             throw pgError(
               "object_not_in_prerequisite_state",
               `materialized view "${view.name}" has not been populated`,
@@ -16695,10 +17792,16 @@ function materializeItem(env, item, scope) {
           }
           rel2 = {
             columns: view.matColumns.map((c) => ({ name: c.name, type: c.type, table: label })),
-            rows: view.matRows
+            rows: view.matRows ?? []
           };
         } else {
-          const viewEnv = { ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
+          const viewEnv = {
+            ctx: env.ctx,
+            params: null,
+            ctes: /* @__PURE__ */ new Map(),
+            outer: null,
+            allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+          };
           rel2 = executeSelectStmt(viewEnv, view.query);
           rel2 = {
             columns: rel2.columns.map((c, i) => ({
@@ -17791,7 +18894,7 @@ function setOpRelation(env, op) {
     return t === UNKNOWN ? "text" : t;
   });
   const columns = left.columns.map((c, i) => ({ name: c.name, type: types[i], table: null }));
-  const normalize = (rel2) => rel2.rows.map(
+  const normalize2 = (rel2) => rel2.rows.map(
     (row) => row.map((v, i) => {
       if (v === null) return null;
       const srcT = rel2.columns[i].type;
@@ -17799,8 +18902,8 @@ function setOpRelation(env, op) {
       return castTo(ctx, tv(srcT === UNKNOWN ? "text" : srcT, v), types[i], {}).v;
     })
   );
-  const lrows = normalize(left);
-  const rrows = normalize(right);
+  const lrows = normalize2(left);
+  const rrows = normalize2(right);
   const keyOf = (row) => row.map((v, i) => v === null ? "\0N" : datumKey(types[i], v)).join("
");
   let rows;
   switch (op.op) {
@@ -18833,7 +19936,13 @@ function applyUpdateSets(env, table, sets, scope, row) {
     });
     if (typeof set.value === "object" && "kind" in set.value && set.value.kind === "row_subquery") {
       const rel2 = executeSelectStmt(
-        { ctx: env.ctx, params: env.params, ctes: env.ctes, outer: scope },
+        {
+          ctx: env.ctx,
+          params: env.params,
+          ctes: env.ctes,
+          outer: scope,
+          allowUnpopulatedMatviews: env.allowUnpopulatedMatviews
+        },
         set.value.query
       );
       if (rel2.rows.length > 1) {
@@ -20616,6 +21725,9 @@ function executeTrigger(env, table, trigger, _event, oldRow, newRow) {
 setTriggerExecutor(executeTrigger);
 
 // src/executor/ddl.ts
+function matviewQueryEnv(env, allowUnpopulatedMatviews) {
+  return { ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null, allowUnpopulatedMatviews };
+}
 function targetSchema(env, parts) {
   const state = env.ctx.state;
   if (parts.length >= 2) {
@@ -21019,6 +22131,7 @@ function executeCreateIndex(env, stmt) {
       }
     }
   }
+  assertGinTrgmIndex(state, table, stmt);
   schema.indexes.set(name, {
     name,
     schema: schema.name,
@@ -21063,7 +22176,7 @@ function executeCreateView(env, stmt) {
   let matRows = null;
   let matColumns = null;
   if (stmt.materialized) {
-    const rel2 = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, stmt.query);
+    const rel2 = executeSelectStmt(matviewQueryEnv(env, !stmt.withData), stmt.query);
     matColumns = rel2.columns.map((c, i) => ({
       name: stmt.columns?.[i] ?? c.name,
       type: c.type === UNKNOWN ? "text" : c.type
@@ -21089,7 +22202,7 @@ function executeRefreshMatView(env, stmt) {
     throw pgError("undefined_table", `materialized view "${stmt.name.join(".")}" does not exist`, "42P01");
   }
   const view = env.ctx.state.ensureWritableView(found);
-  const rel2 = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, view.query);
+  const rel2 = executeSelectStmt(matviewQueryEnv(env, !stmt.withData), view.query);
   view.matColumns = rel2.columns.map((c, i) => ({
     name: view.columns?.[i] ?? c.name,
     type: c.type === UNKNOWN ? "text" : c.type
@@ -21097,6 +22210,32 @@ function executeRefreshMatView(env, stmt) {
   view.matRows = stmt.withData ? rel2.rows : null;
   return commandResult("REFRESH MATERIALIZED VIEW", 0);
 }
+function executeCreateExtension(env, stmt) {
+  const state = env.ctx.state;
+  const schemaName = stmt.schema ?? state.currentSchema();
+  const install = () => {
+    if (stmt.name === "pgcrypto") {
+      if (pgcryptoInstalled(state)) return "exists";
+      installPgcrypto(state, state.getSchema(schemaName).name);
+      return "installed";
+    }
+    if (stmt.name === "pg_trgm") {
+      if (pgTrgmInstalled(state)) return "exists";
+      installPgTrgm(state, state.getSchema(schemaName).name);
+      return "installed";
+    }
+    return "unsupported";
+  };
+  const outcome = install();
+  if (outcome === "unsupported") {
+    throw pgError("feature_not_supported", `extension "${stmt.name}" is not available`, "0A000");
+  }
+  if (outcome === "exists") {
+    if (stmt.ifNotExists) return commandResult("CREATE EXTENSION", 0);
+    throw pgError("duplicate_object", `extension "${stmt.name}" already exists`, "42710");
+  }
+  return commandResult("CREATE EXTENSION", 0);
+}
 function executeCreateSchema(env, stmt) {
   const state = env.ctx.state;
   if (state.schemas.has(stmt.name)) {
@@ -21885,8 +23024,19 @@ function executeDrop(env, stmt) {
         table.triggers.splice(idx, 1);
         break;
       }
-      case "extension":
-        break;
+      case "extension": {
+        const ext = parts[parts.length - 1];
+        if (ext === "pgcrypto" && pgcryptoInstalled(state)) {
+          uninstallPgcrypto(state);
+          break;
+        }
+        if (ext === "pg_trgm" && pgTrgmInstalled(state)) {
+          uninstallPgTrgm(state);
+          break;
+        }
+        if (stmt.ifExists) break;
+        throw pgError("undefined_object", `extension "${ext}" does not exist`, "42704");
+      }
     }
   }
   const label = stmt.kind === "materialized_view" ? "MATERIALIZED VIEW" : stmt.kind.toUpperCase();
@@ -21968,6 +23118,8 @@ function executeStatement(env, stmt) {
       return executeAlterSequence(env, stmt);
     case "create_schema":
       return executeCreateSchema(env, stmt);
+    case "create_extension":
+      return executeCreateExtension(env, stmt);
     case "create_enum":
       return executeCreateEnum(env, stmt);
     case "alter_enum":
@@ -22123,6 +23275,9 @@ var ADOPT = /* @__PURE__ */ Symbol("postgres-mem.adopt");
 function isAdopted(value) {
   return ADOPT in value;
 }
+function project(point) {
+  return { id: point.id, branch: point.branch, parent: point.parent, at: point.at };
+}
 var Database = class {
   /** @internal Engine catalog, tables, session settings. */
   state;
@@ -22143,6 +23298,10 @@ var Database = class {
   closed = false;
   transactionSequence = 0;
   apiTransactionDepth = 0;
+  /** @internal Shared checkpoint DAG. Omitted from published declarations. */
+  timeline;
+  historyBranch = "main";
+  originId = "";
   constructor(options = {}) {
     if (isAdopted(options)) {
       this.seed = options.seed;
@@ -22155,16 +23314,23 @@ var Database = class {
       this.state.prng = this.prng;
       this.state.clock = () => this.now();
       this.transactions = txManagerFor(this.state);
-      return;
+    } else {
+      this.seed = options.seed ?? DEFAULT_DATABASE_SEED;
+      this.randomMode = options.random ?? "deterministic";
+      this.systemClock = options.now === "system";
+      this.int8Mode = options.int8 ?? "bigint";
+      this.prng = this.randomMode === "os" ? new OsEntropy() : new Prng(this.seed);
+      this.now = resolveClock(options.now);
+      this.state = new DatabaseState(this.prng, () => this.now());
+      this.transactions = txManagerFor(this.state);
     }
-    this.seed = options.seed ?? DEFAULT_DATABASE_SEED;
-    this.randomMode = options.random ?? "deterministic";
-    this.systemClock = options.now === "system";
-    this.int8Mode = options.int8 ?? "bigint";
-    this.prng = this.randomMode === "os" ? new OsEntropy() : new Prng(this.seed);
-    this.now = resolveClock(options.now);
-    this.state = new DatabaseState(this.prng, () => this.now());
-    this.transactions = txManagerFor(this.state);
+    this.timeline = new Timeline({
+      now: () => this.now().getTime(),
+      ...options.maxCheckpoints !== void 0 ? { maxCheckpoints: options.maxCheckpoints } : {}
+    });
+    const origin = this.timeline.commit(this.captureLive());
+    this.originId = origin.id;
+    this.timeline.retain(origin.id);
   }
   /**
    * Execute SQL for its side effects. Multiple semicolon-separated statements
@@ -22219,7 +23385,15 @@ var Database = class {
   /** Execute a single-statement query and return all rows keyed by column name. */
   query(sql, params = [], options = {}) {
     this.assertOpen();
-    if (options.at) return options.at.open().query(sql, params);
+    const at = options.at;
+    if (typeof at === "string") {
+      try {
+        return this.timeline.get(at).value.open().query(sql, params);
+      } catch (error) {
+        this.historyError(error);
+      }
+    }
+    if (at) return at.open().query(sql, params);
     return this.prepareSingle(sql).all(...params);
   }
   /** Compile a single SQL statement into a reusable {@link Statement}. */
@@ -22267,23 +23441,77 @@ var Database = class {
    * {@link Snapshot.open} for a copy-on-write fork.
    */
   snapshot() {
+    const point = this.record(this.historyBranch);
+    return this.timeline.get(point.id).value;
+  }
+  /** Alias for {@link snapshot}, naming the value as a timeline checkpoint. */
+  checkpoint() {
+    return this.snapshot();
+  }
+  /**
+   * Commit the live state onto `branch` (default: the branch this database follows).
+   * Does not switch the live database. Illegal inside a transaction.
+   */
+  record(branch = this.historyBranch) {
     this.assertOpen();
     if (this.transactions.inTransaction) {
       throw pgError("transaction_state", "cannot snapshot during a transaction", "25P01");
     }
-    return captureSnapshot(
-      this.state,
-      this.prng,
-      this.now,
-      this.seed,
-      this.randomMode,
-      this.systemClock,
-      this.int8Mode
-    );
+    try {
+      return project(this.timeline.commit(this.captureLive(), { branch }));
+    } catch (error) {
+      this.historyError(error);
+    }
   }
-  /** Alias for {@link snapshot}, naming the value as a timeline checkpoint. */
-  checkpoint() {
-    return this.snapshot();
+  /** Point `name` at a checkpoint without copying rows or switching the live database. */
+  fork(name, at) {
+    this.assertOpen();
+    try {
+      const point = this.timeline.fork(name, at !== void 0 ? { from: at } : {});
+      if (!point) throw pgError("misuse", "no checkpoint to fork from", "XX000");
+      return project(point);
+    } catch (error) {
+      if (error instanceof PostgresError) throw error;
+      this.historyError(error);
+    }
+  }
+  /** Move `branch` to `id` and install that checkpoint as the live database. */
+  checkout(id, branch = this.historyBranch) {
+    this.assertOpen();
+    if (this.transactions.inTransaction) {
+      throw pgError("transaction_state", "cannot checkout during a transaction", "25P01");
+    }
+    try {
+      const point = this.timeline.checkout(branch, id);
+      this.historyBranch = branch;
+      this.install(point.value);
+      return project(point);
+    } catch (error) {
+      this.historyError(error);
+    }
+  }
+  /** Return the live database to the origin checkpoint on `main`. */
+  reset() {
+    return this.checkout(this.originId, "main");
+  }
+  /** Checkpoint ids and branch heads. Values stay inside the timeline. */
+  get history() {
+    const timeline = this.timeline;
+    return {
+      get size() {
+        return timeline.size;
+      },
+      head(branch) {
+        const point = timeline.head(branch);
+        return point ? project(point) : void 0;
+      },
+      branches() {
+        return timeline.branches();
+      },
+      checkpoints() {
+        return timeline.checkpoints().map(project);
+      }
+    };
   }
   /** Open a copy-on-write branch from `at`, or from the current state when omitted. */
   branch(at = this.snapshot()) {
@@ -22328,6 +23556,26 @@ var Database = class {
   assertOpen() {
     if (this.closed) throw pgError("misuse", "Database is closed", "XX000");
   }
+  historyError(error) {
+    const message2 = error instanceof Error ? error.message : String(error);
+    throw pgError("misuse", message2, "XX000");
+  }
+  captureLive() {
+    return captureSnapshot(
+      this.state,
+      this.prng,
+      this.now,
+      this.seed,
+      this.randomMode,
+      this.systemClock,
+      this.int8Mode
+    );
+  }
+  install(snapshot) {
+    this.state.restoreFrom(snapshot.state.cloneShallow());
+    this.prng.setState(snapshot.prngState);
+    if (!this.systemClock) this.now = fixedClock(new Date(snapshot.nowMs));
+  }
   prepareSingle(sql) {
     const statements = parse(sql);
     if (statements.length === 0) {
@@ -22787,7 +24035,7 @@ var FrameParser = class {
     return { kind: "typed", type, body };
   }
 };
-var utf82 = {
+var utf83 = {
   encode: (s) => encoder2.encode(s),
   decode: (b) => decoder.decode(b)
 };
@@ -23008,13 +24256,13 @@ var binaryValue = (type, text) => {
       return out;
     }
     default:
-      return TEXT_TYPES2.has(type) ? utf82.encode(text) : null;
+      return TEXT_TYPES2.has(type) ? utf83.encode(text) : null;
   }
 };
 var binaryEncodable = (type) => TEXT_TYPES2.has(type) || ["bool", "int2", "int4", "oid", "int8", "float4", "float8", "bytea", "uuid"].includes(type);
 var decodeParam = (oid, format, bytes) => {
   if (bytes === null) return null;
-  if (format === 0) return utf82.decode(bytes);
+  if (format === 0) return utf83.decode(bytes);
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   switch (oid) {
     case 16:
@@ -23050,7 +24298,7 @@ var decodeParam = (oid, format, bytes) => {
     case 1042:
     case 1043:
     case 3802:
-      return utf82.decode(bytes);
+      return utf83.decode(bytes);
     default:
       throw pgError2("internal", `binary parameter format is not supported for type oid ${oid}`, "0A000");
   }
@@ -23217,6 +24465,11 @@ var Connection = class {
       return;
     }
     this.user = parameters.user ?? "postgres";
+    const requested = parameters.database && parameters.database.length > 0 ? parameters.database : this.user;
+    if (this.options.database !== void 0 && requested !== this.options.database) {
+      this.fatal("3D000", `database "${requested}" does not exist`);
+      return;
+    }
     if (this.options.password !== void 0) {
       this.scram = new ScramServer(this.options.password);
       this.write(backend.authenticationSASL(["SCRAM-SHA-256"]));
@@ -23232,7 +24485,7 @@ var Connection = class {
     if (!this.scramStarted) {
       const mechanism = body.cstring();
       const length = body.i32();
-      const clientFirst = utf82.decode(body.take(length));
+      const clientFirst = utf83.decode(body.take(length));
       const serverFirst = mechanism === "SCRAM-SHA-256" ? this.scram.first(clientFirst) : null;
       if (serverFirst === null) {
         this.fatal("28000", `SASL authentication with ${mechanism} is not supported or malformed`);
@@ -23242,7 +24495,7 @@ var Connection = class {
       this.write(backend.authenticationSASLContinue(serverFirst));
       return;
     }
-    const serverFinal = this.scram.final(utf82.decode(body.rest()));
+    const serverFinal = this.scram.final(utf83.decode(body.rest()));
     if (serverFinal === null) {
       this.fatal("28P01", `password authentication failed for user "${this.user}"`);
       return;
@@ -23490,7 +24743,7 @@ var Connection = class {
           row.map((value, c) => {
             if (value === null) return null;
             const type = result.columnTypes[c];
-            return formats[c] === 1 ? binaryValue(type, value) ?? utf82.encode(value) : utf82.encode(value);
+            return formats[c] === 1 ? binaryValue(type, value) ?? utf83.encode(value) : utf83.encode(value);
           })
         )
       );
@@ -23658,13 +24911,53 @@ var ConnectionDropped = class extends Error {
 };
 
 // src/wire/index.ts
+var parseUri = (raw) => {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`invalid postgres URI: ${raw}`);
+  }
+  if (url.protocol !== "postgres:" && url.protocol !== "postgresql:") {
+    throw new Error(`unsupported postgres URI protocol ${url.protocol}`);
+  }
+  const databaseName = decodeURIComponent(url.pathname.replace(/^\//, ""));
+  const password = url.password === "" ? void 0 : decodeURIComponent(url.password);
+  const user = decodeURIComponent(url.username || "postgres");
+  const port = url.port === "" ? 5432 : Number(url.port);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`invalid postgres URI port: ${url.port}`);
+  return {
+    host: url.hostname || "127.0.0.1",
+    port,
+    user,
+    ...password !== void 0 ? { password } : {},
+    ...databaseName !== "" ? { databaseName } : {}
+  };
+};
+var normalize = (input) => {
+  if (typeof input === "string") return parseUri(input);
+  if (input.url === void 0) return input;
+  const parsed = parseUri(input.url);
+  return {
+    ...parsed,
+    ...input,
+    host: input.host ?? parsed.host,
+    port: input.port ?? parsed.port,
+    password: input.password ?? parsed.password,
+    databaseName: input.databaseName ?? parsed.databaseName,
+    user: input.user ?? parsed.user,
+    parameters: input.parameters ?? parsed.parameters
+  };
+};
 var isSnapshot = (value) => typeof value === "object" && value !== null && "open" in value && typeof value.open === "function";
-var serve = (options = {}) => {
+var serve = (input = {}) => {
+  const options = normalize(input);
   const database = isSnapshot(options.database) ? options.database.open() : options.database ?? new Database();
   const cluster = new Cluster(database);
   const faults = {};
   const connections = /* @__PURE__ */ new Set();
   const host = options.host ?? "127.0.0.1";
+  const user = options.user || "postgres";
   const server = createServer((socket) => {
     socket.setNoDelay(true);
     const connection = new Connection(socket, cluster, {
@@ -23672,6 +24965,7 @@ var serve = (options = {}) => {
       serverVersion: options.serverVersion ?? "18.3",
       parameters: options.parameters ?? {},
       faults,
+      ...options.databaseName !== void 0 ? { database: options.databaseName } : {},
       ...options.onLog ? { onLog: options.onLog } : {}
     });
     connections.add(connection);
@@ -23683,9 +24977,12 @@ var serve = (options = {}) => {
       server.removeListener("error", reject);
       const address = server.address();
       const port = typeof address === "object" && address !== null ? address.port : 0;
+      const name = options.databaseName ?? "postgres";
+      const auth = options.password ? `${encodeURIComponent(user)}:${encodeURIComponent(options.password)}@` : `${encodeURIComponent(user)}@`;
       resolve({
         port,
         host,
+        connectionString: `postgres://${auth}${host}:${port}/${encodeURIComponent(name)}`,
         database,
         server,
         get connections() {