@crvouga/mockingbird-service-postgres 3.6.0 → 3.8.0

package/dist/api/schema-report.d.ts

@@ -0,0 +1,32 @@
+export interface SchemaReportOptions {
+    /** Hard upper bounds are 4 MiB, 10,000 statements and 1,000 diagnostics. */
+    maxInputBytes?: number;
+    maxStatements?: number;
+    maxDiagnostics?: number;
+}
+export interface SchemaDiagnostic {
+    statement: number;
+    offset: number;
+    line: number;
+    column: number;
+    object?: string;
+    sqlstate: string | null;
+    category: "unsupported" | "syntax" | "prerequisite" | "execution" | "unknown" | "limit";
+    message: string;
+    prerequisiteStatement?: number;
+}
+export interface SchemaReport {
+    /** Identifies the local implementation; this is not a live PostgreSQL compatibility assertion. */
+    engine: "mockingbird-postgres";
+    version: string;
+    statements: number;
+    accepted: number;
+    /** false means a detected gap; null means semantics still require oracle verification. */
+    compatible: false | null;
+    truncated: boolean;
+    diagnostics: SchemaDiagnostic[];
+}
+/** Analyze plain schema SQL in a discarded in-memory database, without network or filesystem access.
+ * Successful execution is explicitly unverified: function bodies and dynamic SQL are not proved.
+ */
+export declare function analyzeSchema(sql: string, options?: SchemaReportOptions): SchemaReport;

package/dist/ast/nodes.d.ts

@@ -555,6 +555,7 @@ export interface CreateSequenceStmt {
     readonly options: SequenceOptions;
 }
 export interface AlterSequenceStmt {
+    readonly renameTo?: string;
     readonly type: "alter_sequence";
     readonly name: string[];
     readonly ifExists: boolean;
@@ -623,6 +624,7 @@ export interface CreateFunctionStmt {
     readonly language: string;
     readonly body: string | null;
     readonly sqlBody: Statement[] | null;
+    readonly settings?: Record<string, string>;
     readonly volatility: "immutable" | "stable" | "volatile" | null;
     readonly strict: boolean;
 }
@@ -643,6 +645,11 @@ export interface CreateTriggerStmt {
     readonly when: Expr | null;
     readonly funcName: string[];
     readonly funcArgs: string[];
+    /** `REFERENCING { OLD | NEW } TABLE [AS] name` items in source order; validated when the trigger is created */
+    readonly transitions?: ReadonlyArray<{
+        isNew: boolean;
+        name: string;
+    }>;
 }
 export type AlterTableAction = {
     kind: "add_column";

package/dist/constraints/enforce.d.ts

@@ -1,6 +1,12 @@
+import type { Expr } from "../ast/nodes.js";
 import type { ExecEnv } from "../executor/relation.js";
 import type { IndexMeta, TableData } from "../storage/database-state.js";
-import { type Datum } from "../types/value.js";
+import { type Datum, type TypeId } from "../types/value.js";
+/**
+ * The type an expression over `table` yields, found by evaluating it against an all-NULL row.
+ * Binding errors (unknown column or function) surface as they would when PostgreSQL parses the expression.
+ */
+export declare function expressionTypeOf(env: ExecEnv, table: TableData, expr: Expr): TypeId;
 /** NOT NULL column constraints (23502). */
 export declare function checkNotNull(env: ExecEnv, table: TableData, row: Datum[]): void;
 /** CHECK constraints (23514); NULL results pass. */

package/dist/executor/relation.d.ts

@@ -8,6 +8,7 @@ export interface RelColumn {
     table: string | null;
     /** hidden columns (e.g. ORDER BY helpers) are excluded from final output */
     hidden?: boolean;
+    system?: boolean;
 }
 export interface Relation {
     columns: RelColumn[];

package/dist/executor/triggers.d.ts

@@ -16,5 +16,18 @@ export type TriggerExecutor = (env: ExecEnv, table: TableData, trigger: TriggerM
 export declare function setTriggerExecutor(e: TriggerExecutor): void;
 export declare function fireRowTriggers(env: ExecEnv, table: TableData, timing: "before" | "after" | "instead_of", event: TriggerEvent, oldRow: Datum[] | null, newRow: Datum[] | null): TriggerFireResult;
 export declare function hasRowTriggers(table: TableData, timing: "before" | "after" | "instead_of", event: TriggerEvent): boolean;
+/** The rows a statement changed, as the `REFERENCING` transition tables of its AFTER statement triggers. */
+export interface TransitionRows {
+    /** rows before the change (UPDATE, DELETE) */
+    oldRows: Datum[][];
+    /** rows after the change (INSERT, UPDATE); position-aligned with `oldRows` for UPDATE */
+    newRows: Datum[][];
+}
+/**
+ * Fire the statement-level triggers of `table` for `event`, once, in trigger-name order. AFTER triggers
+ * that declare transition tables read them as relations named by their `REFERENCING` clause; the
+ * function body sees nothing else of the statement (no outer CTEs, parameters or scope).
+ */
+export declare function fireStatementTriggers(env: ExecEnv, table: TableData, timing: "before" | "after", event: TriggerEvent, transitions?: TransitionRows): void;
 export declare function flushConstraintTriggers(state: DatabaseState, all?: boolean): void;
 export declare function setConstraints(state: DatabaseState, stmt: SetConstraintsStmt): void;

package/dist/expressions/context.d.ts

@@ -8,12 +8,16 @@ import { type TypeId } from "../types/value.js";
  */
 export declare class EngineCtx implements CastEnv, CompareCtx {
     readonly state: DatabaseState;
+    private writeXid;
+    rowVersionXid(): number;
     /** transaction timestamp (now(), current_timestamp) — UTC micros since PG epoch */
     readonly txNow: bigint;
     /** statement timestamp */
     readonly stmtNow: bigint;
     constructor(state: DatabaseState, txNow?: bigint);
     timezone(): string;
+    relationOid(parts: string[]): number;
+    relationName(oid: number): string | null;
     namespaceOid(name: string): number;
     namespaceName(oid: number): string | null;
     zoneOffsetAt(utcMicros: bigint): number;

package/dist/functions/pgtrgm.d.ts

@@ -1,7 +1,7 @@
-import type { CreateIndexStmt } from "../ast/nodes.js";
+import type { CreateIndexStmt, Expr } from "../ast/nodes.js";
 import type { EngineCtx } from "../expressions/context.js";
 import type { DatabaseState, FunctionData, TableData } from "../storage/database-state.js";
-import { type TypedValue } from "../types/value.js";
+import { type TypedValue, type TypeId } from "../types/value.js";
 export declare function pgTrgmSchema(state: DatabaseState): string | null;
 export declare function pgTrgmInstalled(state: DatabaseState): boolean;
 export declare function installPgTrgm(state: DatabaseState, schemaName: string): void;
@@ -11,10 +11,10 @@ export declare function evalPgTrgmFunction(ctx: EngineCtx, fn: FunctionData, arg
 export declare function evalTrgmWordSimilar(ctx: EngineCtx, left: TypedValue, right: TypedValue): TypedValue;
 /**
  * Reject `gin_trgm_ops` unless pg_trgm is installed for access method gin.
- * A single text/varchar column is stored as an ordinary non-unique index:
+ * A single text/varchar column or expression is stored as an ordinary non-unique index:
  * lookup speed is not modelled.
  */
-export declare function assertGinTrgmIndex(state: DatabaseState, table: TableData, stmt: CreateIndexStmt): void;
+export declare function assertGinTrgmIndex(state: DatabaseState, table: TableData, stmt: CreateIndexStmt, expressionType: (expr: Expr) => TypeId): void;
 /** `|intersection| / |union|` as float4. Either empty trigram set yields 0. */
 export declare function trigramSimilarity(left: string, right: string): number;
 /**

package/dist/index.d.ts

@@ -26,3 +26,4 @@ export type { BindValue, JsValue, QueryRow } from "./api/bind.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";
+export { analyzeSchema, type SchemaReport, type SchemaReportOptions, type SchemaDiagnostic, } from "./api/schema-report.js";