@crvouga/mockingbird-service-postgres 3.1.0 → 3.3.0

package/dist/parser/parser.d.ts

@@ -19,6 +19,13 @@ export declare class Parser {
     private qualifiedName;
     parseStatements(): Statement[];
     parseStatement(): Statement;
+    /**
+     * `( option [value] [, ...] )` of ANALYZE / REINDEX. Returns the options that are on;
+     * an option outside `known` is the 42601 PostgreSQL raises.
+     */
+    private parseUtilityOptions;
+    private parseAnalyze;
+    private parseReindex;
     private skipToStatementEnd;
     /** Consume tokens until the matching `)` after an opening `(` already eaten. */
     private skipBalancedCloseParen;
@@ -54,6 +61,8 @@ export declare class Parser {
     private parseRefActions;
     private parseRefAction;
     private parseColumnDef;
+    /** `STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN | DEFAULT }`: an identifier (not a string) or DEFAULT. */
+    private parseStorageMode;
     private parseIdentityOptions;
     private parseSequenceOptions;
     private parseSignedBigInt;

package/dist/schema/catalog-extensions.d.ts

@@ -0,0 +1,5 @@
+import type { Relation } from "../executor/relation.js";
+import type { DatabaseState } from "../storage/database-state.js";
+export declare const EXTENSION_CATALOG_RELATIONS: readonly string[];
+/** Extension catalogs of `pg_catalog`, or null when `name` is not one of them. */
+export declare function extensionCatalogRelation(state: DatabaseState, name: string, namespaceOid: (schema: string) => number): Relation | null;

package/dist/schema/extensions.d.ts

@@ -0,0 +1,33 @@
+import type { DatabaseState, FunctionData } from "../storage/database-state.js";
+/**
+ * Extensions this engine can install, as `pg_available_extensions` lists
+ * them. An extension belongs here only when `CREATE EXTENSION` really
+ * installs something: everything else stays unavailable and fails loud.
+ * Versions and comments are the ones PostgreSQL 18 ships in each control file.
+ */
+export interface ExtensionSpec {
+    readonly name: string;
+    readonly defaultVersion: string;
+    /** every version PostgreSQL has an installation script or update path for */
+    readonly versions: readonly string[];
+    readonly comment: string;
+    readonly relocatable: boolean;
+    /** set for an extension that is part of every database and lives in a fixed schema */
+    readonly builtinSchema?: string;
+}
+export declare const AVAILABLE_EXTENSIONS: readonly ExtensionSpec[];
+export interface InstalledExtension {
+    readonly spec: ExtensionSpec;
+    readonly version: string;
+    readonly schema: string;
+    readonly oid: number;
+}
+export declare function findExtensionSpec(name: string): ExtensionSpec | null;
+/**
+ * Functions an installed extension owns. `CREATE EXTENSION` marks them with
+ * `language = internal` and the extension name as the body, which is what a
+ * PGMM snapshot carries, so installation state needs no catalog of its own.
+ */
+export declare function extensionMembers(state: DatabaseState, name: string): FunctionData[];
+export declare function installedExtension(state: DatabaseState, spec: ExtensionSpec): InstalledExtension | null;
+export declare function installedExtensions(state: DatabaseState): InstalledExtension[];

package/dist/schema/index-catalog.d.ts

@@ -0,0 +1,40 @@
+import type { ConstraintMeta, DatabaseState, IndexMeta, SchemaData, TableData } from "../storage/database-state.js";
+/**
+ * Index identity. Every index, including the one PostgreSQL creates behind a
+ * PRIMARY KEY or UNIQUE constraint, is an `IndexMeta` in its table's schema with
+ * its own oid. `syncIndexCatalog` runs after each statement that can change a
+ * table and re-derives the parts of that catalog that follow from the tables:
+ * which schema and table an index belongs to, and the indexes that back key
+ * constraints. Index objects are shared with transaction snapshots, so every
+ * change replaces the entry instead of mutating it.
+ */
+export type KeyConstraint = Extract<ConstraintMeta, {
+    kind: "primary_key" | "unique";
+}>;
+export declare const isKeyConstraint: (constraint: ConstraintMeta) => constraint is KeyConstraint;
+/** pg_am rows: access method name → [oid, amtype]. */
+export declare const ACCESS_METHODS: ReadonlyMap<string, readonly [oid: number, type: "t" | "i"]>;
+export declare const indexMethod: (index: IndexMeta) => string;
+/** Number of key columns plus INCLUDE columns (`pg_index.indnatts`). */
+export declare const indexAttributeCount: (index: IndexMeta) => number;
+export declare function syncIndexCatalog(state: DatabaseState): void;
+/**
+ * The index behind a key constraint is a relation named after the constraint. A name the
+ * statement spelled out must be free (42P07); a generated one moves on to the next free
+ * name, the way PostgreSQL picks `t_pkey1` when `t_pkey` is already a relation.
+ */
+export declare function claimConstraintIndexName(schema: SchemaData, constraint: KeyConstraint, explicit: boolean, reserved?: Set<string>): void;
+export interface FoundIndex {
+    schema: SchemaData;
+    index: IndexMeta;
+}
+/** Resolve a possibly schema-qualified index name along the search path. */
+export declare function findIndex(state: DatabaseState, parts: readonly string[]): FoundIndex | null;
+export declare function findIndexByOid(state: DatabaseState, oid: number): FoundIndex | null;
+/** The key constraint an index backs, when it backs one. */
+export declare function constraintOfIndex(state: DatabaseState, index: IndexMeta): {
+    table: TableData;
+    constraint: KeyConstraint;
+} | null;
+/** What kind of non-index relation `parts` names, for "is not an index" errors. */
+export declare function otherRelationKind(state: DatabaseState, parts: readonly string[]): "table" | "view" | "sequence" | null;

package/dist/schema/persistence.d.ts

@@ -0,0 +1,32 @@
+import type { ConstraintMeta, DatabaseState, SequenceData, TableData } from "../storage/database-state.js";
+/**
+ * `pg_class.relpersistence`: `p` permanent (logged), `u` unlogged, `t` temporary.
+ *
+ * The engine has no write-ahead log, so the three modes store rows the same
+ * way. What is modelled is the SQL contract: the catalog value, the
+ * transitions `ALTER TABLE ... SET LOGGED | UNLOGGED` allows, and the
+ * foreign-key combinations PostgreSQL rejects.
+ */
+export type Persistence = "p" | "u" | "t";
+export declare function relPersistence(rel: {
+    temp: boolean;
+    unlogged?: boolean;
+}): Persistence;
+/**
+ * A foreign key may not point at a table that is less durable than the one
+ * holding it: permanent tables reference permanent tables, unlogged tables
+ * reference permanent or unlogged ones, temporary tables reference temporary
+ * ones. `self` is the referencing table when it already exists, so a
+ * self-reference is judged against the persistence being created.
+ */
+export declare function checkForeignKeyPersistence(state: DatabaseState, persistence: Persistence, constraints: readonly ConstraintMeta[], self?: TableData | null): void;
+/**
+ * Validate `ALTER TABLE ... SET LOGGED | UNLOGGED` against the table as it is
+ * before the statement runs. Returns false when the table already has the
+ * requested persistence (PostgreSQL accepts that as a no-op).
+ */
+export declare function prepareLoggedChange(state: DatabaseState, table: TableData, logged: boolean): boolean;
+/** Sequences owned by the table's columns (serial and identity); they follow its persistence. */
+export declare function ownedSequences(state: DatabaseState, table: TableData): SequenceData[];
+/** `ALTER SEQUENCE ... SET LOGGED | UNLOGGED` on a temporary sequence is rejected like a temporary table. */
+export declare function assertSequenceNotTemporary(seq: SequenceData): void;

package/dist/schema/storage.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnMeta } from "../storage/database-state.js";
+import { type TypeId } from "../types/value.js";
+/**
+ * Column storage strategy as `pg_attribute.attstorage` reports it:
+ * `p` PLAIN, `e` EXTERNAL, `x` EXTENDED, `m` MAIN.
+ *
+ * Only the SQL and catalog contract is modelled. Values are never compressed
+ * or moved out of line, so the mode has no effect on how rows are held.
+ */
+export type StorageMode = "p" | "e" | "x" | "m";
+/** `pg_type.typstorage`: the strategy a column of this type gets unless `STORAGE` says otherwise. */
+export declare function defaultStorage(type: TypeId): StorageMode;
+/** `pg_attribute.attstorage` for a column: the stored override, else the type default. */
+export declare function columnStorage(column: ColumnMeta): StorageMode;
+/**
+ * Resolve a `STORAGE` keyword for a column of `type`, with PostgreSQL's
+ * errors: an unknown keyword is 22023, and a type that is not toastable
+ * accepts only PLAIN (0A000). Returns `undefined` when the result is the
+ * type default, so `SET STORAGE DEFAULT` and an explicit default leave no
+ * override behind.
+ */
+export declare function resolveStorage(type: TypeId, mode: string): StorageMode | undefined;