@crvouga/postgres-mem 0.1.0 → 1.0.1

package/dist/unstable.js

@@ -2361,6 +2361,36 @@ var TYPE_OIDS = {
   void: 2278,
   unknown: 705
 };
+var ARRAY_OIDS = {
+  bool: 1e3,
+  bytea: 1001,
+  name: 1003,
+  int8: 1016,
+  int2: 1005,
+  int4: 1007,
+  text: 1009,
+  oid: 1028,
+  json: 199,
+  float4: 1021,
+  float8: 1022,
+  money: 791,
+  bpchar: 1014,
+  varchar: 1015,
+  date: 1182,
+  time: 1183,
+  timestamp: 1115,
+  timestamptz: 1185,
+  interval: 1187,
+  timetz: 1270,
+  numeric: 1231,
+  record: 2287,
+  uuid: 2951,
+  jsonb: 3807
+};
+function typeOid(t) {
+  if (isArrayType(t)) return ARRAY_OIDS[arrayElemType(t)] ?? 2277;
+  return TYPE_OIDS[t] ?? 705;
+}
 function shortestParts(v) {
   const s = Math.abs(v).toString();
   if (s.includes("e") || s.includes("E")) {
@@ -4451,6 +4481,9 @@ var FACTORIES = /* @__PURE__ */ new Map([
   ["regr_syy", () => new CorrAcc("regr_syy")],
   ["regr_sxy", () => new CorrAcc("regr_sxy")]
 ]);
+function getAggregateFactories() {
+  return FACTORIES;
+}
 function isAggregateName(name) {
   return FACTORIES.has(name);
 }
@@ -8275,6 +8308,9 @@ function isWindowFunctionName(name) {
 
 // src/schema/catalog.ts
 var builder = null;
+function setCatalogBuilder(b) {
+  builder = b;
+}
 function catalogRelation(ctx, schema, name) {
   if (schema !== "pg_catalog" && schema !== "information_schema") return null;
   return builder ? builder(ctx, schema, name) : null;
@@ -8301,6 +8337,842 @@ var PG_CATALOG_RELATIONS = /* @__PURE__ */ new Set([
   "pg_trigger"
 ]);
 
+// src/schema/catalog-tables.ts
+function rel(specs, rows, table) {
+  const columns = specs.map(([name, type]) => ({ name, type, table }));
+  return { columns, rows };
+}
+var OWNER = "postgres";
+function* allTables(state) {
+  for (const schema of state.schemas.values()) {
+    for (const t of schema.tables.values()) yield t;
+  }
+}
+function* allSequences(state) {
+  for (const schema of state.schemas.values()) {
+    for (const s of schema.sequences.values()) yield s;
+  }
+}
+var NS_PG_CATALOG = 11;
+var NS_INFORMATION_SCHEMA = 13212;
+function namespaceOid(state, name) {
+  if (name === "pg_catalog") return NS_PG_CATALOG;
+  if (name === "information_schema") return NS_INFORMATION_SCHEMA;
+  return state.schemas.get(name)?.oid ?? 0;
+}
+function attTypmod(mod, type) {
+  if (!mod || mod.a === void 0) return -1;
+  if (type === "numeric") return (mod.a << 16 | (mod.b ?? 0)) + 4;
+  if (type === "varchar" || type === "bpchar") return mod.a + 4;
+  return mod.a;
+}
+function enumOid(ctx, t) {
+  if (!isEnumType(t)) return typeOid(t);
+  const e = ctx.state.findEnumByKey(t.slice(5));
+  return e ? e.oid : 0;
+}
+function pgNamespace(state) {
+  const rows = [
+    [NS_PG_CATALOG, "pg_catalog", 10, null],
+    [NS_INFORMATION_SCHEMA, "information_schema", 10, null]
+  ];
+  for (const s of state.schemas.values()) rows.push([s.oid, s.name, 10, null]);
+  return rel(
+    [
+      ["oid", "oid"],
+      ["nspname", "name"],
+      ["nspowner", "oid"],
+      ["nspacl", "text[]"]
+    ],
+    rows,
+    "pg_namespace"
+  );
+}
+function pgClass(ctx) {
+  const state = ctx.state;
+  const rows = [];
+  const push = (oid, name, schema, kind, natts, tuples, hasindex, populated, temp) => {
+    rows.push([
+      oid,
+      name,
+      namespaceOid(state, schema),
+      0,
+      10,
+      kind === "i" ? 403 : kind === "S" || kind === "v" ? 0 : 2,
+      oid,
+      0,
+      0,
+      tuples,
+      0,
+      0,
+      hasindex,
+      false,
+      temp ? "t" : "p",
+      kind,
+      natts,
+      0,
+      false,
+      false,
+      false,
+      false,
+      false,
+      populated,
+      kind === "r" ? "d" : "n",
+      false,
+      0,
+      null,
+      null,
+      null
+    ]);
+  };
+  for (const schemaData of state.schemas.values()) {
+    for (const t of schemaData.tables.values()) {
+      const hasIndex = t.constraints.some((c) => c.kind === "primary_key" || c.kind === "unique") || [...schemaData.indexes.values()].some((i) => i.table === t.name);
+      push(t.oid, t.name, t.schema, "r", t.columns.length, t.rows.length, hasIndex, true, t.temp);
+    }
+    for (const v of schemaData.views.values()) {
+      push(
+        v.oid,
+        v.name,
+        v.schema,
+        v.materialized ? "m" : "v",
+        v.columns?.length ?? 0,
+        v.matRows?.length ?? 0,
+        false,
+        !v.materialized || v.matRows !== null,
+        v.temp
+      );
+    }
+    for (const s of schemaData.sequences.values()) push(s.oid, s.name, s.schema, "S", 3, 1, false, true, s.temp);
+    for (const i of schemaData.indexes.values()) {
+      push(
+        state.schemas.get(i.schema)?.tables.get(i.table)?.oid ?? 0,
+        i.name,
+        i.schema,
+        "i",
+        i.columns.length,
+        0,
+        false,
+        true,
+        false
+      );
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["relname", "name"],
+      ["relnamespace", "oid"],
+      ["reltype", "oid"],
+      ["relowner", "oid"],
+      ["relam", "oid"],
+      ["relfilenode", "oid"],
+      ["reltablespace", "oid"],
+      ["relpages", "int4"],
+      ["reltuples", "float4"],
+      ["relallvisible", "int4"],
+      ["reltoastrelid", "oid"],
+      ["relhasindex", "bool"],
+      ["relisshared", "bool"],
+      ["relpersistence", "bpchar"],
+      ["relkind", "bpchar"],
+      ["relnatts", "int2"],
+      ["relchecks", "int2"],
+      ["relhasrules", "bool"],
+      ["relhastriggers", "bool"],
+      ["relhassubclass", "bool"],
+      ["relrowsecurity", "bool"],
+      ["relforcerowsecurity", "bool"],
+      ["relispopulated", "bool"],
+      ["relreplident", "bpchar"],
+      ["relispartition", "bool"],
+      ["relrewrite", "oid"],
+      ["relacl", "text[]"],
+      ["reloptions", "text[]"],
+      ["relpartbound", "text"]
+    ],
+    rows,
+    "pg_class"
+  );
+}
+function pgAttribute(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    t.columns.forEach((c, i) => {
+      rows.push([
+        t.oid,
+        c.name,
+        enumOid(ctx, c.type.id),
+        i + 1,
+        attTypmod(c.type.mod, c.type.id),
+        -1,
+        c.notNull,
+        c.defaultExpr !== null || c.identity !== null,
+        false,
+        c.identity ? c.identity.always ? "a" : "d" : "",
+        c.generated ? "s" : "",
+        isArrayType(c.type.id) ? 1 : 0
+      ]);
+    });
+  }
+  return rel(
+    [
+      ["attrelid", "oid"],
+      ["attname", "name"],
+      ["atttypid", "oid"],
+      ["attnum", "int2"],
+      ["atttypmod", "int4"],
+      ["attlen", "int2"],
+      ["attnotnull", "bool"],
+      ["atthasdef", "bool"],
+      ["attisdropped", "bool"],
+      ["attidentity", "bpchar"],
+      ["attgenerated", "bpchar"],
+      ["attndims", "int2"]
+    ],
+    rows,
+    "pg_attribute"
+  );
+}
+function pgType(ctx) {
+  const rows = [];
+  for (const [name, oid] of Object.entries(TYPE_OIDS)) {
+    const isArr = name.startsWith("_");
+    rows.push([
+      oid,
+      name,
+      NS_PG_CATALOG,
+      "b",
+      isArr ? "A" : "U",
+      isArr ? TYPE_OIDS[name.slice(1)] ?? 0 : 0,
+      isArr ? 0 : TYPE_OIDS[`_${name}`] ?? 0,
+      0,
+      0,
+      -1
+    ]);
+  }
+  for (const schema of ctx.state.schemas.values()) {
+    for (const e of schema.enums.values()) {
+      rows.push([e.oid, e.name, namespaceOid(ctx.state, e.schema), "e", "E", 0, 0, 0, 0, 4]);
+    }
+    for (const d of schema.domains.values()) {
+      rows.push([d.oid, d.name, namespaceOid(ctx.state, d.schema), "d", "S", 0, 0, typeOid(d.baseType.id), 0, -1]);
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["typname", "name"],
+      ["typnamespace", "oid"],
+      ["typtype", "bpchar"],
+      ["typcategory", "bpchar"],
+      ["typelem", "oid"],
+      ["typarray", "oid"],
+      ["typbasetype", "oid"],
+      ["typrelid", "oid"],
+      ["typlen", "int2"]
+    ],
+    rows,
+    "pg_type"
+  );
+}
+function pgProc(ctx) {
+  const rows = [];
+  let oid = 1e3;
+  const seen = /* @__PURE__ */ new Set();
+  const push = (name, ns, kind, retset, nargs, realOid) => {
+    rows.push([realOid ?? oid++, name, ns, kind, retset, nargs]);
+  };
+  for (const name of getScalarFunctions().keys()) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      push(name, NS_PG_CATALOG, "f", false, -1);
+    }
+  }
+  for (const name of Object.keys(getAggregateFactories())) {
+    if (!seen.has(`agg:${name}`)) {
+      seen.add(`agg:${name}`);
+      push(name, NS_PG_CATALOG, "a", false, -1);
+    }
+  }
+  for (const name of WINDOW_FUNCTION_NAMES) push(name, NS_PG_CATALOG, "w", false, -1);
+  for (const name of getSrfFunctions().keys()) push(name, NS_PG_CATALOG, "f", true, -1);
+  for (const schema of ctx.state.schemas.values()) {
+    for (const fns of schema.functions.values()) {
+      for (const f of fns) {
+        push(f.name, namespaceOid(ctx.state, f.schema), "f", f.returnsSet, f.argTypes.length, f.oid);
+      }
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["proname", "name"],
+      ["pronamespace", "oid"],
+      ["prokind", "bpchar"],
+      ["proretset", "bool"],
+      ["pronargs", "int2"]
+    ],
+    rows,
+    "pg_proc"
+  );
+}
+function pgEnum(ctx) {
+  const rows = [];
+  let oid = 2e4;
+  for (const schema of ctx.state.schemas.values()) {
+    for (const e of schema.enums.values()) {
+      e.labels.forEach((label, i) => {
+        rows.push([oid++, e.oid, i + 1, label]);
+      });
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["enumtypid", "oid"],
+      ["enumsortorder", "float4"],
+      ["enumlabel", "name"]
+    ],
+    rows,
+    "pg_enum"
+  );
+}
+function pgConstraint(ctx) {
+  const rows = [];
+  let oid = 3e4;
+  for (const t of allTables(ctx.state)) {
+    for (const c of t.constraints) {
+      const contype = c.kind === "primary_key" ? "p" : c.kind === "unique" ? "u" : c.kind === "check" ? "c" : "f";
+      const refTable = c.kind === "foreign_key" ? ctx.state.schemas.get(c.refSchema)?.tables.get(c.refTable) : void 0;
+      rows.push([oid++, c.name, namespaceOid(ctx.state, t.schema), contype, false, false, t.oid, refTable?.oid ?? 0]);
+    }
+    for (const col of t.columns) {
+      if (col.notNull) {
+        rows.push([
+          oid++,
+          `${t.name}_${col.name}_not_null`,
+          namespaceOid(ctx.state, t.schema),
+          "n",
+          false,
+          false,
+          t.oid,
+          0
+        ]);
+      }
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["conname", "name"],
+      ["connamespace", "oid"],
+      ["contype", "bpchar"],
+      ["condeferrable", "bool"],
+      ["condeferred", "bool"],
+      ["conrelid", "oid"],
+      ["confrelid", "oid"]
+    ],
+    rows,
+    "pg_constraint"
+  );
+}
+function pgIndex(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const i of schema.indexes.values()) {
+      const table = schema.tables.get(i.table);
+      const isPrimary = i.isConstraint && table?.constraints.some((c) => c.kind === "primary_key" && c.name === i.name) === true;
+      rows.push([table?.oid ?? 0, table?.oid ?? 0, i.columns.length, i.unique, isPrimary, i.where !== null]);
+    }
+  }
+  return rel(
+    [
+      ["indexrelid", "oid"],
+      ["indrelid", "oid"],
+      ["indnatts", "int2"],
+      ["indisunique", "bool"],
+      ["indisprimary", "bool"],
+      ["indpred", "bool"]
+    ],
+    rows,
+    "pg_index"
+  );
+}
+function pgSequence(ctx) {
+  const rows = [];
+  for (const s of allSequences(ctx.state)) {
+    rows.push([s.oid, typeOid(s.dataType), s.startValue, s.increment, s.maxValue, s.minValue, s.cache, s.cycle]);
+  }
+  return rel(
+    [
+      ["seqrelid", "oid"],
+      ["seqtypid", "oid"],
+      ["seqstart", "int8"],
+      ["seqincrement", "int8"],
+      ["seqmax", "int8"],
+      ["seqmin", "int8"],
+      ["seqcache", "int8"],
+      ["seqcycle", "bool"]
+    ],
+    rows,
+    "pg_sequence"
+  );
+}
+function pgSequencesView(ctx) {
+  const rows = [];
+  for (const s of allSequences(ctx.state)) {
+    rows.push([
+      s.schema,
+      s.name,
+      OWNER,
+      typeDisplayName(s.dataType),
+      s.startValue,
+      s.minValue,
+      s.maxValue,
+      s.increment,
+      s.cycle,
+      s.cache,
+      s.isCalled ? s.lastValue : null
+    ]);
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["sequencename", "name"],
+      ["sequenceowner", "name"],
+      ["data_type", "text"],
+      ["start_value", "int8"],
+      ["min_value", "int8"],
+      ["max_value", "int8"],
+      ["increment_by", "int8"],
+      ["cycle", "bool"],
+      ["cache_size", "int8"],
+      ["last_value", "int8"]
+    ],
+    rows,
+    "pg_sequences"
+  );
+}
+function pgTables(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    const hasIndexes = t.constraints.some((c) => c.kind === "primary_key" || c.kind === "unique") || [...ctx.state.schemas.get(t.schema)?.indexes.values() ?? []].some((i) => i.table === t.name);
+    rows.push([t.schema, t.name, OWNER, null, hasIndexes, false, t.triggers.length > 0, false]);
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["tablename", "name"],
+      ["tableowner", "name"],
+      ["tablespace", "name"],
+      ["hasindexes", "bool"],
+      ["hasrules", "bool"],
+      ["hastriggers", "bool"],
+      ["rowsecurity", "bool"]
+    ],
+    rows,
+    "pg_tables"
+  );
+}
+function pgViews(ctx, materialized) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const v of schema.views.values()) {
+      if (v.materialized !== materialized) continue;
+      if (materialized) rows.push([v.schema, v.name, OWNER, null, v.matRows !== null, null]);
+      else rows.push([v.schema, v.name, OWNER, null]);
+    }
+  }
+  if (materialized) {
+    return rel(
+      [
+        ["schemaname", "name"],
+        ["matviewname", "name"],
+        ["matviewowner", "name"],
+        ["tablespace", "name"],
+        ["ispopulated", "bool"],
+        ["definition", "text"]
+      ],
+      rows,
+      "pg_matviews"
+    );
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["viewname", "name"],
+      ["viewowner", "name"],
+      ["definition", "text"]
+    ],
+    rows,
+    "pg_views"
+  );
+}
+function pgIndexesView(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const i of schema.indexes.values()) {
+      rows.push([i.schema, i.table, i.name, null, null]);
+    }
+  }
+  return rel(
+    [
+      ["schemaname", "name"],
+      ["tablename", "name"],
+      ["indexname", "name"],
+      ["tablespace", "name"],
+      ["indexdef", "text"]
+    ],
+    rows,
+    "pg_indexes"
+  );
+}
+function pgSettings(ctx) {
+  const rows = [];
+  const keys = /* @__PURE__ */ new Set([...ctx.state.settings.keys(), ...ctx.state.localSettings.keys()]);
+  for (const name of [...keys].sort()) {
+    rows.push([name, ctx.state.getSetting(name) ?? null]);
+  }
+  return rel(
+    [
+      ["name", "text"],
+      ["setting", "text"]
+    ],
+    rows,
+    "pg_settings"
+  );
+}
+function pgDatabase() {
+  return rel(
+    [
+      ["oid", "oid"],
+      ["datname", "name"],
+      ["encoding", "int4"],
+      ["datistemplate", "bool"],
+      ["datallowconn", "bool"]
+    ],
+    [[5, "postgres", 6, false, true]],
+    "pg_database"
+  );
+}
+function pgRoles() {
+  return rel(
+    [
+      ["oid", "oid"],
+      ["rolname", "name"],
+      ["rolsuper", "bool"],
+      ["rolcanlogin", "bool"]
+    ],
+    [[10, OWNER, true, true]],
+    "pg_roles"
+  );
+}
+function pgTrigger(ctx) {
+  const rows = [];
+  let oid = 4e4;
+  for (const t of allTables(ctx.state)) {
+    for (const tr of t.triggers) {
+      rows.push([oid++, tr.name, t.oid, !tr.forEachRow]);
+    }
+  }
+  return rel(
+    [
+      ["oid", "oid"],
+      ["tgname", "name"],
+      ["tgrelid", "oid"],
+      ["tgisinternal", "bool"]
+    ],
+    rows,
+    "pg_trigger"
+  );
+}
+var CATALOG_NAME = "postgres";
+function infoSchemata(state) {
+  const rows = [
+    [CATALOG_NAME, "pg_catalog", OWNER],
+    [CATALOG_NAME, "information_schema", OWNER]
+  ];
+  for (const s of state.schemas.values()) rows.push([CATALOG_NAME, s.name, OWNER]);
+  return rel(
+    [
+      ["catalog_name", "name"],
+      ["schema_name", "name"],
+      ["schema_owner", "name"]
+    ],
+    rows,
+    "schemata"
+  );
+}
+function infoTables(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const t of schema.tables.values()) {
+      rows.push([CATALOG_NAME, t.schema, t.name, t.temp ? "LOCAL TEMPORARY" : "BASE TABLE", "YES"]);
+    }
+    for (const v of schema.views.values()) {
+      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, "VIEW", "NO"]);
+    }
+  }
+  return rel(
+    [
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["table_type", "text"],
+      ["is_insertable_into", "text"]
+    ],
+    rows,
+    "tables"
+  );
+}
+function infoColumns(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    t.columns.forEach((c, i) => {
+      const id = c.type.id;
+      const isNumeric2 = id === "numeric";
+      const isIntish = id === "int2" || id === "int4" || id === "int8";
+      const charMax = (id === "varchar" || id === "bpchar") && c.type.mod?.a !== void 0 ? c.type.mod.a : null;
+      const dataType = isArrayType(id) ? "ARRAY" : isEnumType(id) ? "USER-DEFINED" : typeDisplayName(id);
+      const udt = isArrayType(id) ? `_${arrayUdt(id)}` : isEnumType(id) ? id.slice(5).split(".").pop() : id;
+      rows.push([
+        CATALOG_NAME,
+        t.schema,
+        t.name,
+        c.name,
+        i + 1,
+        null,
+        c.notNull ? "NO" : "YES",
+        dataType,
+        charMax,
+        isNumeric2 ? c.type.mod?.a ?? null : isIntish ? id === "int2" ? 16 : id === "int4" ? 32 : 64 : null,
+        isNumeric2 ? c.type.mod?.b ?? null : isIntish ? 0 : null,
+        udt,
+        c.identity ? "YES" : "NO",
+        c.generated ? "ALWAYS" : "NEVER",
+        "YES"
+      ]);
+    });
+  }
+  return rel(
+    [
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["column_name", "name"],
+      ["ordinal_position", "int4"],
+      ["column_default", "text"],
+      ["is_nullable", "text"],
+      ["data_type", "text"],
+      ["character_maximum_length", "int4"],
+      ["numeric_precision", "int4"],
+      ["numeric_scale", "int4"],
+      ["udt_name", "name"],
+      ["is_identity", "text"],
+      ["is_generated", "text"],
+      ["is_updatable", "text"]
+    ],
+    rows,
+    "columns"
+  );
+}
+function arrayUdt(t) {
+  const elem = t.slice(0, -2);
+  return isEnumType(elem) ? elem.slice(5).split(".").pop() : elem;
+}
+function infoViews(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const v of schema.views.values()) {
+      if (!v.materialized) rows.push([CATALOG_NAME, v.schema, v.name, null]);
+    }
+  }
+  return rel(
+    [
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["view_definition", "text"]
+    ],
+    rows,
+    "views"
+  );
+}
+function infoSequences(ctx) {
+  const rows = [];
+  for (const s of allSequences(ctx.state)) {
+    rows.push([
+      CATALOG_NAME,
+      s.schema,
+      s.name,
+      typeDisplayName(s.dataType),
+      String(s.startValue),
+      String(s.minValue),
+      String(s.maxValue),
+      String(s.increment),
+      s.cycle ? "YES" : "NO"
+    ]);
+  }
+  return rel(
+    [
+      ["sequence_catalog", "name"],
+      ["sequence_schema", "name"],
+      ["sequence_name", "name"],
+      ["data_type", "text"],
+      ["start_value", "text"],
+      ["minimum_value", "text"],
+      ["maximum_value", "text"],
+      ["increment", "text"],
+      ["cycle_option", "text"]
+    ],
+    rows,
+    "sequences"
+  );
+}
+function infoTableConstraints(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    for (const c of t.constraints) {
+      const type = c.kind === "primary_key" ? "PRIMARY KEY" : c.kind === "unique" ? "UNIQUE" : c.kind === "check" ? "CHECK" : "FOREIGN KEY";
+      rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, type]);
+    }
+  }
+  return rel(
+    [
+      ["constraint_catalog", "name"],
+      ["constraint_schema", "name"],
+      ["constraint_name", "name"],
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["constraint_type", "text"]
+    ],
+    rows,
+    "table_constraints"
+  );
+}
+function infoKeyColumnUsage(ctx) {
+  const rows = [];
+  for (const t of allTables(ctx.state)) {
+    for (const c of t.constraints) {
+      if (c.kind !== "primary_key" && c.kind !== "unique" && c.kind !== "foreign_key") continue;
+      c.columns.forEach((col, i) => {
+        rows.push([CATALOG_NAME, t.schema, c.name, CATALOG_NAME, t.schema, t.name, col, i + 1]);
+      });
+    }
+  }
+  return rel(
+    [
+      ["constraint_catalog", "name"],
+      ["constraint_schema", "name"],
+      ["constraint_name", "name"],
+      ["table_catalog", "name"],
+      ["table_schema", "name"],
+      ["table_name", "name"],
+      ["column_name", "name"],
+      ["ordinal_position", "int4"]
+    ],
+    rows,
+    "key_column_usage"
+  );
+}
+function infoRoutines(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const fns of schema.functions.values()) {
+      for (const f of fns) {
+        rows.push([
+          CATALOG_NAME,
+          f.schema,
+          f.name,
+          "FUNCTION",
+          f.returns ? typeDisplayName(f.returns) : null,
+          f.language.toUpperCase()
+        ]);
+      }
+    }
+  }
+  return rel(
+    [
+      ["routine_catalog", "name"],
+      ["routine_schema", "name"],
+      ["routine_name", "name"],
+      ["routine_type", "text"],
+      ["data_type", "text"],
+      ["external_language", "text"]
+    ],
+    rows,
+    "routines"
+  );
+}
+function buildCatalogRelation(ctx, schema, name) {
+  if (schema === "pg_catalog") {
+    switch (name) {
+      case "pg_namespace":
+        return pgNamespace(ctx.state);
+      case "pg_class":
+        return pgClass(ctx);
+      case "pg_attribute":
+        return pgAttribute(ctx);
+      case "pg_type":
+        return pgType(ctx);
+      case "pg_proc":
+        return pgProc(ctx);
+      case "pg_enum":
+        return pgEnum(ctx);
+      case "pg_constraint":
+        return pgConstraint(ctx);
+      case "pg_index":
+        return pgIndex(ctx);
+      case "pg_sequence":
+        return pgSequence(ctx);
+      case "pg_sequences":
+        return pgSequencesView(ctx);
+      case "pg_tables":
+        return pgTables(ctx);
+      case "pg_views":
+        return pgViews(ctx, false);
+      case "pg_matviews":
+        return pgViews(ctx, true);
+      case "pg_indexes":
+        return pgIndexesView(ctx);
+      case "pg_settings":
+        return pgSettings(ctx);
+      case "pg_database":
+        return pgDatabase();
+      case "pg_roles":
+      case "pg_user":
+        return pgRoles();
+      case "pg_trigger":
+        return pgTrigger(ctx);
+      default:
+        return null;
+    }
+  }
+  switch (name) {
+    case "schemata":
+      return infoSchemata(ctx.state);
+    case "tables":
+      return infoTables(ctx);
+    case "columns":
+      return infoColumns(ctx);
+    case "views":
+      return infoViews(ctx);
+    case "sequences":
+      return infoSequences(ctx);
+    case "table_constraints":
+      return infoTableConstraints(ctx);
+    case "key_column_usage":
+      return infoKeyColumnUsage(ctx);
+    case "routines":
+      return infoRoutines(ctx);
+    default:
+      return null;
+  }
+}
+setCatalogBuilder(buildCatalogRelation);
+
 // src/lexer/tokenize.ts
 var IDENT_START = /[A-Za-z_\u0080-\uffff]/;
 var IDENT_CONT = /[A-Za-z0-9_$\u0080-\uffff]/;
@@ -12352,13 +13224,13 @@ var RowScope = class {
 function childEnv(env, outer) {
   return { ctx: env.ctx, params: env.params, ctes: env.ctes, outer };
 }
-function relationResult(rel, command) {
-  const visible = rel.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
+function relationResult(rel2, command) {
+  const visible = rel2.columns.map((c, i) => ({ i, c })).filter(({ c }) => !c.hidden);
   return {
     columns: visible.map(({ c }) => ({ name: c.name, type: c.type })),
-    rows: rel.rows.map((r) => visible.map(({ i }) => r[i] ?? null)),
+    rows: rel2.rows.map((r) => visible.map(({ i }) => r[i] ?? null)),
     command,
-    rowCount: rel.rows.length
+    rowCount: rel2.rows.length
   };
 }
 function commandResult(command, rowCount) {
@@ -14617,31 +15489,31 @@ function makeEvalScope(env, scope, extras) {
       return p;
     },
     execScalarSubquery(q) {
-      const rel = executeSelectStmt(childEnv(env, scope), q);
-      if (rel.columns.length !== 1) {
+      const rel2 = executeSelectStmt(childEnv(env, scope), q);
+      if (rel2.columns.length !== 1) {
         throw pgError("cardinality_violation", "subquery must return only one column", "42601");
       }
-      if (rel.rows.length > 1) {
+      if (rel2.rows.length > 1) {
         throw pgError(
           "cardinality_violation",
           "more than one row returned by a subquery used as an expression",
           "21000"
         );
       }
-      const t = rel.columns[0].type;
-      return tv(t === UNKNOWN ? "text" : t, rel.rows[0]?.[0] ?? null);
+      const t = rel2.columns[0].type;
+      return tv(t === UNKNOWN ? "text" : t, rel2.rows[0]?.[0] ?? null);
     },
     execExistsSubquery(q) {
-      const rel = executeSelectStmt(childEnv(env, scope), q);
-      return rel.rows.length > 0;
+      const rel2 = executeSelectStmt(childEnv(env, scope), q);
+      return rel2.rows.length > 0;
     },
     execColumnSubquery(q) {
-      const rel = executeSelectStmt(childEnv(env, scope), q);
-      if (rel.columns.length !== 1) {
+      const rel2 = executeSelectStmt(childEnv(env, scope), q);
+      if (rel2.columns.length !== 1) {
         throw pgError("cardinality_violation", "subquery has too many columns", "42601");
       }
-      const t = rel.columns[0].type;
-      return { type: t === UNKNOWN ? "text" : t, values: rel.rows.map((r) => r[0] ?? null) };
+      const t = rel2.columns[0].type;
+      return { type: t === UNKNOWN ? "text" : t, values: rel2.rows.map((r) => r[0] ?? null) };
     },
     aggValue(node) {
       return extras?.aggMap?.get(node);
@@ -14757,39 +15629,39 @@ function referencesRelation(node, name) {
   }
   return false;
 }
-function applyCteColumnNames(rel, cte) {
-  const columns = rel.columns.map((c, i) => ({
+function applyCteColumnNames(rel2, cte) {
+  const columns = rel2.columns.map((c, i) => ({
     name: cte.columns?.[i] ?? c.name,
     type: c.type,
     table: null
   }));
-  if (cte.columns && cte.columns.length > rel.columns.length) {
+  if (cte.columns && cte.columns.length > rel2.columns.length) {
     throw pgError(
       "syntax",
-      `WITH query "${cte.name}" has ${rel.columns.length} columns available but ${cte.columns.length} columns specified`,
+      `WITH query "${cte.name}" has ${rel2.columns.length} columns available but ${cte.columns.length} columns specified`,
       "42P10"
     );
   }
-  return { columns, rows: rel.rows };
+  return { columns, rows: rel2.rows };
 }
 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 };
-    let rel;
+    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)) {
-      rel = executeRecursiveCte(scopedEnv, cte, cte.query);
+      rel2 = executeRecursiveCte(scopedEnv, cte, cte.query);
     } else if (cte.query.type === "select") {
-      rel = executeSelectStmt(scopedEnv, cte.query);
+      rel2 = executeSelectStmt(scopedEnv, cte.query);
     } else {
       const res = runStatement(scopedEnv, cte.query);
-      rel = {
+      rel2 = {
         columns: res.columns.map((c) => ({ name: c.name, type: c.type, table: null })),
         rows: res.rows
       };
     }
-    ctes.set(cte.name, applyCteColumnNames(rel, cte));
+    ctes.set(cte.name, applyCteColumnNames(rel2, cte));
   }
   return { ctx: env.ctx, params: env.params, ctes, outer: env.outer };
 }
@@ -14848,28 +15720,28 @@ function executeRecursiveCte(env, cte, query) {
     }
     working = next;
   }
-  let rel = { columns, rows: result };
+  let rel2 = { columns, rows: result };
   if (query.orderBy.length > 0 || query.limit || query.offset) {
-    const sortSpecs = outputOrderSpecs(env, rel, query.orderBy);
-    if (sortSpecs.length > 0) sortRows(env, rel, sortSpecs);
-    rel = applyLimitOffset(env, rel, query.limit, query.offset);
+    const sortSpecs = outputOrderSpecs(env, rel2, query.orderBy);
+    if (sortSpecs.length > 0) sortRows(env, rel2, sortSpecs);
+    rel2 = applyLimitOffset(env, rel2, query.limit, query.offset);
   }
-  return rel;
+  return rel2;
 }
-function renameWithAliases(rel, label, colAliases, what) {
-  if (colAliases && colAliases.length > rel.columns.length) {
+function renameWithAliases(rel2, label, colAliases, what) {
+  if (colAliases && colAliases.length > rel2.columns.length) {
     throw pgError(
       "invalid_column_reference",
-      `table "${what}" has ${rel.columns.length} columns available but ${colAliases.length} columns specified`,
+      `table "${what}" has ${rel2.columns.length} columns available but ${colAliases.length} columns specified`,
       "42P10"
     );
   }
-  const columns = rel.columns.map((c, i) => ({
+  const columns = rel2.columns.map((c, i) => ({
     name: colAliases?.[i] ?? c.name,
     type: c.type === UNKNOWN ? "text" : c.type,
     table: label
   }));
-  return { columns, rows: rel.rows };
+  return { columns, rows: rel2.rows };
 }
 function materializeItem(env, item, scope) {
   switch (item.type) {
@@ -14884,15 +15756,15 @@ function materializeItem(env, item, scope) {
       const state = env.ctx.state;
       const table = state.findTable(item.name);
       if (table) {
-        const rel = {
+        const rel2 = {
           columns: table.columns.map((c) => ({ name: c.name, type: c.type.id, table: label })),
           rows: table.rows
         };
-        return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+        return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
       const view = state.findView(item.name);
       if (view) {
-        let rel;
+        let rel2;
         if (view.materialized) {
           if (view.matRows === null || view.matColumns === null) {
             throw pgError(
@@ -14901,23 +15773,23 @@ function materializeItem(env, item, scope) {
               "55000"
             );
           }
-          rel = {
+          rel2 = {
             columns: view.matColumns.map((c) => ({ name: c.name, type: c.type, table: label })),
             rows: view.matRows
           };
         } else {
           const viewEnv = { ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null };
-          rel = executeSelectStmt(viewEnv, view.query);
-          rel = {
-            columns: rel.columns.map((c, i) => ({
+          rel2 = executeSelectStmt(viewEnv, view.query);
+          rel2 = {
+            columns: rel2.columns.map((c, i) => ({
               name: view.columns?.[i] ?? c.name,
               type: c.type,
               table: label
             })),
-            rows: rel.rows
+            rows: rel2.rows
           };
         }
-        return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+        return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
       }
       const resolved = state.resolveRelationSchema(item.name);
       if (resolved) {
@@ -14930,9 +15802,9 @@ function materializeItem(env, item, scope) {
     }
     case "from_subquery": {
       const subEnv = childEnv(env, item.lateral ? scope : env.outer);
-      const rel = executeSelectStmt(subEnv, item.query);
+      const rel2 = executeSelectStmt(subEnv, item.query);
       const label = item.alias ?? "unnamed_subquery";
-      return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+      return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
     }
     case "from_func":
       return materializeFunc(env, item, scope);
@@ -14969,7 +15841,7 @@ function srfCallRelation(env, call, scope, alias) {
 }
 function materializeFunc(env, item, scope) {
   const effScope = scope ?? env.outer;
-  let rel;
+  let rel2;
   if (item.rowsFrom) {
     const parts = item.rowsFrom.map((c) => srfCallRelation(env, c, effScope, null));
     const maxLen = Math.max(0, ...parts.map((p) => p.rows.length));
@@ -14984,18 +15856,18 @@ function materializeFunc(env, item, scope) {
       }
       rows.push(row);
     }
-    rel = { columns, rows };
+    rel2 = { columns, rows };
   } else {
-    rel = srfCallRelation(env, item.call, effScope, item.alias);
+    rel2 = srfCallRelation(env, item.call, effScope, item.alias);
   }
   if (item.withOrdinality) {
-    rel = {
-      columns: [...rel.columns, { name: "ordinality", type: "int8", table: null }],
-      rows: rel.rows.map((r, i) => [...r, BigInt(i + 1)])
+    rel2 = {
+      columns: [...rel2.columns, { name: "ordinality", type: "int8", table: null }],
+      rows: rel2.rows.map((r, i) => [...r, BigInt(i + 1)])
     };
   }
   const label = item.alias ?? (item.call.type === "func" ? item.call.name[item.call.name.length - 1] : "unnamed_function");
-  return { rel: renameWithAliases(rel, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
+  return { rel: renameWithAliases(rel2, label, item.colAliases, label), rangeVars: /* @__PURE__ */ new Set([label]) };
 }
 function isLateralItem(item) {
   switch (item.type) {
@@ -15524,9 +16396,9 @@ function computeAggregate(env, call, rows) {
   for (const t of effective) acc.step(t.args);
   return acc.result();
 }
-function sortRows(env, rel, specs) {
+function sortRows(env, rel2, specs) {
   const ctx = env.ctx;
-  const indexed = rel.rows.map((row, i) => ({ row, i }));
+  const indexed = rel2.rows.map((row, i) => ({ row, i }));
   indexed.sort((a, b) => {
     for (const s of specs) {
       const av = a.row[s.colIdx] ?? null;
@@ -15538,14 +16410,14 @@ function sortRows(env, rel, specs) {
         if (c2 !== 0) return c2;
         continue;
       }
-      const t = rel.columns[s.colIdx].type;
+      const t = rel2.columns[s.colIdx].type;
       let c = datumCompare(t === UNKNOWN ? "text" : t, av, bv, ctx);
       if (s.dir === "desc") c = -c;
       if (c !== 0) return c;
     }
     return a.i - b.i;
   });
-  rel.rows = indexed.map((x) => x.row);
+  rel2.rows = indexed.map((x) => x.row);
 }
 function orderDirection(ob) {
   let dir = ob.dir ?? "asc";
@@ -15554,30 +16426,30 @@ function orderDirection(ob) {
   const nullsFirst = ob.nulls ? ob.nulls === "first" : dir === "desc";
   return { dir, nullsFirst };
 }
-function outputOrderSpecs(env, rel, orderBy) {
+function outputOrderSpecs(env, rel2, orderBy) {
   if (orderBy.length === 0) return [];
   const specs = [];
   const extraCols = [];
   const extraExprs = [];
   for (const ob of orderBy) {
     const { dir, nullsFirst } = orderDirection(ob);
-    const pos = orderPosition(ob.expr, rel);
+    const pos = orderPosition(ob.expr, rel2);
     if (pos !== null) {
       specs.push({ colIdx: pos, dir, nullsFirst });
       continue;
     }
-    specs.push({ colIdx: rel.columns.length + extraCols.length, dir, nullsFirst });
+    specs.push({ colIdx: rel2.columns.length + extraCols.length, dir, nullsFirst });
     extraCols.push({ name: `__ord${extraCols.length}`, type: UNKNOWN, table: null, hidden: true });
     extraExprs.push(ob.expr);
   }
   if (extraExprs.length > 0) {
-    const baseCols = rel.columns.slice();
-    rel.columns = [...rel.columns, ...extraCols];
-    rel.rows = rel.rows.map((row) => {
+    const baseCols = rel2.columns.slice();
+    rel2.columns = [...rel2.columns, ...extraCols];
+    rel2.rows = rel2.rows.map((row) => {
       const scope = new RowScope(baseCols, row, env.outer);
       const extras = extraExprs.map((e) => evalScalar(env, scope, e));
       for (let k = 0; k < extras.length; k++) {
-        const col = rel.columns[baseCols.length + k];
+        const col = rel2.columns[baseCols.length + k];
         col.type = unifyAggType(col.type, extras[k].t);
       }
       return [...row, ...extras.map((x) => x.v)];
@@ -15585,8 +16457,8 @@ function outputOrderSpecs(env, rel, orderBy) {
   }
   return specs;
 }
-function orderPosition(e, rel) {
-  const visible = rel.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
+function orderPosition(e, rel2) {
+  const visible = rel2.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
   if (e.type === "number_lit" && /^\d+$/.test(e.raw)) {
     const k = Number(e.raw);
     const v = visible[k - 1];
@@ -15605,16 +16477,16 @@ function orderPosition(e, rel) {
   }
   return null;
 }
-function stripHidden(rel) {
-  if (!rel.columns.some((c) => c.hidden)) return rel;
-  const keep = rel.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
+function stripHidden(rel2) {
+  if (!rel2.columns.some((c) => c.hidden)) return rel2;
+  const keep = rel2.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
   return {
     columns: keep.map(({ c }) => c),
-    rows: rel.rows.map((row) => keep.map(({ i }) => row[i] ?? null))
+    rows: rel2.rows.map((row) => keep.map(({ i }) => row[i] ?? null))
   };
 }
-function applyLimitOffset(env, rel, limit, offset, tieSpecs) {
-  let rows = rel.rows;
+function applyLimitOffset(env, rel2, limit, offset, tieSpecs) {
+  let rows = rel2.rows;
   if (offset) {
     const v = evalScalar(env, env.outer, offset);
     if (v.v !== null) {
@@ -15631,14 +16503,14 @@ function applyLimitOffset(env, rel, limit, offset, tieSpecs) {
       let end = Math.min(n, rows.length);
       if (tieSpecs && end > 0 && end < rows.length) {
         const boundary = rows[end - 1];
-        while (end < rows.length && sortKeysEqual(env, rel, tieSpecs, boundary, rows[end])) end++;
+        while (end < rows.length && sortKeysEqual(env, rel2, tieSpecs, boundary, rows[end])) end++;
       }
       rows = rows.slice(0, end);
     }
   }
-  return { columns: rel.columns, rows };
+  return { columns: rel2.columns, rows };
 }
-function sortKeysEqual(env, rel, specs, a, b) {
+function sortKeysEqual(env, rel2, specs, a, b) {
   for (const s of specs) {
     const av = a[s.colIdx] ?? null;
     const bv = b[s.colIdx] ?? null;
@@ -15646,7 +16518,7 @@ function sortKeysEqual(env, rel, specs, a, b) {
       if (av !== bv) return false;
       continue;
     }
-    const t = rel.columns[s.colIdx].type;
+    const t = rel2.columns[s.colIdx].type;
     if (datumCompare(t === UNKNOWN ? "text" : t, av, bv, env.ctx) !== 0) return false;
   }
   return true;
@@ -15705,10 +16577,10 @@ 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 = (rel) => rel.rows.map(
+  const normalize = (rel2) => rel2.rows.map(
     (row) => row.map((v, i) => {
       if (v === null) return null;
-      const srcT = rel.columns[i].type;
+      const srcT = rel2.columns[i].type;
       if (srcT === types[i]) return v;
       return castTo(ctx, tv(srcT === UNKNOWN ? "text" : srcT, v), types[i], {}).v;
     })
@@ -16136,26 +17008,26 @@ function executeCore(env0, core, orderBy) {
       outRows[r][k] = castTo(ctx, tv(cellT, v), finalT, { explicit: true }).v;
     }
   }
-  let rel = { columns: outColumns, rows: outRows };
+  let rel2 = { columns: outColumns, rows: outRows };
   if (sortSpecs.length > 0) {
-    sortRows(env, rel, sortSpecs);
+    sortRows(env, rel2, sortSpecs);
   }
   if (core.distinct) {
     if (core.distinct.on) {
       const seen = /* @__PURE__ */ new Set();
-      rel.rows = rel.rows.filter((row) => {
+      rel2.rows = rel2.rows.filter((row) => {
         const k = distinctOnIdx.map((ci) => {
           const v = row[ci] ?? null;
-          return v === null ? "\0N" : datumKey(rel.columns[ci].type, v);
+          return v === null ? "\0N" : datumKey(rel2.columns[ci].type, v);
         }).join("
");
         if (seen.has(k)) return false;
         seen.add(k);
         return true;
       });
     } else {
-      const visible = rel.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
+      const visible = rel2.columns.map((c, i) => ({ c, i })).filter(({ c }) => !c.hidden);
       const seen = /* @__PURE__ */ new Set();
-      rel.rows = rel.rows.filter((row) => {
+      rel2.rows = rel2.rows.filter((row) => {
         const k = visible.map(({ c, i }) => {
           const v = row[i] ?? null;
           return v === null ? "\0N" : datumKey(c.type, v);
@@ -16166,28 +17038,28 @@ function executeCore(env0, core, orderBy) {
       });
     }
   }
-  rel = stripHidden(rel);
-  return rel;
+  rel2 = stripHidden(rel2);
+  return rel2;
 }
 function executeSelectStmt(env0, stmt) {
   const env = applyWith(env0, stmt.with);
-  let rel;
+  let rel2;
   if (stmt.body.type === "select_core") {
-    rel = executeCore(env, stmt.body, stmt.orderBy);
+    rel2 = executeCore(env, stmt.body, stmt.orderBy);
   } else {
-    rel = executeBody(env, stmt.body);
-    const specs = outputOrderSpecs(env, rel, stmt.orderBy);
-    if (specs.length > 0) sortRows(env, rel, specs);
-    rel = stripHidden(rel);
+    rel2 = executeBody(env, stmt.body);
+    const specs = outputOrderSpecs(env, rel2, stmt.orderBy);
+    if (specs.length > 0) sortRows(env, rel2, specs);
+    rel2 = stripHidden(rel2);
   }
   if (stmt.limitWithTies) {
     if (stmt.orderBy.length === 0) {
       throw pgError("syntax", "WITH TIES cannot be specified without ORDER BY clause", "42601");
     }
-    const tieSpecs = outputOrderSpecs(env, rel, stmt.orderBy);
-    return stripHidden(applyLimitOffset(env, rel, stmt.limit, stmt.offset, tieSpecs));
+    const tieSpecs = outputOrderSpecs(env, rel2, stmt.orderBy);
+    return stripHidden(applyLimitOffset(env, rel2, stmt.limit, stmt.offset, tieSpecs));
   }
-  return applyLimitOffset(env, rel, stmt.limit, stmt.offset);
+  return applyLimitOffset(env, rel2, stmt.limit, stmt.offset);
 }
 
 // src/executor/triggers.ts
@@ -16195,6 +17067,9 @@ function matches(t, event) {
   return t.events.some((e) => e.event === event);
 }
 var executor = null;
+function setTriggerExecutor(e) {
+  executor = e;
+}
 function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
   let row = newRow ?? oldRow;
   for (const t of table.triggers) {
@@ -16209,6 +17084,261 @@ function fireRowTriggers(env, table, timing, event, oldRow, newRow) {
   return { row };
 }
 
+// src/executor/triggers-exec.ts
+var PlParser = class {
+  constructor(src) {
+    this.src = src;
+    this.tokens = tokenize(src);
+  }
+  src;
+  tokens;
+  pos = 0;
+  peek(offset = 0) {
+    return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
+  }
+  next() {
+    const t = this.peek();
+    if (t.type !== "eof") this.pos++;
+    return t;
+  }
+  atKw(kw) {
+    const t = this.peek();
+    return t.type === "ident" && t.value === kw;
+  }
+  expectKw(kw) {
+    if (!this.atKw(kw)) throw unsupported(`trigger body: expected "${kw.toUpperCase()}" near "${this.peek().value}"`);
+    this.pos++;
+  }
+  expectSemi() {
+    const t = this.next();
+    if (t.type !== "punct" || t.value !== ";") throw unsupported(`trigger body: expected ";" near "${t.value}"`);
+  }
+  parseBody() {
+    if (this.atKw("declare")) throw unsupported("trigger body: DECLARE section");
+    this.expectKw("begin");
+    const stmts = this.parseStmts();
+    this.expectKw("end");
+    if (this.peek().type === "punct" && this.peek().value === ";") this.pos++;
+    if (this.peek().type !== "eof") throw unsupported(`trigger body: trailing content near "${this.peek().value}"`);
+    return stmts;
+  }
+  parseStmts() {
+    const out = [];
+    while (!this.atKw("end") && !this.atKw("elsif") && !this.atKw("else") && this.peek().type !== "eof") {
+      out.push(this.parseStmt());
+    }
+    return out;
+  }
+  parseStmt() {
+    if (this.atKw("return")) {
+      this.pos++;
+      const t = this.next();
+      let what;
+      if (t.type === "ident" && (t.value === "new" || t.value === "old" || t.value === "null")) {
+        what = t.value;
+      } else {
+        throw unsupported(`trigger body: RETURN ${t.value}`);
+      }
+      this.expectSemi();
+      return { kind: "return", what };
+    }
+    if (this.atKw("if")) {
+      this.pos++;
+      const branches = [];
+      let elseBody = [];
+      const cond = this.parseExprUntilKw("then");
+      branches.push({ cond, body: this.parseStmts() });
+      while (this.atKw("elsif")) {
+        this.pos++;
+        const c = this.parseExprUntilKw("then");
+        branches.push({ cond: c, body: this.parseStmts() });
+      }
+      if (this.atKw("else")) {
+        this.pos++;
+        elseBody = this.parseStmts();
+      }
+      this.expectKw("end");
+      this.expectKw("if");
+      this.expectSemi();
+      return { kind: "if", branches, elseBody };
+    }
+    if (this.atKw("null")) {
+      this.pos++;
+      this.expectSemi();
+      return { kind: "null" };
+    }
+    if (this.atKw("raise")) {
+      this.pos++;
+      if (this.peek().type === "ident") this.pos++;
+      let message = "";
+      while (!(this.peek().type === "punct" && this.peek().value === ";") && this.peek().type !== "eof") {
+        const t = this.next();
+        if (t.type === "string" && message === "") message = t.value;
+      }
+      this.expectSemi();
+      return { kind: "raise", message: message || "raised exception" };
+    }
+    const target = [];
+    const first = this.next();
+    if (first.type !== "ident" && first.type !== "quoted_ident") {
+      throw unsupported(`trigger body statement near "${first.value}"`);
+    }
+    target.push(first.type === "ident" ? first.value : first.value);
+    while (this.peek().type === "punct" && this.peek().value === ".") {
+      this.pos++;
+      const f = this.next();
+      target.push(f.value);
+    }
+    const opTok = this.next();
+    if (!(opTok.type === "op" && (opTok.value === ":=" || opTok.value === "="))) {
+      throw unsupported(`trigger body: expected assignment near "${opTok.value}"`);
+    }
+    const expr = this.parseExprUntilSemi();
+    return { kind: "assign", target, expr };
+  }
+  /** Slice raw source from the current token to the terminator and parse as a SQL expression. */
+  parseExprUntilSemi() {
+    const start = this.peek().pos;
+    let depth = 0;
+    for (; ; ) {
+      const t = this.peek();
+      if (t.type === "eof") throw unsupported("trigger body: unterminated statement");
+      if (t.type === "punct" && t.value === "(") depth++;
+      if (t.type === "punct" && t.value === ")") depth--;
+      if (t.type === "punct" && t.value === ";" && depth === 0) {
+        const text = this.src.slice(start, t.pos);
+        this.pos++;
+        return parseSqlExpr(text);
+      }
+      this.pos++;
+    }
+  }
+  parseExprUntilKw(kw) {
+    const start = this.peek().pos;
+    let depth = 0;
+    for (; ; ) {
+      const t = this.peek();
+      if (t.type === "eof") throw unsupported(`trigger body: expected "${kw.toUpperCase()}"`);
+      if (t.type === "punct" && t.value === "(") depth++;
+      if (t.type === "punct" && t.value === ")") depth--;
+      if (t.type === "ident" && t.value === kw && depth === 0) {
+        const text = this.src.slice(start, t.pos);
+        this.pos++;
+        return parseSqlExpr(text);
+      }
+      this.pos++;
+    }
+  }
+};
+function parseSqlExpr(text) {
+  const stmts = parse(`SELECT ${text}`);
+  const sel = stmts[0];
+  const body = sel.body;
+  const target = body.targets?.[0];
+  if (!target) throw unsupported(`trigger body expression "${text}"`);
+  return target.expr;
+}
+var bodyCache = /* @__PURE__ */ new Map();
+function compiledBody(fn) {
+  const raw = fn.rawBody;
+  if (raw === null) throw unsupported(`trigger function ${fn.name} has no body`);
+  let cached = bodyCache.get(raw);
+  if (cached === void 0) {
+    cached = new PlParser(raw).parseBody();
+    bodyCache.set(raw, cached);
+  }
+  return cached;
+}
+var ReturnSignal = class {
+  constructor(row) {
+    this.row = row;
+  }
+  row;
+};
+function runTriggerBody(env, table, stmts, vars) {
+  const scope = () => triggerScope(table, vars.newRow, vars.oldRow);
+  for (const stmt of stmts) {
+    switch (stmt.kind) {
+      case "assign": {
+        if (stmt.target.length !== 2 || stmt.target[0] !== "new") {
+          throw unsupported(`trigger body: assignment to "${stmt.target.join(".")}"`);
+        }
+        if (vars.newRow === null) {
+          throw pgError("object_not_in_prerequisite_state", `record "new" is not assigned yet`, "55000");
+        }
+        const colName = stmt.target[1];
+        const idx = table.columns.findIndex((c) => c.name === colName);
+        if (idx === -1) {
+          throw pgError("undefined_column", `record "new" has no field "${colName}"`, "42703");
+        }
+        const v = evalScalar(env, scope(), stmt.expr);
+        vars.newRow = vars.newRow.slice();
+        vars.newRow[idx] = v.v === null ? null : castTo(env.ctx, v, table.columns[idx].type.id, { assignment: true }).v;
+        break;
+      }
+      case "return":
+        throw new ReturnSignal(stmt.what === "new" ? vars.newRow : stmt.what === "old" ? vars.oldRow : null);
+      case "if": {
+        let taken = false;
+        for (const b of stmt.branches) {
+          if (evalPredicate(env, scope(), b.cond)) {
+            runTriggerBody(env, table, b.body, vars);
+            taken = true;
+            break;
+          }
+        }
+        if (!taken) runTriggerBody(env, table, stmt.elseBody, vars);
+        break;
+      }
+      case "null":
+        break;
+      case "raise":
+        throw pgError("raise_exception", stmt.message, "P0001");
+    }
+  }
+}
+function triggerScope(table, newRow, oldRow) {
+  const cols = [];
+  const row = [];
+  const rangeVars = /* @__PURE__ */ new Set();
+  if (newRow) {
+    rangeVars.add("new");
+    for (let i = 0; i < table.columns.length; i++) {
+      cols.push({ name: table.columns[i].name, type: table.columns[i].type.id, table: "new" });
+      row.push(newRow[i] ?? null);
+    }
+  }
+  if (oldRow) {
+    rangeVars.add("old");
+    for (let i = 0; i < table.columns.length; i++) {
+      cols.push({ name: table.columns[i].name, type: table.columns[i].type.id, table: "old" });
+      row.push(oldRow[i] ?? null);
+    }
+  }
+  return new RowScope(cols, row, null, rangeVars);
+}
+function executeTrigger(env, table, trigger, _event, oldRow, newRow) {
+  const state = env.ctx.state;
+  if (trigger.when !== null && !evalPredicate(env, triggerScope(table, newRow, oldRow), trigger.when)) {
+    return newRow;
+  }
+  const fns = state.schemas.get(trigger.funcSchema)?.functions.get(trigger.funcName);
+  const fn = fns?.[0];
+  if (!fn) {
+    throw pgError("undefined_function", `function ${trigger.funcSchema}.${trigger.funcName}() does not exist`, "42883");
+  }
+  const stmts = compiledBody(fn);
+  const vars = { newRow: newRow ? newRow.slice() : null, oldRow };
+  try {
+    runTriggerBody(env, table, stmts, vars);
+  } catch (e) {
+    if (e instanceof ReturnSignal) return e.row;
+    throw e;
+  }
+  throw pgError("invalid_function_definition", `control reached end of trigger procedure without RETURN`, "2F005");
+}
+setTriggerExecutor(executeTrigger);
+
 // src/expressions/context.ts
 var EngineCtx = class {
   state;
@@ -17093,8 +18223,8 @@ function executeCreateTableAs(env, stmt) {
     if (stmt.ifNotExists) return commandResult("CREATE TABLE AS", 0);
     throw pgError("duplicate_table", `relation "${name}" already exists`, "42P07");
   }
-  const rel = executeSelectStmt(env, stmt.query);
-  const columns = rel.columns.map((c, i) => ({
+  const rel2 = executeSelectStmt(env, stmt.query);
+  const columns = rel2.columns.map((c, i) => ({
     name: stmt.columns?.[i] ?? c.name,
     type: { id: c.type === UNKNOWN ? "text" : c.type, mod: null },
     notNull: false,
@@ -17106,7 +18236,7 @@ function executeCreateTableAs(env, stmt) {
   }));
   const table = new TableData(schema.name, name, columns, state.nextOid(), stmt.temp);
   if (stmt.withData) {
-    table.rows = rel.rows.map((r) => r.slice());
+    table.rows = rel2.rows.map((r) => r.slice());
   }
   schema.tables.set(name, table);
   const count = stmt.withData ? table.rows.length : 0;
@@ -17177,12 +18307,12 @@ function executeCreateView(env, stmt) {
   let matRows = null;
   let matColumns = null;
   if (stmt.materialized) {
-    const rel = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, stmt.query);
-    matColumns = rel.columns.map((c, i) => ({
+    const rel2 = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, stmt.query);
+    matColumns = rel2.columns.map((c, i) => ({
       name: stmt.columns?.[i] ?? c.name,
       type: c.type === UNKNOWN ? "text" : c.type
     }));
-    matRows = stmt.withData ? rel.rows : null;
+    matRows = stmt.withData ? rel2.rows : null;
   }
   schema.views.set(name, {
     name,
@@ -17202,12 +18332,12 @@ function executeRefreshMatView(env, stmt) {
   if (!view?.materialized) {
     throw pgError("undefined_table", `materialized view "${stmt.name.join(".")}" does not exist`, "42P01");
   }
-  const rel = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, view.query);
-  view.matColumns = rel.columns.map((c, i) => ({
+  const rel2 = executeSelectStmt({ ctx: env.ctx, params: null, ctes: /* @__PURE__ */ new Map(), outer: null }, view.query);
+  view.matColumns = rel2.columns.map((c, i) => ({
     name: view.columns?.[i] ?? c.name,
     type: c.type === UNKNOWN ? "text" : c.type
   }));
-  view.matRows = stmt.withData ? rel.rows : null;
+  view.matRows = stmt.withData ? rel2.rows : null;
   return commandResult("REFRESH MATERIALIZED VIEW", 0);
 }
 function executeCreateSchema(env, stmt) {
@@ -18176,13 +19306,13 @@ function insertSourceRows(env, stmt, colIdxs) {
     }
     return rows;
   }
-  const rel = executeSelectStmt(env, src);
-  if (rel.columns.length > colIdxs.length) {
+  const rel2 = executeSelectStmt(env, src);
+  if (rel2.columns.length > colIdxs.length) {
     throw pgError("syntax", "INSERT has more expressions than target columns", "42601");
   }
-  return rel.rows.map(
+  return rel2.rows.map(
     (r) => r.map((v, i) => {
-      const t = rel.columns[i].type;
+      const t = rel2.columns[i].type;
       return tv(t === UNKNOWN ? "text" : t, v);
     })
   );
@@ -18345,21 +19475,21 @@ function applyUpdateSets(env, table, sets, scope, row) {
       return i;
     });
     if (typeof set.value === "object" && "kind" in set.value && set.value.kind === "row_subquery") {
-      const rel = executeSelectStmt(
+      const rel2 = executeSelectStmt(
         { ctx: env.ctx, params: env.params, ctes: env.ctes, outer: scope },
         set.value.query
       );
-      if (rel.rows.length > 1) {
+      if (rel2.rows.length > 1) {
         throw pgError(
           "cardinality_violation",
           "more than one row returned by a subquery used as an expression",
           "21000"
         );
       }
-      const srcRow = rel.rows[0] ?? null;
+      const srcRow = rel2.rows[0] ?? null;
       for (let k = 0; k < colIdxs.length; k++) {
         const col2 = table.columns[colIdxs[k]];
-        const v = srcRow === null ? tv(col2.type.id, null) : tv(rel.columns[k]?.type ?? "text", srcRow[k] ?? null);
+        const v = srcRow === null ? tv(col2.type.id, null) : tv(rel2.columns[k]?.type ?? "text", srcRow[k] ?? null);
         row[colIdxs[k]] = coerceToColumn(env, v.t === UNKNOWN ? tv("text", v.v) : v, col2);
       }
       continue;