@crvouga/mockingbird-service-postgres 3.1.0 → 3.3.0

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

@@ -0,0 +1,12 @@
+import type { Expr } from "../ast/nodes.js";
+import type { EngineCtx } from "../expressions/context.js";
+import { type ColumnType, type TypeId } from "../types/value.js";
+/** True when the default is a NULL constant, which PostgreSQL does not store as a default. */
+export declare function isNullDefault(ctx: EngineCtx, expr: Expr): boolean;
+/**
+ * Static type of a default expression: a type name, `unknown` for an untyped
+ * string literal, or null when the expression is outside what is analyzed.
+ */
+export declare function defaultExprType(ctx: EngineCtx, expr: Expr): TypeId | null;
+/** PostgreSQL's text for a column default of the given column type, or null for a NULL default. */
+export declare function deparseDefault(ctx: EngineCtx, expr: Expr, column: ColumnType): string | null;

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

@@ -1,3 +1,13 @@
+import type { EngineCtx } from "../expressions/context.js";
 import type { IndexMeta } from "../storage/database-state.js";
-export declare function deparseIndexColumn(column: IndexMeta["columns"][number]): string;
-export declare function deparseIndex(index: IndexMeta): string;
+/** The WHERE predicate of a partial index, or null. */
+export declare function deparseIndexPredicate(ctx: EngineCtx, index: IndexMeta, pretty?: boolean): string | null;
+/** The expression keys of an index, comma-separated (`pg_get_expr(indexprs, indrelid)`), or null. */
+export declare function deparseIndexExpressions(ctx: EngineCtx, index: IndexMeta): string | null;
+/** `pg_get_indexdef(oid)` / `pg_get_indexdef(oid, 0, pretty)`: the whole CREATE INDEX command. */
+export declare function deparseIndex(ctx: EngineCtx, index: IndexMeta, pretty?: boolean): string;
+/**
+ * `pg_get_indexdef(oid, n, pretty)` for n >= 1: the n-th index column, key columns first
+ * and INCLUDE columns after them, without ordering or opclass. Empty when there is no such column.
+ */
+export declare function deparseIndexColumn(ctx: EngineCtx, index: IndexMeta, position: number, pretty?: boolean): string;

package/dist/sql/keywords.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Identifier quoting as PostgreSQL's `quote_identifier` does it, used wherever the
+ * engine prints a name back as SQL (pg_get_indexdef, regnamespace output).
+ */
+/** Quote `name` unless it is safe bare: lower-case letters, digits and `_`, not starting with a digit, not a keyword. */
+export declare function quoteIdentifier(name: string): string;

package/dist/sql/ruleutils.d.ts

@@ -0,0 +1,27 @@
+import type { Expr } from "../ast/nodes.js";
+import type { EngineCtx } from "../expressions/context.js";
+import type { TableData } from "../storage/database-state.js";
+import { type ColumnType, type TypeId } from "../types/value.js";
+/**
+ * Expression deparsing the way PostgreSQL's ruleutils.c prints a stored expression
+ * (pg_get_indexdef, pg_get_expr): constants carry their resolved type, the implicit
+ * casts operator resolution added are visible, and parentheses follow the node tree
+ * rather than the text the user wrote.
+ *
+ * PostgreSQL deparses the analyzed tree; this engine keeps the parsed one, so the
+ * first half of this file redoes the part of analysis that shows in the output:
+ * what type an untyped literal took and where a cast was inserted. It covers the
+ * operators, predicates and functions index definitions are written with; anything
+ * else falls back to `deparseExpr` and is not claimed to match.
+ */
+export interface RuleScope {
+    ctx: EngineCtx;
+    /** table the expression's columns belong to */
+    table: TableData | null;
+}
+/** format_type(): the SQL name of a type with its modifier. */
+export declare function formatType(scope: RuleScope, type: TypeId, mod?: ColumnType["mod"]): string;
+/** A stored expression as PostgreSQL prints it: a predicate, CHECK body or default. */
+export declare function deparseRuleExpr(scope: RuleScope, expr: Expr, pretty?: boolean): string;
+/** An index key expression: parenthesized unless it is a bare function call. */
+export declare function deparseIndexExpr(scope: RuleScope, expr: Expr, pretty?: boolean): string;

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

@@ -16,16 +16,20 @@ export interface ColumnMeta {
     collate: string | null;
     /** resolved domain name when column type came from a domain */
     domain: string | null;
+    /** `pg_attribute.attstorage` override (p/e/x/m); absent = the type's default strategy */
+    storage?: "p" | "e" | "x" | "m";
 }
 export type ConstraintMeta = {
     kind: "primary_key";
     name: string;
     columns: string[];
+    indexOid?: number;
 } | {
     kind: "unique";
     name: string;
     columns: string[];
     nullsNotDistinct: boolean;
+    indexOid?: number;
 } | {
     kind: "check";
     name: string;
@@ -46,16 +50,32 @@ export interface IndexMeta {
     name: string;
     schema: string;
     table: string;
+    /** oid of the indexed table: the link that survives table and schema renames */
+    tableOid?: number;
     unique: boolean;
     comment?: string | null;
+    /** false after a failed or interrupted CREATE INDEX CONCURRENTLY / REINDEX CONCURRENTLY */
     valid?: boolean;
     scans?: bigint;
+    /** clock time (ms) of the most recent scan counted in `scans` */
+    lastScan?: number;
+    /** access method (`USING ...`); absent means btree */
+    method?: string;
+    /** non-key columns of INCLUDE (...) */
+    include?: string[];
+    /** WITH (...) storage parameters as written, values unquoted */
+    options?: Array<{
+        name: string;
+        value: string;
+    }>;
     /** simple column indexes store names; expression indexes store the AST */
     columns: Array<{
         column: string | null;
         expr: Expr | null;
         dir: "asc" | "desc";
         nulls: "first" | "last";
+        /** operator class as written, possibly schema-qualified; absent means the default */
+        opclass?: string[] | null;
     }>;
     where: Expr | null;
     nullsNotDistinct: boolean;
@@ -82,6 +102,8 @@ export declare class TableData {
     constraints: ConstraintMeta[];
     triggers: TriggerMeta[];
     temp: boolean;
+    /** UNLOGGED table (`pg_class.relpersistence = 'u'`); catalog metadata only, there is no WAL to skip */
+    unlogged: boolean;
     /** monotonically increasing oid-like id for catalog output */
     readonly oid: number;
     /** >0 while shared with a clone or transaction snapshot. */
@@ -138,6 +160,8 @@ export interface SequenceData {
     } | null;
     dataType: TypeId;
     temp: boolean;
+    /** UNLOGGED sequence (`pg_class.relpersistence = 'u'`); absent = logged */
+    unlogged?: boolean;
     oid: number;
     shareCount?: number;
 }
@@ -178,6 +202,8 @@ export interface FunctionData {
     rawBody: string | null;
     strict: boolean;
     oid: number;
+    /** on an extension's member functions: the installed version when it is not the extension's default */
+    extensionVersion?: string;
     jsImpl?: (...args: Array<null | boolean | number | bigint | string | Uint8Array>) => null | boolean | number | bigint | string | Uint8Array;
 }
 export declare class SchemaData {
@@ -197,6 +223,17 @@ export declare class SchemaData {
     /** Share table/sequence objects; copy maps so CREATE/DROP is isolated. */
     cloneShallow(): SchemaData;
 }
+/** ANALYZE bookkeeping for pg_stat_user_tables, keyed by table oid in {@link DatabaseState.tableStats}. */
+export interface TableStats {
+    analyzeCount: number;
+    /** clock time (ms) of the most recent ANALYZE */
+    lastAnalyze: number;
+}
+/** One-shot failure presets armed by tests (`Database.fault`). */
+export interface EngineFaults {
+    /** SQLSTATE raised by the next concurrent index build, which leaves its index invalid. */
+    concurrentIndexBuild?: string;
+}
 export interface PreparedStatement {
     name: string;
     argTypes: TypeId[] | null;
@@ -207,6 +244,16 @@ export declare class DatabaseState {
     settings: Map<string, string>;
     /** SET LOCAL values, cleared on COMMIT/ROLLBACK */
     localSettings: Map<string, string>;
+    /**
+     * What `RESET` and `SET ... TO DEFAULT` return to, over the built-in defaults: the settings a
+     * wire session started with. Belongs to the session executing, so clones do not carry it.
+     */
+    settingDefaults: ReadonlyMap<string, string> | null;
+    /**
+     * Host functions registered under `pg_catalog`: found ahead of the search path, the way
+     * PostgreSQL finds its own functions whatever `search_path` says. Copied to clones, not encoded.
+     */
+    systemFunctions: Map<string, FunctionData[]>;
     prepared: Map<string, PreparedStatement>;
     prng: Prng;
     clock: Clock;
@@ -220,6 +267,10 @@ export declare class DatabaseState {
     } | null;
     /** Session currval per sequence; absent entry means currval is undefined. */
     sequenceCurrval: Map<string, bigint>;
+    /** Per-table ANALYZE bookkeeping, keyed by table oid. */
+    tableStats: Map<number, TableStats>;
+    /** Armed failure presets. Not part of snapshots, clones or transaction rollback. */
+    faults: EngineFaults;
     constructor(prng: Prng, clock: Clock);
     nextOid(): number;
     getSetting(name: string): string | undefined;

package/dist/types/regnamespace.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `regnamespace`: an oid that reads and prints as a schema name (regnamespacein /
+ * regnamespaceout). The catalog lookups stay with the caller; this is the text form.
+ */
+/** Schemas every database has, with the oids PostgreSQL gives them (information_schema's is not fixed). */
+export declare const BUILTIN_NAMESPACES: ReadonlyArray<readonly [name: string, oid: number]>;
+export declare const builtinNamespaceOid: (name: string) => number | undefined;
+export declare const builtinNamespaceName: (oid: number) => string | undefined;
+/** oidin: an unsigned 32-bit integer; a negative literal is its two's-complement reading. */
+export declare function parseOidText(text: string): number;
+/** A cast from an integer type: int2/int4 reinterpret their bits, int8 must fit. */
+export declare function oidFromInteger(value: number | bigint): number;
+/**
+ * Split regnamespace input as SplitIdentifierString does. `-` and an all-digit string are
+ * oids; anything else must be exactly one identifier, case-folded unless double-quoted.
+ */
+export declare function parseNamespaceInput(text: string): {
+    oid: number;
+} | {
+    name: string;
+};
+/** regnamespaceout: `-` for zero, the quoted schema name, or the bare number when no schema has that oid. */
+export declare function namespaceText(oid: number, name: string | null | undefined): string;

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 {
+    /** unquoted schema name for an oid, or null when no schema has it */
     namespaceName?(oid: number): string | null;
     /** offset seconds east of UTC for rendering timestamptz at given UTC micros */
     zoneOffsetAt(utcMicros: bigint): number;
@@ -90,6 +91,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 {
+    /** oid of the schema with exactly this name; raises 3F000 when there is none */
     namespaceOid?(name: string): number;
     /** session zone offset lookup for naive timestamptz input */
     zoneOffsetForNaive(naiveMicros: bigint): number;