@crvouga/mockingbird-service-postgres 1.3.1 → 1.4.0

package/dist/unstable.js

@@ -11037,10 +11037,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");
@@ -11517,7 +11539,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";
@@ -13442,7 +13468,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, command) {
   const visible = rel2.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
@@ -13567,6 +13599,234 @@ function datumToJs(t, v, ctx, int8 = "bigint") {
   }
 }
 
+// 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) {
@@ -13710,6 +13970,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);
   }
@@ -15392,6 +15654,634 @@ function evalLazyFunc(ctx, scope, name, argExprs) {
   }
 }
 
+// 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/indexes/index.ts
 var IndexStore = class _IndexStore {
   name;
@@ -16296,7 +17186,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 }));
@@ -16322,6 +17218,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");
@@ -16398,7 +17298,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);
@@ -16413,7 +17319,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;
@@ -16445,7 +17357,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");
@@ -16517,7 +17435,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`,
@@ -16526,10 +17444,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) => ({
@@ -18598,7 +19522,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++) {
@@ -18640,7 +19570,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;
@@ -18653,7 +19589,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";
@@ -19341,6 +20283,9 @@ var DatabaseState = class _DatabaseState {
 };
 
 // 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) {
@@ -19744,6 +20689,7 @@ function executeCreateIndex(env, stmt) {
       }
     }
   }
+  assertGinTrgmIndex(state, table, stmt);
   schema.indexes.set(name, {
     name,
     schema: schema.name,
@@ -19788,7 +20734,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
@@ -19814,7 +20760,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
@@ -19822,6 +20768,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)) {
@@ -20610,8 +21582,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();
@@ -20983,7 +21966,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) {
@@ -21722,6 +22711,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":