ts-prorm-orm 1.1.0

package/dist/sqlite-advanced.js

@@ -0,0 +1,1047 @@
+"use strict";
+/**
+ * SQLite Advanced Features Module
+ *
+ * Comprehensive support for SQLite advanced features including:
+ * - Views (Standard and updatable)
+ * - Triggers (BEFORE/AFTER INSERT/UPDATE/DELETE, recursive triggers)
+ * - Foreign Tables (FTS5, carray, etc.)
+ * - Full-Text Search (FTS5) - MATCH, rank, highlighting
+ * - JSON JSON1 extension - JSON each, extract
+ * - Generated Columns - VIRTUAL, STORED
+ * - Indexes - Partial, UNIQUE, expression indexes
+ * - Window Functions - SQLite 3.25+ (ROW_NUMBER, etc.)
+ * - CTEs - WITH RECURSIVE
+ * - Common Table Expressions
+ * - VACUUM and ANALYZE - Optimization
+ * - Savepoints - Transaction management
+ * - UPSERT - INSERT ... ON CONFLICT
+ * - Table-valued Functions - json_each, fts5, etc.
+ * - Extensions - Loadable extensions
+ * - SQLite-specific Types - INTEGER PRIMARY KEY, affinity
+ * - Constraints - CHECK, UNIQUE, NOT NULL with ON CONFLICT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteAdvanced = void 0;
+exports.createSQLiteAdvanced = createSQLiteAdvanced;
+/**
+ * SQLite Advanced Features Class
+ * Provides comprehensive SQLite-specific features beyond standard SQL
+ */
+class SQLiteAdvanced {
+    constructor(dialect) {
+        this.dialect = dialect;
+        this.connection = dialect.getConnection();
+    }
+    // ============================================
+    // VIEW MANAGEMENT
+    // ============================================
+    /**
+     * Create a standard or updatable view
+     * SQLite views are read-only by default, but can be made updatable via INSTEAD OF triggers
+     */
+    async createView(viewName, query, options) {
+        let sql = 'CREATE ';
+        if (options?.temporary) {
+            sql += 'TEMPORARY ';
+        }
+        if (options?.replace) {
+            sql = 'CREATE OR REPLACE ';
+        }
+        sql += 'VIEW ';
+        if (options?.columns) {
+            sql += `${this.escapeId(viewName)} (${options.columns.join(', ')}) `;
+        }
+        else {
+            sql += `${this.escapeId(viewName)} `;
+        }
+        sql += `AS ${query}`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * Drop a view
+     */
+    async dropView(viewName, options) {
+        let sql = 'DROP VIEW';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        if (options?.cascade) {
+            sql += ' CASCADE';
+        }
+        sql += ` ${this.escapeId(viewName)}`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * List all views in the database
+     */
+    async listViews(schema) {
+        const sql = schema
+            ? "SELECT name FROM sqlite_master WHERE type='view' AND name NOT LIKE 'sqlite_%' AND name LIKE ?"
+            : "SELECT name FROM sqlite_master WHERE type='view' AND name NOT LIKE 'sqlite_%'";
+        const result = await this.dialect.query(sql, schema ? { replacements: [schema] } : undefined);
+        return result.rows.map((row) => row.name);
+    }
+    /**
+     * Get view definition
+     */
+    async getViewDefinition(viewName) {
+        const sql = "SELECT sql FROM sqlite_master WHERE type='view' AND name = ?";
+        const result = await this.dialect.query(sql, { replacements: [viewName] });
+        return result.rows[0]?.sql || null;
+    }
+    // ============================================
+    // TRIGGER MANAGEMENT
+    // ============================================
+    /**
+     * Create a trigger
+     */
+    async createTrigger(triggerName, timing, events, tableName, body, options) {
+        // SQLite does not support `CREATE OR REPLACE TRIGGER` (unlike MySQL/Postgres).
+        // Emulate "replace" semantics by dropping any existing trigger with the same
+        // name first, then creating the new one.
+        if (options?.replace) {
+            await this.dropTrigger(triggerName, { ifExists: true });
+        }
+        let sql = 'CREATE TRIGGER ';
+        sql += this.escapeId(triggerName);
+        sql += ` ${timing} ${(events || []).join(' OR ')} ON ${this.escapeId(tableName)}`;
+        if (options?.forEachRow) {
+            sql += ' FOR EACH ROW';
+        }
+        if (options?.whenCondition) {
+            sql += ` WHEN ${options.whenCondition}`;
+        }
+        sql += `\nBEGIN\n${body}\nEND`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * Create an AFTER INSERT trigger
+     */
+    async createAfterInsertTrigger(triggerName, tableName, body) {
+        await this.createTrigger(triggerName, 'AFTER', ['INSERT'], tableName, body, {
+            forEachRow: true,
+        });
+    }
+    /**
+     * Create an AFTER UPDATE trigger
+     */
+    async createAfterUpdateTrigger(triggerName, tableName, body, columns) {
+        const events = columns ? ['UPDATE OF ' + columns.join(', ')] : ['UPDATE'];
+        await this.createTrigger(triggerName, 'AFTER', events, tableName, body, {
+            forEachRow: true,
+        });
+    }
+    /**
+     * Create an AFTER DELETE trigger
+     */
+    async createAfterDeleteTrigger(triggerName, tableName, body) {
+        await this.createTrigger(triggerName, 'AFTER', ['DELETE'], tableName, body, {
+            forEachRow: true,
+        });
+    }
+    /**
+     * Create a BEFORE INSERT trigger
+     */
+    async createBeforeInsertTrigger(triggerName, tableName, body) {
+        await this.createTrigger(triggerName, 'BEFORE', ['INSERT'], tableName, body, {
+            forEachRow: true,
+        });
+    }
+    /**
+     * Create a BEFORE UPDATE trigger
+     */
+    async createBeforeUpdateTrigger(triggerName, tableName, body) {
+        await this.createTrigger(triggerName, 'BEFORE', ['UPDATE'], tableName, body, {
+            forEachRow: true,
+        });
+    }
+    /**
+     * Create an INSTEAD OF trigger (for views)
+     */
+    async createInsteadOfTrigger(triggerName, viewName, events, body) {
+        await this.createTrigger(triggerName, 'INSTEAD OF', events, viewName, body, {
+            forEachRow: true,
+        });
+    }
+    /**
+     * Create a recursive trigger
+     */
+    async createRecursiveTrigger(triggerName, tableName, insertBody, updateBody, deleteBody) {
+        // Create INSERT trigger
+        await this.createTrigger(`${triggerName}_insert`, 'AFTER', ['INSERT'], tableName, insertBody, {
+            forEachRow: true,
+        });
+        // Create UPDATE trigger
+        await this.createTrigger(`${triggerName}_update`, 'AFTER', ['UPDATE'], tableName, updateBody, {
+            forEachRow: true,
+        });
+        // Create DELETE trigger if provided
+        if (deleteBody) {
+            await this.createTrigger(`${triggerName}_delete`, 'AFTER', ['DELETE'], tableName, deleteBody, { forEachRow: true });
+        }
+    }
+    /**
+     * Drop a trigger
+     */
+    async dropTrigger(triggerName, options) {
+        let sql = 'DROP TRIGGER';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(triggerName)}`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * List all triggers
+     */
+    async listTriggers(tableName) {
+        const sql = tableName
+            ? "SELECT name FROM sqlite_master WHERE type='trigger' AND tbl_name = ?"
+            : "SELECT name FROM sqlite_master WHERE type='trigger' AND name NOT LIKE 'sqlite_%'";
+        const finalSql = tableName ? this.dialect.replaceReplacements(sql, [tableName]) : sql;
+        const result = await this.dialect.query(finalSql);
+        return result.rows.map((row) => row.name);
+    }
+    /**
+     * Get trigger definition
+     */
+    async getTriggerDefinition(triggerName) {
+        const sql = "SELECT sql FROM sqlite_master WHERE type='trigger' AND name = ?";
+        const result = await this.dialect.query(sql, { replacements: [triggerName] });
+        return result.rows[0]?.sql || null;
+    }
+    // ============================================
+    // FULL-TEXT SEARCH (FTS5)
+    // ============================================
+    /**
+     * Create an FTS5 virtual table for full-text search
+     */
+    async createFTS5Table(tableName, columns, options) {
+        const columnDefs = columns
+            .map((col) => {
+            let def = this.escapeId(col.name);
+            if (col.type) {
+                def += ` ${col.type}`;
+            }
+            if (col.notindexed) {
+                def += ' NOTINDEXED';
+            }
+            return def;
+        })
+            .join(', ');
+        let sql = `CREATE VIRTUAL TABLE ${this.escapeId(tableName)} USING fts5(${columnDefs}`;
+        if (options?.tokenizer) {
+            if (typeof options.tokenizer === 'string') {
+                sql += `, tokenize='${options.tokenizer}'`;
+            }
+            else {
+                const opts = options.tokenizer.options
+                    ? `, ${Object.entries(options.tokenizer.options)
+                        .map(([k, v]) => `${k}=${v}`)
+                        .join(', ')}`
+                    : '';
+                sql += `, tokenize='${options.tokenizer.name}${opts}'`;
+            }
+        }
+        if (options?.content) {
+            sql += `, content='${options.content}'`;
+        }
+        if (options?.contentRowId) {
+            sql += `, content_rowid='${options.contentRowId}'`;
+        }
+        if (options?.prefix) {
+            if (Array.isArray(options.prefix)) {
+                sql += `, prefix='${options.prefix.join(' ')}'`;
+            }
+            else {
+                sql += `, prefix='${options.prefix}'`;
+            }
+        }
+        sql += ')';
+        await this.dialect.query(sql);
+    }
+    /**
+     * Create FTS5 table with existing content table
+     */
+    async createFTS5FromTable(ftsTableName, sourceTable, sourceColumns, options) {
+        // Create FTS5 virtual table
+        await this.createFTS5Table(ftsTableName, sourceColumns.map((col) => ({ name: col })), options);
+        // Populate with data from source table
+        const columnsStr = sourceColumns.map((c) => this.escapeId(c)).join(', ');
+        const insertSql = `INSERT INTO ${this.escapeId(ftsTableName)} (${columnsStr}) SELECT ${columnsStr} FROM ${this.escapeId(sourceTable)}`;
+        await this.dialect.query(insertSql);
+        // Create triggers to keep FTS table in sync
+        await this.createTrigger(`${ftsTableName}_ai`, 'AFTER', ['INSERT'], sourceTable, `BEGIN\nINSERT INTO ${this.escapeId(ftsTableName)} (${columnsStr}) VALUES (new.${sourceColumns.join(', new.')});\nEND`);
+        await this.createTrigger(`${ftsTableName}_ad`, 'AFTER', ['DELETE'], sourceTable, `BEGIN\nDELETE FROM ${this.escapeId(ftsTableName)} WHERE rowid = old.rowid;\nEND`);
+        const setClauses = sourceColumns.map((col) => `${col} = new.${col}`).join(', ');
+        await this.createTrigger(`${ftsTableName}_au`, 'AFTER', ['UPDATE'], sourceTable, `BEGIN\nUPDATE ${this.escapeId(ftsTableName)} SET ${setClauses} WHERE rowid = old.rowid;\nEND`);
+    }
+    /**
+     * Drop an FTS5 table
+     */
+    async dropFTS5Table(tableName, options) {
+        let sql = 'DROP TABLE';
+        if (options?.ifExists) {
+            sql += ' IF EXISTS';
+        }
+        sql += ` ${this.escapeId(tableName)}`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * Perform full-text search
+     */
+    async fullTextSearch(ftsTable, searchQuery, options) {
+        let sql = 'SELECT';
+        if (options?.bm25) {
+            sql += ` bm25(${this.escapeId(ftsTable)}) AS score, `;
+        }
+        else {
+            sql += ' 0 AS score, ';
+        }
+        if (options?.highlight) {
+            const col = options.highlight.column || '*';
+            sql += ` highlight(${this.escapeId(ftsTable)}, ${options.columns?.indexOf(col) ?? 0}${options.highlight.before ? `, '${options.highlight.before}'` : ''}${options.highlight.after ? `, '${options.highlight.after}'` : ''}) AS highlighted, `;
+        }
+        sql += options?.columns?.map((c) => this.escapeId(c)).join(', ') || '*';
+        sql += ` FROM ${this.escapeId(ftsTable)}`;
+        sql += ` WHERE ${this.escapeId(ftsTable)} MATCH ?`;
+        if (options?.orderBy) {
+            sql += ` ORDER BY ${options.orderBy.map((o) => `${this.escapeId(o.column)}${o.desc ? ' DESC' : ''}`).join(', ')}`;
+        }
+        if (options?.limit) {
+            sql += ` LIMIT ${options.limit}`;
+        }
+        if (options?.offset) {
+            sql += ` OFFSET ${options.offset}`;
+        }
+        return this.dialect.query(sql, { replacements: [searchQuery] });
+    }
+    /**
+     * Rebuild FTS5 index
+     */
+    async rebuildFTS5(tableName) {
+        await this.dialect.query(`INSERT INTO ${this.escapeId(tableName)}(${this.escapeId(tableName)}) VALUES('rebuild')`);
+    }
+    /**
+     * Optimize FTS5 index
+     */
+    async optimizeFTS5(tableName) {
+        await this.dialect.query(`INSERT INTO ${this.escapeId(tableName)}(${this.escapeId(tableName)}) VALUES('optimize')`);
+    }
+    // ============================================
+    // JSON JSON1 EXTENSION
+    // ============================================
+    /**
+     * Parse JSON string
+     */
+    parseJson(jsonString) {
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extract value from JSON
+     */
+    jsonExtract(jsonColumn, path) {
+        return `json_extract(${jsonColumn}, '${this.escapePathLiteral(path)}')`;
+    }
+    /**
+     * Set value in JSON
+     */
+    jsonSet(jsonColumn, path, value) {
+        return `json_set(${jsonColumn}, '${this.escapePathLiteral(path)}', ${this.escape(value)})`;
+    }
+    /**
+     * Insert into JSON array
+     */
+    jsonArrayAppend(jsonColumn, path, value) {
+        return `json_array_append(${jsonColumn}, '${this.escapePathLiteral(path)}', ${this.escape(value)})`;
+    }
+    /**
+     * Remove from JSON
+     */
+    jsonRemove(jsonColumn, path) {
+        return `json_remove(${jsonColumn}, '${this.escapePathLiteral(path)}')`;
+    }
+    /**
+     * Get JSON array length
+     */
+    jsonArrayLength(jsonColumn, path) {
+        return path
+            ? `json_array_length(${jsonColumn}, '${this.escapePathLiteral(path)}')`
+            : `json_array_length(${jsonColumn})`;
+    }
+    /**
+     * Check if JSON contains value
+     *
+     * Note: SQLite's JSON1 extension has no `json_contains` function (that name is
+     * MySQL-specific); calling this would fail at runtime with "no such function:
+     * json_contains". Emulate it with json_extract() equality instead.
+     */
+    jsonContains(jsonColumn, value, path) {
+        const target = path ? `json_extract(${jsonColumn}, '${this.escapePathLiteral(path)}')` : jsonColumn;
+        return `${target} = ${this.escape(typeof value === 'string' ? value : JSON.stringify(value))}`;
+    }
+    /**
+     * Query JSON array as table
+     */
+    jsonEach(jsonColumn, path) {
+        return path ? `json_each(${jsonColumn}, '${this.escapePathLiteral(path)}')` : `json_each(${jsonColumn})`;
+    }
+    /**
+     * Query JSON object as table
+     */
+    jsonTree(jsonColumn, path) {
+        return path ? `json_tree(${jsonColumn}, '${this.escapePathLiteral(path)}')` : `json_tree(${jsonColumn})`;
+    }
+    /**
+     * Get JSON type
+     */
+    jsonType(jsonColumn, path) {
+        return path ? `json_type(${jsonColumn}, '${this.escapePathLiteral(path)}')` : `json_type(${jsonColumn})`;
+    }
+    /**
+     * Valid JSON check
+     */
+    jsonValid(jsonColumn) {
+        return `json_valid(${jsonColumn})`;
+    }
+    /**
+     * Query using json_each (table-valued function)
+     */
+    async jsonEachQuery(jsonColumn, path, options) {
+        const tableRef = path ? `json_each(${jsonColumn}, '${path}')` : `json_each(${jsonColumn})`;
+        let sql = `SELECT * FROM ${tableRef}`;
+        if (options?.key || options?.value || options?.type) {
+            const cols = [];
+            if (options?.key)
+                cols.push(`key AS ${options.key}`);
+            if (options?.value)
+                cols.push(`value AS ${options.value}`);
+            if (options?.type)
+                cols.push(`type AS ${options.type}`);
+            if (options?.id)
+                cols.push(`id AS ${options.id}`);
+            if (options?.parent)
+                cols.push(`parent AS ${options.parent}`);
+            sql = `SELECT ${cols.join(', ')} FROM ${tableRef}`;
+        }
+        return this.dialect.query(sql);
+    }
+    // ============================================
+    // GENERATED COLUMNS
+    // ============================================
+    /**
+     * Create table with generated columns
+     */
+    createTableWithGeneratedColumns(tableName, columns) {
+        const columnDefs = columns
+            .map((col) => {
+            let def = `${this.escapeId(col.name)} ${col.type}`;
+            if (col.primaryKey) {
+                def += ' PRIMARY KEY';
+            }
+            if (col.notNull && !col.generated) {
+                def += ' NOT NULL';
+            }
+            if (col.defaultValue !== undefined && !col.generated) {
+                def += ` DEFAULT ${this.escape(col.defaultValue)}`;
+            }
+            if (col.generated) {
+                def += ` GENERATED ALWAYS AS (${col.generated.expression}) ${col.generated.type}`;
+            }
+            return def;
+        })
+            .join(', ');
+        return `CREATE TABLE ${this.escapeId(tableName)} (${columnDefs})`;
+    }
+    /**
+     * Create a VIRTUAL generated column
+     */
+    createVirtualColumn(name, type, expression) {
+        return `${this.escapeId(name)} ${type} GENERATED ALWAYS AS (${expression}) VIRTUAL`;
+    }
+    /**
+     * Create a STORED generated column
+     */
+    createStoredColumn(name, type, expression) {
+        return `${this.escapeId(name)} ${type} GENERATED ALWAYS AS (${expression}) STORED`;
+    }
+    // ============================================
+    // INDEXES - ADVANCED
+    // ============================================
+    /**
+     * Create a UNIQUE index
+     */
+    async createUniqueIndex(tableName, indexName, columns) {
+        const sql = `CREATE UNIQUE INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')})`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * Create a partial index (with WHERE clause)
+     */
+    async createPartialIndex(tableName, indexName, columns, whereCondition) {
+        const sql = `CREATE INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) WHERE ${whereCondition}`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * Create an expression index
+     */
+    async createExpressionIndex(tableName, indexName, expression) {
+        const sql = `CREATE INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${expression})`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * Create an index with IF NOT EXISTS
+     */
+    async createIndexIfNotExists(tableName, indexName, columns, options) {
+        const sql = `CREATE INDEX IF NOT EXISTS ${this.escapeId(indexName)} ON ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')})${options?.where ? ` WHERE ${options.where}` : ''}`;
+        await this.dialect.query(sql);
+    }
+    /**
+     * List all indexes for a table
+     */
+    async listIndexes(tableName) {
+        const sql = `SELECT name, sql FROM sqlite_master WHERE type='index' AND tbl_name=? AND name NOT LIKE 'sqlite_%'`;
+        const result = await this.dialect.query(sql, { replacements: [tableName] });
+        return result.rows.map((row) => ({
+            name: row.name,
+            unique: row.sql?.toUpperCase().includes('UNIQUE') || false,
+            partial: row.sql?.includes('WHERE') || false,
+        }));
+    }
+    /**
+     * Reindex a table or database
+     */
+    async reindex(target) {
+        const sql = target ? `REINDEX ${this.escapeId(target)}` : 'REINDEX';
+        await this.dialect.query(sql);
+    }
+    // ============================================
+    // WINDOW FUNCTIONS
+    // ============================================
+    /**
+     * Build a window function query
+     */
+    buildWindowFunction(functionName, options) {
+        let sql = functionName;
+        if (options?.distinct) {
+            sql = `DISTINCT ${sql}`;
+        }
+        if (options?.filter) {
+            sql += ` FILTER (WHERE ${options.filter})`;
+        }
+        if (options?.over) {
+            sql += ' OVER (';
+            if (options.over.partitionBy?.length) {
+                sql += `PARTITION BY ${options.over.partitionBy.map((c) => this.escapeId(c)).join(', ')}`;
+            }
+            if (options.over.orderBy?.length) {
+                if (options.over.partitionBy?.length)
+                    sql += ' ';
+                sql += `ORDER BY ${options.over.orderBy.map((o) => `${this.escapeId(o.column)}${o.desc ? ' DESC' : ''}`).join(', ')}`;
+            }
+            if (options.over.frame) {
+                const frame = options.over.frame;
+                const rows = options.over.rows;
+                const range = options.over.range;
+                sql += ` ${frame} BETWEEN `;
+                if (rows?.start !== undefined) {
+                    sql += rows.start < 0 ? `CURRENT ROW + ${rows.start}` : `${rows.start}`;
+                }
+                else if (range?.start !== undefined) {
+                    sql += range.start < 0 ? `CURRENT ROW + ${range.start}` : `${range.start}`;
+                }
+                else {
+                    sql += 'UNBOUNDED PRECEDING';
+                }
+                sql += ' AND ';
+                if (rows?.end !== undefined) {
+                    sql += rows.end < 0 ? `CURRENT ROW + ${rows.end}` : `${rows.end}`;
+                }
+                else if (range?.end !== undefined) {
+                    sql += range.end < 0 ? `CURRENT ROW + ${range.end}` : `${range.end}`;
+                }
+                else {
+                    sql += 'UNBOUNDED FOLLOWING';
+                }
+            }
+            sql += ')';
+        }
+        return sql;
+    }
+    /**
+     * ROW_NUMBER() window function
+     */
+    rowNumber(options) {
+        return this.buildWindowFunction('ROW_NUMBER()', { over: options });
+    }
+    /**
+     * RANK() window function
+     */
+    rank(options) {
+        return this.buildWindowFunction('RANK()', { over: options });
+    }
+    /**
+     * DENSE_RANK() window function
+     */
+    denseRank(options) {
+        return this.buildWindowFunction('DENSE_RANK()', { over: options });
+    }
+    /**
+     * NTILE(n) window function
+     */
+    ntile(n, options) {
+        return this.buildWindowFunction(`NTILE(${n})`, { over: options });
+    }
+    /**
+     * LAG() window function
+     */
+    lag(column, offset, defaultValue) {
+        const func = `LAG(${this.escapeId(column)}${offset ? `, ${offset}` : ''}${defaultValue !== undefined ? `, ${this.escape(defaultValue)}` : ''})`;
+        return this.buildWindowFunction(func);
+    }
+    /**
+     * LEAD() window function
+     */
+    lead(column, offset, defaultValue) {
+        const func = `LEAD(${this.escapeId(column)}${offset ? `, ${offset}` : ''}${defaultValue !== undefined ? `, ${this.escape(defaultValue)}` : ''})`;
+        return this.buildWindowFunction(func);
+    }
+    /**
+     * FIRST_VALUE() window function
+     */
+    firstValue(column) {
+        return this.buildWindowFunction(`FIRST_VALUE(${this.escapeId(column)})`);
+    }
+    /**
+     * LAST_VALUE() window function
+     */
+    lastValue(column) {
+        return this.buildWindowFunction(`LAST_VALUE(${this.escapeId(column)})`);
+    }
+    /**
+     * NTH_VALUE() window function
+     */
+    nthValue(column, n) {
+        return this.buildWindowFunction(`NTH_VALUE(${this.escapeId(column)}, ${n})`);
+    }
+    // ============================================
+    // COMMON TABLE EXPRESSIONS (CTEs)
+    // ============================================
+    /**
+     * Build a CTE query
+     */
+    buildCTE(cteName, columns, query, recursive) {
+        const cols = columns.length ? `(${columns.join(', ')})` : '';
+        return `WITH ${recursive ? 'RECURSIVE ' : ''}${this.escapeId(cteName)}${cols} AS (${query})`;
+    }
+    /**
+     * Build multiple CTEs
+     */
+    buildMultipleCTEs(ctes, mainQuery, recursive) {
+        const cteSqlParts = [];
+        for (const cte of ctes) {
+            const cols = cte.columns?.length ? `(${cte.columns.join(', ')})` : '';
+            const escapedName = this.escapeId(cte.name);
+            cteSqlParts.push(`${escapedName}${cols} AS (${cte.query})`);
+        }
+        const cteSql = cteSqlParts.join(', ');
+        const withPrefix = recursive ? 'WITH RECURSIVE ' : 'WITH ';
+        return `${withPrefix}${cteSql} ${mainQuery}`;
+    }
+    /**
+     * Execute a recursive CTE query
+     */
+    async executeRecursiveCTE(cteName, baseQuery, recursiveQuery, finalQuery) {
+        const sql = `WITH RECURSIVE ${this.escapeId(cteName)} AS (${baseQuery} UNION ALL ${recursiveQuery}) ${finalQuery}`;
+        return this.dialect.query(sql);
+    }
+    /**
+     * Recursive CTE example: Generate sequence
+     */
+    generateSequence(start, end) {
+        return `WITH RECURSIVE cnt(x) AS (
+      SELECT ${start}
+      UNION ALL
+      SELECT x + 1 FROM cnt WHERE x < ${end}
+    ) SELECT x FROM cnt`;
+    }
+    // ============================================
+    // VACUUM AND ANALYZE
+    // ============================================
+    /**
+     * VACUUM the database
+     * Reclaims disk space and defragments the database
+     */
+    async vacuum(options) {
+        let sql = 'VACUUM';
+        if (options?.schema) {
+            sql += ` ${options.schema}`;
+        }
+        if (options?.shrinkTo !== undefined) {
+            sql += ` INTO 'shrink_${options.shrinkTo}.db'`;
+        }
+        await this.dialect.query(sql);
+        if (options?.analyze) {
+            await this.analyze();
+        }
+    }
+    /**
+     * ANALYZE the database
+     * Updates statistics for the query optimizer
+     */
+    async analyze(target) {
+        const sql = target ? `ANALYZE ${this.escapeId(target)}` : 'ANALYZE';
+        await this.dialect.query(sql);
+    }
+    /**
+     * ANALYZE with detailed information
+     */
+    async analyzeDetailed(tableName) {
+        const sql = tableName ? `ANALYZE ${this.escapeId(tableName)}` : 'ANALYZE';
+        await this.dialect.query(sql);
+        if (tableName) {
+            const statSql = this.dialect.replaceReplacements(`SELECT * FROM sqlite_stat1 WHERE tbl = ?`, [tableName]);
+            return this.dialect.query(statSql);
+        }
+        return this.dialect.query(`SELECT * FROM sqlite_stat1`);
+    }
+    /**
+     * Get table statistics
+     */
+    async getTableStats(tableName) {
+        const sql = `SELECT * FROM sqlite_stat1 WHERE tbl = ?`;
+        const finalSql = this.dialect.replaceReplacements(sql, [tableName]);
+        return this.dialect.query(finalSql);
+    }
+    /**
+     * Get index statistics
+     */
+    async getIndexStats(indexName) {
+        const sql = `SELECT * FROM sqlite_stat1 WHERE idx = ?`;
+        const finalSql = this.dialect.replaceReplacements(sql, [indexName]);
+        return this.dialect.query(finalSql);
+    }
+    // ============================================
+    // SAVEPOINTS AND TRANSACTION MANAGEMENT
+    // ============================================
+    /**
+     * Create a savepoint
+     */
+    async savepoint(savepointName) {
+        await this.dialect.query(`SAVEPOINT ${this.escapeId(savepointName)}`);
+    }
+    /**
+     * Release a savepoint
+     */
+    async releaseSavepoint(savepointName) {
+        await this.dialect.query(`RELEASE SAVEPOINT ${this.escapeId(savepointName)}`);
+    }
+    /**
+     * Rollback to a savepoint
+     */
+    async rollbackToSavepoint(savepointName) {
+        await this.dialect.query(`ROLLBACK TO SAVEPOINT ${this.escapeId(savepointName)}`);
+    }
+    /**
+     * Execute within a savepoint
+     */
+    async withSavepoint(savepointName, fn) {
+        try {
+            await this.savepoint(savepointName);
+            return await fn();
+        }
+        catch (error) {
+            await this.rollbackToSavepoint(savepointName);
+            throw error;
+        }
+        finally {
+            try {
+                await this.releaseSavepoint(savepointName);
+            }
+            catch {
+                // Ignore release errors
+            }
+        }
+    }
+    // ============================================
+    // UPSERT (INSERT ON CONFLICT)
+    // ============================================
+    /**
+     * Build an UPSERT query
+     */
+    buildUpsertQuery(tableName, columns, conflictColumns, updateColumns, options) {
+        if (options?.ignore) {
+            const sql = `INSERT OR IGNORE INTO ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`;
+            return sql;
+        }
+        if (options?.replace) {
+            const sql = `INSERT OR REPLACE INTO ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`;
+            return sql;
+        }
+        const conflictCols = conflictColumns.map((c) => this.escapeId(c)).join(', ');
+        const setClause = (updateColumns || columns.filter((c) => !conflictColumns.includes(c)))
+            .map((c) => `${this.escapeId(c)} = excluded.${this.escapeId(c)}`)
+            .join(', ');
+        return `INSERT INTO ${this.escapeId(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES (${columns.map(() => '?').join(', ')}) ON CONFLICT (${conflictCols}) DO UPDATE SET ${setClause}`;
+    }
+    /**
+     * Perform an upsert
+     */
+    async upsert(tableName, values, conflictColumns, updateColumns) {
+        const columns = Object.keys(values);
+        const sql = this.buildUpsertQuery(tableName, columns, conflictColumns, updateColumns);
+        const finalSql = this.dialect.replaceReplacements(sql, Object.values(values));
+        return this.dialect.query(finalSql);
+    }
+    // ============================================
+    // TABLE-VALUED FUNCTIONS
+    // ============================================
+    /**
+     * Use json_each as table-valued function
+     */
+    async jsonEachAsTable(jsonColumn, path) {
+        const tableRef = path ? `json_each(${jsonColumn}, '${path}')` : `json_each(${jsonColumn})`;
+        return this.dialect.query(`SELECT * FROM ${tableRef}`);
+    }
+    /**
+     * Use json_tree as table-valued function
+     */
+    async jsonTreeAsTable(jsonColumn, path) {
+        const tableRef = path ? `json_tree(${jsonColumn}, '${path}')` : `json_tree(${jsonColumn})`;
+        return this.dialect.query(`SELECT * FROM ${tableRef}`);
+    }
+    /**
+     * Generate series using recursive CTE
+     */
+    async generateSeries(start, end, step) {
+        const stepStr = step ? `, ${step}` : '';
+        return this.dialect.query(`WITH RECURSIVE range(x) AS (SELECT ${start} UNION ALL SELECT x + ${step || 1} FROM range WHERE x < ${end}) SELECT x FROM range`);
+    }
+    /**
+     * Use fts5 as table-valued function
+     */
+    async fts5Search(ftsTable, query) {
+        const sql = `SELECT * FROM ${this.escapeId(ftsTable)} WHERE ${this.escapeId(ftsTable)} MATCH ?`;
+        const finalSql = this.dialect.replaceReplacements(sql, [query]);
+        return this.dialect.query(finalSql);
+    }
+    // ============================================
+    // EXTENSIONS
+    // ============================================
+    /**
+     * Load a SQLite extension
+     */
+    loadExtension(extensionPath) {
+        // Note: entryPoint parameter may not be supported by all extensions
+        this.connection.loadExtension(extensionPath);
+    }
+    /**
+     * Enable/disable extension loading
+     */
+    setExtensionLoading(enabled) {
+        this.connection.pragma(`enable_load_extension = ${enabled ? 1 : 0}`);
+    }
+    /**
+     * Get list of loaded extensions
+     */
+    getLoadedExtensions() {
+        const stmt = this.connection.prepare('SELECT * FROM pragma_compile_options WHERE compile_options LIKE "%ENABLE%"');
+        const rows = stmt.all();
+        return rows.map((row) => row.compile_options);
+    }
+    // ============================================
+    // SQLITE-SPECIFIC TYPES
+    // ============================================
+    /**
+     * Create INTEGER PRIMARY KEY column definition
+     */
+    createIntegerPrimaryKey(columnName, autoIncrement) {
+        return autoIncrement
+            ? `${this.escapeId(columnName)} INTEGER PRIMARY KEY AUTOINCREMENT`
+            : `${this.escapeId(columnName)} INTEGER PRIMARY KEY`;
+    }
+    /**
+     * Create column with specific affinity
+     */
+    createColumnWithAffinity(columnName, affinity) {
+        return `${this.escapeId(columnName)} ${affinity}`;
+    }
+    /**
+     * Get column affinity
+     */
+    getColumnAffinity(type) {
+        const upperType = type.toUpperCase();
+        if (upperType.includes('INT'))
+            return 'INTEGER';
+        if (upperType.includes('REAL') || upperType.includes('DOUBLE') || upperType.includes('FLOAT'))
+            return 'REAL';
+        if (upperType.includes('BLOB'))
+            return 'BLOB';
+        if (upperType.includes('CHAR') || upperType.includes('CLOB') || upperType.includes('TEXT'))
+            return 'TEXT';
+        return 'NUMERIC';
+    }
+    // ============================================
+    // CONSTRAINTS WITH ON CONFLICT
+    // ============================================
+    /**
+     * Create CHECK constraint
+     */
+    createCheckConstraint(columnName, condition) {
+        return `CHECK (${columnName} ${condition})`;
+    }
+    /**
+     * Create table with ON CONFLICT clause
+     */
+    createTableWithOnConflict(tableName, columns, conflictAlgorithm) {
+        const columnDefs = columns
+            .map((col) => {
+            let def = `${this.escapeId(col.name)} ${col.type}`;
+            if (col.constraints?.length) {
+                def += ` ${col.constraints.join(', ')}`;
+            }
+            return def;
+        })
+            .join(', ');
+        let sql = `CREATE TABLE ${this.escapeId(tableName)} (${columnDefs})`;
+        if (conflictAlgorithm) {
+            sql += ` ON CONFLICT ${conflictAlgorithm}`;
+        }
+        return sql;
+    }
+    /**
+     * Add ON CONFLICT to column definition
+     */
+    addOnConflictClause(constraint, conflictAlgorithm) {
+        return `${constraint} ON CONFLICT ${conflictAlgorithm}`;
+    }
+    /**
+     * Create UNIQUE constraint
+     */
+    createUniqueConstraint(columns) {
+        return `UNIQUE (${columns.map((c) => this.escapeId(c)).join(', ')})`;
+    }
+    /**
+     * Create NOT NULL constraint with ON CONFLICT
+     */
+    createNotNullConstraint(columnName, conflictAlgorithm) {
+        return conflictAlgorithm ? `NOT NULL ON CONFLICT ${conflictAlgorithm}` : 'NOT NULL';
+    }
+    // ============================================
+    // PRAGMA COMMANDS
+    // ============================================
+    /**
+     * Execute a PRAGMA command
+     */
+    async pragma(pragmaName, value) {
+        const sql = value !== undefined ? `PRAGMA ${pragmaName} = ${value}` : `PRAGMA ${pragmaName}`;
+        return this.dialect.query(sql);
+    }
+    /**
+     * Get database info
+     */
+    async getDatabaseInfo() {
+        const result = await Promise.all([
+            this.pragma('schema_version'),
+            this.pragma('user_version'),
+            this.pragma('foreign_keys'),
+            this.pragma('journal_mode'),
+            this.pragma('synchronous'),
+            this.pragma('cache_size'),
+            this.pragma('page_size'),
+        ]);
+        return {
+            schemaVersion: result[0].rows[0]?.schema_version,
+            userVersion: result[1].rows[0]?.user_version,
+            foreignKeys: result[2].rows[0]?.foreign_keys === 1,
+            journalingMode: result[3].rows[0]?.journal_mode,
+            synchronous: result[4].rows[0]?.synchronous,
+            cacheSize: result[5].rows[0]?.cache_size,
+            pageSize: result[6].rows[0]?.page_size,
+        };
+    }
+    /**
+     * Set database options
+     */
+    async setDatabaseOptions(options) {
+        if (options.foreignKeys !== undefined) {
+            await this.pragma('foreign_keys', options.foreignKeys ? 1 : 0);
+        }
+        if (options.journalingMode) {
+            await this.pragma('journal_mode', options.journalingMode);
+        }
+        if (options.synchronous) {
+            await this.pragma('synchronous', options.synchronous);
+        }
+        if (options.cacheSize !== undefined) {
+            await this.pragma('cache_size', options.cacheSize);
+        }
+    }
+    /**
+     * Get table info using PRAGMA
+     */
+    async getTableInfo(tableName) {
+        // Note: PRAGMA table_info(x) takes its argument in parentheses, not as
+        // part of the pragma name - this.pragma() only builds `PRAGMA name` /
+        // `PRAGMA name = value`, so it's built directly here instead.
+        return this.dialect.query(`PRAGMA table_info(${this.escapeId(tableName)})`);
+    }
+    /**
+     * Get index list for table
+     */
+    async getIndexList(tableName) {
+        return this.dialect.query(`PRAGMA index_list(${this.escapeId(tableName)})`);
+    }
+    /**
+     * Get foreign key list for table
+     */
+    async getForeignKeyList(tableName) {
+        return this.dialect.query(`PRAGMA foreign_key_list(${this.escapeId(tableName)})`);
+    }
+    // ============================================
+    // UTILITY METHODS
+    // ============================================
+    /**
+     * Escape identifier
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+    /**
+     * Escape a JSON path (or any other value) for safe interpolation inside a
+     * single-quoted SQL string literal, by doubling embedded single quotes.
+     */
+    escapePathLiteral(value) {
+        return value.replace(/'/g, "''");
+    }
+    /**
+     * Escape value
+     */
+    escape(value) {
+        if (value === null)
+            return 'NULL';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'boolean')
+            return value ? '1' : '0';
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, "''")}'`;
+        if (value instanceof Date)
+            return `'${value.toISOString()}'`;
+        return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+    }
+}
+exports.SQLiteAdvanced = SQLiteAdvanced;
+/**
+ * Create SQLiteAdvanced instance from dialect
+ */
+function createSQLiteAdvanced(dialect) {
+    return new SQLiteAdvanced(dialect);
+}