firebird-wasm 0.9.0 → 0.10.1

package/dist/kysely/index.js

@@ -0,0 +1,777 @@
+"use strict";
+/**
+ * firebird-wasm/kysely – a Kysely dialect for `FirebirdBrowser` and `FirebirdLite`.
+ *
+ * ```ts
+ * import { Kysely } from 'kysely';
+ * import type { Generated } from 'kysely';
+ * import { FirebirdDialect, createKysely } from 'firebird-wasm/kysely';
+ *
+ * interface Database {
+ *   items: {
+ *     id: Generated<number>;
+ *     title: string;
+ *     done: boolean;
+ *   };
+ * }
+ *
+ * const db = createKysely<Database>(fb);
+ * // or: new Kysely<Database>({ dialect: new FirebirdDialect({ database: fb }) });
+ *
+ * const rows = await db
+ *   .selectFrom('items')
+ *   .select(['id', 'title', 'done'])
+ *   .where('done', '=', false)
+ *   .orderBy('id')
+ *   .offset(10)
+ *   .limit(5)
+ *   .execute();
+ * ```
+ *
+ * Compiles to Firebird 3+ SQL:
+ * - `?` positional parameter placeholders;
+ * - `OFFSET ? ROWS FETCH NEXT ? ROWS ONLY` pagination (and `ROWS ?` on `UPDATE`/`DELETE`);
+ * - `INSERT / UPDATE / DELETE … RETURNING`;
+ * - `UPDATE OR INSERT INTO … MATCHING (…)` on `.onConflict(oc => oc.column(…).doUpdateSet(…))`;
+ * - multi-row `INSERT INTO … SELECT … FROM RDB$DATABASE UNION ALL …`;
+ * - `GENERATED BY DEFAULT AS IDENTITY` for `autoIncrement` / `serial` / `bigserial`;
+ * - bijective identifier folding (`items` ↔ `"ITEMS"`, while `"camelCase"` stays `"camelCase"`),
+ *   so lowercase Kysely table/column types work out of the box against unquoted Firebird DDL.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FirebirdDialect_config, _FirebirdQueryCompiler_identifierCase, _FirebirdQueryCompiler_pendingSelectLimits, _FirebirdDriver_config, _FirebirdDriver_db, _FirebirdDriver_connection, _FirebirdDriver_queue, _FirebirdDriver_releaseCurrent, _FirebirdConnection_db, _FirebirdConnection_identifierCase, _FirebirdConnection_tx, _FirebirdConnection_finishTx, _FirebirdConnection_txDone, _FirebirdIntrospector_db, _FirebirdIntrospector_identifierCase;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebirdIntrospector = exports.FirebirdDriver = exports.FirebirdQueryCompiler = exports.FirebirdAdapter = exports.FirebirdDialect = void 0;
+exports.createKysely = createKysely;
+exports.parseMultiRowInsert = parseMultiRowInsert;
+const kysely_1 = require("kysely");
+/**
+ * Convenience helper to construct a `Kysely<DB>` instance over a `FirebirdBrowser`
+ * or `FirebirdLite` database.
+ */
+function createKysely(database, options = {}) {
+    return new kysely_1.Kysely({
+        dialect: new FirebirdDialect({ database, ...options }),
+    });
+}
+/**
+ * Kysely dialect for Firebird (`FirebirdBrowser` and `FirebirdLite`).
+ */
+class FirebirdDialect {
+    constructor(config) {
+        _FirebirdDialect_config.set(this, void 0);
+        __classPrivateFieldSet(this, _FirebirdDialect_config, { ...config }, "f");
+    }
+    createDriver() {
+        return new FirebirdDriver(__classPrivateFieldGet(this, _FirebirdDialect_config, "f"));
+    }
+    createQueryCompiler() {
+        return new FirebirdQueryCompiler(__classPrivateFieldGet(this, _FirebirdDialect_config, "f").identifierCase ?? 'lower');
+    }
+    createAdapter() {
+        return new FirebirdAdapter();
+    }
+    createIntrospector(db) {
+        return new FirebirdIntrospector(db, __classPrivateFieldGet(this, _FirebirdDialect_config, "f").identifierCase ?? 'lower');
+    }
+}
+exports.FirebirdDialect = FirebirdDialect;
+_FirebirdDialect_config = new WeakMap();
+/**
+ * Kysely dialect adapter for Firebird.
+ *
+ * Firebird supports `INSERT / UPDATE / DELETE … RETURNING`, and requires DDL
+ * to commit before DML in the same table can use the new metadata.
+ */
+class FirebirdAdapter extends kysely_1.DialectAdapterBase {
+    get supportsTransactionalDdl() {
+        return false;
+    }
+    get supportsReturning() {
+        return true;
+    }
+    async acquireMigrationLock() {
+        // Firebird databases are either single-user in the browser or serialize
+        // DDL through metadata locks on the server.
+    }
+    async releaseMigrationLock() {
+        // No-op.
+    }
+}
+exports.FirebirdAdapter = FirebirdAdapter;
+const DATA_TYPE_MAP = {
+    serial: 'integer generated by default as identity',
+    bigserial: 'bigint generated by default as identity',
+    text: 'blob sub_type text',
+    bytea: 'blob sub_type binary',
+    timestamptz: 'timestamp with time zone',
+    timetz: 'time with time zone',
+    float4: 'float',
+    float8: 'double precision',
+    int2: 'smallint',
+    int4: 'integer',
+    int8: 'bigint',
+    uuid: 'varchar(36)',
+    json: 'blob sub_type text',
+    jsonb: 'blob sub_type text',
+};
+/**
+ * Kysely query compiler targeting Firebird 3+ SQL syntax.
+ */
+class FirebirdQueryCompiler extends kysely_1.DefaultQueryCompiler {
+    constructor(identifierCase = 'lower') {
+        super();
+        _FirebirdQueryCompiler_identifierCase.set(this, void 0);
+        _FirebirdQueryCompiler_pendingSelectLimits.set(this, []);
+        __classPrivateFieldSet(this, _FirebirdQueryCompiler_identifierCase, identifierCase, "f");
+    }
+    getCurrentParameterPlaceholder() {
+        return '?';
+    }
+    getLeftIdentifierWrapper() {
+        return '"';
+    }
+    getRightIdentifierWrapper() {
+        return '"';
+    }
+    getAutoIncrement() {
+        return 'generated by default as identity';
+    }
+    compileUnwrappedIdentifier(node) {
+        const mapped = __classPrivateFieldGet(this, _FirebirdQueryCompiler_identifierCase, "f") === 'lower' && /^[a-z_][a-z0-9_$]*$/.test(node.name)
+            ? node.name.toUpperCase()
+            : node.name;
+        super.compileUnwrappedIdentifier({ ...node, name: mapped });
+    }
+    visitSelectQuery(node) {
+        if (node.offset && node.limit) {
+            // Firebird SQL requires OFFSET <n> ROWS before FETCH NEXT <m> ROWS ONLY.
+            __classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f").push(node.limit);
+            try {
+                super.visitSelectQuery({ ...node, limit: undefined });
+            }
+            finally {
+                __classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f").pop();
+            }
+            return;
+        }
+        __classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f").push(undefined);
+        try {
+            super.visitSelectQuery(node);
+        }
+        finally {
+            __classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f").pop();
+        }
+    }
+    visitOffset(node) {
+        this.append('offset ');
+        this.visitNode(node.offset);
+        this.append(' rows');
+        const pendingLimit = __classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f")[__classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f").length - 1];
+        if (pendingLimit) {
+            __classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f")[__classPrivateFieldGet(this, _FirebirdQueryCompiler_pendingSelectLimits, "f").length - 1] = undefined;
+            this.append(' ');
+            this.visitNode(pendingLimit);
+        }
+    }
+    visitLimit(node) {
+        const parent = this.parentNode;
+        if (parent &&
+            (parent.kind === 'UpdateQueryNode' || parent.kind === 'DeleteQueryNode')) {
+            this.append('rows ');
+            this.visitNode(node.limit);
+            return;
+        }
+        this.append('fetch next ');
+        this.visitNode(node.limit);
+        this.append(' rows only');
+    }
+    visitValues(node) {
+        if (node.values.length <= 1) {
+            super.visitValues(node);
+            return;
+        }
+        // Firebird multi-row INSERT: SELECT ?, ? FROM RDB$DATABASE UNION ALL ...
+        for (let i = 0; i < node.values.length; i++) {
+            if (i > 0)
+                this.append(' union all ');
+            this.append('select ');
+            const item = node.values[i];
+            if (item.kind === 'PrimitiveValueListNode') {
+                const vals = item.values;
+                for (let j = 0; j < vals.length; j++) {
+                    if (j > 0)
+                        this.append(', ');
+                    this.appendValue(vals[j]);
+                }
+            }
+            else if (item.kind === 'ValueListNode') {
+                this.compileList(item.values);
+            }
+            else {
+                this.visitNode(item);
+            }
+            this.append(' from rdb$database');
+        }
+    }
+    visitInsertQuery(node) {
+        if (node.onConflict &&
+            node.onConflict.columns &&
+            node.onConflict.columns.length > 0 &&
+            !node.onConflict.doNothing) {
+            // Compile Kysely's onConflict(oc => oc.column(...).doUpdateSet(...))
+            // to Firebird's native UPDATE OR INSERT INTO ... VALUES (...) MATCHING (...).
+            if (node.with) {
+                this.visitNode(node.with);
+                this.append(' ');
+            }
+            this.append('update or insert');
+            if (node.into) {
+                this.append(' into ');
+                this.visitNode(node.into);
+            }
+            if (node.columns) {
+                this.append(' (');
+                this.compileList(node.columns);
+                this.append(')');
+            }
+            if (node.values) {
+                this.append(' ');
+                this.visitNode(node.values);
+            }
+            this.append(' matching (');
+            this.compileList(node.onConflict.columns);
+            this.append(')');
+            if (node.returning) {
+                this.append(' ');
+                this.visitNode(node.returning);
+            }
+            return;
+        }
+        super.visitInsertQuery(node);
+    }
+    visitCreateTable(node) {
+        if (node.temporary) {
+            // Firebird syntax: CREATE GLOBAL TEMPORARY TABLE ...
+            this.append('create global temporary table ');
+            if (node.ifNotExists) {
+                this.append('if not exists ');
+            }
+            this.visitNode(node.table);
+            if (!node.selectQuery) {
+                this.append(' (');
+                this.compileList([
+                    ...node.columns,
+                    ...(node.constraints ?? []),
+                ]);
+                this.append(')');
+            }
+            if (node.onCommit) {
+                this.append(' on commit ');
+                this.append(node.onCommit);
+            }
+            if (node.selectQuery) {
+                this.append(' as ');
+                this.visitNode(node.selectQuery);
+            }
+            return;
+        }
+        super.visitCreateTable(node);
+    }
+    visitColumnDefinition(node) {
+        if (node.autoIncrement) {
+            super.visitColumnDefinition({
+                ...node,
+                autoIncrement: false,
+                frontModifiers: [
+                    ...(node.frontModifiers ?? []),
+                    {
+                        kind: 'RawNode',
+                        sqlFragments: [this.getAutoIncrement()],
+                        parameters: [],
+                    },
+                ],
+            });
+            return;
+        }
+        super.visitColumnDefinition(node);
+    }
+    visitDataType(node) {
+        const mapped = DATA_TYPE_MAP[String(node.dataType).toLowerCase()];
+        if (mapped) {
+            this.append(mapped);
+            return;
+        }
+        super.visitDataType(node);
+    }
+    visitAddColumn(node) {
+        this.append('add ');
+        this.visitNode(node.column);
+    }
+    visitDropColumn(node) {
+        this.append('drop ');
+        this.visitNode(node.column);
+    }
+    visitRenameColumn(node) {
+        this.append('alter column ');
+        this.visitNode(node.column);
+        this.append(' to ');
+        this.visitNode(node.renameTo);
+    }
+}
+exports.FirebirdQueryCompiler = FirebirdQueryCompiler;
+_FirebirdQueryCompiler_identifierCase = new WeakMap(), _FirebirdQueryCompiler_pendingSelectLimits = new WeakMap();
+const BEGIN_TX = Symbol('BEGIN_TX');
+const COMMIT_TX = Symbol('COMMIT_TX');
+const ROLLBACK_TX = Symbol('ROLLBACK_TX');
+/**
+ * Kysely driver backed by a `FirebirdBrowser` or `FirebirdLite` instance.
+ */
+class FirebirdDriver {
+    constructor(config) {
+        _FirebirdDriver_config.set(this, void 0);
+        _FirebirdDriver_db.set(this, void 0);
+        _FirebirdDriver_connection.set(this, void 0);
+        _FirebirdDriver_queue.set(this, Promise.resolve());
+        _FirebirdDriver_releaseCurrent.set(this, void 0);
+        __classPrivateFieldSet(this, _FirebirdDriver_config, config, "f");
+    }
+    async init() {
+        __classPrivateFieldSet(this, _FirebirdDriver_db, __classPrivateFieldGet(this, _FirebirdDriver_db, "f") ?? (typeof __classPrivateFieldGet(this, _FirebirdDriver_config, "f").database === 'function'
+            ? await __classPrivateFieldGet(this, _FirebirdDriver_config, "f").database()
+            : __classPrivateFieldGet(this, _FirebirdDriver_config, "f").database), "f");
+        __classPrivateFieldSet(this, _FirebirdDriver_connection, new FirebirdConnection(__classPrivateFieldGet(this, _FirebirdDriver_db, "f"), __classPrivateFieldGet(this, _FirebirdDriver_config, "f").identifierCase ?? 'lower'), "f");
+        if (__classPrivateFieldGet(this, _FirebirdDriver_config, "f").onCreateConnection) {
+            await __classPrivateFieldGet(this, _FirebirdDriver_config, "f").onCreateConnection(__classPrivateFieldGet(this, _FirebirdDriver_connection, "f"));
+        }
+    }
+    async acquireConnection() {
+        const prev = __classPrivateFieldGet(this, _FirebirdDriver_queue, "f");
+        let release;
+        __classPrivateFieldSet(this, _FirebirdDriver_queue, new Promise((r) => {
+            release = r;
+        }), "f");
+        await prev;
+        __classPrivateFieldSet(this, _FirebirdDriver_releaseCurrent, release, "f");
+        return __classPrivateFieldGet(this, _FirebirdDriver_connection, "f");
+    }
+    async beginTransaction(connection, settings) {
+        await connection[BEGIN_TX](settings);
+    }
+    async commitTransaction(connection) {
+        await connection[COMMIT_TX]();
+    }
+    async rollbackTransaction(connection) {
+        await connection[ROLLBACK_TX]();
+    }
+    async savepoint(connection, savepointName) {
+        await connection.executeQuery(kysely_1.CompiledQuery.raw(`savepoint ${quoteSavepoint(savepointName)}`));
+    }
+    async rollbackToSavepoint(connection, savepointName) {
+        await connection.executeQuery(kysely_1.CompiledQuery.raw(`rollback to savepoint ${quoteSavepoint(savepointName)}`));
+    }
+    async releaseSavepoint(connection, savepointName) {
+        await connection.executeQuery(kysely_1.CompiledQuery.raw(`release savepoint ${quoteSavepoint(savepointName)}`));
+    }
+    async releaseConnection() {
+        const release = __classPrivateFieldGet(this, _FirebirdDriver_releaseCurrent, "f");
+        __classPrivateFieldSet(this, _FirebirdDriver_releaseCurrent, undefined, "f");
+        release?.();
+    }
+    async destroy() {
+        if (__classPrivateFieldGet(this, _FirebirdDriver_config, "f").closeOnDestroy && __classPrivateFieldGet(this, _FirebirdDriver_db, "f")?.close) {
+            await __classPrivateFieldGet(this, _FirebirdDriver_db, "f").close();
+        }
+    }
+}
+exports.FirebirdDriver = FirebirdDriver;
+_FirebirdDriver_config = new WeakMap(), _FirebirdDriver_db = new WeakMap(), _FirebirdDriver_connection = new WeakMap(), _FirebirdDriver_queue = new WeakMap(), _FirebirdDriver_releaseCurrent = new WeakMap();
+class FirebirdConnection {
+    constructor(db, identifierCase) {
+        _FirebirdConnection_db.set(this, void 0);
+        _FirebirdConnection_identifierCase.set(this, void 0);
+        _FirebirdConnection_tx.set(this, void 0);
+        _FirebirdConnection_finishTx.set(this, void 0);
+        _FirebirdConnection_txDone.set(this, void 0);
+        __classPrivateFieldSet(this, _FirebirdConnection_db, db, "f");
+        __classPrivateFieldSet(this, _FirebirdConnection_identifierCase, identifierCase, "f");
+    }
+    async executeQuery(compiledQuery) {
+        const target = __classPrivateFieldGet(this, _FirebirdConnection_tx, "f") ?? __classPrivateFieldGet(this, _FirebirdConnection_db, "f");
+        const params = [...compiledQuery.parameters];
+        const multiInsert = parseMultiRowInsert(compiledQuery.sql, params);
+        if (shouldUseExec(compiledQuery.query, compiledQuery.sql)) {
+            if (multiInsert && typeof target.execBatch === 'function') {
+                if (multiInsert.uniformSql) {
+                    const res = await target.execBatch(multiInsert.uniformSql, multiInsert.rows.map((r) => r.params));
+                    const affected = extractAffectedRows(res) ?? multiInsert.rows.length;
+                    return {
+                        numAffectedRows: BigInt(affected),
+                        rows: [],
+                    };
+                }
+                for (const row of multiInsert.rows) {
+                    await target.exec(row.sql, row.params);
+                }
+                return {
+                    numAffectedRows: BigInt(multiInsert.rows.length),
+                    rows: [],
+                };
+            }
+            const res = await target.exec(compiledQuery.sql, params);
+            const affected = extractAffectedRows(res);
+            return {
+                ...(affected !== undefined ? { numAffectedRows: BigInt(affected) } : {}),
+                rows: [],
+            };
+        }
+        if (multiInsert && multiInsert.hasReturning && typeof target.execBatch === 'function') {
+            const rawRows = [];
+            for (const row of multiInsert.rows) {
+                const res = await target.query(row.sql, row.params, {
+                    rowMode: 'object',
+                });
+                rawRows.push(...res.rows);
+            }
+            const rows = mapRows(rawRows, __classPrivateFieldGet(this, _FirebirdConnection_identifierCase, "f"));
+            return {
+                numAffectedRows: BigInt(rows.length),
+                rows,
+            };
+        }
+        const result = await target.query(compiledQuery.sql, params, {
+            rowMode: 'object',
+        });
+        const rows = mapRows(result.rows, __classPrivateFieldGet(this, _FirebirdConnection_identifierCase, "f"));
+        const kind = compiledQuery.query?.kind;
+        const isMutatingReturning = kind === 'InsertQueryNode' ||
+            kind === 'UpdateQueryNode' ||
+            kind === 'DeleteQueryNode';
+        return {
+            ...(isMutatingReturning ? { numAffectedRows: BigInt(rows.length) } : {}),
+            rows,
+        };
+    }
+    async *streamQuery(compiledQuery, chunkSize = 500) {
+        const target = __classPrivateFieldGet(this, _FirebirdConnection_tx, "f") ?? __classPrivateFieldGet(this, _FirebirdConnection_db, "f");
+        if (typeof target.queryStream === 'function') {
+            const stream = target.queryStream(compiledQuery.sql, [...compiledQuery.parameters], { batchSize: chunkSize && chunkSize > 0 ? chunkSize : 500, rowMode: 'object' });
+            for await (const batch of stream) {
+                yield {
+                    rows: mapRows(batch.rows, __classPrivateFieldGet(this, _FirebirdConnection_identifierCase, "f")),
+                };
+            }
+            return;
+        }
+        const result = await this.executeQuery(compiledQuery);
+        if (result.rows.length > 0) {
+            yield { rows: result.rows };
+        }
+    }
+    async [(_FirebirdConnection_db = new WeakMap(), _FirebirdConnection_identifierCase = new WeakMap(), _FirebirdConnection_tx = new WeakMap(), _FirebirdConnection_finishTx = new WeakMap(), _FirebirdConnection_txDone = new WeakMap(), BEGIN_TX)](settings) {
+        let signalReady;
+        let signalStartError;
+        const ready = new Promise((resolve, reject) => {
+            signalReady = resolve;
+            signalStartError = reject;
+        });
+        const waitForAction = new Promise((resolve) => {
+            __classPrivateFieldSet(this, _FirebirdConnection_finishTx, resolve, "f");
+        });
+        __classPrivateFieldSet(this, _FirebirdConnection_txDone, __classPrivateFieldGet(this, _FirebirdConnection_db, "f")
+            .transaction(async (tx) => {
+            __classPrivateFieldSet(this, _FirebirdConnection_tx, tx, "f");
+            signalReady();
+            const action = await waitForAction;
+            if (action === 'rollback') {
+                await tx.rollback();
+            }
+        }, mapTransactionSettings(settings))
+            .then(() => undefined, (err) => {
+            signalStartError(err);
+            throw err;
+        }), "f");
+        await ready;
+    }
+    async [COMMIT_TX]() {
+        const finish = __classPrivateFieldGet(this, _FirebirdConnection_finishTx, "f");
+        const done = __classPrivateFieldGet(this, _FirebirdConnection_txDone, "f");
+        __classPrivateFieldSet(this, _FirebirdConnection_finishTx, undefined, "f");
+        __classPrivateFieldSet(this, _FirebirdConnection_txDone, undefined, "f");
+        __classPrivateFieldSet(this, _FirebirdConnection_tx, undefined, "f");
+        finish?.('commit');
+        await done;
+    }
+    async [ROLLBACK_TX]() {
+        const finish = __classPrivateFieldGet(this, _FirebirdConnection_finishTx, "f");
+        const done = __classPrivateFieldGet(this, _FirebirdConnection_txDone, "f");
+        __classPrivateFieldSet(this, _FirebirdConnection_finishTx, undefined, "f");
+        __classPrivateFieldSet(this, _FirebirdConnection_txDone, undefined, "f");
+        __classPrivateFieldSet(this, _FirebirdConnection_tx, undefined, "f");
+        finish?.('rollback');
+        await done?.catch(() => undefined);
+    }
+}
+/**
+ * Kysely database introspector reading Firebird's `RDB$RELATIONS` and `RDB$RELATION_FIELDS`.
+ */
+class FirebirdIntrospector {
+    constructor(db, identifierCase = 'lower') {
+        _FirebirdIntrospector_db.set(this, void 0);
+        _FirebirdIntrospector_identifierCase.set(this, void 0);
+        __classPrivateFieldSet(this, _FirebirdIntrospector_db, db, "f");
+        __classPrivateFieldSet(this, _FirebirdIntrospector_identifierCase, identifierCase, "f");
+    }
+    async getSchemas() {
+        return [];
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        const relResult = await (0, kysely_1.sql) `SELECT TRIM(RDB$RELATION_NAME) AS "name", CASE WHEN RDB$VIEW_BLR IS NULL THEN 0 ELSE 1 END AS "is_view" FROM RDB$RELATIONS WHERE COALESCE(RDB$SYSTEM_FLAG, 0) = 0 ORDER BY RDB$RELATION_NAME`.execute(__classPrivateFieldGet(this, _FirebirdIntrospector_db, "f"));
+        const colResult = await (0, kysely_1.sql) `SELECT TRIM(rf.RDB$RELATION_NAME) AS "relation_name", TRIM(rf.RDB$FIELD_NAME) AS "field_name", f.RDB$FIELD_TYPE AS "field_type", COALESCE(f.RDB$FIELD_SUB_TYPE, 0) AS "field_sub_type", COALESCE(f.RDB$FIELD_SCALE, 0) AS "field_scale", COALESCE(rf.RDB$NULL_FLAG, f.RDB$NULL_FLAG, 0) AS "null_flag", CASE WHEN rf.RDB$DEFAULT_SOURCE IS NOT NULL OR f.RDB$DEFAULT_SOURCE IS NOT NULL THEN 1 ELSE 0 END AS "has_default", CASE WHEN rf.RDB$IDENTITY_TYPE IS NOT NULL THEN 1 ELSE 0 END AS "is_identity" FROM RDB$RELATION_FIELDS rf JOIN RDB$FIELDS f ON f.RDB$FIELD_NAME = rf.RDB$FIELD_SOURCE JOIN RDB$RELATIONS r ON r.RDB$RELATION_NAME = rf.RDB$RELATION_NAME WHERE COALESCE(r.RDB$SYSTEM_FLAG, 0) = 0 ORDER BY rf.RDB$RELATION_NAME, rf.RDB$FIELD_POSITION`.execute(__classPrivateFieldGet(this, _FirebirdIntrospector_db, "f"));
+        const colsByRelation = new Map();
+        for (const c of colResult.rows) {
+            const rel = String(c.relation_name).trim();
+            const rawName = String(c.field_name).trim();
+            const colName = formatOutputIdentifier(rawName, __classPrivateFieldGet(this, _FirebirdIntrospector_identifierCase, "f"));
+            const list = colsByRelation.get(rel) ?? [];
+            list.push({
+                name: colName,
+                dataType: firebirdFieldTypeName(Number(c.field_type), Number(c.field_sub_type), Number(c.field_scale)),
+                isNullable: Number(c.null_flag) === 0,
+                isAutoIncrementing: Number(c.is_identity) === 1,
+                hasDefaultValue: Number(c.has_default) === 1 || Number(c.is_identity) === 1,
+            });
+            colsByRelation.set(rel, list);
+        }
+        const tables = [];
+        for (const r of relResult.rows) {
+            const rawRel = String(r.name).trim();
+            const lowerRel = rawRel.toLowerCase();
+            if (!options.withInternalKyselyTables &&
+                (lowerRel === 'kysely_migration' || lowerRel === 'kysely_migration_lock')) {
+                continue;
+            }
+            tables.push({
+                name: formatOutputIdentifier(rawRel, __classPrivateFieldGet(this, _FirebirdIntrospector_identifierCase, "f")),
+                isView: Number(r.is_view) === 1,
+                columns: colsByRelation.get(rawRel) ?? [],
+            });
+        }
+        return tables;
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+}
+exports.FirebirdIntrospector = FirebirdIntrospector;
+_FirebirdIntrospector_db = new WeakMap(), _FirebirdIntrospector_identifierCase = new WeakMap();
+function shouldUseExec(node, sql) {
+    if (!node)
+        return !/^\s*(select|with|execute\s+procedure)\b/i.test(sql) && !/\breturning\b/i.test(sql);
+    switch (node.kind) {
+        case 'SelectQueryNode':
+            return false;
+        case 'InsertQueryNode':
+        case 'UpdateQueryNode':
+        case 'DeleteQueryNode':
+            return !node.returning;
+        case 'CreateTableNode':
+        case 'DropTableNode':
+        case 'AlterTableNode':
+        case 'CreateIndexNode':
+        case 'DropIndexNode':
+        case 'CreateViewNode':
+        case 'DropViewNode':
+        case 'CreateSchemaNode':
+        case 'DropSchemaNode':
+            return true;
+        default:
+            return (!/^\s*(select|with|execute\s+procedure)\b/i.test(sql) &&
+                !/\b(returning|returns)\b/i.test(sql));
+    }
+}
+function formatOutputIdentifier(name, mode) {
+    if (mode === 'lower' && /^[A-Z_][A-Z0-9_$]*$/.test(name)) {
+        return name.toLowerCase();
+    }
+    return name;
+}
+function mapRows(rows, mode) {
+    if (mode === 'preserve' || rows.length === 0) {
+        return rows;
+    }
+    const first = rows[0];
+    const keys = Object.keys(first);
+    const mappedKeys = keys.map((k) => formatOutputIdentifier(k, mode));
+    if (keys.every((k, i) => k === mappedKeys[i])) {
+        return rows;
+    }
+    return rows.map((row) => {
+        const out = {};
+        for (let i = 0; i < keys.length; i++) {
+            out[mappedKeys[i]] = row[keys[i]];
+        }
+        return out;
+    });
+}
+function mapTransactionSettings(settings) {
+    const options = {};
+    if (settings.accessMode === 'read only') {
+        options.readOnly = true;
+    }
+    switch (settings.isolationLevel) {
+        case 'read uncommitted':
+        case 'read committed':
+            options.isolationLevel = 'READ_COMMITTED';
+            break;
+        case 'repeatable read':
+        case 'snapshot':
+            options.isolationLevel = 'SNAPSHOT';
+            break;
+        case 'serializable':
+            options.isolationLevel = 'SNAPSHOT_TABLE_STABILITY';
+            break;
+    }
+    return options;
+}
+function quoteSavepoint(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(name)) {
+        throw new Error(`Invalid savepoint name: ${name}`);
+    }
+    return name;
+}
+function firebirdFieldTypeName(type, subType, scale) {
+    if ((type === 7 || type === 8 || type === 16 || type === 26) && (scale < 0 || subType === 1 || subType === 2)) {
+        return subType === 2 ? 'decimal' : 'numeric';
+    }
+    switch (type) {
+        case 7:
+            return 'smallint';
+        case 8:
+            return 'integer';
+        case 10:
+            return 'float';
+        case 12:
+            return 'date';
+        case 13:
+            return 'time';
+        case 14:
+            return 'char';
+        case 16:
+            return 'bigint';
+        case 23:
+            return 'boolean';
+        case 24:
+        case 25:
+            return 'decfloat';
+        case 26:
+            return 'int128';
+        case 27:
+            return 'double precision';
+        case 28:
+            return 'time with time zone';
+        case 29:
+            return 'timestamp with time zone';
+        case 35:
+            return 'timestamp';
+        case 37:
+            return 'varchar';
+        case 261:
+            return subType === 1 ? 'text' : 'blob';
+        default:
+            return `type_${type}`;
+    }
+}
+function extractAffectedRows(res) {
+    if (typeof res === 'object' && res !== null && 'affectedRows' in res) {
+        const n = res.affectedRows;
+        return typeof n === 'number' ? n : undefined;
+    }
+    if (Array.isArray(res)) {
+        let total = 0;
+        for (const item of res) {
+            if (typeof item === 'object' && item !== null && 'affectedRows' in item) {
+                total += Number(item.affectedRows ?? 0);
+            }
+        }
+        return total;
+    }
+    return undefined;
+}
+const MULTI_ROW_INSERT_RE = /^((?:with\b[\s\S]+?\s+)?insert\s+into\s+[\s\S]+?\)\s+(?:overriding\s+system\s+value\s+)?)(select\s+[\s\S]+?\s+from\s+rdb\$database(?:\s+union\s+all\s+select\s+[\s\S]+?\s+from\s+rdb\$database)+)(\s+returning\s+[\s\S]+)?$/i;
+function countPlaceholders(sqlFragment) {
+    let count = 0;
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < sqlFragment.length; i++) {
+        const ch = sqlFragment[i];
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+        }
+        else if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+        }
+        else if (ch === '?' && !inSingle && !inDouble) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Splits a multi-row `INSERT INTO ... SELECT ... FROM RDB$DATABASE UNION ALL ...`
+ * statement into per-row `INSERT INTO ... VALUES (...)` statements so execution
+ * against `FirebirdLite` / `FirebirdBrowser` can use `execBatch` (or per-row
+ * `INSERT ... VALUES (...) RETURNING ...`), avoiding Firebird's `-804 Data type unknown`
+ * error on untyped `?` parameters inside `SELECT ? FROM RDB$DATABASE`.
+ * @internal
+ */
+function parseMultiRowInsert(sql, params) {
+    const m = MULTI_ROW_INSERT_RE.exec(sql.trim());
+    if (!m)
+        return undefined;
+    const prefix = m[1];
+    const selectsBody = m[2];
+    const returningSuffix = m[3] ?? '';
+    const branches = selectsBody.split(/\s+union\s+all\s+/i);
+    if (branches.length < 2)
+        return undefined;
+    const rows = [];
+    let paramOffset = 0;
+    for (const branch of branches) {
+        const bm = /^select\s+([\s\S]+?)\s+from\s+rdb\$database$/i.exec(branch.trim());
+        if (!bm)
+            return undefined;
+        const exprs = bm[1];
+        const pCount = countPlaceholders(exprs);
+        if (paramOffset + pCount > params.length)
+            return undefined;
+        const rowParams = params.slice(paramOffset, paramOffset + pCount);
+        paramOffset += pCount;
+        rows.push({
+            sql: `${prefix}values (${exprs})${returningSuffix}`,
+            params: rowParams,
+        });
+    }
+    if (paramOffset !== params.length)
+        return undefined;
+    const firstSql = rows[0].sql;
+    const uniformSql = rows.every((r) => r.sql === firstSql) ? firstSql : undefined;
+    return {
+        rows,
+        uniformSql,
+        hasReturning: returningSuffix.length > 0,
+    };
+}
+//# sourceMappingURL=index.js.map