ts-prorm-orm 1.1.0

package/dist/dialects/sqlite/index.js

@@ -0,0 +1,3382 @@
+"use strict";
+/**
+ * SQLite dialect implementation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteTransaction = exports.SQLiteDialect = void 0;
+exports.createSQLiteDialect = createSQLiteDialect;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const stream_1 = require("stream");
+const prorm_1 = require("../../prorm");
+const operators_1 = require("../../operators");
+const sqlite_advanced_1 = require("../../sqlite-advanced");
+/**
+ * SQLite dialect class that implements the Dialect interface
+ */
+class SQLiteDialect {
+    constructor(config) {
+        this.name = 'sqlite';
+        this.library = 'better-sqlite3';
+        this.connection = null;
+        this._isConnected = false;
+        this.transactionDepth = 0;
+        this._advanced = null;
+        this.config = {
+            storage: ':memory:',
+            ...config,
+        };
+    }
+    /**
+     * Connect to the SQLite database
+     */
+    async connect() {
+        try {
+            const options = {
+                readonly: this.config.readonly || false,
+                fileMustExist: this.config.fileMustExist || false,
+                timeout: this.config.timeout || 5000,
+                verbose: this.config.verbose || undefined,
+            };
+            this.connection = new better_sqlite3_1.default(this.config.storage, options);
+            this._isConnected = true;
+            // Enable foreign keys by default
+            this.connection.pragma('foreign_keys = ON');
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to SQLite database: ${error}`);
+        }
+    }
+    /**
+     * Disconnect from the SQLite database
+     */
+    async disconnect() {
+        if (this.connection) {
+            this.connection.close();
+            this.connection = null;
+            this._isConnected = false;
+        }
+    }
+    /**
+     * Get the current database connection
+     */
+    getConnection() {
+        return this.connection;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this._isConnected && this.connection !== null;
+    }
+    /**
+     * Get SQLite advanced features instance
+     */
+    get advanced() {
+        if (!this._advanced) {
+            this._advanced = (0, sqlite_advanced_1.createSQLiteAdvanced)(this);
+        }
+        return this._advanced;
+    }
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     */
+    replaceReplacements(sql, replacements) {
+        if (!replacements) {
+            return sql;
+        }
+        // Handle positional replacements (?)
+        if (Array.isArray(replacements)) {
+            let result = sql;
+            for (const value of replacements) {
+                result = result.replace(/\?/, () => this.escape(value));
+            }
+            return result;
+        }
+        // Handle named replacements (:param)
+        let result = sql;
+        for (const [key, value] of Object.entries(replacements)) {
+            // Handle array values for IN clauses
+            if (Array.isArray(value)) {
+                const escapedValues = value.map((v) => this.escape(v)).join(', ');
+                // Replace :paramName (word boundary) with the array values
+                const regex = new RegExp(`:${key}(?![\\w])`, 'g');
+                result = result.replace(regex, escapedValues);
+            }
+            else if (value === null) {
+                // Handle null values
+                const regex = new RegExp(`:${key}(?![\\w])`, 'g');
+                result = result.replace(regex, 'NULL');
+            }
+            else {
+                // Handle scalar values
+                const regex = new RegExp(`:${key}(?![\\w])`, 'g');
+                result = result.replace(regex, () => this.escape(value));
+            }
+        }
+        return result;
+    }
+    /**
+     * Execute a raw SQL query with retry support
+     */
+    async query(sql, options) {
+        // Default retry options for queries
+        const defaultQueryRetryOptions = {
+            max: 3,
+            timeout: 1000,
+            match: ['SQLITE_BUSY', 'SQLITE_LOCKED', 'database is locked', 'database table is locked'],
+            backoff: false,
+            backoffMultiplier: 2,
+            backoffMax: 10000,
+        };
+        const retryOptions = options?.retry;
+        const effectiveRetry = retryOptions
+            ? {
+                ...defaultQueryRetryOptions,
+                ...retryOptions,
+                match: retryOptions.match || defaultQueryRetryOptions.match,
+            }
+            : null;
+        const executeQuery = async () => {
+            if (!this.connection) {
+                throw new Error('Not connected to database');
+            }
+            const sqlUpper = sql.trim().toUpperCase();
+            // EXPLAIN / EXPLAIN QUERY PLAN and WITH (CTE) statements also return rows.
+            const isSelect = sqlUpper.startsWith('SELECT') ||
+                sqlUpper.startsWith('PRAGMA') ||
+                sqlUpper.startsWith('EXPLAIN') ||
+                sqlUpper.startsWith('WITH');
+            const stmt = this.connection.prepare(sql);
+            // Bind parameters for `?` / named placeholders. Several call sites in this
+            // dialect (bulkInsert, getCreateTable, getTableStatus, sqlite-advanced.ts
+            // listViews/getViewDefinition/etc.) build parameterized SQL and pass the
+            // values via `replacements` (array) or `bind` (array or named object) -
+            // previously these were silently dropped and better-sqlite3 would throw
+            // "Too few parameter values were provided" whenever placeholders were used.
+            const rawParams = options?.replacements ?? options?.bind ?? options?.bindings;
+            // better-sqlite3 only binds numbers/strings/bigints/buffers/null. Coerce
+            // the JS types the query/where builders commonly produce (boolean, Date,
+            // plain object/array) so those bindings don't throw at execution time.
+            const coerceBind = (v) => {
+                if (typeof v === 'boolean')
+                    return v ? 1 : 0;
+                if (v instanceof Date)
+                    return v.toISOString();
+                if (v !== null && v !== undefined && typeof v === 'object' && !Buffer.isBuffer(v)) {
+                    return JSON.stringify(v);
+                }
+                return v;
+            };
+            const params = Array.isArray(rawParams)
+                ? rawParams.map(coerceBind)
+                : rawParams && typeof rawParams === 'object'
+                    ? Object.fromEntries(Object.entries(rawParams).map(([k, v]) => [
+                        k,
+                        coerceBind(v),
+                    ]))
+                    : rawParams;
+            try {
+                if (isSelect) {
+                    const rows = params === undefined
+                        ? stmt.all()
+                        : Array.isArray(params)
+                            ? stmt.all(...params)
+                            : stmt.all(params);
+                    return {
+                        rows,
+                        rowCount: rows.length,
+                        fields: [],
+                    };
+                }
+                else {
+                    const result = params === undefined
+                        ? stmt.run()
+                        : Array.isArray(params)
+                            ? stmt.run(...params)
+                            : stmt.run(params);
+                    return {
+                        rows: [],
+                        rowCount: result.changes,
+                        fields: [],
+                        lastInsertRowid: result.lastInsertRowid !== undefined ? Number(result.lastInsertRowid) : undefined,
+                    };
+                }
+            }
+            catch (error) {
+                throw new Error(`Query error: ${error}`);
+            }
+        };
+        // If retry options are provided, use retry logic
+        if (effectiveRetry && effectiveRetry.max > 0) {
+            return this.executeWithRetry(executeQuery, effectiveRetry);
+        }
+        return executeQuery();
+    }
+    /**
+     * Stream query results using better-sqlite3's native `Statement#iterate()`
+     * — a real in-process cursor (no round trips at all, since sqlite is
+     * embedded), so this is more efficient than the generic paginated
+     * LIMIT/OFFSET fallback other dialects use.
+     * @param sql - The SELECT statement to stream
+     * @param options - Streaming options (batch size only affects backpressure batching, not fetch round trips)
+     */
+    queryStream(sql, options) {
+        const stream = new stream_1.Readable({ objectMode: true, highWaterMark: options?.highWaterMark || 1000, read() { } });
+        if (!this.connection) {
+            process.nextTick(() => stream.destroy(new Error('Not connected to database')));
+            return stream;
+        }
+        let iterator;
+        try {
+            iterator = this.connection.prepare(sql).iterate();
+        }
+        catch (error) {
+            process.nextTick(() => stream.destroy(error instanceof Error ? error : new Error(String(error))));
+            return stream;
+        }
+        // Pull rows out of the synchronous iterator on a microtask loop so we
+        // still respect Readable backpressure (stop pulling once push() returns
+        // false, resume from _read()).
+        const pump = () => {
+            let canContinue = true;
+            while (canContinue) {
+                const next = iterator.next();
+                if (next.done) {
+                    stream.push(null);
+                    return;
+                }
+                const row = next.value;
+                if (options?.mapToModel && options?.model) {
+                    const instance = new options.model();
+                    Object.assign(instance, row);
+                    canContinue = stream.push(instance);
+                }
+                else {
+                    canContinue = stream.push(row);
+                }
+            }
+        };
+        stream._read = pump;
+        return stream;
+    }
+    /**
+     * Execute a function with retry logic for query execution
+     */
+    async executeWithRetry(fn, retryOptions) {
+        let lastError;
+        const { backoff, backoffMultiplier, backoffMax } = retryOptions;
+        for (let attempt = 0; attempt <= retryOptions.max; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                const errorMessage = lastError.message;
+                // Check if this error should be retried
+                const shouldRetry = retryOptions.match.some((pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase()));
+                if (!shouldRetry || attempt === retryOptions.max) {
+                    throw lastError;
+                }
+                // Calculate delay - use exponential backoff if enabled
+                let delay;
+                if (backoff) {
+                    delay = retryOptions.timeout * Math.pow(backoffMultiplier || 2, attempt);
+                    delay = Math.min(delay, backoffMax || 10000);
+                }
+                else {
+                    delay = retryOptions.timeout;
+                }
+                // Add some jitter to avoid thundering herd
+                const jitter = Math.random() * 100;
+                await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        // Handle undefined - return NULL (similar to null)
+        if (value === undefined) {
+            return 'NULL';
+        }
+        // Handle Literal (raw SQL) values
+        if (value instanceof prorm_1.Literal) {
+            return value.val;
+        }
+        if (typeof value === 'string') {
+            return `'${this.escapeString(value)}'`;
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        // JSON stringify objects
+        return `'${this.escapeString(JSON.stringify(value))}'`;
+    }
+    /**
+     * Build a JSON extraction query for SQLite
+     * SQLite: json_extract(column, '$.path')
+     */
+    buildJsonExtract(column, path, asText = true) {
+        const columnRef = this.escapeId(column);
+        const normalizedPath = this.escapeString(path.startsWith('$.') ? path : `$.${path}`);
+        // SQLite's json_extract returns JSON by default. When comparing to text values,
+        // we need to CAST to TEXT to ensure proper comparison (equivalent to PostgreSQL's ->> operator)
+        if (asText) {
+            return `CAST(json_extract(${columnRef}, '${normalizedPath}') AS TEXT)`;
+        }
+        return `json_extract(${columnRef}, '${normalizedPath}')`;
+    }
+    /**
+     * Build a JSON contains query for SQLite
+     * SQLite: uses json_each and json_extract for containment checks
+     */
+    buildJsonContains(column, value, path) {
+        const columnRef = this.escapeId(column);
+        // json_extract() returns scalars (string/number/boolean) unwrapped, but returns
+        // objects/arrays as compact JSON text. JSON.stringify()-ing a scalar (e.g. the
+        // string "foo" -> '"foo"') would never match the unwrapped value SQLite returns,
+        // so only stringify non-scalar values here.
+        const isScalar = value === null || (typeof value !== 'object' && typeof value !== 'function');
+        const comparisonValue = isScalar ? value : JSON.stringify(value);
+        if (path) {
+            const normalizedPath = path.startsWith('$.') ? path : `$.${path}`;
+            // SQLite: check if the path contains the value
+            return {
+                sql: `json_extract(${columnRef}, '${this.escapeString(normalizedPath)}') = ?`,
+                values: [comparisonValue],
+            };
+        }
+        // For JSON objects, compare as stringified JSON
+        return {
+            sql: `${columnRef} = ?`,
+            values: [JSON.stringify(value)],
+        };
+    }
+    /**
+     * Build a JSON has key query for SQLite
+     * SQLite: json_each or json_extract for key existence
+     */
+    buildJsonHasKey(column, key, type = 'one') {
+        const columnRef = this.escapeId(column);
+        const normalizedKey = this.escapeString(key.startsWith('$.') ? key.substring(2) : key);
+        // SQLite: check if key exists by checking if json_extract returns non-null
+        return `json_extract(${columnRef}, '$.${normalizedKey}') IS NOT NULL`;
+    }
+    /**
+     * Build a JSON path query for SQLite
+     */
+    buildJsonPathQuery(column, path, value, operator = '=') {
+        const values = [];
+        const columnRef = this.escapeId(column);
+        const normalizedPath = this.escapeString(path.startsWith('$.') ? path : `$.${path}`);
+        const jsonExtract = `json_extract(${columnRef}, '${normalizedPath}')`;
+        if (value !== undefined) {
+            values.push(value);
+            return { sql: `${jsonExtract} ${operator} ?`, values };
+        }
+        return { sql: jsonExtract, values };
+    }
+    /**
+     * Build a `json_group_array()` aggregate expression for SQLite.
+     *
+     * `json_group_array()` is SQLite's JSON1 aggregate for collecting the
+     * values of `valueExpr` (evaluated once per row in the current group) into
+     * a single JSON array. Commonly used for "hasMany as nested JSON" style
+     * queries, e.g. rolling up child rows into a JSON array column of a
+     * grouped parent query.
+     *
+     * @param valueExpr - a column name or SQL expression to collect per row.
+     *   Bare identifiers are escaped as columns; anything containing SQL
+     *   syntax (parens, function calls, `.`) is passed through as-is so
+     *   callers can pass expressions like `json_object('id', id)`.
+     * @param options.distinct - emit `json_group_array(DISTINCT ...)`
+     */
+    buildJsonGroupArray(valueExpr, options) {
+        const expr = this.escapeAggregateExpr(valueExpr);
+        const distinct = options?.distinct ? 'DISTINCT ' : '';
+        return `json_group_array(${distinct}${expr})`;
+    }
+    /**
+     * Build a `json_group_object()` aggregate expression for SQLite.
+     *
+     * `json_group_object()` collects `(keyExpr, valueExpr)` pairs from the
+     * rows of the current group into a single JSON object, keyed by
+     * `keyExpr`. Useful for building a JSON map of `{ [key]: value }` from
+     * grouped rows (e.g. nested-relation queries keyed by id).
+     */
+    buildJsonGroupObject(keyExpr, valueExpr) {
+        const key = this.escapeAggregateExpr(keyExpr);
+        const value = this.escapeAggregateExpr(valueExpr);
+        return `json_group_object(${key}, ${value})`;
+    }
+    /**
+     * Escape a column/expression argument passed to an aggregate builder.
+     * Bare identifiers (letters, digits, underscore, dot for table.column)
+     * are quoted as an identifier; anything else (function calls, literals,
+     * `*`, etc.) is passed through untouched so callers can supply arbitrary
+     * SQL expressions.
+     */
+    escapeAggregateExpr(expr) {
+        if (/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/.test(expr)) {
+            return expr
+                .split('.')
+                .map((part) => this.escapeId(part))
+                .join('.');
+        }
+        return expr;
+    }
+    /**
+     * Build a `json_patch()` expression for SQLite (RFC 7396 JSON Merge Patch).
+     *
+     * `json_patch(target, patch)` applies an RFC 7396 merge patch to the JSON
+     * stored in `column`, returning the patched JSON document. Unlike
+     * `json_set()` (which sets a single path) this can add, replace, and
+     * remove multiple keys in one call - keys in `patch` set to `null` are
+     * removed from the result.
+     *
+     * @param column - the JSON column to patch
+     * @param patch - a JS object/value to be JSON-stringified and applied as
+     *   the merge patch; passed as a bound parameter, not interpolated.
+     */
+    buildJsonPatch(column, patch) {
+        const columnRef = this.escapeId(column);
+        return {
+            sql: `json_patch(${columnRef}, json(?))`,
+            values: [JSON.stringify(patch)],
+        };
+    }
+    /**
+     * Escape a string for SQL
+     */
+    escapeString(str) {
+        return str.replace(/'/g, "''");
+    }
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+    /**
+     * Quote an identifier (column name, table name)
+     * Same as escapeId for SQLite
+     */
+    quoteIdentifier(identifier) {
+        return this.escapeId(identifier);
+    }
+    /**
+     * Quote a table name
+     * Same as escapeId for SQLite
+     * If schema is provided, returns schema.tableName (SQLite treats schemas as prefixes)
+     */
+    quoteTable(tableName, schema) {
+        if (schema) {
+            return `${this.escapeId(schema)}.${this.escapeId(tableName)}`;
+        }
+        return this.escapeId(tableName);
+    }
+    /**
+     * Get the database version
+     */
+    async getDatabaseVersion() {
+        if (!this.connection) {
+            throw new Error('Not connected to database');
+        }
+        const result = this.connection.pragma('user_version', { simple: true });
+        return String(result);
+    }
+    /**
+     * Generate SQL for creating a database
+     * SQLite uses ATTACH DATABASE for creating new database files
+     */
+    createDatabaseSQL(options) {
+        const sql = `CREATE DATABASE "${options.name}"`;
+        const optionsList = [];
+        if (options.encoding)
+            optionsList.push(`ENCODING = '${options.encoding}'`);
+        if (options.lcCollate)
+            optionsList.push(`LC_COLLATE = '${options.lcCollate}'`);
+        if (options.lcCtype)
+            optionsList.push(`LC_CTYPE = '${options.lcCtype}'`);
+        if (options.collate)
+            optionsList.push(`COLLATE = '${options.collate}'`);
+        if (optionsList.length > 0) {
+            return sql + ' ' + optionsList.join(' ');
+        }
+        return sql;
+    }
+    /**
+     * Generate SQL for dropping a database
+     * SQLite uses DETACH DATABASE for dropping database files
+     */
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE "${name}"`;
+    }
+    /**
+     * Attach an external SQLite database file to the current connection under
+     * `alias`, making its tables reachable as `alias.tableName` in subsequent
+     * queries (cross-database queries/joins). Executes a real
+     * `ATTACH DATABASE ? AS <alias>` statement rather than just documenting the
+     * capability.
+     *
+     * @param path - filesystem path to the database file to attach (or
+     *   `:memory:` for an attached in-memory database)
+     * @param alias - schema name subsequent SQL will use to refer to the
+     *   attached database (e.g. `alias.users`)
+     */
+    async attachDatabase(path, alias) {
+        if (!this.connection) {
+            throw new Error('Not connected to database');
+        }
+        if (!alias || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(alias)) {
+            throw new Error(`Invalid database alias: ${alias}`);
+        }
+        const aliasId = this.escapeId(alias);
+        this.connection.prepare(`ATTACH DATABASE ? AS ${aliasId}`).run(path);
+    }
+    /**
+     * Detach a previously-attached database from the current connection.
+     * Executes a real `DETACH DATABASE <alias>` statement.
+     *
+     * @param alias - the schema name the database was attached under via
+     *   `attachDatabase()`
+     */
+    async detachDatabase(alias) {
+        if (!this.connection) {
+            throw new Error('Not connected to database');
+        }
+        if (!alias || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(alias)) {
+            throw new Error(`Invalid database alias: ${alias}`);
+        }
+        const aliasId = this.escapeId(alias);
+        this.connection.exec(`DETACH DATABASE ${aliasId}`);
+    }
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name) {
+        const savepointName = name || `sp_${Date.now()}`;
+        return `SAVEPOINT ${savepointName}`;
+    }
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name) {
+        return `RELEASE SAVEPOINT ${name}`;
+    }
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name) {
+        return `ROLLBACK TO SAVEPOINT ${name}`;
+    }
+    /**
+     * Create a new table
+     */
+    async createTable(tableName, columns, options) {
+        const columnDefs = [];
+        for (const [columnName, definition] of Object.entries(columns)) {
+            // Skip virtual fields - they don't create database columns
+            const typeObj = definition.type;
+            if (typeObj && typeObj.key === 'VIRTUAL') {
+                continue;
+            }
+            columnDefs.push(this.getColumnDefinitionSql(columnName, definition));
+        }
+        // Add constraints from options
+        if (options?.constraints) {
+            for (const constraint of options.constraints) {
+                const constraintSql = this.buildConstraintSql(constraint);
+                if (constraintSql) {
+                    columnDefs.push(constraintSql);
+                }
+            }
+        }
+        let sql = `CREATE TABLE`;
+        if (options?.ifNotExists) {
+            sql += ' IF NOT EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)} (${columnDefs.join(', ')})`;
+        // SQLite 3.37+ STRICT tables and WITHOUT ROWID tables are both table-level
+        // modifiers that go after the closing paren of the column-def list, and
+        // can be combined as `) STRICT, WITHOUT ROWID`.
+        const tableModifiers = [];
+        if (options?.strict) {
+            tableModifiers.push('STRICT');
+        }
+        if (options?.withoutRowid) {
+            tableModifiers.push('WITHOUT ROWID');
+        }
+        if (tableModifiers.length > 0) {
+            sql += ` ${tableModifiers.join(', ')}`;
+        }
+        // SQLite does not support ENGINE, CHARSET, COLLATE in CREATE TABLE
+        // These options are ignored for SQLite but can be logged for debugging
+        if (options?.engine) {
+            console.warn(`SQLite: engine option '${options.engine}' is not supported and will be ignored`);
+        }
+        if (options?.charset) {
+            console.warn(`SQLite: charset option '${options.charset}' is not supported and will be ignored`);
+        }
+        if (options?.collate) {
+            // SQLite supports COLLATE in column definitions, not table-level
+            // Add COLLATE to text columns instead
+            console.warn(`SQLite: table-level collate option is not supported, apply collate to text columns instead`);
+        }
+        if (options?.rowFormat) {
+            console.warn(`SQLite: rowFormat option '${options.rowFormat}' is not supported and will be ignored`);
+        }
+        // Handle uniqueKeys for SQLite by creating unique indexes after table creation
+        let uniqueKeysToCreate = [];
+        if (options?.uniqueKeys) {
+            if (Array.isArray(options.uniqueKeys)) {
+                // New format: UniqueKeyOptions[]
+                uniqueKeysToCreate = options.uniqueKeys.map((uk) => ({
+                    name: uk.name || `${tableName}_${uk.fields.join('_')}_key`,
+                    fields: uk.fields,
+                }));
+            }
+            else {
+                // Legacy format: Record<string, string[]>
+                uniqueKeysToCreate = Object.entries(options.uniqueKeys).map(([keyName, fields]) => ({
+                    name: keyName || `uq_${tableName}_${fields.join('_')}`,
+                    fields,
+                }));
+            }
+        }
+        if (options?.initialAutoIncrement) {
+            console.warn(`SQLite: initialAutoIncrement option '${options.initialAutoIncrement}' is not supported and will be ignored`);
+        }
+        // Handle comment - SQLite doesn't support table comments natively
+        // Store in sqlite_master as a comment (extended feature)
+        let tableComment;
+        if (options?.comment) {
+            tableComment = options.comment;
+        }
+        await this.query(sql);
+        // Store table comment as extended property if provided
+        // SQLite has no native mechanism to attach a comment to a table, so this
+        // is a documented no-op kept for interface compatibility with other dialects.
+        if (tableComment) {
+            try {
+                // no-op: SQLite does not support table comments
+            }
+            catch (e) {
+                // Ignore if extended comments aren't supported
+            }
+        }
+        // SQLite doesn't support initialAutoIncrement in CREATE TABLE
+        // It's controlled by AUTOINCREMENT keyword on column definitions
+        if (options?.initialAutoIncrement) {
+            console.warn(`SQLite: initialAutoIncrement option is not supported in CREATE TABLE`);
+        }
+        // Create indexes after table creation
+        if (options?.indexes) {
+            for (const index of options.indexes) {
+                await this.addIndex(tableName, index.name || `idx_${tableName}_${index.fields.join('_')}`, index.fields, {
+                    unique: index.unique,
+                    type: index.type,
+                    using: index.using,
+                    where: index.where,
+                    expression: index.expression,
+                });
+            }
+        }
+    }
+    /**
+     * Build constraint SQL for table creation
+     */
+    buildConstraintSql(constraint) {
+        const name = constraint.name ? `CONSTRAINT "${constraint.name}" ` : '';
+        const fields = constraint.fields?.map((f) => this.escapeId(f)).join(', ') || '';
+        switch (constraint.type) {
+            case 'PRIMARY KEY':
+                return `${name}PRIMARY KEY (${fields})`;
+            case 'UNIQUE':
+                return `${name}UNIQUE (${fields})`;
+            case 'FOREIGN KEY':
+                if (!constraint.references)
+                    return null;
+                let fkSql = `${name}FOREIGN KEY (${fields}) `;
+                // Handle composite foreign keys (string | string[])
+                const refField = constraint.references.field;
+                const refFieldSql = Array.isArray(refField)
+                    ? `(${refField.map((f) => this.escapeId(f)).join(', ')})`
+                    : this.escapeId(refField);
+                fkSql += `REFERENCES ${this.escapeId(constraint.references.table)}${refFieldSql}`;
+                if (constraint.references.onDelete) {
+                    fkSql += ` ON DELETE ${constraint.references.onDelete}`;
+                }
+                if (constraint.references.onUpdate) {
+                    fkSql += ` ON UPDATE ${constraint.references.onUpdate}`;
+                }
+                return fkSql;
+            case 'CHECK':
+                if (!constraint.check)
+                    return null;
+                return `${name}CHECK (${constraint.check})`;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Generate column definition SQL
+     */
+    getColumnDefinitionSql(columnName, definition) {
+        let sql = `${this.escapeId(columnName)} ${this.getDataTypeSql(definition.type, columnName)}`;
+        if (definition.allowNull === false) {
+            sql += ' NOT NULL';
+        }
+        if (definition.defaultValue !== undefined) {
+            sql += ` DEFAULT ${this.getDefaultValue(definition.defaultValue)}`;
+        }
+        if (definition.primaryKey) {
+            sql += ' PRIMARY KEY';
+            // SQLite AUTOINCREMENT is only valid on INTEGER PRIMARY KEY columns
+            if (definition.autoIncrement) {
+                const resolvedType = this.getDataTypeSql(definition.type).toUpperCase();
+                if (resolvedType === 'INTEGER') {
+                    sql += ' AUTOINCREMENT';
+                }
+            }
+        }
+        if (definition.unique) {
+            sql += ' UNIQUE';
+        }
+        if (definition.references) {
+            // Handle composite foreign keys (string | string[])
+            const refField5 = definition.references.field;
+            const refFieldSql5 = Array.isArray(refField5)
+                ? `(${refField5.map((f) => this.escapeId(f)).join(', ')})`
+                : `(${this.escapeId(refField5)})`;
+            sql += ` REFERENCES ${this.escapeId(definition.references.table)}${refFieldSql5}`;
+            if (definition.references.onDelete) {
+                sql += ` ON DELETE ${definition.references.onDelete}`;
+            }
+            if (definition.references.onUpdate) {
+                sql += ` ON UPDATE ${definition.references.onUpdate}`;
+            }
+        }
+        // SQLite does not support column-level comments in CREATE TABLE
+        // Comments are stored separately and not part of the column definition
+        return sql;
+    }
+    /**
+     * Get default value SQL
+     */
+    getDefaultValue(value) {
+        // Handle Literal (raw SQL) values - insert directly without escaping
+        if (value instanceof prorm_1.Literal) {
+            return value.val;
+        }
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${this.escapeString(value)}'`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        // For functions like CURRENT_TIMESTAMP
+        if (typeof value === 'string' && value.toUpperCase().includes('CURRENT_')) {
+            return value;
+        }
+        // Handle DataType instances with toDefaultValue method (e.g., DataTypes.NOW)
+        if (typeof value === 'object' &&
+            value !== null &&
+            typeof value.toDefaultValue === 'function') {
+            return value.toDefaultValue();
+        }
+        return `'${this.escapeString(String(value))}'`;
+    }
+    /**
+     * Drop a table
+     */
+    async dropTable(tableName, options) {
+        let sql = 'DROP TABLE';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)}`;
+        // SQLite has no `DROP TABLE ... CASCADE` syntax - appending it produces a
+        // syntax error, which made every `cascade: true` drop fail (silently
+        // swallowed by callers like `Prorm.syncForce()`, which only logs a
+        // warning and moves on). That meant `sync({ force: true })` never
+        // actually dropped/recreated tables that already existed, since
+        // `CREATE TABLE IF NOT EXISTS` is then a no-op against the stale table.
+        // SQLite doesn't need an explicit CASCADE: dropping a table just removes
+        // its schema entry - it doesn't cascade-delete rows in other tables the
+        // way `ON DELETE CASCADE` does, so `cascade` is a no-op here rather than
+        // an error.
+        await this.query(sql);
+    }
+    /**
+     * Create a partitioned table (SQLite emulation)
+     * Creates base table + child partition tables + union view
+     */
+    async createPartitionedTable(tableName, columns, options) {
+        const partitionConfig = options?.partitionBy;
+        // Handle partitions being a number (e.g., partitions: 2 for KEY partitioning)
+        // or undefined, or an array
+        const partitions = Array.isArray(options?.partitions)
+            ? options.partitions
+            : typeof options?.partitions === 'number'
+                ? []
+                : [];
+        // Create the base table (used as template)
+        await this.createTable(tableName, columns, {
+            ...options,
+            ifNotExists: options?.ifNotExists ?? true,
+        });
+        // Store partition metadata
+        const metadataTable = `${tableName}_partitions`;
+        await this.query(`CREATE TABLE IF NOT EXISTS ${this.escapeId(metadataTable)} (
+        partition_name TEXT PRIMARY KEY,
+        parent_table TEXT NOT NULL,
+        bound TEXT,
+        is_detached INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      )`);
+        // Create partitions if specified
+        for (const partition of partitions) {
+            await this.createPartition({
+                parentTable: tableName,
+                name: partition.name,
+                bound: partition.bound,
+                tablespace: partition.tablespace,
+                storageParameters: partition.storageParameters,
+            });
+        }
+        // Create a UNION ALL view to provide a unified interface
+        if (partitions.length > 0) {
+            const partitionSelects = partitions.map((p) => `SELECT * FROM ${this.escapeId(p.name)}`).join('\n  UNION ALL\n  ');
+            const viewName = `${tableName}_union`;
+            await this.createView(viewName, partitionSelects, { replace: true });
+        }
+    }
+    /**
+     * Create a partition for an existing partitioned table (SQLite emulation)
+     */
+    async createPartition(options) {
+        const { parentTable, name, bound } = options;
+        // Get the column structure from the parent table
+        const parentColumns = await this.describeTable(parentTable);
+        // Create the partition table with the same structure
+        const partitionColumns = {};
+        for (const [colName, colDef] of Object.entries(parentColumns)) {
+            partitionColumns[colName] = {
+                type: colDef.type,
+                allowNull: colDef.allowNull,
+                defaultValue: colDef.defaultValue,
+                autoIncrement: colDef.autoIncrement,
+            };
+        }
+        // Create the partition table
+        await this.createTable(name, partitionColumns, { ifNotExists: true });
+        // Insert partition metadata
+        const metadataTable = `${parentTable}_partitions`;
+        const boundStr = bound ? JSON.stringify(bound) : 'NULL';
+        await this.query(`INSERT OR IGNORE INTO ${this.escapeId(metadataTable)} (partition_name, parent_table, bound) VALUES (${this.escape(name)}, ${this.escape(parentTable)}, ${boundStr})`);
+    }
+    /**
+     * Attach a partition to a partitioned table (SQLite emulation)
+     */
+    async attachPartition(options) {
+        const { parentTable, partitionName } = options;
+        // Verify the partition table exists
+        const tables = await this.showTables();
+        if (!tables.includes(partitionName)) {
+            throw new Error(`Partition table '${partitionName}' does not exist`);
+        }
+        // Update partition metadata to mark as attached
+        const metadataTable = `${parentTable}_partitions`;
+        await this.query(`INSERT OR REPLACE INTO ${this.escapeId(metadataTable)} (partition_name, parent_table, is_detached) VALUES (${this.escape(partitionName)}, ${this.escape(parentTable)}, 0)`);
+    }
+    /**
+     * Detach a partition from a partitioned table (SQLite emulation)
+     * Marks the partition as detached but keeps the table
+     */
+    async detachPartition(options) {
+        const { partitionName } = options;
+        // Find the parent table from metadata
+        const partitions = await this.listPartitions(partitionName);
+        if (partitions.length === 0) {
+            throw new Error(`Partition '${partitionName}' not found`);
+        }
+        const partitionInfo = partitions[0];
+        const metadataTable = `${partitionInfo.parent_table}_partitions`;
+        // Mark partition as detached
+        await this.query(`UPDATE ${this.escapeId(metadataTable)} SET is_detached = 1 WHERE partition_name = ${this.escape(partitionName)}`);
+    }
+    /**
+     * Drop a partition (SQLite emulation)
+     */
+    async dropPartition(partitionName, options) {
+        const ifExists = options?.ifExists ?? false;
+        const cascade = options?.cascade ?? false;
+        // Find the parent table from metadata
+        const partitions = await this.listPartitions(partitionName);
+        let parentTable = null;
+        if (partitions.length > 0) {
+            parentTable = partitions[0].parent_table;
+        }
+        // Drop the partition table
+        let sql = 'DROP TABLE';
+        if (ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(partitionName)}`;
+        if (cascade) {
+            sql += ' CASCADE';
+        }
+        await this.query(sql);
+        // Remove partition metadata if parent table exists
+        if (parentTable) {
+            const metadataTable = `${parentTable}_partitions`;
+            try {
+                await this.query(`DELETE FROM ${this.escapeId(metadataTable)} WHERE partition_name = ${this.escape(partitionName)}`);
+            }
+            catch {
+                // Ignore if metadata table doesn't exist
+            }
+        }
+    }
+    /**
+     * Add a partition to an existing partitioned table (SQLite emulation)
+     * @param tableName - Name of the partitioned table
+     * @param partitionName - Name for the new partition
+     * @param partitionSpec - Partition specification
+     */
+    async addPartition(tableName, partitionName, partitionSpec) {
+        // SQLite does not support table partitioning
+        throw new Error(`Table partitioning is not supported by SQLite. ` +
+            `Please use PostgreSQL, MySQL, or another database that supports partitioning.`);
+    }
+    /**
+     * List partitions for a table (SQLite emulation)
+     */
+    async listPartitions(tableName) {
+        const metadataTable = `${tableName}_partitions`;
+        try {
+            const result = await this.query(`SELECT * FROM ${this.escapeId(metadataTable)}`);
+            return result.rows.map((row) => ({
+                name: row.partition_name,
+                parent_table: row.parent_table,
+                bound: row.bound,
+                is_detached: row.is_detached,
+            }));
+        }
+        catch {
+            // If metadata table doesn't exist, return empty array
+            return [];
+        }
+    }
+    /**
+     * Check if a table has partitions (SQLite emulation)
+     */
+    async hasPartition(tableName) {
+        const partitions = await this.listPartitions(tableName);
+        return partitions.length > 0;
+    }
+    // ==================== User Management Stubs ====================
+    /**
+     * Create a user (stub - not supported by SQLite)
+     */
+    async createUser(_username, _options) {
+        throw new Error('User management is not supported by SQLite');
+    }
+    /**
+     * Drop a user (stub - not supported by SQLite)
+     */
+    async dropUser(_username, _options) {
+        throw new Error('User management is not supported by SQLite');
+    }
+    /**
+     * List users (stub - not supported by SQLite)
+     */
+    async listUsers() {
+        throw new Error('User management is not supported by SQLite');
+    }
+    /**
+     * Create a role (stub - not supported by SQLite)
+     */
+    async createRole(_roleName, _options) {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    /**
+     * Drop a role (stub - not supported by SQLite)
+     */
+    async dropRole(_roleName, _options) {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    /**
+     * List roles (stub - not supported by SQLite)
+     */
+    async listRoles() {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    /**
+     * Grant privileges (stub - not supported by SQLite)
+     */
+    async grant(_privilege, _on, _to) {
+        throw new Error('User management is not supported by SQLite');
+    }
+    /**
+     * Revoke privileges (stub - not supported by SQLite)
+     */
+    async revoke(_privilege, _on, _from) {
+        throw new Error('User management is not supported by SQLite');
+    }
+    /**
+     * Add a column to a table
+     */
+    async addColumn(tableName, columnName, definition) {
+        const sql = `ALTER TABLE ${this.escapeId(tableName)} ADD COLUMN ${this.getColumnDefinitionSql(columnName, definition)}`;
+        await this.query(sql);
+    }
+    /**
+     * Remove a column from a table
+     */
+    async removeColumn(tableName, columnName) {
+        // SQLite doesn't support DROP COLUMN directly, need to recreate table
+        await this.recreateTableWithoutColumn(tableName, columnName);
+    }
+    /**
+     * Change a column definition
+     */
+    async changeColumn(tableName, columnName, definition) {
+        // SQLite doesn't support ALTER COLUMN, need to recreate table
+        await this.recreateTableModifyColumn(tableName, columnName, definition);
+    }
+    /**
+     * Show all tables in the database
+     */
+    async showTables() {
+        const sql = "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'";
+        const result = await this.query(sql);
+        return result.rows.map((row) => row.name);
+    }
+    /**
+     * Get table status (SQLite implementation)
+     */
+    async getTableStatus(tableName) {
+        const sql = tableName
+            ? "SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?"
+            : "SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'";
+        const result = tableName
+            ? await this.query(sql, { replacements: [tableName] })
+            : await this.query(sql);
+        return result.rows;
+    }
+    /**
+     * Get table create statement (SQLite implementation)
+     */
+    async getCreateTable(tableName) {
+        const sql = "SELECT sql FROM sqlite_master WHERE type='table' AND name = ?";
+        const result = await this.query(sql, { replacements: [tableName] });
+        return result.rows[0]?.sql || '';
+    }
+    /**
+     * Get MariaDB-specific version info (not supported in SQLite)
+     * This method exists for compatibility when tests fall back to SQLite
+     */
+    async getMariaDBVersionInfo() {
+        throw new Error('getMariaDBVersionInfo is not supported in SQLite. Use MariaDB dialect for this feature.');
+    }
+    /**
+     * Show constraints for a table (SQLite)
+     */
+    async showConstraints(tableName) {
+        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => ({
+            name: row.name,
+            type: row.type,
+            notnull: row.notnull === 1,
+            dflt_value: row.dflt_value,
+            pk: row.pk === 1,
+        }));
+    }
+    /**
+     * Show indexes for a table
+     */
+    async showIndexes(tableName) {
+        const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => ({
+            name: row.name,
+            unique: row.unique === 1,
+            origin: row.origin,
+        }));
+    }
+    /**
+     * Create a schema
+     * SQLite doesn't have native schema support, but we can use ATTACH DATABASE
+     * For now, this is a no-op for compatibility with other dialects
+     * @param schema - The schema name to create
+     */
+    async createSchema(_schema) {
+        // SQLite doesn't have native schema support
+        // Schemas are typically simulated using database files or naming conventions
+        // For compatibility, this is a no-op - there is no SQL statement to execute
+        return;
+    }
+    /**
+     * Drop a schema
+     * SQLite doesn't have native schema support
+     * For now, this is a no-op for compatibility with other dialects
+     * @param schema - The schema name to drop
+     * @param options - Drop options
+     */
+    async dropSchema(_schema, _options) {
+        // SQLite doesn't have native schema support
+        // For compatibility, this is a no-op - there is no SQL statement to execute
+        return;
+    }
+    /**
+     * Show all schemas in the database
+     * SQLite doesn't have native schema support, returns default schema
+     */
+    async showAllSchemas() {
+        // SQLite only has the main schema
+        return ['main'];
+    }
+    /**
+     * List all schemas (SQLite only has main)
+     */
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    /**
+     * VACUUM the database - reclaims disk space and defragments
+     * @param options - VACUUM options
+     */
+    async vacuum(options) {
+        return this.advanced.vacuum(options);
+    }
+    /**
+     * ANALYZE the database - updates statistics for query optimizer
+     * @param target - Optional table or index name
+     */
+    async analyze(target) {
+        return this.advanced.analyze(target);
+    }
+    /**
+     * Get database information using PRAGMA
+     */
+    async getDatabaseInfo() {
+        return this.advanced.getDatabaseInfo();
+    }
+    /**
+     * Create an FTS5 virtual table for full-text search
+     */
+    async createFTS5Table(tableName, columns, options) {
+        return this.advanced.createFTS5Table(tableName, columns, options);
+    }
+    /**
+     * Perform full-text search
+     */
+    async fullTextSearch(ftsTable, searchQuery, options) {
+        return this.advanced.fullTextSearch(ftsTable, searchQuery, options);
+    }
+    // ==================== Stored Procedures ====================
+    // SQLite does not support stored procedures natively
+    // These methods provide helpful messages explaining limitations and workarounds
+    /**
+     * Create a stored procedure (SQLite - Not Supported)
+     *
+     * SQLite does not support stored procedures natively. However, you can achieve
+     * similar functionality using:
+     *
+     * 1. Application-level code: Move business logic into your application code
+     * 2. Views: For read-only operations
+     * 3. Triggers: For automated responses to data changes
+     * 4. FTS5 virtual tables: For full-text search operations
+     * 5. SQLite ATTACH: Connect to another database that supports stored procedures
+     *
+     * Example workaround using application code:
+     * ```typescript
+     * // Instead of:
+     * await db.executeStoredProcedure({ procedureName: 'calculateTotal', params: { orderId: 1 } });
+     *
+     * // Use application-level code:
+     * const total = await calculateTotal(orderId);
+     * ```
+     */
+    async createStoredProcedure(options) {
+        const procName = options.name;
+        throw new Error(`SQLite does not support stored procedures. Cannot create '${procName}'.\n\n` +
+            `Workarounds:\n` +
+            `- Move logic to application code\n` +
+            `- Use views for read-only operations\n` +
+            `- Use triggers for automated data changes\n` +
+            `- Use FTS5 for full-text search\n` +
+            `- Use ATTACH DATABASE to connect to PostgreSQL/MySQL for stored procedures\n\n` +
+            `Example: If using this in an app, create a TypeScript function that executes ` +
+            `the same SQL logic and call that instead.`);
+    }
+    /**
+     * Drop a stored procedure (SQLite - Not Supported)
+     *
+     * Since SQLite does not support stored procedures, there is nothing to drop.
+     * If you previously created a stored procedure in an attached database,
+     * drop it from that database instead.
+     */
+    async dropStoredProcedure(procedureName, _options) {
+        throw new Error(`SQLite does not support stored procedures. Cannot drop '${procedureName}'.\n\n` +
+            `If you created this procedure in an attached database using ATTACH, ` +
+            `drop it from that database instead:\n` +
+            `  await db.query("DETACH DATABASE alias");\n` +
+            `Then recreate the procedure in the target database.`);
+    }
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     * SQLite does not support stored procedures - use application code instead.
+     */
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    /**
+     * Execute a stored procedure (SQLite - Not Supported)
+     *
+     * SQLite does not support stored procedures. To execute the equivalent logic,
+     * move the procedure's SQL statements into your application code.
+     *
+     * Example:
+     * ```typescript
+     * // Instead of:
+     * const result = await db.executeStoredProcedure({
+     *   procedureName: 'getUserOrders',
+     *   params: { userId: 123 }
+     * });
+     *
+     * // Use a query directly:
+     * const result = await db.query(
+     *   'SELECT * FROM orders WHERE user_id = ?',
+     *   [123]
+     * );
+     * ```
+     */
+    async executeStoredProcedure(options) {
+        const procName = options.procedureName;
+        throw new Error(`SQLite does not support stored procedures. Cannot execute '${procName}'.\n\n` +
+            `Workaround: Execute the SQL logic directly in your application:\n` +
+            `  const result = await db.query('YOUR_SQL_HERE', [params]);\n\n` +
+            `If you need to reuse this logic, create a TypeScript/JavaScript function ` +
+            `that wraps the SQL query.`);
+    }
+    /**
+     * Check if a stored procedure exists (SQLite - Always Returns False)
+     *
+     * Since SQLite does not support stored procedures, this always returns false.
+     * If you are checking for a procedure in an attached database, use that
+     * database's native method instead.
+     */
+    async hasStoredProcedure(_procedureName, _schema) {
+        // SQLite does not support stored procedures, so none can exist
+        return false;
+    }
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     * SQLite does not support stored procedures - use application code instead.
+     */
+    async createProcedure(options) {
+        return this.createStoredProcedure(options);
+    }
+    /**
+     * Create a foreign data wrapper (SQLite - not supported)
+     * @param fdwName - Foreign data wrapper name
+     * @param options - Options including handler function
+     */
+    async createForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignDataWrapper(_fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignServer(_serverName, _fdwName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    async dropForeignServer(_serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    async createForeignTable(_tableName, _columns, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    async changeOwner(_newOwner, _tableName) {
+        throw new Error('changeOwner is not supported in SQLite');
+    }
+    async addConstraint(_tableName, _options) {
+        // SQLite cannot ALTER TABLE ADD CONSTRAINT, but a UNIQUE constraint is
+        // equivalent to a UNIQUE INDEX, which we can create on an existing table.
+        const type = String(_options.type || '').toUpperCase();
+        const name = _options.name ||
+            `${_tableName}_${(_options.fields || []).join('_')}_${type.toLowerCase().replace(/\s+/g, '_')}`;
+        if (type === 'UNIQUE') {
+            await this.addIndex(_tableName, name, _options.fields, { unique: true });
+            return;
+        }
+        throw new Error(`addConstraint type "${type}" cannot be added to an existing SQLite table; ` +
+            `define it when the table is created (SQLite only supports UNIQUE via a unique index post-hoc).`);
+    }
+    async removeConstraint(_tableName, _constraintName) {
+        // The only post-hoc constraint we create is a unique index; drop it if present.
+        await this.query(`DROP INDEX IF EXISTS ${this.escapeId(_constraintName)}`);
+    }
+    async createSecurityPolicy(_policyName, _tableName, _options) {
+        throw new Error('Security policies are not supported in SQLite');
+    }
+    async dropSecurityPolicy(_policyName, _tableName) {
+        throw new Error('Security policies are not supported in SQLite');
+    }
+    // ==================== Triggers ====================
+    /**
+     * Create a trigger
+     */
+    async createTrigger(triggerName, timing, events, tableName, body, options) {
+        return this.advanced.createTrigger(triggerName, timing, events, tableName, body, options);
+    }
+    /**
+     * Drop a trigger
+     */
+    async dropTrigger(triggerName, options) {
+        return this.advanced.dropTrigger(triggerName, options);
+    }
+    async hasTrigger(_triggerName, _tableName) {
+        // Check if trigger exists
+        const sql = `SELECT name FROM sqlite_master WHERE type='trigger' AND name=?`;
+        const result = await this.query(sql, { plain: true });
+        return !!result;
+    }
+    // ==================== Sequences ====================
+    // SQLite does not have native sequences, but they can be simulated
+    // using INTEGER PRIMARY KEY AUTOINCREMENT tables
+    /**
+     * Create a sequence (simulated using AUTOINCREMENT table)
+     */
+    async createSequence(options) {
+        const seqName = options.name;
+        const schema = options.schema;
+        // Use a special prefix to distinguish sequence tables
+        const tableName = this.quoteTable(this._getSequenceTableName(seqName, schema));
+        // Check if sequence already exists
+        if (options.ifNotExists) {
+            const exists = await this.hasSequence(seqName, schema);
+            if (exists) {
+                return;
+            }
+        }
+        // Build the CREATE TABLE statement
+        let sql = `CREATE TABLE ${tableName} (value INTEGER PRIMARY KEY AUTOINCREMENT)`;
+        // Handle startWith - SQLite AUTOINCREMENT starts at 1 by default
+        // To set a different starting value, we need to insert a row first
+        if (options.startWith !== undefined && options.startWith > 1) {
+            // Create the table first
+            await this.query(sql);
+            // Insert a row with value = startWith - 1 so next value will be startWith
+            const insertSql = `INSERT INTO ${tableName} (value) VALUES (?)`;
+            await this.query(insertSql, { bind: [options.startWith - 1] });
+            // Delete that row so the sequence starts at the correct value
+            const deleteSql = `DELETE FROM ${tableName}`;
+            await this.query(deleteSql);
+        }
+        else {
+            await this.query(sql);
+        }
+    }
+    /**
+     * Drop a sequence (simulated by dropping the sequence table)
+     */
+    async dropSequence(sequenceName, options) {
+        const schema = options?.schema;
+        const tableName = this._getSequenceTableName(sequenceName, schema);
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const sql = `DROP TABLE ${ifExists}${this.quoteTable(tableName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Get next value from a sequence
+     * (simulated by inserting and getting last_insert_rowid)
+     */
+    async nextSequenceValue(sequenceName, schema) {
+        const tableName = this._getSequenceTableName(sequenceName, schema);
+        const sql = `INSERT INTO ${this.quoteTable(tableName)} (value) VALUES (NULL)`;
+        await this.query(sql);
+        // Get the last inserted rowid (the auto-generated value)
+        const result = await this.query('SELECT last_insert_rowid() as value', { raw: true });
+        return result.rows?.[0]?.value;
+    }
+    /**
+     * Check if a sequence exists
+     * (simulated by checking if the sequence table exists)
+     */
+    async hasSequence(sequenceName, schema) {
+        const tableName = this._getSequenceTableName(sequenceName, schema);
+        const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name=?`;
+        const result = await this.query(sql, { bind: [tableName], plain: true });
+        return !!result;
+    }
+    /**
+     * List all sequences in the database (SQLite - simulated via tables)
+     * @returns Array of sequence names
+     */
+    async listSequences() {
+        const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name LIKE '_sequence_%'`;
+        const result = await this.query(sql);
+        return result.rows.map((row) => row.name.replace(/^_sequence_/, ''));
+    }
+    /**
+     * Get the internal table name for a sequence
+     */
+    _getSequenceTableName(sequenceName, schema) {
+        // Prefix with _sequence_ to avoid name collisions with regular tables
+        const prefix = '_sequence_';
+        const schemaPrefix = schema ? `${schema}_` : '';
+        return `${prefix}${schemaPrefix}${sequenceName}`;
+    }
+    // ==================== Row-Level Security (RLS) ====================
+    async createPolicy(_options) {
+        throw new Error('Row-level security is not supported by SQLite');
+    }
+    async dropPolicy(_policyName, _tableName, _options) {
+        throw new Error('Row-level security is not supported by SQLite');
+    }
+    async enableRLS(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by SQLite');
+    }
+    async enableRowLevelSecurity(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by SQLite');
+    }
+    async disableRLS(_tableName, _schema) {
+        throw new Error('Row-level security is not supported by SQLite');
+    }
+    async hasPolicy(_policyName, _tableName) {
+        return false;
+    }
+    // ==================== Comments ====================
+    async commentTable(_tableName, _comment) {
+        // SQLite does not support table comments natively
+        // Could use SQLITE_SQLITE_MASTER comment extension or pragma
+    }
+    async commentColumn(_tableName, _columnName, _comment) {
+        // SQLite does not support column comments natively
+    }
+    // ==================== Advanced Indexes ====================
+    async createPartialIndex(tableName, indexName, fields, where, options) {
+        // SQLite supports partial indexes via WHERE clause
+        const fieldsSql = fields.map((f) => this.quoteIdentifier(f)).join(', ');
+        let sql = `CREATE INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteTable(tableName)} (${fieldsSql}) WHERE ${where}`;
+        if (options?.unique)
+            sql = sql.replace('CREATE INDEX', 'CREATE UNIQUE INDEX');
+        if (options?.ifNotExists)
+            sql = sql.replace('CREATE INDEX', 'CREATE INDEX IF NOT EXISTS');
+        await this.query(sql);
+    }
+    async createExpressionIndex(tableName, indexName, expression, options) {
+        // SQLite supports expression indexes
+        let sql = `CREATE INDEX ${this.quoteIdentifier(indexName)} ON ${this.quoteTable(tableName)} (${expression})`;
+        if (options?.unique)
+            sql = sql.replace('CREATE INDEX', 'CREATE UNIQUE INDEX');
+        if (options?.ifNotExists)
+            sql = sql.replace('CREATE INDEX', 'CREATE INDEX IF NOT EXISTS');
+        await this.query(sql);
+    }
+    // ==================== Identity & Computed Columns ====================
+    async createIdentityColumn(_tableName, _columnName, _options) {
+        throw new Error('Identity columns are not supported by SQLite. Use AUTOINCREMENT instead.');
+    }
+    async createComputedColumn(tableName, columnName, expression, options) {
+        // SQLite supports generated columns (computed)
+        const persistedSql = options?.persisted ? 'STORED' : 'VIRTUAL';
+        const typeSql = options?.type || 'ANY';
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} ADD COLUMN ${this.quoteIdentifier(columnName)} ${typeSql} GENERATED ALWAYS AS (${expression}) ${persistedSql}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a PostgreSQL extension (not supported in SQLite)
+     */
+    async createExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Drop a PostgreSQL extension (not supported in SQLite)
+     */
+    async dropExtension(_extensionName, _options) {
+        throw new Error('Extensions are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Get all installed PostgreSQL extensions (not supported in SQLite)
+     */
+    async getExtensions() {
+        throw new Error('Extensions are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Check if a PostgreSQL extension is installed (not supported in SQLite)
+     */
+    async hasExtension(_extensionName) {
+        throw new Error('Extensions are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    // ---------------------------------------------------------------------------
+    // Foreign Data Wrapper – not supported in SQLite
+    // ---------------------------------------------------------------------------
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildDropServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildDropForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    getServersQuery() {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Create a database view (SQLite uses CREATE VIEW)
+     * @param viewName - Name of the view to create
+     * @param query - The SELECT query for the view
+     * @param options - View options
+     */
+    async createView(viewName, query, options) {
+        let sql = 'CREATE VIEW';
+        if (options?.replace) {
+            sql = 'CREATE OR REPLACE VIEW';
+        }
+        sql += ` ${this.escapeId(viewName)} AS ${query}`;
+        await this.query(sql);
+    }
+    /**
+     * Drop a database view
+     * @param viewName - Name of the view to drop
+     * @param options - Drop options
+     */
+    async dropView(viewName, options) {
+        let sql = 'DROP VIEW';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(viewName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Show all views in the database
+     */
+    async showViews() {
+        const sql = "SELECT name FROM sqlite_master WHERE type='view' AND name NOT LIKE 'sqlite_%'";
+        const result = await this.query(sql);
+        return result.rows.map((row) => row.name);
+    }
+    /**
+     * Create a materialized view - Not supported by SQLite
+     */
+    async createMaterializedView(_options) {
+        throw new Error('Materialized views are not supported in SQLite. This feature is only available in PostgreSQL.');
+    }
+    /**
+     * Refresh a materialized view - Not supported by SQLite
+     */
+    async refreshMaterializedView(_viewName, _options) {
+        throw new Error('Materialized views are not supported in SQLite. This feature is only available in PostgreSQL.');
+    }
+    /**
+     * Drop a materialized view - Not supported by SQLite
+     */
+    async dropMaterializedView(_viewName, _options) {
+        throw new Error('Materialized views are not supported in SQLite. This feature is only available in PostgreSQL.');
+    }
+    /**
+     * Check if a materialized view exists - Not supported by SQLite
+     */
+    async hasMaterializedView(_viewName) {
+        throw new Error('Materialized views are not supported in SQLite. This feature is only available in PostgreSQL.');
+    }
+    /**
+     * Show all materialized views - Not supported by SQLite
+     */
+    async showMaterializedViews() {
+        throw new Error('Materialized views are not supported in SQLite. This feature is only available in PostgreSQL.');
+    }
+    /**
+     * Describe a table (get column information)
+     */
+    async describeTable(tableName) {
+        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
+        const result = await this.query(sql);
+        // PRAGMA table_info doesn't expose AUTOINCREMENT directly, but SQLite only
+        // allows a single AUTOINCREMENT column per table and it must be the INTEGER
+        // PRIMARY KEY, so we can detect it by checking whether the table's own
+        // CREATE TABLE statement contains the AUTOINCREMENT keyword and attribute it
+        // to the (single) primary key column. Without this, table-rebuild operations
+        // (removeColumn/changeColumn/createConstraint) would silently drop
+        // AUTOINCREMENT from the primary key every time they run.
+        let tableHasAutoIncrement = false;
+        try {
+            const createTableSql = await this.getCreateTable(tableName);
+            tableHasAutoIncrement = /\bAUTOINCREMENT\b/i.test(createTableSql);
+        }
+        catch {
+            // If we can't determine this (e.g. table doesn't exist yet), default to false
+        }
+        const description = {};
+        for (const row of result.rows) {
+            const rowData = row;
+            const isPrimaryKey = rowData.pk === 1;
+            description[rowData.name] = {
+                type: rowData.type || 'TEXT',
+                allowNull: rowData.notnull === 0,
+                defaultValue: rowData.dflt_value,
+                primaryKey: isPrimaryKey,
+                autoIncrement: isPrimaryKey && tableHasAutoIncrement,
+            };
+        }
+        return description;
+    }
+    /**
+     * Convert a column description (as returned by describeTable, sourced from
+     * PRAGMA table_info) into a ColumnDefinition suitable for getColumnDefinitionSql.
+     *
+     * PRAGMA table_info's `dflt_value` is already a raw SQL literal exactly as SQLite
+     * stored it (e.g. the string column default `'foo'` comes back as the 3-character
+     * string `'foo'`, quotes included). It must be wrapped in a Literal so it is
+     * emitted verbatim instead of being re-escaped and quoted a second time.
+     */
+    toColumnDefinition(colInfo) {
+        const rawDefault = colInfo.defaultValue;
+        return {
+            ...colInfo,
+            defaultValue: typeof rawDefault === 'string' ? new prorm_1.Literal(rawDefault) : rawDefault,
+        };
+    }
+    /**
+     * Rename a table
+     */
+    async renameTable(oldName, newName) {
+        const sql = `ALTER TABLE ${this.escapeId(oldName)} RENAME TO ${this.escapeId(newName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Add an index to a table
+     * Supports partial indexes (WHERE) and expression indexes (SQLite 3.9.0+)
+     */
+    async addIndex(tableName, indexName, fields = [], options) {
+        // Support the `(tableName, fields, options)` shorthand: when the second
+        // argument is an array, it holds the fields and the index name is derived.
+        if (Array.isArray(indexName)) {
+            if (fields && !Array.isArray(fields)) {
+                options = fields;
+            }
+            fields = indexName;
+            indexName = `${tableName}_${fields.join('_')}_idx`;
+        }
+        let sql = 'CREATE';
+        if (options?.unique) {
+            sql += ' UNIQUE';
+        }
+        sql += ' INDEX';
+        // Use IF NOT EXISTS to avoid errors when recreating indexes
+        sql += ' IF NOT EXISTS';
+        if (options?.type) {
+            sql += ` ${options.type}`;
+        }
+        sql += ` ${this.escapeId(indexName)} ON ${this.escapeId(tableName)}`;
+        // Handle expression index (SQLite 3.9.0+)
+        if (options?.expression) {
+            sql += ` ((${options.expression}))`;
+        }
+        else {
+            sql += ` (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        }
+        // Add partial index WHERE clause (SQLite 3.8.0+)
+        if (options?.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Remove an index from a table
+     */
+    async removeIndex(tableName, indexName) {
+        // Drop by the exact name if present, otherwise fall back to the name the
+        // `(tableName, fields)` addIndex shorthand generates (`${table}_${col}_idx`),
+        // so callers can remove an index by either the explicit or derived name.
+        await this.query(`DROP INDEX IF EXISTS ${this.escapeId(indexName)}`);
+        const derived = `${tableName}_${indexName}_idx`;
+        await this.query(`DROP INDEX IF EXISTS ${this.escapeId(derived)}`);
+    }
+    /**
+     * Create an index on a table with full options support
+     * Supports partial indexes (WHERE) and expression indexes (SQLite 3.9.0+)
+     */
+    async createIndex(tableName, indexDef) {
+        const fields = indexDef.fields || [];
+        let sql = 'CREATE';
+        if (indexDef.unique) {
+            sql += ' UNIQUE';
+        }
+        sql += ' INDEX IF NOT EXISTS';
+        if (indexDef.type) {
+            sql += ` ${indexDef.type}`;
+        }
+        sql += ` ${this.escapeId(indexDef.name)} ON ${this.escapeId(tableName)}`;
+        // Handle expression index (SQLite 3.9.0+)
+        if (indexDef.expression) {
+            sql += ` ((${indexDef.expression}))`;
+        }
+        else {
+            sql += ` (${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        }
+        if (indexDef.using) {
+            sql += ` USING ${indexDef.using}`;
+        }
+        if (indexDef.where && Object.keys(indexDef.where).length > 0) {
+            const whereClause = this.buildWhereClause(indexDef.where);
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        await this.query(sql);
+    }
+    /**
+     * Drop an index from a table
+     */
+    async dropIndex(tableName, indexName, _options) {
+        const sql = `DROP INDEX ${this.escapeId(indexName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a constraint on a table
+     * Note: SQLite has limited ALTER TABLE support for constraints
+     */
+    async createConstraint(tableName, constraintDef) {
+        // SQLite doesn't support ADD CONSTRAINT via ALTER TABLE in most versions
+        // We need to recreate the table with the new constraint
+        await this.recreateTableWithConstraint(tableName, constraintDef);
+    }
+    /**
+     * Drop a constraint from a table
+     * Note: SQLite has limited ALTER TABLE support for constraints
+     */
+    async dropConstraint(tableName, constraintName, _options) {
+        // SQLite doesn't support DROP CONSTRAINT via ALTER TABLE
+        // We would need to recreate the table without the constraint
+        throw new Error('SQLite does not support dropping constraints with ALTER TABLE. Recreate the table instead.');
+    }
+    /**
+     * Recreate table with a new constraint (for createConstraint)
+     */
+    async recreateTableWithConstraint(tableName, constraintDef) {
+        const tableInfo = await this.describeTable(tableName);
+        // Build column definitions, preserving existing NOT NULL / DEFAULT / PRIMARY KEY /
+        // AUTOINCREMENT / UNIQUE constraints (not just the bare data type) since SQLite
+        // requires a full table rebuild rather than in-place ALTER for constraint changes.
+        const columnDefs = [];
+        for (const [colName, colInfo] of Object.entries(tableInfo)) {
+            columnDefs.push(this.getColumnDefinitionSql(colName, this.toColumnDefinition(colInfo)));
+        }
+        // Add constraint to column definitions
+        if (constraintDef.fields && constraintDef.fields.length > 0) {
+            const escapedFields = constraintDef.fields.map((f) => this.escapeId(f)).join(', ');
+            switch (constraintDef.type) {
+                case 'PRIMARY KEY':
+                    columnDefs.push(`PRIMARY KEY (${escapedFields})`);
+                    break;
+                case 'UNIQUE':
+                    columnDefs.push(`UNIQUE (${escapedFields})`);
+                    break;
+                case 'FOREIGN KEY':
+                    if (constraintDef.references) {
+                        // Handle composite foreign keys (string | string[])
+                        const refField2 = constraintDef.references.field;
+                        const refFieldSql2 = Array.isArray(refField2)
+                            ? `(${refField2.map((f) => this.escapeId(f)).join(', ')})`
+                            : this.escapeId(refField2);
+                        let fkDef = `FOREIGN KEY (${escapedFields}) REFERENCES ${this.escapeId(constraintDef.references.table)}${refFieldSql2}`;
+                        if (constraintDef.references.onDelete) {
+                            fkDef += ` ON DELETE ${constraintDef.references.onDelete}`;
+                        }
+                        if (constraintDef.references.onUpdate) {
+                            fkDef += ` ON UPDATE ${constraintDef.references.onUpdate}`;
+                        }
+                        columnDefs.push(fkDef);
+                    }
+                    break;
+                case 'CHECK':
+                    if (constraintDef.check) {
+                        columnDefs.push(`CHECK (${constraintDef.check})`);
+                    }
+                    break;
+            }
+        }
+        const tempTable = `${tableName}_temp_${Date.now()}`;
+        // Rename old table
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} RENAME TO ${this.escapeId(tempTable)}`);
+        // Create new table with constraint
+        await this.query(`CREATE TABLE ${this.escapeId(tableName)} (${columnDefs.join(', ')})`);
+        // Copy data
+        const colNames = Object.keys(tableInfo)
+            .map((c) => this.escapeId(c))
+            .join(', ');
+        await this.query(`INSERT INTO ${this.escapeId(tableName)} SELECT ${colNames} FROM ${this.escapeId(tempTable)}`);
+        // Drop old table
+        await this.query(`DROP TABLE ${this.escapeId(tempTable)}`);
+    }
+    /**
+     * Begin a new transaction
+     */
+    async startTransaction(options) {
+        if (!this.connection) {
+            throw new Error('Not connected to database');
+        }
+        const transaction = new SQLiteTransaction(this.connection, this.transactionDepth++, options, this);
+        if (transaction.isOuter) {
+            this.connection.exec('BEGIN TRANSACTION');
+        }
+        else {
+            this.connection.exec(`SAVEPOINT ${transaction.id}`);
+        }
+        return transaction;
+    }
+    /**
+     * Commit a transaction
+     */
+    async commitTransaction(transaction) {
+        if (!this.connection) {
+            throw new Error('Not connected to database');
+        }
+        const sqliteTx = transaction;
+        if (sqliteTx.isOuter) {
+            this.connection.exec('COMMIT');
+        }
+        else {
+            this.connection.exec(`RELEASE SAVEPOINT ${sqliteTx.id}`);
+        }
+        this.transactionDepth--;
+    }
+    /**
+     * Rollback a transaction
+     */
+    async rollbackTransaction(transaction) {
+        if (!this.connection) {
+            throw new Error('Not connected to database');
+        }
+        const sqliteTx = transaction;
+        if (sqliteTx.isOuter) {
+            this.connection.exec('ROLLBACK');
+        }
+        else {
+            this.connection.exec(`ROLLBACK TO SAVEPOINT ${sqliteTx.id}`);
+        }
+        this.transactionDepth--;
+    }
+    /**
+     * Get the SQL for a data type
+     */
+    getDataTypeSql(dataType, columnName) {
+        if (typeof dataType === 'string') {
+            // SQLite has no native ENUM; emulate a string ENUM(...) type as TEXT with
+            // a CHECK on the allowed values (matching the object-form ENUM below).
+            const enumMatch = dataType.match(/^\s*ENUM\s*\((.*)\)\s*$/i);
+            if (enumMatch) {
+                const colRef = columnName ? this.escapeId(columnName) : 'value';
+                return `TEXT CHECK(${colRef} IN (${enumMatch[1]}))`;
+            }
+            return dataType;
+        }
+        // If passed a factory function (e.g. DataTypes.INTEGER without calling it), call it to get an instance
+        if (typeof dataType === 'function') {
+            try {
+                dataType = dataType();
+            }
+            catch {
+                return 'TEXT';
+            }
+        }
+        if (!dataType || typeof dataType !== 'object') {
+            return 'TEXT';
+        }
+        const dt = dataType;
+        switch (dt.key) {
+            case 'STRING':
+                return `VARCHAR(${dt.length || 255})`;
+            case 'CHAR':
+                return `CHAR(${dt.length || 1})`;
+            case 'TEXT':
+                return dt.length ? `TEXT(${dt.length})` : 'TEXT';
+            case 'INTEGER':
+                return dt.unsigned ? 'INTEGER UNSIGNED' : 'INTEGER';
+            case 'BIGINT':
+                return dt.unsigned ? 'BIGINT UNSIGNED' : 'BIGINT';
+            case 'FLOAT':
+                return `FLOAT(${dt.length || 10},${dt.decimals || 2})`;
+            case 'DOUBLE':
+                return `DOUBLE(${dt.length || 10},${dt.decimals || 2})`;
+            case 'DECIMAL':
+                return `DECIMAL(${dt.precision || 10},${dt.scale || 0})`;
+            case 'BOOLEAN':
+                return 'INTEGER'; // SQLite uses INTEGER for booleans
+            case 'DATE':
+                return 'DATETIME';
+            case 'DATEONLY':
+                return 'DATE';
+            case 'TIME':
+                return 'TIME';
+            case 'BLOB':
+                return 'BLOB';
+            case 'ENUM': {
+                // Reference the actual column being defined, not a hardcoded literal "col"
+                // (SQLite would otherwise fail with "no such column: col", or worse silently
+                // reference an unrelated column that happens to be named "col").
+                const colRef = columnName ? this.escapeId(columnName) : 'value';
+                return `TEXT CHECK(${dt.values ? `${colRef} IN (${dt.values.map((v) => `'${this.escapeString(String(v))}'`).join(',')})` : '1=1'})`;
+            }
+            case 'JSON':
+                return 'TEXT'; // SQLite stores JSON as text
+            case 'JSONB':
+                return 'TEXT';
+            case 'UUID':
+                return 'TEXT';
+            case 'GEOMETRY':
+                return 'BLOB';
+            case 'VIRTUAL':
+                // Virtual fields don't create a database column - return empty string
+                return '';
+            default:
+                return 'TEXT';
+        }
+    }
+    /**
+     * Build a WHERE clause from a WhereOptions object
+     */
+    buildWhereClause(where, options) {
+        const values = [];
+        if (!where ||
+            (Object.keys(where).length === 0 && Object.getOwnPropertySymbols(where).length === 0)) {
+            return { sql: '', values };
+        }
+        const buildCondition = (condition, parentKey) => {
+            if (!condition) {
+                return { sql: '', values: [] };
+            }
+            if (typeof condition !== 'object') {
+                values.push(condition);
+                return { sql: '?', values: [condition] };
+            }
+            // Normalize Symbol operator keys at the top level too
+            const rawCond = condition;
+            const topSymbols = Object.getOwnPropertySymbols(rawCond);
+            const normalizedCond = { ...rawCond };
+            for (const sym of topSymbols) {
+                const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                if (strKey)
+                    normalizedCond[strKey] = rawCond[sym];
+            }
+            const cond = normalizedCond;
+            // Handle logical operators. These are collected (NOT returned early) so
+            // that sibling field conditions on the same object — e.g.
+            // { active: 1, $or: [...] } — are still AND-ed in rather than dropped.
+            const logicalConditions = [];
+            if (cond.$and || cond.$or || cond.$not) {
+                if (cond.$and) {
+                    const andConditions = cond.$and
+                        .map((c) => buildCondition(c).sql)
+                        .filter(Boolean);
+                    if (andConditions.length)
+                        logicalConditions.push(`(${andConditions.join(' AND ')})`);
+                }
+                if (cond.$or) {
+                    const orConditions = cond.$or
+                        .map((c) => buildCondition(c).sql)
+                        .filter(Boolean);
+                    if (orConditions.length)
+                        logicalConditions.push(`(${orConditions.join(' OR ')})`);
+                }
+                if (cond.$not) {
+                    const result = buildCondition(cond.$not);
+                    if (result.sql)
+                        logicalConditions.push(`NOT (${result.sql})`);
+                }
+            }
+            // Handle field conditions
+            const fieldConditions = [...logicalConditions];
+            for (const [key, value] of Object.entries(cond)) {
+                if (key.startsWith('$'))
+                    continue;
+                // A bare array value (e.g. `where: { id: [1, 2, 3] }`, the common
+                // Sequelize-style shorthand for "IN") used to fall through to the
+                // generic object-condition branch below, which spreads the array
+                // into a plain object (`{0: 1, 1: 2, 2: 3}`), matches none of the
+                // `$eq`/`$in`/etc. operator keys, and ends up binding the whole
+                // array as a single `= ?` parameter - better-sqlite3 silently
+                // matches nothing for that (no rows have an id equal to an array),
+                // so `where: { id: [...] }` matched zero rows instead of the
+                // intended "any of these ids".
+                if (Array.isArray(value)) {
+                    values.push(...value);
+                    fieldConditions.push(`${this.escapeId(key)} IN (${value.map(() => '?').join(',') || 'NULL'})`);
+                    continue;
+                }
+                if (value && typeof value === 'object') {
+                    // Normalize Symbol operator keys to string keys ($gt, $eq, etc.)
+                    const rawValueObj = value;
+                    const symbolKeys = Object.getOwnPropertySymbols(rawValueObj);
+                    const normalizedObj = { ...rawValueObj };
+                    for (const sym of symbolKeys) {
+                        const strKey = (0, operators_1.operatorToWhereKey)(sym);
+                        if (strKey)
+                            normalizedObj[strKey] = rawValueObj[sym];
+                    }
+                    const valueObj = normalizedObj;
+                    // When several operators target the same field (e.g. { age: { $gte, $lte } }),
+                    // the single-operator dispatch below would only emit the first one. Split
+                    // into one condition per operator and AND them together.
+                    const opKeys = Object.keys(valueObj).filter((k) => k.startsWith('$'));
+                    if (opKeys.length > 1) {
+                        const parts = opKeys
+                            .map((ok) => buildCondition({ [key]: { [ok]: valueObj[ok] } }).sql)
+                            .filter(Boolean);
+                        if (parts.length > 0) {
+                            fieldConditions.push(parts.length > 1 ? `(${parts.join(' AND ')})` : parts[0]);
+                        }
+                        continue;
+                    }
+                    if (valueObj.$eq !== undefined) {
+                        values.push(valueObj.$eq);
+                        fieldConditions.push(`${this.escapeId(key)} = ?`);
+                    }
+                    else if (valueObj.$ne !== undefined) {
+                        values.push(valueObj.$ne);
+                        fieldConditions.push(`${this.escapeId(key)} != ?`);
+                    }
+                    else if (valueObj.$gt !== undefined) {
+                        values.push(valueObj.$gt);
+                        fieldConditions.push(`${this.escapeId(key)} > ?`);
+                    }
+                    else if (valueObj.$gte !== undefined) {
+                        values.push(valueObj.$gte);
+                        fieldConditions.push(`${this.escapeId(key)} >= ?`);
+                    }
+                    else if (valueObj.$lt !== undefined) {
+                        values.push(valueObj.$lt);
+                        fieldConditions.push(`${this.escapeId(key)} < ?`);
+                    }
+                    else if (valueObj.$lte !== undefined) {
+                        values.push(valueObj.$lte);
+                        fieldConditions.push(`${this.escapeId(key)} <= ?`);
+                    }
+                    else if (valueObj.$like !== undefined) {
+                        values.push(valueObj.$like);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notLike !== undefined) {
+                        values.push(valueObj.$notLike);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$startsWith !== undefined) {
+                        values.push(valueObj.$startsWith + '%');
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notStartsWith !== undefined) {
+                        values.push(valueObj.$notStartsWith + '%');
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$endsWith !== undefined) {
+                        values.push('%' + valueObj.$endsWith);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notEndsWith !== undefined) {
+                        values.push('%' + valueObj.$notEndsWith);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$substring !== undefined) {
+                        values.push('%' + valueObj.$substring + '%');
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notSubstring !== undefined) {
+                        values.push('%' + valueObj.$notSubstring + '%');
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$in) {
+                        const inValues = valueObj.$in;
+                        values.push(...inValues);
+                        fieldConditions.push(`${this.escapeId(key)} IN (${inValues.map(() => '?').join(',')})`);
+                    }
+                    else if (valueObj.$notIn) {
+                        const notInValues = valueObj.$notIn;
+                        values.push(...notInValues);
+                        fieldConditions.push(`${this.escapeId(key)} NOT IN (${notInValues.map(() => '?').join(',')})`);
+                    }
+                    else if (valueObj.$between) {
+                        const between = valueObj.$between;
+                        values.push(between[0], between[1]);
+                        fieldConditions.push(`${this.escapeId(key)} BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$notBetween) {
+                        const notBetween = valueObj.$notBetween;
+                        values.push(notBetween[0], notBetween[1]);
+                        fieldConditions.push(`${this.escapeId(key)} NOT BETWEEN ? AND ?`);
+                    }
+                    else if (valueObj.$isNull !== undefined) {
+                        if (valueObj.$isNull) {
+                            fieldConditions.push(`${this.escapeId(key)} IS NULL`);
+                        }
+                        else {
+                            fieldConditions.push(`${this.escapeId(key)} IS NOT NULL`);
+                        }
+                    }
+                    else if (valueObj.$isNotNull !== undefined) {
+                        if (valueObj.$isNotNull) {
+                            fieldConditions.push(`${this.escapeId(key)} IS NOT NULL`);
+                        }
+                        else {
+                            fieldConditions.push(`${this.escapeId(key)} IS NULL`);
+                        }
+                    }
+                    else if (valueObj.$iLike !== undefined) {
+                        // SQLite's LIKE is case-insensitive for ASCII, so it serves as ILIKE.
+                        values.push(valueObj.$iLike);
+                        fieldConditions.push(`${this.escapeId(key)} LIKE ?`);
+                    }
+                    else if (valueObj.$notILike !== undefined) {
+                        values.push(valueObj.$notILike);
+                        fieldConditions.push(`${this.escapeId(key)} NOT LIKE ?`);
+                    }
+                    else if (valueObj.$is !== undefined) {
+                        if (valueObj.$is === null) {
+                            fieldConditions.push(`${this.escapeId(key)} IS NULL`);
+                        }
+                        else {
+                            values.push(valueObj.$is);
+                            fieldConditions.push(`${this.escapeId(key)} IS ?`);
+                        }
+                    }
+                    else if (valueObj.$not !== undefined) {
+                        if (valueObj.$not === null) {
+                            fieldConditions.push(`${this.escapeId(key)} IS NOT NULL`);
+                        }
+                        else {
+                            values.push(valueObj.$not);
+                            fieldConditions.push(`${this.escapeId(key)} != ?`);
+                        }
+                    }
+                    else if (valueObj.$contains !== undefined) {
+                        // Array containment: the JSON-array column must contain every given
+                        // element. Emulated with json_each since SQLite has no array type.
+                        const contained = Array.isArray(valueObj.$contains)
+                            ? valueObj.$contains
+                            : [valueObj.$contains];
+                        const placeholders = contained.map(() => '?').join(', ');
+                        values.push(...contained);
+                        fieldConditions.push(`(SELECT COUNT(DISTINCT value) FROM json_each(${this.escapeId(key)}) WHERE value IN (${placeholders})) = ${contained.length}`);
+                    }
+                    else if (valueObj.$col !== undefined) {
+                        fieldConditions.push(`${this.escapeId(key)} = ${this.escapeId(String(valueObj.$col))}`);
+                    }
+                    else {
+                        values.push(value);
+                        fieldConditions.push(`${this.escapeId(key)} = ?`);
+                    }
+                }
+                else {
+                    values.push(value);
+                    fieldConditions.push(`${this.escapeId(key)} = ?`);
+                }
+            }
+            return { sql: fieldConditions.join(' AND '), values };
+        };
+        const result = buildCondition(where);
+        return { sql: result.sql, values: result.values };
+    }
+    /**
+     * Build an ORDER BY clause
+     */
+    buildOrderClause(order, options) {
+        const orderArray = order;
+        if (!orderArray || !Array.isArray(orderArray) || orderArray.length === 0) {
+            return '';
+        }
+        const orderParts = [];
+        for (const item of orderArray) {
+            if (Array.isArray(item)) {
+                const field = typeof item[0] === 'string' ? this.escapeId(item[0]) : item[0];
+                const direction = item[1] ? ` ${item[1]}` : '';
+                orderParts.push(`${field}${direction}`);
+            }
+            else if (typeof item === 'string') {
+                orderParts.push(item);
+            }
+            else if (item && typeof item === 'object') {
+                const itemArr = item;
+                const [modelOrString, field] = itemArr;
+                const model = typeof modelOrString === 'string'
+                    ? modelOrString
+                    : modelOrString.tableName || '';
+                const fieldStr = typeof field === 'string' ? field : '';
+                orderParts.push(`${model ? `${this.escapeId(model)}.` : ''}${this.escapeId(fieldStr)}`);
+            }
+        }
+        return orderParts.length > 0 ? `ORDER BY ${orderParts.join(', ')}` : '';
+    }
+    /**
+     * Build a LIMIT/OFFSET clause
+     */
+    buildLimitOffset(limit, offset) {
+        let sql = '';
+        if (limit !== undefined) {
+            sql += ` LIMIT ${Number(limit)}`;
+            if (offset !== undefined) {
+                sql += ` OFFSET ${Number(offset)}`;
+            }
+        }
+        else if (offset !== undefined) {
+            // SQLite requires LIMIT to use OFFSET; use -1 for "all rows"
+            sql += ` LIMIT -1 OFFSET ${Number(offset)}`;
+        }
+        return sql;
+    }
+    /**
+     * Build an INSERT query
+     */
+    buildInsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        // If no values provided, return a minimal valid INSERT (for defaults only)
+        if (columns.length === 0) {
+            return {
+                sql: `INSERT INTO ${this.quoteTable(tableName, options?.schema)} DEFAULT VALUES`,
+                values: [],
+            };
+        }
+        const processedValues = [];
+        const placeholders = [];
+        // Process each value - handle Literal differently
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                // For Literal values, inline the SQL directly
+                placeholders.push(value.val);
+            }
+            else {
+                // For regular values, use parameterized placeholder
+                placeholders.push('?');
+                processedValues.push(value);
+            }
+        }
+        let sql = `INSERT INTO ${this.quoteTable(tableName, options?.schema)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders.join(', ')})`;
+        if (options?.upsert) {
+            if (options.conflictTargets && options.conflictTargets.length > 0) {
+                sql += this.buildConflictClausesSql(options.conflictTargets, columns);
+            }
+            else if (options.doNothing) {
+                // `DO NOTHING` is the one form of `ON CONFLICT` SQLite allows without an
+                // explicit conflict target - it applies to any constraint violation.
+                sql +=
+                    options.conflictFields && options.conflictFields.length > 0
+                        ? ` ON CONFLICT (${options.conflictFields.map((c) => this.escapeId(c)).join(', ')}) DO NOTHING`
+                        : ' ON CONFLICT DO NOTHING';
+            }
+            else {
+                const updateColumns = columns
+                    .map((c) => `${this.escapeId(c)} = excluded.${this.escapeId(c)}`)
+                    .join(', ');
+                // SQLite's `ON CONFLICT (...) DO UPDATE` requires an explicit conflict target
+                // that matches a real PRIMARY KEY/UNIQUE index on the table - unlike
+                // `DO NOTHING`, it cannot be omitted. Defaulting to "all inserted columns"
+                // (the previous behavior) almost never matches a real constraint and fails
+                // at runtime with a confusing "ON CONFLICT clause does not match any
+                // PRIMARY KEY or UNIQUE constraint" error, so fail fast with a clear message.
+                if (!options.conflictFields || options.conflictFields.length === 0) {
+                    throw new Error('SQLite upsert requires `conflictFields` naming the PRIMARY KEY or UNIQUE ' +
+                        'columns to resolve conflicts against (e.g. { conflictFields: ["id"] }), ' +
+                        'unless `doNothing` is set (which allows a bare `ON CONFLICT DO NOTHING`).');
+                }
+                sql += ` ON CONFLICT (${options.conflictFields.map((c) => this.escapeId(c)).join(', ')}) DO UPDATE SET ${updateColumns}`;
+            }
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Build one or more chained `ON CONFLICT (...) DO ...` clauses. SQLite allows
+     * multiple `ON CONFLICT` clauses in a single INSERT, each targeting a
+     * different PRIMARY KEY/UNIQUE constraint and evaluated in order until one
+     * matches, e.g.:
+     *   INSERT INTO t (...) VALUES (...)
+     *     ON CONFLICT (a) DO NOTHING
+     *     ON CONFLICT (b) DO UPDATE SET ...
+     */
+    buildConflictClausesSql(targets, insertedColumns) {
+        let clause = '';
+        for (const target of targets) {
+            if (!target.fields || target.fields.length === 0) {
+                throw new Error('Each entry in `conflictTargets` requires a non-empty `fields` array naming the ' +
+                    'PRIMARY KEY or UNIQUE columns to resolve conflicts against.');
+            }
+            const targetSql = `ON CONFLICT (${target.fields.map((c) => this.escapeId(c)).join(', ')})`;
+            const action = target.action || 'DO UPDATE';
+            if (action === 'DO NOTHING') {
+                clause += ` ${targetSql} DO NOTHING`;
+            }
+            else {
+                const updateColumns = target.updateColumns && target.updateColumns.length > 0
+                    ? target.updateColumns
+                    : insertedColumns;
+                const setClauses = updateColumns
+                    .map((c) => `${this.escapeId(c)} = excluded.${this.escapeId(c)}`)
+                    .join(', ');
+                clause += ` ${targetSql} DO UPDATE SET ${setClauses}`;
+                if (target.where) {
+                    clause += ` WHERE ${target.where}`;
+                }
+            }
+        }
+        return clause;
+    }
+    /**
+     * Build an UPSERT query (INSERT ... ON CONFLICT DO UPDATE)
+     * SQLite supports: INSERT OR REPLACE, INSERT OR IGNORE, and ON CONFLICT DO UPDATE
+     */
+    buildUpsertQuery(tableName, values, options) {
+        const columns = Object.keys(values);
+        const processedValues = [];
+        const placeholders = [];
+        // Process each value - handle Literal differently
+        for (const value of Object.values(values)) {
+            if (value instanceof prorm_1.Literal) {
+                // For Literal values, inline the SQL directly
+                placeholders.push(value.val);
+            }
+            else {
+                // For regular values, use parameterized placeholder
+                placeholders.push('?');
+                processedValues.push(value);
+            }
+        }
+        let sql = `INSERT INTO ${this.quoteTable(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${placeholders.join(', ')})`;
+        // Handle upsert (ON CONFLICT)
+        if (options) {
+            if (options.conflictTargets && options.conflictTargets.length > 0) {
+                sql += this.buildConflictClausesSql(options.conflictTargets, columns);
+            }
+            else if (options.doNothing) {
+                // `DO NOTHING` is the one form of `ON CONFLICT` SQLite allows without an
+                // explicit conflict target - it applies to any constraint violation.
+                sql +=
+                    options.conflictFields && options.conflictFields.length > 0
+                        ? ` ON CONFLICT (${options.conflictFields.map((c) => this.escapeId(c)).join(', ')}) DO NOTHING`
+                        : ' ON CONFLICT DO NOTHING';
+            }
+            else {
+                // SQLite's `ON CONFLICT (...) DO UPDATE` requires an explicit conflict target
+                // that matches a real PRIMARY KEY/UNIQUE index; it cannot be inferred from the
+                // set of inserted columns (see buildInsertQuery for the same issue).
+                if (!options.conflictFields || options.conflictFields.length === 0) {
+                    throw new Error('SQLite upsert requires `conflictFields` naming the PRIMARY KEY or UNIQUE ' +
+                        'columns to resolve conflicts against (e.g. { conflictFields: ["id"] }), ' +
+                        'unless `doNothing` is set (which allows a bare `ON CONFLICT DO NOTHING`).');
+                }
+                // Determine which columns to update
+                const updateColumns = options.updateOnDuplicate && options.updateOnDuplicate.length > 0
+                    ? options.updateOnDuplicate
+                    : columns;
+                const setClauses = updateColumns
+                    .map((c) => `${this.escapeId(c)} = excluded.${this.escapeId(c)}`)
+                    .join(', ');
+                sql += ` ON CONFLICT (${options.conflictFields.map((c) => this.escapeId(c)).join(', ')}) DO UPDATE SET ${setClauses}`;
+            }
+        }
+        // Handle RETURNING clause (SQLite 3.35+)
+        if (options?.returning) {
+            if (options.returning === true) {
+                sql += ' RETURNING *';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` RETURNING ${options.returning.map((c) => this.escapeId(c)).join(', ')}`;
+            }
+        }
+        return { sql, values: processedValues };
+    }
+    /**
+     * Build an increment query
+     * @param tableName - Table name
+     * @param fields - Fields to increment
+     * @param where - Where clause
+     * @param options - Query options (by: number)
+     */
+    buildIncrementQuery(tableName, fields, where, options) {
+        const by = options?.by ?? 1;
+        const setClauses = [];
+        const queryValues = [];
+        // Handle different field formats
+        if (typeof fields === 'string') {
+            // Single field: increment('count')
+            setClauses.push(`${this.escapeId(fields)} = ${this.escapeId(fields)} + ?`);
+            queryValues.push(by);
+        }
+        else if (Array.isArray(fields)) {
+            // Array of fields: increment(['count', 'value'], { by: 5 })
+            for (const field of fields) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + ?`);
+                queryValues.push(by);
+            }
+        }
+        else {
+            // Object: increment({ count: 1, value: 10 })
+            for (const [field, value] of Object.entries(fields)) {
+                setClauses.push(`${this.escapeId(field)} = ${this.escapeId(field)} + ?`);
+                queryValues.push(value);
+            }
+        }
+        // Build WHERE clause
+        const whereClause = this.buildWhereClause(where);
+        queryValues.push(...whereClause.values);
+        const sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')} WHERE ${whereClause.sql}`;
+        return { sql, values: queryValues };
+    }
+    /**
+     * Build an UPDATE query
+     */
+    buildUpdateQuery(tableName, values, where, options) {
+        const setClauses = [];
+        const queryValues = [];
+        for (const [key, value] of Object.entries(values)) {
+            if (value instanceof prorm_1.Literal) {
+                // For Literal values, inline the SQL directly
+                setClauses.push(`${this.escapeId(key)} = ${value.val}`);
+            }
+            else {
+                // For regular values, use parameterized placeholder
+                setClauses.push(`${this.escapeId(key)} = ?`);
+                queryValues.push(value);
+            }
+        }
+        const whereClause = this.buildWhereClause(where);
+        let sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (options?.limit) {
+            sql += ` LIMIT ${options.limit}`;
+        }
+        // Handle RETURNING clause (SQLite 3.35+)
+        if (options?.returning) {
+            if (options.returning === true) {
+                sql += ' RETURNING *';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` RETURNING ${options.returning.map((c) => this.escapeId(c)).join(', ')}`;
+            }
+        }
+        return { sql, values: [...queryValues, ...whereClause.values] };
+    }
+    /**
+     * Build a DELETE query
+     */
+    buildDeleteQuery(tableName, where, options) {
+        const whereClause = this.buildWhereClause(where);
+        let sql = `DELETE FROM ${this.escapeId(tableName)}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (options?.limit) {
+            sql += ` LIMIT ${options.limit}`;
+        }
+        // Handle RETURNING clause (SQLite 3.35+)
+        if (options?.returning) {
+            if (options.returning === true) {
+                sql += ' RETURNING *';
+            }
+            else if (Array.isArray(options.returning)) {
+                sql += ` RETURNING ${options.returning.map((c) => this.escapeId(c)).join(', ')}`;
+            }
+        }
+        return { sql, values: whereClause.values };
+    }
+    /**
+     * Check if a value is a function expression (fn('COUNT', ...))
+     */
+    isFnExpression(value) {
+        return value !== null && typeof value === 'object' && value.__type === 'fn';
+    }
+    /**
+     * Check if a value is a column expression (col('name'))
+     */
+    isColExpression(value) {
+        return value !== null && typeof value === 'object' && value.__type === 'col';
+    }
+    /**
+     * Check if a value is a literal expression (literal('sql'))
+     */
+    isLiteralExpression(value) {
+        return value !== null && typeof value === 'object' && value.__type === 'literal';
+    }
+    /**
+     * Compile a function expression to SQL
+     */
+    compileFnExpression(fnExpr) {
+        const args = fnExpr.args.map((arg) => {
+            if (this.isColExpression(arg)) {
+                return this.escapeId(arg.col);
+            }
+            else if (typeof arg === 'string') {
+                return this.escape(arg);
+            }
+            else if (this.isFnExpression(arg)) {
+                return this.compileFnExpression(arg);
+            }
+            else {
+                return String(arg);
+            }
+        });
+        return `${fnExpr.fn}(${args.join(', ')})`;
+    }
+    /**
+     * Build SELECT clause with support for function expressions and aliases
+     * Handles: 'field', ['field'], ['field', 'alias'], [fn('COUNT', 'id'), 'count']
+     */
+    buildSelectClause(attributes) {
+        if (!attributes)
+            return '*';
+        if (Array.isArray(attributes)) {
+            const parts = attributes.map((attr) => {
+                // Handle array format: [expression, alias] or [fn, alias]
+                if (Array.isArray(attr)) {
+                    const [expr, alias] = attr;
+                    let sql;
+                    if (this.isFnExpression(expr)) {
+                        sql = this.compileFnExpression(expr);
+                    }
+                    else if (this.isColExpression(expr)) {
+                        sql = this.escapeId(expr.col);
+                    }
+                    else if (this.isLiteralExpression(expr)) {
+                        sql = expr.sql;
+                    }
+                    else if (typeof expr === 'string') {
+                        // Check if it's a column reference or literal SQL
+                        if (expr.includes('(') || expr.includes(' ')) {
+                            sql = expr; // Literal SQL
+                        }
+                        else {
+                            sql = this.escapeId(expr);
+                        }
+                    }
+                    else {
+                        sql = String(expr);
+                    }
+                    return `${sql} AS ${this.escapeId(alias)}`;
+                }
+                else if (this.isFnExpression(attr)) {
+                    // Function without alias - let DB assign a name
+                    return this.compileFnExpression(attr);
+                }
+                else if (this.isColExpression(attr)) {
+                    return this.escapeId(attr.col);
+                }
+                else if (this.isLiteralExpression(attr)) {
+                    return attr.sql;
+                }
+                else if (typeof attr === 'string') {
+                    // Plain column name
+                    return this.escapeId(attr);
+                }
+                return String(attr);
+            });
+            return parts.join(', ');
+        }
+        else if (attributes.include) {
+            return attributes.include.map((a) => this.escapeId(a)).join(', ');
+        }
+        else if (attributes.exclude) {
+            return `* EXCEPT (${attributes.exclude.map((a) => this.escapeId(a)).join(', ')})`;
+        }
+        return '*';
+    }
+    /**
+     * Build GROUP BY clause with support for function expressions and aliases
+     * Handles: 'field', ['field1', 'field2'], [[fn('COUNT', 'id'), 'count']]
+     */
+    buildGroupByClause(group) {
+        if (!group)
+            return '';
+        const groupArray = Array.isArray(group) ? group : [group];
+        if (groupArray.length === 0)
+            return '';
+        const parts = groupArray.map((field) => {
+            if (Array.isArray(field)) {
+                // Array format: [expression, alias] or [fn, alias]
+                const [expr, alias] = field;
+                let sql;
+                if (this.isFnExpression(expr)) {
+                    sql = this.compileFnExpression(expr);
+                }
+                else if (this.isColExpression(expr)) {
+                    sql = this.escapeId(expr.col);
+                }
+                else if (this.isLiteralExpression(expr)) {
+                    sql = expr.sql;
+                }
+                else if (typeof expr === 'string') {
+                    sql = this.escapeId(expr);
+                }
+                else {
+                    sql = String(expr);
+                }
+                // Alias is optional in GROUP BY
+                if (alias) {
+                    return `${sql} AS ${this.escapeId(alias)}`;
+                }
+                return sql;
+            }
+            else if (this.isFnExpression(field)) {
+                return this.compileFnExpression(field);
+            }
+            else if (this.isColExpression(field)) {
+                return this.escapeId(field.col);
+            }
+            else if (this.isLiteralExpression(field)) {
+                return field.sql;
+            }
+            else if (typeof field === 'string') {
+                if (field.includes('.')) {
+                    return field
+                        .split('.')
+                        .map((part) => this.escapeId(part))
+                        .join('.');
+                }
+                return this.escapeId(field);
+            }
+            return String(field);
+        });
+        return `GROUP BY ${parts.join(', ')}`;
+    }
+    /**
+     * Build a WHERE clause condition using standard operators (Op.gt, Op.eq, etc.)
+     * Uses SQLite ? placeholders
+     */
+    buildCondition(condition, values, paramChar = '?') {
+        if (!condition || (typeof condition === 'object' && Object.keys(condition).length === 0)) {
+            return '';
+        }
+        // Handle logical operators
+        if ('$and' in condition) {
+            const andParts = condition.$and.map((c) => this.buildCondition(c, values, paramChar));
+            return `(${andParts.join(' AND ')})`;
+        }
+        if ('$or' in condition) {
+            const orParts = condition.$or.map((c) => this.buildCondition(c, values, paramChar));
+            return `(${orParts.join(' OR ')})`;
+        }
+        if ('$not' in condition) {
+            return `NOT (${this.buildCondition(condition.$not, values, paramChar)})`;
+        }
+        // Handle regular conditions
+        const conditions = [];
+        for (const [key, value] of Object.entries(condition)) {
+            if (key.startsWith('$'))
+                continue; // Skip logical operators
+            let sql = '';
+            // Check if value is an operator object
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                const opKeys = Object.keys(value);
+                if (opKeys.length === 1) {
+                    const opKey = opKeys[0];
+                    const opValue = value[opKey];
+                    // Map Op symbol to string
+                    if (opKey === 'Symbol(eq)' || opKey === 'Symbol(operators.eq)') {
+                        sql = `${this.escapeId(key)} = ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(ne)' || opKey === 'Symbol(operators.ne)') {
+                        sql = `${this.escapeId(key)} != ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(gt)' || opKey === 'Symbol(operators.gt)') {
+                        sql = `${this.escapeId(key)} > ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(gte)' || opKey === 'Symbol(operators.gte)') {
+                        sql = `${this.escapeId(key)} >= ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(lt)' || opKey === 'Symbol(operators.lt)') {
+                        sql = `${this.escapeId(key)} < ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(lte)' || opKey === 'Symbol(operators.lte)') {
+                        sql = `${this.escapeId(key)} <= ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(in)' || opKey === 'Symbol(operators.in)') {
+                        sql = `${this.escapeId(key)} IN (${paramChar})`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(notIn)' || opKey === 'Symbol(operators.notIn)') {
+                        sql = `${this.escapeId(key)} NOT IN (${paramChar})`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(between)' || opKey === 'Symbol(operators.between)') {
+                        sql = `${this.escapeId(key)} BETWEEN ${paramChar} AND ${paramChar}`;
+                        values.push(...opValue);
+                    }
+                    else if (opKey === 'Symbol(notBetween)' || opKey === 'Symbol(operators.notBetween)') {
+                        sql = `${this.escapeId(key)} NOT BETWEEN ${paramChar} AND ${paramChar}`;
+                        values.push(...opValue);
+                    }
+                    else if (opKey === 'Symbol(isNull)' || opKey === 'Symbol(operators.isNull)') {
+                        sql = `${this.escapeId(key)} IS NULL`;
+                    }
+                    else if (opKey === 'Symbol(isNotNull)' || opKey === 'Symbol(operators.isNotNull)') {
+                        sql = `${this.escapeId(key)} IS NOT NULL`;
+                    }
+                    else if (opKey === 'Symbol(like)' || opKey === 'Symbol(operators.like)') {
+                        sql = `${this.escapeId(key)} LIKE ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(notLike)' || opKey === 'Symbol(operators.notLike)') {
+                        sql = `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(iLike)' || opKey === 'Symbol(operators.iLike)') {
+                        sql = `${this.escapeId(key)} LIKE ${paramChar}`; // SQLite doesn't have ILIKE
+                        values.push(opValue);
+                    }
+                    else if (opKey === 'Symbol(notILike)' || opKey === 'Symbol(operators.notILike)') {
+                        sql = `${this.escapeId(key)} NOT LIKE ${paramChar}`;
+                        values.push(opValue);
+                    }
+                }
+                if (!sql) {
+                    // Fallback: treat as equals
+                    sql = `${this.escapeId(key)} = ${paramChar}`;
+                    values.push(value);
+                }
+            }
+            else if (Array.isArray(value)) {
+                // Handle IN arrays
+                sql = `${this.escapeId(key)} IN (${value.map(() => paramChar).join(', ')})`;
+                values.push(...value);
+            }
+            else {
+                // Simple equality
+                sql = `${this.escapeId(key)} = ${paramChar}`;
+                values.push(value);
+            }
+            if (sql) {
+                conditions.push(sql);
+            }
+        }
+        return conditions.join(' AND ');
+    }
+    /**
+     * Build a HAVING clause with support for standard Op operators
+     */
+    buildHavingClause(having) {
+        const values = [];
+        if (!having || (typeof having === 'object' && Object.keys(having).length === 0)) {
+            return { sql: '', values };
+        }
+        // Use the condition builder with Op operator support
+        const sql = this.buildCondition(having, values);
+        return { sql, values };
+    }
+    /**
+     * Build a `WITH [RECURSIVE] name [(cols)] AS (query), ...` clause from
+     * `SelectOptions.cte`. Nested `SelectOptions` queries are compiled via a
+     * recursive call to `buildSelectQuery`; raw SQL strings are used verbatim.
+     *
+     * SQLite uses unnumbered `?` placeholders (unlike Postgres/MSSQL's
+     * numbered `$n`/`@pN`), so no placeholder renumbering is needed here -
+     * each CTE's `values` are simply concatenated in the order their `?`
+     * markers appear in the rendered SQL, and the caller prepends the whole
+     * batch ahead of the main query's own values.
+     */
+    buildWithClause(ctes) {
+        if (!ctes || ctes.length === 0) {
+            return { sql: '', values: [] };
+        }
+        const values = [];
+        const anyRecursive = ctes.some((cte) => cte.recursive === true);
+        const parts = ctes.map((cte) => {
+            const columnsSql = cte.columns && cte.columns.length > 0
+                ? ` (${cte.columns.map((c) => this.escapeId(c)).join(', ')})`
+                : '';
+            let bodySql;
+            if (typeof cte.query === 'string') {
+                bodySql = cte.query;
+            }
+            else {
+                const built = this.buildSelectQuery(cte.query);
+                bodySql = built.sql;
+                values.push(...built.values);
+            }
+            return `${this.escapeId(cte.name)}${columnsSql} AS (${bodySql})`;
+        });
+        const withKeyword = anyRecursive ? 'WITH RECURSIVE' : 'WITH';
+        return { sql: `${withKeyword} ${parts.join(', ')} `, values };
+    }
+    /**
+     * Build a SELECT query
+     */
+    buildSelectQuery(options) {
+        const queryValues = [];
+        // Build WITH clause (Common Table Expressions), if provided
+        let withSql = '';
+        if (options.cte && options.cte.length > 0) {
+            const withClause = this.buildWithClause(options.cte);
+            withSql = withClause.sql;
+            queryValues.push(...withClause.values);
+        }
+        // Helper function to format a column/expression for SELECT
+        const formatSelectAttribute = (attr) => {
+            // Handle Col class instance (has toSql method)
+            if (attr && typeof attr === 'object' && typeof attr.toSql === 'function') {
+                return attr.toSql();
+            }
+            // Handle the modern typed-expression shapes from src/operators.ts / the
+            // src/query-builders/functions/** builder library: { __type: 'literal', sql },
+            // { __type: 'fn', fn, args }, { __type: 'col', col }. Without this, these
+            // objects fall through to the generic branches below (which look for the
+            // older { val }/{ fn }/{ col }/{ literal } shapes) and end up stringified
+            // as "[object Object]", producing invalid SQL like "[object Object] AS alias".
+            if (attr && typeof attr === 'object' && attr.__type === 'literal' && typeof attr.sql === 'string') {
+                return attr.sql;
+            }
+            if (attr && typeof attr === 'object' && attr.__type === 'col' && typeof attr.col === 'string') {
+                return this.escapeId(attr.col);
+            }
+            if (attr && typeof attr === 'object' && attr.__type === 'fn' && Array.isArray(attr.args)) {
+                const formattedArgs = attr.args.map((arg) => formatSelectAttribute(arg));
+                return `${attr.fn}(${formattedArgs.join(', ')})`;
+            }
+            // Handle Literal class instance (has val property)
+            if (attr && typeof attr === 'object' && 'val' in attr) {
+                return attr.val;
+            }
+            // Handle Fn type: { fn: 'COUNT', args: [...] }
+            if (attr && typeof attr === 'object' && 'fn' in attr) {
+                const fn = attr;
+                const formattedArgs = fn.args.map((arg) => {
+                    // Handle Col class or object
+                    if (arg && typeof arg === 'object') {
+                        if (typeof arg.toSql === 'function') {
+                            return arg.toSql();
+                        }
+                        // Handle Col type object: { col: 'name' }
+                        if ('col' in arg) {
+                            return this.escapeId(arg.col);
+                        }
+                        // Handle Fn type (nested)
+                        if ('fn' in arg) {
+                            return formatSelectAttribute(arg);
+                        }
+                        // Handle Literal type object: { literal: 'sql' }
+                        if ('literal' in arg) {
+                            return arg.literal;
+                        }
+                    }
+                    // Handle string column names
+                    if (typeof arg === 'string') {
+                        // Check if it looks like a function call already
+                        if (arg.includes('(') && arg.includes(')')) {
+                            return arg;
+                        }
+                        return this.escapeId(arg);
+                    }
+                    // Handle literals
+                    return String(arg);
+                });
+                return `${fn.fn}(${formattedArgs.join(', ')})`;
+            }
+            // Handle Col type object: { col: 'name' }
+            if (attr && typeof attr === 'object' && 'col' in attr) {
+                return this.escapeId(attr.col);
+            }
+            // Handle Literal type object: { literal: 'sql' }
+            if (attr && typeof attr === 'object' && 'literal' in attr) {
+                return attr.literal;
+            }
+            // Handle string column names
+            if (typeof attr === 'string') {
+                return this.escapeId(attr);
+            }
+            // Fallback
+            return String(attr);
+        };
+        // Helper function to format an attribute with optional alias
+        // Handles [expression, alias] or [fn, alias] format
+        const formatAttributeWithAlias = (attr) => {
+            // Check if it's an array with alias [expression, alias]
+            if (Array.isArray(attr) && attr.length === 2) {
+                const [expr, alias] = attr;
+                return `${formatSelectAttribute(expr)} AS ${this.escapeId(alias)}`;
+            }
+            return formatSelectAttribute(attr);
+        };
+        // Build SELECT clause
+        let selectSql = '*';
+        if (options.attributes) {
+            if (Array.isArray(options.attributes)) {
+                selectSql = options.attributes.map((a) => formatAttributeWithAlias(a)).join(', ');
+            }
+            else if (options.attributes.include) {
+                selectSql = options.attributes.include.map((a) => this.escapeId(a)).join(', ');
+            }
+            else if (options.attributes.exclude) {
+                selectSql = `* EXCEPT (${options.attributes.exclude.map((a) => this.escapeId(a)).join(', ')})`;
+            }
+        }
+        // Handle DISTINCT (for COUNT(DISTINCT col))
+        let distinctClause = '';
+        if (options.distinct) {
+            if (options.col) {
+                distinctClause = `DISTINCT ${this.escapeId(options.col)} `;
+            }
+            else {
+                distinctClause = 'DISTINCT ';
+            }
+        }
+        let sql = `${withSql}SELECT ${distinctClause}${selectSql} FROM ${this.quoteTable(options.tableName, options.schema)}`;
+        // Build JOIN clause (for includes)
+        if (options.include && options.include.length > 0) {
+            for (const include of options.include) {
+                const joinType = include.required ? 'INNER JOIN' : 'LEFT JOIN';
+                const includeSchema = include.schema || include.model?.schema;
+                const includeTableName = include.model.tableName;
+                const tableName = includeTableName ? includeTableName : include.model.toString();
+                const alias = include.as || tableName;
+                sql += ` ${joinType} ${this.quoteTable(tableName, includeSchema)} ${this.escapeId(alias)}`;
+                if (include.where) {
+                    const whereClause = this.buildWhereClause(include.where);
+                    sql += ` ON ${whereClause.sql}`;
+                    queryValues.push(...whereClause.values);
+                }
+            }
+        }
+        // Build WHERE clause
+        if (options.where) {
+            const whereClause = this.buildWhereClause(options.where);
+            if (whereClause.sql) {
+                sql += ` WHERE ${whereClause.sql}`;
+                queryValues.push(...whereClause.values);
+            }
+        }
+        // Build GROUP BY clause
+        if (options.group) {
+            const groupByClause = this.buildGroupByClause(options.group);
+            if (groupByClause) {
+                sql += ` ${groupByClause}`;
+            }
+        }
+        // Build HAVING clause
+        if (options.having) {
+            const havingClause = this.buildHavingClause(options.having);
+            if (havingClause.sql) {
+                sql += ` HAVING ${havingClause.sql}`;
+                queryValues.push(...havingClause.values);
+            }
+        }
+        // Build ORDER BY clause
+        if (options.order) {
+            const orderClause = this.buildOrderClause(options.order);
+            if (orderClause) {
+                sql += ` ${orderClause}`;
+            }
+        }
+        // Build LIMIT/OFFSET clause
+        sql += this.buildLimitOffset(options.limit, options.offset);
+        // Build UNION clause if provided
+        if (options.union && options.union.length > 0) {
+            const unionType = options.unionType || 'UNION';
+            for (const unionQuery of options.union) {
+                const unionModel = unionQuery.model;
+                const unionTableName = unionModel.tableName || unionModel.name || '';
+                // Build the union query
+                let unionSql = `SELECT * FROM ${this.escapeId(unionTableName)}`;
+                // Add WHERE clause for union query
+                if (unionQuery.where) {
+                    const whereClause = this.buildWhereClause(unionQuery.where);
+                    if (whereClause.sql) {
+                        unionSql += ` WHERE ${whereClause.sql}`;
+                        queryValues.push(...whereClause.values);
+                    }
+                }
+                // Add ORDER BY for union query
+                if (unionQuery.order) {
+                    const orderClause = this.buildOrderClause(unionQuery.order);
+                    if (orderClause) {
+                        unionSql += ` ${orderClause}`;
+                    }
+                }
+                // Add LIMIT for union query
+                if (unionQuery.limit) {
+                    unionSql += ` LIMIT ${unionQuery.limit}`;
+                }
+                // Add OFFSET for union query
+                if (unionQuery.offset) {
+                    unionSql += ` OFFSET ${unionQuery.offset}`;
+                }
+                sql += ` ${unionType} ${unionSql}`;
+            }
+        }
+        return { sql, values: queryValues };
+    }
+    /**
+     * Recreate table without a column (for removeColumn)
+     */
+    async recreateTableWithoutColumn(tableName, columnName) {
+        const tableInfo = await this.describeTable(tableName);
+        const columns = Object.keys(tableInfo).filter((col) => col !== columnName);
+        // Preserve NOT NULL / DEFAULT / PRIMARY KEY / AUTOINCREMENT / UNIQUE constraints
+        // of the remaining columns during the rebuild (see recreateTableWithConstraint).
+        const columnsDef = columns.map((col) => this.getColumnDefinitionSql(col, this.toColumnDefinition(tableInfo[col])));
+        const tempTable = `${tableName}_temp`;
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} RENAME TO ${this.escapeId(tempTable)}`);
+        await this.query(`CREATE TABLE ${this.escapeId(tableName)} (${columnsDef.join(', ')})`);
+        await this.query(`INSERT INTO ${this.escapeId(tableName)} SELECT ${columns.map((c) => this.escapeId(c)).join(', ')} FROM ${this.escapeId(tempTable)}`);
+        await this.query(`DROP TABLE ${this.escapeId(tempTable)}`);
+    }
+    /**
+     * Recreate table to modify a column
+     */
+    async recreateTableModifyColumn(tableName, columnName, newDefinition) {
+        const tableInfo = await this.describeTable(tableName);
+        const columns = [];
+        for (const [colName, colInfo] of Object.entries(tableInfo)) {
+            if (colName === columnName) {
+                columns.push(this.getColumnDefinitionSql(colName, newDefinition));
+            }
+            else {
+                // Preserve NOT NULL / DEFAULT / PRIMARY KEY / AUTOINCREMENT / UNIQUE constraints
+                // of unaffected columns during the rebuild.
+                columns.push(this.getColumnDefinitionSql(colName, this.toColumnDefinition(colInfo)));
+            }
+        }
+        const tempTable = `${tableName}_temp`;
+        await this.query(`ALTER TABLE ${this.escapeId(tableName)} RENAME TO ${this.escapeId(tempTable)}`);
+        await this.query(`CREATE TABLE ${this.escapeId(tableName)} (${columns.join(', ')})`);
+        const colNames = Object.keys(tableInfo)
+            .map((c) => this.escapeId(c))
+            .join(', ');
+        await this.query(`INSERT INTO ${this.escapeId(tableName)} SELECT ${colNames} FROM ${this.escapeId(tempTable)}`);
+        await this.query(`DROP TABLE ${this.escapeId(tempTable)}`);
+    }
+    // ── User-management stubs (not supported by SQLite) ─────────────────────
+    buildCreateUserQuery(_username, _options) {
+        throw new Error('User management is not supported by SQLite');
+    }
+    buildAlterUserQuery(_username, _options) {
+        throw new Error('User management is not supported by SQLite');
+    }
+    buildDropUserQuery(_username, _options) {
+        throw new Error('User management is not supported by SQLite');
+    }
+    getUsersQuery() {
+        throw new Error('User management is not supported by SQLite');
+    }
+    buildGrantQuery(_options) {
+        throw new Error('GRANT is not supported by SQLite');
+    }
+    buildRevokeQuery(_options) {
+        throw new Error('REVOKE is not supported by SQLite');
+    }
+    buildShowGrantsQuery(_username, _host) {
+        throw new Error('SHOW GRANTS is not supported by SQLite');
+    }
+    buildFlushPrivilegesQuery() {
+        throw new Error('FLUSH PRIVILEGES is not supported by SQLite');
+    }
+    buildCreateRoleQuery(_roleName, _options) {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    buildDropRoleQuery(_roleName, _options) {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    buildGrantRoleQuery(_role, _to, _options) {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    buildRevokeRoleQuery(_role, _from, _options) {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    getRolesQuery() {
+        throw new Error('Role management is not supported by SQLite');
+    }
+    /**
+     * Bulk insert records into a table
+     */
+    async bulkInsert(tableName, records, _options) {
+        if (records.length === 0) {
+            return { rows: [], rowCount: 0, fields: [] };
+        }
+        const columns = Object.keys(records[0]);
+        const placeholders = records.map(() => `(${columns.map(() => '?').join(', ')})`);
+        const values = records.flatMap((record) => columns.map((col) => record[col]));
+        const sql = `INSERT INTO ${this.quoteTable(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES ${placeholders.join(', ')}`;
+        return this.query(sql, { replacements: values });
+    }
+    /**
+     * Update every row matching `where` with `values` in a single statement.
+     */
+    async bulkUpdate(tableName, values, where = {}) {
+        const cols = Object.keys(values);
+        if (cols.length === 0)
+            return undefined;
+        const setValues = [];
+        const setClause = cols
+            .map((c) => {
+            setValues.push(values[c]);
+            return `${this.escapeId(c)} = ?`;
+        })
+            .join(', ');
+        let sql = `UPDATE ${this.quoteTable(tableName)} SET ${setClause}`;
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql)
+            sql += ` WHERE ${whereClause.sql}`;
+        return this.query(sql, { replacements: [...setValues, ...whereClause.values] });
+    }
+    /**
+     * Delete every row matching `where` (deletes all rows when `where` is empty).
+     */
+    async bulkDelete(tableName, where = {}) {
+        let sql = `DELETE FROM ${this.quoteTable(tableName)}`;
+        const whereClause = this.buildWhereClause(where);
+        if (whereClause.sql)
+            sql += ` WHERE ${whereClause.sql}`;
+        return this.query(sql, { replacements: whereClause.values });
+    }
+    /**
+     * Add a foreign key to a table
+     * Note: SQLite does not support ALTER TABLE ADD CONSTRAINT.
+     * Foreign keys must be defined when the table is created.
+     */
+    async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, options) {
+        // SQLite has no ALTER TABLE ADD CONSTRAINT, so adding a foreign key to an
+        // existing table requires the documented 12-step table rebuild: recreate the
+        // table with the FK baked into its definition, copy the rows over, then swap.
+        let createSql;
+        try {
+            createSql = await this.getCreateTable(tableName);
+        }
+        catch {
+            throw new Error(`Cannot add foreign key: table "${tableName}" not found`);
+        }
+        if (!createSql) {
+            throw new Error(`Cannot add foreign key: table "${tableName}" not found`);
+        }
+        let fkClause = `FOREIGN KEY (${this.escapeId(columnName)}) REFERENCES ${this.quoteTable(referencedTableName)} (${this.escapeId(referencedColumnName)})`;
+        if (options?.onDelete)
+            fkClause += ` ON DELETE ${options.onDelete}`;
+        if (options?.onUpdate)
+            fkClause += ` ON UPDATE ${options.onUpdate}`;
+        // Insert the FK clause just before the closing paren of the CREATE TABLE body.
+        const lastParen = createSql.lastIndexOf(')');
+        const newCreateSql = createSql.slice(0, lastParen).trimEnd() + `,\n  ${fkClause}\n` + createSql.slice(lastParen);
+        const tmpName = `${tableName}__fk_rebuild`;
+        // Setter PRAGMAs don't return rows, so run them via exec() rather than query()
+        // (which would try stmt.all() and throw "statement does not return data").
+        this.connection?.exec('PRAGMA foreign_keys=OFF');
+        try {
+            await this.query(`ALTER TABLE ${this.quoteTable(tableName)} RENAME TO ${this.escapeId(tmpName)}`);
+            await this.query(newCreateSql);
+            await this.query(`INSERT INTO ${this.quoteTable(tableName)} SELECT * FROM ${this.escapeId(tmpName)}`);
+            await this.query(`DROP TABLE ${this.escapeId(tmpName)}`);
+        }
+        finally {
+            this.connection?.exec('PRAGMA foreign_keys=ON');
+        }
+    }
+    /**
+     * Rename a column
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        const sql = `ALTER TABLE ${this.quoteTable(tableName)} RENAME COLUMN ${this.escapeId(oldColumnName)} TO ${this.escapeId(newColumnName)}`;
+        await this.query(sql);
+    }
+    /**
+     * Create a fulltext index (SQLite supports FTS5)
+     */
+    async createFulltextIndex(_tableName, indexName, fields, _options) {
+        // SQLite uses FTS5 for fulltext search
+        const sql = `CREATE VIRTUAL TABLE ${this.escapeId(indexName)} USING fts5(${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        await this.query(sql);
+    }
+    /**
+     * Create a spatial index (SQLite supports spatial indexing via RTree)
+     */
+    async createSpatialIndex(_tableName, indexName, fields, _options) {
+        // SQLite uses RTree for spatial indexing
+        const sql = `CREATE VIRTUAL TABLE ${this.escapeId(indexName)} USING rtree(${fields.map((f) => this.escapeId(f)).join(', ')})`;
+        await this.query(sql);
+    }
+    /**
+     * Create user mapping (SQLite doesn't support user mappings)
+     */
+    async createUserMapping(_userName, _serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    /**
+     * Drop user mapping (SQLite doesn't support user mappings)
+     */
+    async dropUserMapping(_userName, _serverName, _options) {
+        throw new Error('Foreign Data Wrappers are not supported by SQLite. This is a PostgreSQL-specific feature.');
+    }
+    // ==================== Spatial Functions ====================
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * SQLite uses SpatiaLite extension or custom implementation
+     */
+    stDistance(geom1, geom2, _srid) {
+        // SQLite doesn't have built-in ST_Distance, use Haversine approximation for point coordinates
+        // For full spatial support, SpatiaLite extension is required
+        return `ST_Distance(${geom1}, ${geom2})`;
+    }
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     */
+    stDWithin(geom1, geom2, distance, _srid) {
+        return `ST_DWithin(${geom1}, ${geom2}, ${distance})`;
+    }
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     */
+    stWithin(geom1, geom2, _srid) {
+        return `ST_Within(${geom1}, ${geom2})`;
+    }
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     */
+    stContains(geom1, geom2, _srid) {
+        return `ST_Contains(${geom1}, ${geom2})`;
+    }
+    /**
+     * ST_Intersects - check if geometries intersect
+     */
+    stIntersects(geom1, geom2, _srid) {
+        return `ST_Intersects(${geom1}, ${geom2})`;
+    }
+    /**
+     * ST_AsText - convert geometry to text representation
+     */
+    stAsText(geom) {
+        return `ST_AsText(${geom})`;
+    }
+    /**
+     * ST_GeomFromText - create geometry from text
+     */
+    stGeomFromText(wkt, srid) {
+        return srid ? `ST_GeomFromText('${wkt}', ${srid})` : `ST_GeomFromText('${wkt}')`;
+    }
+    /**
+     * Build an expression to shred a JSON document/array into relational rows.
+     * SQLite has no `JSON_TABLE` function; its real equivalent is the `json_each`
+     * table-valued function, which yields fixed columns (key, value, type, atom, id,
+     * parent, fullkey, path). To project those into named/typed columns (matching the
+     * other dialects' JSON_TABLE/OPENJSON shape), this wraps json_each in a derived table
+     * that applies `json_extract` per requested column.
+     * SQLite: (SELECT json_extract(je.value, '$.path') AS name, ... FROM
+     *   json_each(expr, '$.rowPath') AS je) AS alias
+     */
+    buildJsonTable(jsonExpression, rowPath, columns, alias) {
+        const pathArg = rowPath && rowPath !== '$' ? `, '${rowPath}'` : '';
+        const selectCols = columns
+            .map((col) => {
+            if (col.forOrdinality) {
+                return `je."key" AS ${this.escapeId(col.name)}`;
+            }
+            return `json_extract(je.value, '${col.path}') AS ${this.escapeId(col.name)}`;
+        })
+            .join(', ');
+        return `(SELECT ${selectCols} FROM json_each(${jsonExpression}${pathArg}) AS je) AS ${this.escapeId(alias)}`;
+    }
+}
+exports.SQLiteDialect = SQLiteDialect;
+/**
+ * SQLite-specific transaction class
+ */
+class SQLiteTransaction {
+    constructor(connection, depth, options, 
+    // Owning dialect, used so commit()/rollback() called directly on the
+    // transaction object (rather than via dialect.commitTransaction/
+    // rollbackTransaction) still actually execute COMMIT/ROLLBACK/SAVEPOINT SQL.
+    // Previously these were no-ops that only flipped `finished`, leaving the
+    // underlying SQLite transaction open forever if a caller used this API.
+    dialect) {
+        this.connection = connection;
+        this.dialect = dialect;
+        this.finished = false;
+        this.parent = null;
+        this.savepoints = [];
+        // `depth` is the pre-increment transactionDepth at creation time (0 for
+        // the outermost transaction). The id itself is used verbatim as the
+        // SAVEPOINT name for nested transactions, so it must not also get a
+        // separate "sp_" prefix prepended at the call site (that produced
+        // "SAVEPOINT sp_sp_0_..." double-prefixed names that never matched what
+        // was actually created).
+        this.id = `sp_${depth}_${Date.now()}`;
+        this.isOuter = depth === 0;
+        this.options = options || {};
+    }
+    async commit() {
+        if (this.finished)
+            return;
+        if (this.dialect) {
+            await this.dialect.commitTransaction(this);
+        }
+        this.finished = true;
+    }
+    async rollback() {
+        if (this.finished)
+            return;
+        if (this.dialect) {
+            await this.dialect.rollbackTransaction(this);
+        }
+        this.finished = true;
+    }
+}
+exports.SQLiteTransaction = SQLiteTransaction;
+/**
+ * Create a new SQLite dialect instance
+ */
+function createSQLiteDialect(options) {
+    return new SQLiteDialect(options || {});
+}
+exports.default = SQLiteDialect;