ts-prorm-orm 1.1.0 → 1.2.0

package/dist/dialects/exasol/index.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Exasol dialect implementation for the TypeScript ORM.
+ *
+ * Exasol is an in-memory, column-oriented, massively-parallel (MPP) analytic
+ * database. Its SQL grammar and wire behavior are close enough to PostgreSQL
+ * that this dialect extends {@link PostgresDialect} and reuses the pg-style
+ * grammar (double-quoted identifiers, `$1` placeholders, `ON CONFLICT`-free
+ * INSERTs, etc.) as its base, overriding only the places where Exasol really
+ * differs. Notable differences from PostgreSQL captured here:
+ *
+ * - Default SQL port is 8563 (not 5432).
+ * - CREATE TABLE supports MPP distribution/partitioning clauses:
+ *     `... DISTRIBUTE BY col1, col2` controls how rows are hash-distributed
+ *     across cluster nodes, and `... PARTITION BY col` controls on-disk
+ *     partitioning within a node. Both are surfaced via table options and
+ *     emitted as trailing clauses.
+ * - No SERIAL / BIGSERIAL. Auto-increment columns use an `IDENTITY` column
+ *   constraint on a numeric (DECIMAL) column instead.
+ * - Type mapping differs: TEXT maps to `VARCHAR(2000000)` (Exasol's max
+ *   VARCHAR width), STRING to `VARCHAR(n)`, integers to `DECIMAL(18,0)`
+ *   (Exasol has no native narrow integer types — everything numeric is a
+ *   DECIMAL), and DECIMAL(p,s)/BOOLEAN/TIMESTAMP map straight through.
+ * - Bulk load/unload uses Exasol's `IMPORT` / `EXPORT` statements against a
+ *   file/connection endpoint rather than PostgreSQL's `COPY`.
+ * - Exasol upper-cases unquoted identifiers (like Oracle). This dialect quotes
+ *   identifiers with double quotes (inherited from PostgresDialect), so the
+ *   ORM's mixed-case names are preserved exactly rather than being folded to
+ *   upper case.
+ * - Exasol has **no `RETURNING` clause** on INSERT/UPDATE/DELETE and **no
+ *   `ON CONFLICT`**. So the write builders inherited from PostgresDialect
+ *   (`buildInsertQuery`, `buildUpdateQuery`, `buildDeleteQuery`,
+ *   `buildUpsertQuery`) are overridden here to strip `RETURNING` and to express
+ *   upserts as a `MERGE INTO ... USING (SELECT ...) ON (...) WHEN MATCHED /
+ *   WHEN NOT MATCHED` statement instead.
+ * - Plain SELECT (WHERE, ORDER BY, GROUP BY / HAVING, JOIN, `LIMIT ... OFFSET`)
+ *   and `buildLimitOffset` are inherited unchanged: Exasol's SELECT grammar
+ *   matches the PostgreSQL forms the base emits, including `LIMIT n OFFSET m`.
+ *
+ * Placeholders: this dialect keeps the PostgreSQL `$n` positional style so it
+ * composes with the rest of the ORM's parameter handling. Exasol's own JDBC/
+ * WebSocket drivers use `?`; a live driver binding would translate accordingly.
+ */
+import { PostgresDialect, PostgresDialectOptions } from '../postgres';
+import { ColumnDefinition, TableOptions, InsertOptions, UpsertQueryOptions, UpdateOptions, DeleteOptions } from '../dialect';
+import { DataType } from '../../types';
+/**
+ * Exasol-specific table options. Adds the MPP `DISTRIBUTE BY` and `PARTITION BY`
+ * clauses. `partitionBy` is redeclared here (widened to accept a column list)
+ * so it can name one or more columns rather than the base string-only form.
+ */
+export interface ExasolTableOptions extends Omit<TableOptions, 'partitionBy'> {
+    /** Columns to hash-distribute rows across cluster nodes (`DISTRIBUTE BY ...`). */
+    distributeBy?: string | string[];
+    /** Columns to partition table storage by within a node (`PARTITION BY ...`). */
+    partitionBy?: string | string[];
+}
+/**
+ * Options for building an Exasol `IMPORT` / `EXPORT` statement.
+ */
+export interface ExasolImportExportOptions {
+    /** Source/target file format. Defaults to `'CSV'`. */
+    format?: 'CSV' | 'FBV';
+    /** The `AT '<connection-or-url>'` endpoint (e.g. an FTP/HTTP/S3 URL or connection name). */
+    at: string;
+    /** The `FILE '<path>'` to read from / write to at the endpoint. */
+    file: string;
+}
+/**
+ * Exasol dialect. Extends {@link PostgresDialect}; see the file header for the
+ * list of Exasol-specific behaviors.
+ */
+export declare class ExasolDialect extends PostgresDialect {
+    readonly name = "exasol";
+    constructor(config: PostgresDialectOptions);
+    /**
+     * Map an ORM data type to its Exasol SQL type. Overrides the Postgres
+     * mapping for the types that differ on Exasol:
+     *  - TEXT      -> VARCHAR(2000000)  (Exasol's max VARCHAR width; no TEXT type)
+     *  - STRING    -> VARCHAR(n)
+     *  - INTEGER   -> DECIMAL(18,0)     (no SERIAL; IDENTITY is applied separately)
+     *  - BIGINT    -> DECIMAL(36,0)
+     *  - DECIMAL   -> DECIMAL(p,s)
+     *  - BOOLEAN   -> BOOLEAN
+     *  - DATE      -> TIMESTAMP
+     * Everything else delegates to the PostgreSQL mapping.
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Format a single column's definition for CREATE TABLE. Emits `IDENTITY`
+     * (rather than SERIAL) for auto-increment columns.
+     */
+    private buildColumnSql;
+    /** Format a DEFAULT value literal for a column definition. */
+    private formatDefault;
+    /** Render a `DISTRIBUTE BY` / `PARTITION BY` column list. */
+    private columnList;
+    /**
+     * Build a `CREATE TABLE` statement, including Exasol's MPP `DISTRIBUTE BY`
+     * and `PARTITION BY` clauses. Exposed synchronously so the emitted SQL can be
+     * built (and tested) without a live connection.
+     */
+    buildCreateTableSQL(tableName: string, columns: Record<string, ColumnDefinition>, options?: ExasolTableOptions): string;
+    /**
+     * Create a table. Overrides the Postgres implementation to emit Exasol's
+     * IDENTITY columns and `DISTRIBUTE BY` / `PARTITION BY` clauses.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: ExasolTableOptions): Promise<void>;
+    /**
+     * Add a column. Overrides the Postgres implementation, which would emit a
+     * `SERIAL` for auto-increment columns; Exasol uses `IDENTITY` instead (see
+     * {@link buildColumnSql}). Exasol accepts the optional `COLUMN` keyword.
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Change a column's type. Exasol uses `ALTER TABLE ... MODIFY COLUMN col type`
+     * rather than PostgreSQL's `ALTER COLUMN col TYPE type`.
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Build an INSERT. Same as the PostgreSQL base but Exasol has no `RETURNING`
+     * clause, and upserts are expressed as a `MERGE` (Exasol has no
+     * `ON CONFLICT`). When `options.upsert` is set this delegates to
+     * {@link buildMergeSQL}; the `returning` option is ignored.
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPSERT as an Exasol `MERGE` statement. Exasol has no
+     * `INSERT ... ON CONFLICT`.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build the Exasol `MERGE INTO ... USING (SELECT ...) ON (...)` statement that
+     * implements an upsert for a single row of `values`.
+     *
+     * The row is presented as a one-row derived source via a FROM-less
+     * `SELECT $1 AS "col", ...` (Exasol permits SELECT without FROM). Rows are
+     * matched on `conflictFields`; matched rows are updated (excluding the
+     * conflict columns, which Exasol forbids updating because they appear in the
+     * `ON` condition) and unmatched rows are inserted.
+     */
+    buildMergeSQL(tableName: string, values: Record<string, unknown>, options?: {
+        conflictFields?: string[];
+        updateOnDuplicate?: string[];
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPDATE. Same as the PostgreSQL base, but Exasol supports neither a
+     * `RETURNING` clause nor a `LIMIT` on UPDATE, so both are stripped from the
+     * options before delegating.
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: Parameters<PostgresDialect['buildUpdateQuery']>[2], options?: UpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a DELETE. Exasol has no `RETURNING` and no `LIMIT` on DELETE, so both
+     * are stripped; `truncate` (which maps to `TRUNCATE TABLE`) is preserved.
+     */
+    buildDeleteQuery(tableName: string, where: Parameters<PostgresDialect['buildDeleteQuery']>[1], options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an Exasol `IMPORT INTO <table> FROM <format> AT '<endpoint>' FILE '<path>'`
+     * statement for bulk-loading data. `schema` on the options, if any, is not
+     * used here; qualify the table name yourself if needed.
+     */
+    buildImportSQL(tableName: string, options: ExasolImportExportOptions): string;
+    /**
+     * Build an Exasol `EXPORT <table> INTO <format> AT '<endpoint>' FILE '<path>'`
+     * statement for bulk-unloading data.
+     */
+    buildExportSQL(tableName: string, options: ExasolImportExportOptions): string;
+    /**
+     * Execute an Exasol `IMPORT` bulk-load (see {@link buildImportSQL}). This is
+     * the ORM-level, no-raw-SQL entry point for loading data into a table from an
+     * external file/connection endpoint.
+     */
+    importData(tableName: string, options: ExasolImportExportOptions): Promise<void>;
+    /**
+     * Execute an Exasol `EXPORT` bulk-unload (see {@link buildExportSQL}).
+     */
+    exportData(tableName: string, options: ExasolImportExportOptions): Promise<void>;
+}
+/**
+ * Create a new Exasol dialect instance.
+ */
+export declare function createExasolDialect(options?: PostgresDialectOptions): ExasolDialect;
+export default ExasolDialect;

package/dist/dialects/exasol/index.js

@@ -346,6 +346,20 @@ class ExasolDialect extends postgres_1.PostgresDialect {
         return (`EXPORT ${this.escapeId(tableName)} INTO ${format}` +
             ` AT '${options.at.replace(/'/g, "''")}' FILE '${options.file.replace(/'/g, "''")}'`);
     }
+    /**
+     * Execute an Exasol `IMPORT` bulk-load (see {@link buildImportSQL}). This is
+     * the ORM-level, no-raw-SQL entry point for loading data into a table from an
+     * external file/connection endpoint.
+     */
+    async importData(tableName, options) {
+        await this.query(this.buildImportSQL(tableName, options));
+    }
+    /**
+     * Execute an Exasol `EXPORT` bulk-unload (see {@link buildExportSQL}).
+     */
+    async exportData(tableName, options) {
+        await this.query(this.buildExportSQL(tableName, options));
+    }
 }
 exports.ExasolDialect = ExasolDialect;
 /**

package/dist/dialects/firebird/index.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Firebird dialect implementation for the TypeScript ORM
+ *
+ * This dialect provides Firebird SQL generation. A real deployment would use a
+ * dedicated Firebird driver (e.g. `node-firebird`); here it extends the
+ * PostgreSQL dialect and overrides only the SQL grammar that differs, reusing
+ * PostgresDialect's query-builder scaffolding for everything Firebird shares
+ * with standard SQL.
+ *
+ * Notable Firebird SQL differences overridden below:
+ *
+ * - Row limiting: Firebird has no `LIMIT ... OFFSET ...` clause. It uses
+ *   `SELECT FIRST n SKIP m ...` placed right after the `SELECT` keyword (e.g.
+ *   `SELECT FIRST 10 SKIP 20 * FROM ...`). We override `buildLimitOffset` to
+ *   emit nothing (so the base's trailing LIMIT/OFFSET disappears) and
+ *   `buildSelectQuery` to inject the `FIRST/SKIP` fragment after the top-level
+ *   `SELECT`. `UPDATE`/`DELETE` row limiting uses `ROWS n` (not `LIMIT n`),
+ *   handled in `buildUpdateQuery`/`buildDeleteQuery`.
+ * - Upsert: Firebird has no PostgreSQL `INSERT ... ON CONFLICT`. It uses
+ *   `UPDATE OR INSERT INTO t (...) VALUES (...) MATCHING (...)` instead, where
+ *   `MATCHING` names the key columns (defaulting to the primary key when
+ *   omitted). `buildUpsertQuery` and the upsert branch of `buildInsertQuery`
+ *   emit this form. Because `UPDATE OR INSERT` always overwrites every listed
+ *   column, `updateOnDuplicate` (a subset of columns to update) has no Firebird
+ *   equivalent and is ignored.
+ * - Auto-increment: Firebird 3+ uses `GENERATED BY DEFAULT AS IDENTITY` rather
+ *   than PostgreSQL's `SERIAL`. `getDataTypeSql` maps auto-increment
+ *   INTEGER/BIGINT accordingly, `getIdentityColumnSql` builds a full identity
+ *   column definition, and `createTable`/`addColumn` emit IDENTITY (not SERIAL)
+ *   for auto-increment columns.
+ * - Column DDL: Firebird omits the `COLUMN` keyword in `ALTER TABLE`. Adding a
+ *   column is `ALTER TABLE t ADD col type` and dropping is `ALTER TABLE t DROP
+ *   col` (PostgreSQL spells these `ADD COLUMN` / `DROP COLUMN`).
+ * - Generators/sequences: Firebird's sequence objects are historically called
+ *   "generators". `createGenerator(name)` emits `CREATE SEQUENCE name` (the
+ *   modern, SQL-standard spelling Firebird accepts).
+ * - Type mapping: Firebird uses `BLOB SUB_TYPE TEXT` for long text (no `TEXT`
+ *   type), `DOUBLE PRECISION`, `TIMESTAMP`, `BOOLEAN`, and `INTEGER`/`BIGINT`.
+ *   `getDataTypeSql` overrides the relevant mappings.
+ * - Identifiers: Firebird upper-cases unquoted identifiers; quoting an
+ *   identifier with double quotes makes it case-sensitive. We keep the base's
+ *   double-quote quoting (`"identifier"`), which preserves case as written.
+ * - RETURNING: Firebird DOES support `RETURNING` on INSERT/UPDATE/DELETE (for
+ *   singleton statements), so the inherited RETURNING handling is kept.
+ *
+ * The default SQL port is 3050 (Firebird's default), not PostgreSQL's 5432.
+ */
+import { PostgresDialect, PostgresDialectOptions } from '../postgres';
+import { DataType, WhereOptions, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions, PolicyOptions, DropPolicyOptions, SequenceOptions, DropSequenceOptions } from '../../types';
+import { SelectOptions, InsertOptions, UpsertQueryOptions, UpdateOptions, DeleteOptions, ColumnDefinition, TableOptions, CreateExtensionOptions, DropExtensionOptions } from '../dialect';
+/**
+ * Firebird dialect options. Identical in shape to the PostgreSQL options (the
+ * dialect reuses PostgresDialect's connection scaffolding); the default port
+ * differs (3050).
+ */
+export interface FirebirdDialectOptions extends PostgresDialectOptions {
+}
+/**
+ * Firebird dialect class. Extends the PostgreSQL dialect and overrides the SQL
+ * grammar that Firebird spells differently.
+ */
+export declare class FirebirdDialect extends PostgresDialect {
+    readonly name = "firebird";
+    constructor(config?: FirebirdDialectOptions);
+    /**
+     * Firebird does not support a trailing `LIMIT ... OFFSET ...` clause, so we
+     * emit nothing here. The actual row-limiting keywords (`FIRST`/`SKIP`) are
+     * injected right after the `SELECT` keyword by `buildSelectQuery` below.
+     */
+    buildLimitOffset(_limit?: number | string, _offset?: number | string): string;
+    /**
+     * Build the Firebird `FIRST n SKIP m` fragment (without surrounding spaces).
+     * Returns an empty string when neither limit nor offset is provided.
+     *
+     * Firebird allows `SKIP` on its own (`SELECT SKIP 20 ...`), so an offset with
+     * no limit is emitted as just `SKIP m`. `FIRST` always precedes `SKIP`.
+     */
+    private buildFirstSkip;
+    /**
+     * Find the index just past the top-level `SELECT ` keyword in a compiled
+     * query so the `FIRST/SKIP` fragment can be inserted there. Scans at
+     * parenthesis depth 0 so that `SELECT`s inside CTEs/sub-selects (which live
+     * inside parentheses) are skipped and the main query's `SELECT` is targeted.
+     * Returns -1 if no top-level `SELECT ` is found.
+     */
+    private mainSelectInsertIndex;
+    /**
+     * Build a SELECT query using Firebird's `FIRST n SKIP m` row limiting instead
+     * of a trailing `LIMIT/OFFSET`. Delegates the heavy lifting to the base
+     * PostgreSQL builder (whose `buildLimitOffset` we've neutralized above), then
+     * injects the `FIRST/SKIP` fragment right after the top-level `SELECT` — so
+     * it works uniformly for plain SELECTs, JOINs, GROUP BY/HAVING, DISTINCT, and
+     * queries fronted by a `WITH` CTE (whose inner SELECTs are parenthesized and
+     * therefore skipped by `mainSelectInsertIndex`).
+     */
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an INSERT query. When `options.upsert` is set, Firebird uses
+     * `UPDATE OR INSERT INTO ... MATCHING (...)` instead of PostgreSQL's
+     * `INSERT ... ON CONFLICT`. `MATCHING` names the key columns; when
+     * `conflictFields` is omitted Firebird matches on the primary key.
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPSERT query for Firebird using
+     * `UPDATE OR INSERT INTO t (...) VALUES (...) MATCHING (...)`.
+     *
+     * Unlike PostgreSQL's `ON CONFLICT ... DO UPDATE SET <subset>`, Firebird's
+     * `UPDATE OR INSERT` always overwrites every listed column on a match, so a
+     * `updateOnDuplicate` subset has no Firebird equivalent and is ignored.
+     * `conflictFields`, when given, becomes the `MATCHING` key column list;
+     * otherwise Firebird matches on the table's primary key.
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: UpsertQueryOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a ` RETURNING ...` suffix (or empty string). Firebird supports
+     * RETURNING on singleton INSERT/UPDATE/DELETE/UPDATE-OR-INSERT statements.
+     */
+    private buildReturningClause;
+    /**
+     * Build an UPDATE query. Firebird limits affected rows with `ROWS n`, not
+     * PostgreSQL's `LIMIT n`; we delegate to the base builder and rewrite the
+     * emitted `LIMIT n` fragment to `ROWS n` (positioned identically, before any
+     * RETURNING clause).
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, options?: UpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a DELETE query. Firebird limits affected rows with `ROWS n`, not
+     * PostgreSQL's `LIMIT n`; rewrite the base builder's `LIMIT n` accordingly.
+     */
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Map an ORM data type to its Firebird SQL spelling. Overrides the mappings
+     * that differ from PostgreSQL and delegates everything else to the base.
+     */
+    getDataTypeSql(dataType: DataType): string;
+    /**
+     * Build a Firebird `CREATE TABLE` statement. Unlike the PostgreSQL base,
+     * auto-increment columns use `GENERATED BY DEFAULT AS IDENTITY` (not
+     * `SERIAL`). Firebird does not support `CREATE TABLE IF NOT EXISTS`, so that
+     * option is ignored. Exposed separately from `createTable` so the generated
+     * SQL can be asserted without a live connection.
+     */
+    buildCreateTableSQL(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): string;
+    /**
+     * Create a table using Firebird DDL (identity columns, no SERIAL). After the
+     * table is created, unique keys, indexes and a table comment (if requested)
+     * are applied as separate statements, mirroring the base dialect's behaviour.
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions): Promise<void>;
+    /**
+     * Build a single Firebird column definition (used by CREATE TABLE and
+     * ADD COLUMN). Auto-increment INTEGER/BIGINT columns become identity columns.
+     */
+    private getFirebirdColumnSql;
+    /**
+     * Build an inline table constraint for Firebird CREATE TABLE.
+     */
+    private buildFirebirdConstraintSql;
+    /**
+     * Add a column to a table. Firebird's `ALTER TABLE ... ADD` omits the
+     * `COLUMN` keyword that PostgreSQL uses.
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Remove a column from a table. Firebird's `ALTER TABLE ... DROP` omits the
+     * `COLUMN` keyword that PostgreSQL uses.
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Build a Firebird identity-column definition, e.g.
+     * `"id" INTEGER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY`.
+     *
+     * Firebird 3+ replaces PostgreSQL's `SERIAL` shorthand with the SQL-standard
+     * `GENERATED BY DEFAULT AS IDENTITY` clause.
+     *
+     * @param columnName - Name of the identity column
+     * @param options - `type` selects INTEGER (default) or BIGINT; `primaryKey`
+     *   appends `PRIMARY KEY`
+     */
+    getIdentityColumnSql(columnName: string, options?: {
+        type?: 'INTEGER' | 'BIGINT';
+        primaryKey?: boolean;
+    }): string;
+    /**
+     * Build the SQL to create a Firebird generator (sequence). Firebird's
+     * sequence objects were historically called "generators"; modern Firebird
+     * accepts the SQL-standard `CREATE SEQUENCE` spelling, which is emitted here.
+     *
+     * @param name - Generator/sequence name
+     * @returns `CREATE SEQUENCE "name"`
+     */
+    createGenerator(name: string): string;
+    /**
+     * Build a Firebird `GEN_ID(generator, step)` expression, the legacy function
+     * for atomically advancing a generator/sequence and reading its new value
+     * (e.g. `GEN_ID(my_gen, 1)`). Step 0 reads the current value without changing
+     * it. Still widely used in triggers and default expressions.
+     */
+    genId(generator: string, step?: number): string;
+    /**
+     * Build a Firebird `NEXT VALUE FOR sequence` expression (the SQL-standard
+     * spelling Firebird 3+ accepts alongside `GEN_ID`).
+     */
+    nextValueFor(sequence: string): string;
+    /**
+     * Create a Firebird sequence (generator). Firebird accepts the SQL-standard
+     * `CREATE SEQUENCE` spelling; `START WITH`/`INCREMENT BY` are supported by
+     * Firebird 3+. Overrides the inherited PostgreSQL builder, which emits
+     * `MINVALUE`/`MAXVALUE`/`CYCLE`/`CACHE` clauses Firebird does not accept.
+     */
+    createSequence(options: SequenceOptions): Promise<void>;
+    /**
+     * Drop a Firebird sequence (generator). Firebird has no `IF EXISTS`/`CASCADE`
+     * on `DROP SEQUENCE`, so those options are ignored.
+     */
+    dropSequence(sequenceName: string, _options?: DropSequenceOptions): Promise<void>;
+    /**
+     * Read the next value of a Firebird sequence. Firebird has no `nextval()`
+     * function (PostgreSQL's spelling); it uses `NEXT VALUE FOR seq` selected from
+     * the one-row system table `RDB$DATABASE`.
+     */
+    nextSequenceValue(sequenceName: string): Promise<number>;
+    /**
+     * Check whether a Firebird sequence/generator exists via the system catalog
+     * `RDB$GENERATORS` (PostgreSQL's `pg_sequences` does not exist in Firebird).
+     */
+    hasSequence(sequenceName: string): Promise<boolean>;
+    /**
+     * Build a Firebird `EXECUTE BLOCK` statement — Firebird's anonymous PSQL
+     * block, used to run multi-statement / procedural logic (loops, variables,
+     * exception handling) in a single round trip without creating a stored
+     * procedure. This is Firebird's equivalent of PostgreSQL's `DO $$ ... $$`.
+     *
+     * @param body - The PSQL statements between `AS BEGIN` and `END`.
+     * @param options - Optional input parameters, `RETURNS` output parameters,
+     *   and local `DECLARE` variables.
+     */
+    buildExecuteBlock(body: string, options?: {
+        params?: Array<{
+            name: string;
+            type: string;
+            value?: unknown;
+        }>;
+        returns?: Array<{
+            name: string;
+            type: string;
+        }>;
+        declares?: Array<{
+            name: string;
+            type: string;
+        }>;
+    }): string;
+    private unsupported;
+    createMaterializedView(_options: MaterializedViewOptions): Promise<void>;
+    refreshMaterializedView(_viewName: string, _options?: RefreshOptions): Promise<void>;
+    dropMaterializedView(_viewName: string, _options?: DropMaterializedViewOptions): Promise<void>;
+    hasMaterializedView(_viewName: string): Promise<boolean>;
+    createPolicy(_options: PolicyOptions): Promise<void>;
+    dropPolicy(_policyName: string, _tableName: string, _options?: DropPolicyOptions): Promise<void>;
+    enableRLS(_tableName: string, _schema?: string): Promise<void>;
+    disableRLS(_tableName: string, _schema?: string): Promise<void>;
+    hasPolicy(_policyName: string, _tableName: string): Promise<boolean>;
+    createExtension(_extensionName: string, _options?: CreateExtensionOptions): Promise<void>;
+    dropExtension(_extensionName: string, _options?: DropExtensionOptions): Promise<void>;
+}
+/**
+ * Create a new Firebird dialect instance
+ */
+export declare function createFirebirdDialect(options?: FirebirdDialectOptions): FirebirdDialect;
+export default FirebirdDialect;

package/dist/dialects/firebird/index.js

@@ -484,6 +484,141 @@ class FirebirdDialect extends postgres_1.PostgresDialect {
     createGenerator(name) {
         return `CREATE SEQUENCE ${this.escapeId(name)}`;
     }
+    /**
+     * Build a Firebird `GEN_ID(generator, step)` expression, the legacy function
+     * for atomically advancing a generator/sequence and reading its new value
+     * (e.g. `GEN_ID(my_gen, 1)`). Step 0 reads the current value without changing
+     * it. Still widely used in triggers and default expressions.
+     */
+    genId(generator, step = 1) {
+        return `GEN_ID(${this.escapeId(generator)}, ${Number(step)})`;
+    }
+    /**
+     * Build a Firebird `NEXT VALUE FOR sequence` expression (the SQL-standard
+     * spelling Firebird 3+ accepts alongside `GEN_ID`).
+     */
+    nextValueFor(sequence) {
+        return `NEXT VALUE FOR ${this.escapeId(sequence)}`;
+    }
+    /**
+     * Create a Firebird sequence (generator). Firebird accepts the SQL-standard
+     * `CREATE SEQUENCE` spelling; `START WITH`/`INCREMENT BY` are supported by
+     * Firebird 3+. Overrides the inherited PostgreSQL builder, which emits
+     * `MINVALUE`/`MAXVALUE`/`CYCLE`/`CACHE` clauses Firebird does not accept.
+     */
+    async createSequence(options) {
+        let sql = `CREATE SEQUENCE ${this.escapeId(options.name)}`;
+        if (options.startWith !== undefined) {
+            sql += ` START WITH ${Number(options.startWith)}`;
+        }
+        if (options.incrementBy !== undefined) {
+            sql += ` INCREMENT BY ${Number(options.incrementBy)}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Drop a Firebird sequence (generator). Firebird has no `IF EXISTS`/`CASCADE`
+     * on `DROP SEQUENCE`, so those options are ignored.
+     */
+    async dropSequence(sequenceName, _options) {
+        await this.query(`DROP SEQUENCE ${this.escapeId(sequenceName)}`);
+    }
+    /**
+     * Read the next value of a Firebird sequence. Firebird has no `nextval()`
+     * function (PostgreSQL's spelling); it uses `NEXT VALUE FOR seq` selected from
+     * the one-row system table `RDB$DATABASE`.
+     */
+    async nextSequenceValue(sequenceName) {
+        const result = await this.query(`SELECT NEXT VALUE FOR ${this.escapeId(sequenceName)} AS val FROM RDB$DATABASE`);
+        const row = (result.rows && result.rows[0]);
+        return Number(row?.val ?? row?.VAL ?? 0);
+    }
+    /**
+     * Check whether a Firebird sequence/generator exists via the system catalog
+     * `RDB$GENERATORS` (PostgreSQL's `pg_sequences` does not exist in Firebird).
+     */
+    async hasSequence(sequenceName) {
+        const result = await this.query(`SELECT 1 AS present FROM RDB$GENERATORS WHERE RDB$GENERATOR_NAME = ${this.escape(sequenceName.toUpperCase())}`);
+        return !!(result.rows && result.rows.length > 0);
+    }
+    // ==========================================================================
+    // EXECUTE BLOCK (Firebird anonymous PSQL)
+    // ==========================================================================
+    /**
+     * Build a Firebird `EXECUTE BLOCK` statement — Firebird's anonymous PSQL
+     * block, used to run multi-statement / procedural logic (loops, variables,
+     * exception handling) in a single round trip without creating a stored
+     * procedure. This is Firebird's equivalent of PostgreSQL's `DO $$ ... $$`.
+     *
+     * @param body - The PSQL statements between `AS BEGIN` and `END`.
+     * @param options - Optional input parameters, `RETURNS` output parameters,
+     *   and local `DECLARE` variables.
+     */
+    buildExecuteBlock(body, options) {
+        let header = 'EXECUTE BLOCK';
+        if (options?.params && options.params.length > 0) {
+            const paramList = options.params
+                .map((p) => `${this.escapeId(p.name)} ${p.type} = ?`)
+                .join(', ');
+            header += ` (${paramList})`;
+        }
+        if (options?.returns && options.returns.length > 0) {
+            const returnsList = options.returns
+                .map((r) => `${this.escapeId(r.name)} ${r.type}`)
+                .join(', ');
+            header += ` RETURNS (${returnsList})`;
+        }
+        const declares = (options?.declares || [])
+            .map((d) => `  DECLARE VARIABLE ${this.escapeId(d.name)} ${d.type};`)
+            .join('\n');
+        const declareBlock = declares ? `${declares}\n` : '';
+        return `${header} AS\n${declareBlock}BEGIN\n${body}\nEND`;
+    }
+    // ==========================================================================
+    // PostgreSQL-only capabilities Firebird does not have.
+    //
+    // FirebirdDialect extends PostgresDialect, so without these overrides the
+    // inherited methods would silently emit PostgreSQL-specific SQL that fails on
+    // Firebird. We surface a clear, typed capability error instead of generating
+    // invalid SQL (the "never silent raw-SQL" contract).
+    // ==========================================================================
+    unsupported(feature, alternative) {
+        const suffix = alternative ? ` ${alternative}` : '';
+        return new Error(`${feature} is not supported by Firebird.${suffix}`);
+    }
+    async createMaterializedView(_options) {
+        throw this.unsupported('Materialized views', 'Emulate with a regular table refreshed by a trigger or scheduled job.');
+    }
+    async refreshMaterializedView(_viewName, _options) {
+        throw this.unsupported('Materialized views');
+    }
+    async dropMaterializedView(_viewName, _options) {
+        throw this.unsupported('Materialized views');
+    }
+    async hasMaterializedView(_viewName) {
+        return false;
+    }
+    async createPolicy(_options) {
+        throw this.unsupported('Row-level security policies', 'Enforce row filtering via views or application-level predicates.');
+    }
+    async dropPolicy(_policyName, _tableName, _options) {
+        throw this.unsupported('Row-level security policies');
+    }
+    async enableRLS(_tableName, _schema) {
+        throw this.unsupported('Row-level security');
+    }
+    async disableRLS(_tableName, _schema) {
+        throw this.unsupported('Row-level security');
+    }
+    async hasPolicy(_policyName, _tableName) {
+        return false;
+    }
+    async createExtension(_extensionName, _options) {
+        throw this.unsupported('Extensions', 'Firebird ships built-in functions and UDR modules instead of PostgreSQL extensions.');
+    }
+    async dropExtension(_extensionName, _options) {
+        throw this.unsupported('Extensions');
+    }
 }
 exports.FirebirdDialect = FirebirdDialect;
 /**