@crvouga/mockingbird-service-postgres 3.2.0 → 3.3.0

package/dist/api/database.d.ts

@@ -1,4 +1,5 @@
 import { type DatabaseOptions, type Int8Mode, type RandomMode } from "../runtime/index.js";
+import type { EngineFaults } from "../storage/database-state.js";
 import type { BindValue, JsValue, QueryRow } from "./bind.js";
 import { type Snapshot } from "./snapshot.js";
 import { Statement } from "./statement.js";
@@ -24,6 +25,8 @@ export interface QueryOptions {
      */
     at?: Snapshot | string;
 }
+/** One-shot failures armed with {@link Database.fault}. */
+export type DatabaseFaults = EngineFaults;
 /**
  * Pure TypeScript in-memory PostgreSQL database.
  *
@@ -99,6 +102,14 @@ export declare class Database {
     get history(): DatabaseHistory;
     /** Open a copy-on-write branch from `at`, or from the current state when omitted. */
     branch(at?: Snapshot): Database;
+    /**
+     * Arm a one-shot failure for a test. `concurrentIndexBuild` makes the next
+     * `CREATE INDEX CONCURRENTLY` or `REINDEX ... CONCURRENTLY` fail with that SQLSTATE
+     * (`57014` canceled, `40P01` deadlock) and, as PostgreSQL does when such a build is
+     * interrupted, leave the index it was building in the catalog with `indisvalid = false`.
+     * Faults are not part of snapshots and survive transaction rollback until they fire.
+     */
+    fault(faults: DatabaseFaults): void;
     /** Close the database. Further SQL throws. Idempotent. */
     close(): void;
     /**

package/dist/ast/nodes.d.ts

@@ -206,6 +206,8 @@ export interface SubstringExpr {
     readonly forLen: Expr | null;
     readonly similar: Expr | null;
     readonly escape: Expr | null;
+    /** written as an ordinary call, `substring(x, 1, 2)`, rather than with FROM / FOR */
+    readonly call?: boolean;
 }
 export interface OverlayExpr {
     readonly type: "overlay";
@@ -433,6 +435,11 @@ export type ColumnConstraint = {
 } | {
     kind: "collate";
     collation: string[];
+}
+/** `STORAGE mode`; the mode is validated against the column type when the column is built */
+ | {
+    kind: "storage";
+    mode: string;
 };
 export type RefAction = "no_action" | "restrict" | "cascade" | "set_null" | "set_default" | null;
 export interface ColumnDef {
@@ -489,6 +496,7 @@ export interface CreateTableAsStmt {
     readonly query: SelectStmt;
     readonly withData: boolean;
     readonly materialized: boolean;
+    readonly unlogged?: boolean;
 }
 export interface CreateIndexStmt {
     readonly type: "create_index";
@@ -505,6 +513,11 @@ export interface CreateIndexStmt {
         opclass: string[] | null;
     }>;
     readonly include: string[];
+    /** WITH (...) storage parameters as written */
+    readonly options?: ReadonlyArray<{
+        name: string;
+        value: string;
+    }>;
     readonly where: Expr | null;
     readonly nullsNotDistinct: boolean;
     readonly concurrently: boolean;
@@ -530,12 +543,15 @@ export interface SequenceOptions {
     ownedBy?: string[] | "none";
     as?: TypeName;
     restart?: bigint | "default";
+    /** ALTER SEQUENCE ... SET LOGGED (true) / SET UNLOGGED (false) */
+    logged?: boolean;
 }
 export interface CreateSequenceStmt {
     readonly type: "create_sequence";
     readonly name: string[];
     readonly ifNotExists: boolean;
     readonly temp: boolean;
+    readonly unlogged?: boolean;
     readonly options: SequenceOptions;
 }
 export interface AlterSequenceStmt {
@@ -652,6 +668,15 @@ export type AlterTableAction = {
 } | {
     kind: "drop_not_null";
     column: string;
+}
+/** `mode` is the identifier as written (or "default"); validated against the column type at execution */
+ | {
+    kind: "set_storage";
+    column: string;
+    mode: string;
+} | {
+    kind: "set_logged";
+    logged: boolean;
 } | {
     kind: "add_constraint";
     constraint: TableConstraint;
@@ -739,6 +764,8 @@ export interface DropStmt {
     readonly funcArgs: TypeName[][] | null;
     readonly ifExists: boolean;
     readonly cascade: boolean;
+    /** DROP INDEX CONCURRENTLY */
+    readonly concurrently?: boolean;
 }
 export interface TruncateStmt {
     readonly type: "truncate";
@@ -810,6 +837,21 @@ export interface CommentStmt {
     readonly objectName: string[];
     readonly comment: string | null;
 }
+export interface AnalyzeStmt {
+    readonly type: "analyze";
+    /** empty means every table */
+    readonly targets: ReadonlyArray<{
+        table: string[];
+        columns: string[] | null;
+    }>;
+}
+export interface ReindexStmt {
+    readonly type: "reindex";
+    readonly kind: "index" | "table" | "schema" | "database" | "system";
+    /** null only for REINDEX DATABASE / SYSTEM without a name */
+    readonly name: string[] | null;
+    readonly concurrently: boolean;
+}
 export interface NoOpStmt {
     readonly type: "no_op";
     readonly what: string;
@@ -819,4 +861,4 @@ export interface DoStmt {
     readonly language: string;
     readonly body: string;
 }
-export type Statement = SelectStmt | InsertStmt | UpdateStmt | DeleteStmt | CreateTableStmt | CreateTableAsStmt | CreateIndexStmt | CreateViewStmt | CreateSequenceStmt | AlterSequenceStmt | CreateSchemaStmt | CreateExtensionStmt | CreateEnumStmt | AlterEnumStmt | CreateDomainStmt | CreateFunctionStmt | CreateTriggerStmt | AlterTableStmt | AlterViewStmt | AlterIndexStmt | AlterSchemaStmt | DropStmt | TruncateStmt | RefreshMaterializedViewStmt | TransactionStmt | SetStmt | ShowStmt | ResetStmt | PrepareStmt | ExecuteStmt | DeallocateStmt | ExplainStmt | CopyStmt | CommentStmt | NoOpStmt | DoStmt;
+export type Statement = SelectStmt | InsertStmt | UpdateStmt | DeleteStmt | CreateTableStmt | CreateTableAsStmt | CreateIndexStmt | CreateViewStmt | CreateSequenceStmt | AlterSequenceStmt | CreateSchemaStmt | CreateExtensionStmt | CreateEnumStmt | AlterEnumStmt | CreateDomainStmt | CreateFunctionStmt | CreateTriggerStmt | AlterTableStmt | AlterViewStmt | AlterIndexStmt | AlterSchemaStmt | DropStmt | TruncateStmt | RefreshMaterializedViewStmt | TransactionStmt | SetStmt | ShowStmt | ResetStmt | PrepareStmt | ExecuteStmt | DeallocateStmt | ExplainStmt | CopyStmt | CommentStmt | AnalyzeStmt | ReindexStmt | NoOpStmt | DoStmt;

package/dist/constraints/enforce.d.ts

@@ -18,6 +18,8 @@ interface UniqueSpec {
     isPrimary: boolean;
 }
 export declare function uniqueSpecsFor(env: ExecEnv, table: TableData): UniqueSpec[];
+/** The uniqueness rule a unique index states, whether or not the index is currently valid. */
+export declare function uniqueSpecOfIndex(table: TableData, idx: IndexMeta): UniqueSpec;
 export declare function uniqueKeyOf(env: ExecEnv, table: TableData, spec: UniqueSpec, row: Datum[]): string | null;
 /**
  * Unique / primary key enforcement (23505). `selfIdx` is the row's own index

package/dist/executor/alter-column.d.ts

@@ -0,0 +1,27 @@
+import type { AlterTableAction, AlterTableStmt, Expr } from "../ast/nodes.js";
+import type { ColumnMeta, DatabaseState, SequenceData, TableData } from "../storage/database-state.js";
+import type { ExecEnv } from "./relation.js";
+/** The named user column, or PostgreSQL's error for a system or missing one. */
+export declare function alterableColumn(table: TableData, name: string): ColumnMeta;
+/** `ALTER SEQUENCE ... SET LOGGED | UNLOGGED`, also reachable as `ALTER TABLE <sequence> SET ...`. */
+export declare function setSequenceLogged(state: DatabaseState, seq: SequenceData, logged: boolean): void;
+/**
+ * `ALTER TABLE` named something that is not a table. Returns true when the
+ * statement was carried out against a sequence; throws PostgreSQL's
+ * wrong-object-type error for the actions views do not accept; otherwise
+ * returns false and the caller reports the relation as it always has.
+ */
+export declare function alterNonTableRelation(state: DatabaseState, stmt: AlterTableStmt): boolean;
+/**
+ * Validate every SET LOGGED / SET UNLOGGED action of one statement against
+ * the table as it stands, the way PostgreSQL's preparation phase does: once
+ * an action really changes the persistence, a second one is an error.
+ * Returns the persistence to apply, or null when nothing changes.
+ */
+export declare function planLoggedChange(state: DatabaseState, table: TableData, actions: readonly AlterTableAction[]): boolean | null;
+/** Flip the table and the sequences its columns own; indexes report their table's persistence. */
+export declare function applyLoggedChange(state: DatabaseState, table: TableData, logged: boolean): void;
+export declare function setColumnStorage(table: TableData, columnName: string, mode: string): void;
+export declare function dropColumnNotNull(table: TableData, columnName: string): void;
+export declare function setColumnDefault(env: ExecEnv, table: TableData, columnName: string, expr: Expr): void;
+export declare function dropColumnDefault(table: TableData, columnName: string): void;

package/dist/executor/comment.d.ts

@@ -1,3 +1,7 @@
 import type { CommentStmt } from "../ast/nodes.js";
 import { type ExecEnv, type ExecResult } from "./relation.js";
+/**
+ * COMMENT ON. Only index comments are stored (they surface in pg_description);
+ * comments on every other kind of object are accepted and dropped.
+ */
 export declare function executeComment(env: ExecEnv, stmt: CommentStmt): ExecResult;

package/dist/executor/ddl.d.ts

@@ -1,4 +1,4 @@
-import type { AlterEnumStmt, AlterIndexStmt, AlterSchemaStmt, AlterSequenceStmt, AlterTableStmt, AlterViewStmt, CreateDomainStmt, CreateEnumStmt, CreateExtensionStmt, CreateFunctionStmt, CreateIndexStmt, CreateSchemaStmt, CreateSequenceStmt, CreateTableAsStmt, CreateTableStmt, CreateTriggerStmt, CreateViewStmt, DropStmt, RefreshMaterializedViewStmt, SequenceOptions, TruncateStmt } from "../ast/nodes.js";
+import type { AlterEnumStmt, AlterIndexStmt, AlterSchemaStmt, AlterSequenceStmt, AlterTableStmt, AlterViewStmt, CreateDomainStmt, CreateEnumStmt, CreateFunctionStmt, CreateIndexStmt, CreateSchemaStmt, CreateSequenceStmt, CreateTableAsStmt, CreateTableStmt, CreateTriggerStmt, CreateViewStmt, DropStmt, RefreshMaterializedViewStmt, SequenceOptions, TruncateStmt } from "../ast/nodes.js";
 import { SchemaData, type SequenceData } from "../storage/database-state.js";
 import { type ExecEnv, type ExecResult } from "./relation.js";
 export declare function buildSequence(env: ExecEnv, schema: SchemaData, name: string, options: SequenceOptions, temp: boolean): SequenceData;
@@ -9,7 +9,6 @@ export declare function executeCreateTableAs(env: ExecEnv, stmt: CreateTableAsSt
 export declare function executeCreateIndex(env: ExecEnv, stmt: CreateIndexStmt): ExecResult;
 export declare function executeCreateView(env: ExecEnv, stmt: CreateViewStmt): ExecResult;
 export declare function executeRefreshMatView(env: ExecEnv, stmt: RefreshMaterializedViewStmt): ExecResult;
-export declare function executeCreateExtension(env: ExecEnv, stmt: CreateExtensionStmt): ExecResult;
 export declare function executeCreateSchema(env: ExecEnv, stmt: CreateSchemaStmt): ExecResult;
 export declare function executeCreateEnum(env: ExecEnv, stmt: CreateEnumStmt): ExecResult;
 export declare function executeAlterEnum(env: ExecEnv, stmt: AlterEnumStmt): ExecResult;

package/dist/executor/dml.d.ts

@@ -2,6 +2,8 @@ import type { DeleteStmt, InsertStmt, SelectStmt, UpdateStmt } from "../ast/node
 import type { TableData } from "../storage/database-state.js";
 import { type Datum } from "../types/value.js";
 import { type ExecEnv, type ExecResult, type Relation } from "./relation.js";
+/** Roll back trigger/constraint side effects when a statement fails under autocommit. */
+export declare function withStatementRollback<T>(env: ExecEnv, fn: () => T): T;
 export declare function executeInsert(env0: ExecEnv, stmt: InsertStmt): ExecResult;
 export declare function executeUpdate(env0: ExecEnv, stmt: UpdateStmt): ExecResult;
 export declare function executeDelete(env0: ExecEnv, stmt: DeleteStmt): ExecResult;

package/dist/executor/extensions.d.ts

@@ -0,0 +1,11 @@
+import type { CreateExtensionStmt, DropStmt } from "../ast/nodes.js";
+import type { FunctionData } from "../storage/database-state.js";
+import { type ExecEnv, type ExecResult } from "./relation.js";
+export declare function executeCreateExtension(env: ExecEnv, stmt: CreateExtensionStmt): ExecResult;
+/** A function an extension installed goes away with the extension, not on its own. */
+export declare function assertNotExtensionMember(fn: FunctionData): void;
+/**
+ * `DROP EXTENSION [IF EXISTS] name [, ...] [CASCADE | RESTRICT]`: every name
+ * is resolved, and every dependency checked, before anything is dropped.
+ */
+export declare function executeDropExtension(env: ExecEnv, stmt: DropStmt): ExecResult;

package/dist/executor/maintenance.d.ts

@@ -0,0 +1,25 @@
+import type { AnalyzeStmt, ReindexStmt, Statement } from "../ast/nodes.js";
+import { PostgresError } from "../errors/error.js";
+import type { DatabaseState, IndexMeta, TableData } from "../storage/database-state.js";
+import { type ExecEnv, type ExecResult } from "./relation.js";
+/**
+ * Commands PostgreSQL refuses inside a transaction block, named as its 25001 message
+ * names them. The sync API and the wire server both check this before running a statement,
+ * because each tracks the transaction block in its own way.
+ */
+export declare function refusedInTransactionBlock(stmt: Statement): string | null;
+/** A statement whose failure must keep what it wrote: the invalid index a concurrent build leaves behind. */
+export declare function leavesInvalidIndexOnFailure(stmt: Statement): boolean;
+/**
+ * Take the armed `concurrentIndexBuild` fault, if any: the error an interrupted concurrent
+ * build ends with. PostgreSQL leaves the index it was building in the catalog, invalid.
+ */
+export declare function takeConcurrentBuildFault(state: DatabaseState): PostgresError | null;
+/** Raise 23505 when the rows of `table` cannot satisfy unique index `index`, as an index build does. */
+export declare function assertUniqueIndexBuildable(env: ExecEnv, table: TableData, index: IndexMeta, name?: string): void;
+export declare function executeReindex(env: ExecEnv, stmt: ReindexStmt): ExecResult;
+/**
+ * ANALYZE. The planner statistics it gathers have no counterpart here; what it leaves
+ * is the per-table bookkeeping pg_stat_user_tables reports (analyze_count, last_analyze).
+ */
+export declare function executeAnalyze(env: ExecEnv, stmt: AnalyzeStmt): ExecResult;

package/dist/expressions/context.d.ts

@@ -14,7 +14,7 @@ export declare class EngineCtx implements CastEnv, CompareCtx {
     readonly stmtNow: bigint;
     constructor(state: DatabaseState, txNow?: bigint);
     timezone(): string;
-    namespaceOid(input: string): number;
+    namespaceOid(name: string): number;
     namespaceName(oid: number): string | null;
     zoneOffsetAt(utcMicros: bigint): number;
     zoneOffsetForNaive(naiveMicros: bigint): number;

package/dist/index.d.ts

@@ -23,6 +23,6 @@
  */
 import "./serialization/codec.js";
 export type { BindValue, JsValue, QueryRow } from "./api/bind.js";
-export { Database, type DatabaseHistory, type DatabaseOptions, type HistoryCheckpoint, type QueryOptions, type RegisterFunctionOptions, Snapshot, } from "./api/database.js";
+export { Database, type DatabaseFaults, type DatabaseHistory, type DatabaseOptions, type HistoryCheckpoint, type QueryOptions, type RegisterFunctionOptions, Snapshot, } from "./api/database.js";
 export { type ResultSet, type RunResult, Statement } from "./api/statement.js";
 export { type ErrorCategory, PostgresError } from "./errors/error.js";