@crvouga/mockingbird-service-postgres 2.3.0 → 3.0.1

package/dist/sql/deparse-index.d.ts

@@ -0,0 +1,3 @@
+import type { IndexMeta } from "../storage/database-state.js";
+export declare function deparseIndexColumn(column: IndexMeta["columns"][number]): string;
+export declare function deparseIndex(index: IndexMeta): string;

package/dist/sql/deparse.d.ts

@@ -1,4 +1,5 @@
-import type { SelectStmt } from "../ast/nodes.js";
+import type { Expr, SelectStmt } from "../ast/nodes.js";
 /** Minimal SELECT deparsing for pg_get_viewdef / information_schema. */
 export declare function deparseSelect(stmt: SelectStmt): string;
 export declare function quoteIdent(name: string): string;
+export declare function deparseExpr(e: Expr): string;

package/dist/storage/database-state.d.ts

@@ -42,10 +42,14 @@ export type ConstraintMeta = {
     match: "full" | "simple";
 };
 export interface IndexMeta {
+    oid?: number;
     name: string;
     schema: string;
     table: string;
     unique: boolean;
+    comment?: string | null;
+    valid?: boolean;
+    scans?: bigint;
     /** simple column indexes store names; expression indexes store the AST */
     columns: Array<{
         column: string | null;

package/dist/types/value.d.ts

@@ -80,6 +80,7 @@ export declare function parseUuidText(text: string): string;
 export declare function parseMoneyText(text: string): bigint;
 export declare function moneyText(cents: bigint): string;
 export interface OutputCtx {
+    namespaceName?(oid: number): string | null;
     /** offset seconds east of UTC for rendering timestamptz at given UTC micros */
     zoneOffsetAt(utcMicros: bigint): number;
 }
@@ -89,6 +90,7 @@ export declare function recordText(rec: PgRecord, ctx: OutputCtx): string;
 /** Render a non-null datum of type `t` to PG wire text. */
 export declare function datumText(t: TypeId, v: Datum, ctx: OutputCtx): string;
 export interface InputCtx {
+    namespaceOid?(name: string): number;
     /** session zone offset lookup for naive timestamptz input */
     zoneOffsetForNaive(naiveMicros: bigint): number;
     /** enum label validation: returns true when label is valid for the enum type */

package/dist/unstable.js

@@ -2351,6 +2351,7 @@ var TYPE_ALIASES = {
   regclass: "regclass",
   regtype: "regtype",
   regproc: "regproc",
+  regnamespace: "regnamespace",
   oid: "oid",
   void: "void",
   record: "record",
@@ -2444,6 +2445,7 @@ var TYPE_OIDS = {
   numeric: 1700,
   regclass: 2205,
   regtype: 2206,
+  regnamespace: 4089,
   record: 2249,
   uuid: 2950,
   jsonb: 3802,
@@ -2744,6 +2746,7 @@ function recordText(rec, ctx) {
   return `(${parts.join(",")})`;
 }
 function datumText(t, v, ctx) {
+  if (t === "regnamespace") return ctx.namespaceName?.(v) ?? String(v);
   if (v === null) throw pgError("internal", "datumText called with null");
   if (isArrayType(t)) return arrayText(v, ctx);
   if (isEnumType(t)) return v;
@@ -2817,6 +2820,11 @@ function datumText(t, v, ctx) {
 }
 var UTC_INPUT = { zoneOffsetForNaive: () => 0 };
 function datumFromText(t, text, ctx) {
+  if (t === "regnamespace") {
+    if (/^\s*\d+\s*$/.test(text)) return datumFromText("oid", text, ctx);
+    if (!ctx.namespaceOid) throw unsupported("regnamespace input without a catalog");
+    return ctx.namespaceOid(text);
+  }
   if (isArrayType(t)) return parseArrayText(t, text, ctx);
   if (isEnumType(t)) {
     if (ctx.enumHasLabel && !ctx.enumHasLabel(t, text)) {
@@ -3137,7 +3145,11 @@ function castTo(env, value, target, opts = {}) {
     );
     return tv(target, makeArray(toElem, items, arr.dims.slice(), arr.lbs.slice()));
   }
-  if ((from === "int4" || from === "int8" || from === "int2") && (target === "oid" || target === "regclass" || target === "regtype" || target === "regproc")) {
+  if (from === "oid" && target === "regnamespace") return tv(target, v);
+  if (from === "regnamespace" && (target === "oid" || target === "int4" || target === "int8")) {
+    return tv(target, target === "int8" ? BigInt(v) : v);
+  }
+  if ((from === "int4" || from === "int8" || from === "int2") && (target === "oid" || target === "regclass" || target === "regtype" || target === "regproc" || target === "regnamespace")) {
     return tv(target, Number(v));
   }
   if (from === "oid" && (target === "int4" || target === "int8")) {
@@ -3435,6 +3447,7 @@ function datumCompare(t, a, b, ctx = DEFAULT_COMPARE_CTX) {
     case "int2":
     case "int4":
     case "oid":
+    case "regnamespace":
     case "date":
       return expectNumber(a, t) - expectNumber(b, t);
     case "float4":
@@ -6525,10 +6538,99 @@ function exactDegTan(x) {
 }
 
 // src/sql/deparse.ts
+function deparseSelect(stmt) {
+  return deparseBody(stmt.body);
+}
+function deparseBody(body) {
+  switch (body.type) {
+    case "select_core":
+      return deparseSelectCore(body);
+    case "setop":
+      return `${deparseBody(body.left)} ${body.op.toUpperCase()}${body.all ? " ALL" : ""} ${deparseBody(body.right)}`;
+    case "values":
+      return `VALUES ${body.rows.map((r) => `(${r.map(deparseExpr).join(", ")})`).join(", ")}`;
+  }
+}
+function deparseSelectCore(body) {
+  const targets = body.targets.length === 0 ? "*" : body.targets.map((t) => {
+    const expr = deparseExpr(t.expr);
+    return t.alias ? `${expr} AS ${quoteIdent(t.alias)}` : expr;
+  }).join(", ");
+  let sql = `SELECT ${targets}`;
+  if (body.from.length > 0) {
+    sql += ` FROM ${body.from.map(deparseFrom).join(", ")}`;
+  }
+  if (body.where) sql += ` WHERE ${deparseExpr(body.where)}`;
+  if (body.groupBy && body.groupBy.length > 0) {
+    sql += ` GROUP BY ${body.groupBy.map((g) => g.kind === "expr" ? deparseExpr(g.expr) : "?").join(", ")}`;
+  }
+  if (body.having) sql += ` HAVING ${deparseExpr(body.having)}`;
+  return sql;
+}
+function deparseFrom(item) {
+  if (item.type === "from_table") {
+    const name = item.name.join(".");
+    return item.alias ? `${name} ${quoteIdent(item.alias)}` : name;
+  }
+  return "(subquery)";
+}
 function quoteIdent(name) {
   if (/^[a-z_][a-z0-9_$]*$/.test(name)) return name;
   return `"${name.replaceAll('"', '""')}"`;
 }
+function deparseExpr(e) {
+  switch (e.type) {
+    case "null_lit":
+      return "NULL";
+    case "string_lit":
+      return `'${e.value.replaceAll("'", "''")}'`;
+    case "number_lit":
+      return e.raw;
+    case "bool_lit":
+      return e.value ? "true" : "false";
+    case "colref":
+      return e.parts.join(".");
+    case "star":
+      return e.table ? `${e.table.join(".")}.*` : "*";
+    case "binop":
+      return `(${deparseExpr(e.left)} ${e.op} ${deparseExpr(e.right)})`;
+    case "unop":
+      return `${e.op}${deparseExpr(e.operand)}`;
+    case "cast":
+      return `CAST(${deparseExpr(e.expr)} AS ${e.target.parts.join(".")})`;
+    case "func":
+      return `${e.name.join(".")}(${e.args.map(deparseExpr).join(", ")})`;
+    case "case": {
+      let out = "CASE";
+      if (e.operand) out += ` ${deparseExpr(e.operand)}`;
+      for (const arm of e.whens) {
+        out += ` WHEN ${deparseExpr(arm.when)} THEN ${deparseExpr(arm.then)}`;
+      }
+      if (e.elseExpr) out += ` ELSE ${deparseExpr(e.elseExpr)}`;
+      return `${out} END`;
+    }
+    case "subquery_expr":
+      return `(${deparseSelect(e.query)})`;
+    default:
+      return "?";
+  }
+}
+
+// src/sql/deparse-index.ts
+function deparseIndexColumn(column) {
+  let result = column.column === null ? deparseExpr(column.expr) : quoteIdent(column.column);
+  if (column.dir === "desc") result += " DESC";
+  const defaultNulls = column.dir === "desc" ? "first" : "last";
+  if (column.nulls !== defaultNulls) result += ` NULLS ${column.nulls.toUpperCase()}`;
+  return result;
+}
+function deparseIndex(index) {
+  const columns = index.columns.map(deparseIndexColumn).join(", ");
+  const unique = index.unique ? "UNIQUE " : "";
+  const nulls = index.nullsNotDistinct ? " NULLS NOT DISTINCT" : "";
+  const predicate = index.where ? ` WHERE ${deparseExpr(index.where)}` : "";
+  return `CREATE ${unique}INDEX ${quoteIdent(index.name)} ON ${quoteIdent(index.schema)}.${quoteIdent(index.table)} USING btree (${columns})${nulls}${predicate}`;
+}
 
 // src/runtime/database-context.ts
 var contexts = /* @__PURE__ */ new WeakMap();
@@ -6619,6 +6721,22 @@ function sequenceNextval(ctx, seq) {
 }
 function getMiscFunctions() {
   const m = /* @__PURE__ */ new Map();
+  m.set(
+    "pg_get_indexdef",
+    strict("text", (ctx, args) => {
+      const oid = argInt(ctx, args[0]);
+      const column = args[1] ? argInt(ctx, args[1]) : 0;
+      for (const schema of ctx.state.schemas.values()) {
+        for (const index of schema.indexes.values()) {
+          if (index.oid !== oid) continue;
+          if (column === 0) return tv("text", deparseIndex(index));
+          const part = index.columns[column - 1];
+          return tv("text", part ? deparseIndexColumn(part) : "");
+        }
+      }
+      return tv("text", null);
+    })
+  );
   m.set("version", () => tv("text", PG_VERSION_TEXT));
   m.set("current_database", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
   m.set("current_catalog", (ctx) => tv("name", databaseCatalogContext(ctx.state).name));
@@ -8483,6 +8601,9 @@ var PG_CATALOG_RELATIONS = /* @__PURE__ */ new Set([
   "pg_enum",
   "pg_constraint",
   "pg_index",
+  "pg_description",
+  "pg_stat_user_tables",
+  "pg_stat_user_indexes",
   "pg_sequence",
   "pg_sequences",
   "pg_tables",
@@ -8605,7 +8726,7 @@ function pgClass(ctx) {
     for (const s of schemaData.sequences.values()) push(s.oid, s.name, s.schema, "S", 3, 1, false, true, s.temp);
     for (const i of schemaData.indexes.values()) {
       push(
-        state.schemas.get(i.schema)?.tables.get(i.table)?.oid ?? 0,
+        i.oid ?? state.schemas.get(i.schema)?.tables.get(i.table)?.oid ?? 0,
         i.name,
         i.schema,
         "i",
@@ -8842,7 +8963,15 @@ function pgIndex(ctx) {
     for (const i of schema.indexes.values()) {
       const table = schema.tables.get(i.table);
       const isPrimary = i.isConstraint && table?.constraints.some((c) => c.kind === "primary_key" && c.name === i.name) === true;
-      rows.push([table?.oid ?? 0, table?.oid ?? 0, i.columns.length, i.unique, isPrimary, i.where !== null]);
+      rows.push([
+        i.oid ?? table?.oid ?? 0,
+        table?.oid ?? 0,
+        i.columns.length,
+        i.unique,
+        isPrimary,
+        i.where !== null,
+        i.valid !== false
+      ]);
     }
   }
   return rel(
@@ -8852,12 +8981,73 @@ function pgIndex(ctx) {
       ["indnatts", "int2"],
       ["indisunique", "bool"],
       ["indisprimary", "bool"],
-      ["indpred", "bool"]
+      ["indpred", "bool"],
+      ["indisvalid", "bool"]
     ],
     rows,
     "pg_index"
   );
 }
+function pgStatUserTables(ctx) {
+  return rel(
+    [
+      ["relid", "oid"],
+      ["schemaname", "name"],
+      ["relname", "name"],
+      ["n_live_tup", "int8"]
+    ],
+    [...allTables(ctx.state)].map((table) => [table.oid, table.schema, table.name, BigInt(table.rowCount())]),
+    "pg_stat_user_tables"
+  );
+}
+function pgDescription(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    for (const index of schema.indexes.values()) {
+      if (index.comment) rows.push([index.oid ?? 0, 1259, 0, index.comment]);
+    }
+  }
+  return rel(
+    [
+      ["objoid", "oid"],
+      ["classoid", "oid"],
+      ["objsubid", "int4"],
+      ["description", "text"]
+    ],
+    rows,
+    "pg_description"
+  );
+}
+function pgStatUserIndexes(ctx) {
+  const rows = [];
+  for (const schema of ctx.state.schemas.values()) {
+    if (schema.name === "pg_catalog" || schema.name === "information_schema" || schema.name.startsWith("pg_toast"))
+      continue;
+    for (const index of schema.indexes.values()) {
+      const table = schema.tables.get(index.table);
+      rows.push([
+        table?.oid ?? 0,
+        index.oid ?? table?.oid ?? 0,
+        schema.name,
+        index.table,
+        index.name,
+        index.scans ?? 0n
+      ]);
+    }
+  }
+  return rel(
+    [
+      ["relid", "oid"],
+      ["indexrelid", "oid"],
+      ["schemaname", "name"],
+      ["relname", "name"],
+      ["indexrelname", "name"],
+      ["idx_scan", "int8"]
+    ],
+    rows,
+    "pg_stat_user_indexes"
+  );
+}
 function pgSequence(ctx) {
   const rows = [];
   for (const s of allSequences(ctx.state)) {
@@ -8972,7 +9162,7 @@ function pgIndexesView(ctx) {
   const rows = [];
   for (const schema of ctx.state.schemas.values()) {
     for (const i of schema.indexes.values()) {
-      rows.push([i.schema, i.table, i.name, null, null]);
+      rows.push([i.schema, i.table, i.name, null, deparseIndex(i)]);
     }
   }
   return rel(
@@ -9293,6 +9483,12 @@ function buildCatalogRelation(ctx, schema, name) {
         return pgConstraint(ctx);
       case "pg_index":
         return pgIndex(ctx);
+      case "pg_description":
+        return pgDescription(ctx);
+      case "pg_stat_user_tables":
+        return pgStatUserTables(ctx);
+      case "pg_stat_user_indexes":
+        return pgStatUserIndexes(ctx);
       case "pg_sequence":
         return pgSequence(ctx);
       case "pg_sequences":
@@ -12068,8 +12264,8 @@ var Parser = class {
       this.eatKw("column");
       const column = this.ident();
       let alterType = this.eatKw("type");
-      if (!alterType && this.eatKw("set") && this.atKw("data")) {
-        this.pos += 1;
+      if (!alterType && this.atKw("set") && this.atKw("data", 1)) {
+        this.pos += 2;
         this.expectKw("type");
         alterType = true;
       }
@@ -16470,7 +16666,7 @@ function uniqueSpecsFor(env, table) {
   const schema = env.ctx.state.schemas.get(table.schema);
   if (schema) {
     for (const idx of schema.indexes.values()) {
-      if (idx.table !== table.name || !idx.unique || idx.isConstraint) continue;
+      if (idx.table !== table.name || !idx.unique || idx.isConstraint || idx.valid === false) continue;
       specs.push({
         name: idx.name,
         keys: idx.columns.map((c) => ({
@@ -16652,6 +16848,9 @@ function tryIndexedTableRows(env, table, alias, where) {
   const key = uniqueKeyOf(env, table, spec, probeRow);
   if (key === null) return [];
   const hits = indexStoreFor(env, table, spec).lookup(key);
+  const schema = env.ctx.state.schemas.get(table.schema);
+  const index = schema?.indexes.get(spec.name);
+  if (schema && index) schema.indexes.set(spec.name, { ...index, scans: (index.scans ?? 0n) + 1n });
   return hits.map((i) => table.rowAt(i));
 }
 function tryIndexedFromItem(env, item, where) {
@@ -19836,6 +20035,25 @@ var EngineCtx = class {
   timezone() {
     return this.state.getSetting("timezone") ?? "UTC";
   }
+  namespaceOid(input) {
+    const trimmed = input.trim();
+    const name = trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1).replaceAll('""', '"') : trimmed.toLowerCase();
+    if (name === "pg_catalog") return 11;
+    if (name === "information_schema") return 13212;
+    const schema = this.state.schemas.get(name);
+    if (!schema) throw pgError("undefined_object", `schema "${name}" does not exist`, "3F000");
+    return schema.oid;
+  }
+  namespaceName(oid) {
+    if (oid === 11) return "pg_catalog";
+    if (oid === 13212) return "information_schema";
+    for (const schema of this.state.schemas.values()) {
+      if (schema.oid === oid) {
+        return /^[a-z_][a-z0-9_$]*$/.test(schema.name) ? schema.name : `"${schema.name.replaceAll('"', '""')}"`;
+      }
+    }
+    return null;
+  }
   zoneOffsetAt(utcMicros) {
     return zoneOffsetAtUtc(this.timezone(), utcMicros);
   }
@@ -20730,6 +20948,7 @@ function executeCreateIndex(env, stmt) {
   }
   assertGinTrgmIndex(state, table, stmt);
   schema.indexes.set(name, {
+    oid: state.nextOid(),
     name,
     schema: schema.name,
     table: table.name,
@@ -20742,7 +20961,8 @@ function executeCreateIndex(env, stmt) {
     })),
     where: stmt.where,
     nullsNotDistinct: stmt.nullsNotDistinct,
-    isConstraint: false
+    isConstraint: false,
+    valid: true
   });
   if (stmt.unique) {
     try {
@@ -20750,7 +20970,9 @@ function executeCreateIndex(env, stmt) {
         checkUnique(env, table, table.rowAt(i), i);
       }
     } catch (err) {
-      schema.indexes.delete(name);
+      if (stmt.concurrently) schema.indexes.get(name).valid = false;
+      else schema.indexes.delete(name);
+      table.indexStores = null;
       throw err;
     }
   }