ts-prorm-orm 1.1.0 → 1.2.1

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

@@ -0,0 +1,1133 @@
+/**
+ * SQLite dialect implementation
+ */
+import type Database from 'better-sqlite3';
+import { Dialect, DialectOptions, ColumnDefinition, TableOptions, DropTableOptions, TableDescription, IndexOptions, InsertOptions, UpdateOptions as DUpdateOptions, DeleteOptions, SelectOptions, UpsertQueryOptions, CreateExtensionOptions, DropExtensionOptions, ExtensionInfo, MaterializedViewOptions, RefreshOptions, DropMaterializedViewOptions, FdwForeignServerOptions, FdwAlterForeignServerOptions, FdwUserMappingOptions, FdwForeignTableOptions, FdwImportForeignSchemaOptions, CTEOption } from '../dialect';
+import { Transaction, TransactionOptions, QueryResult, QueryOptions, DataType, WhereOptions, Order, CreatePartitionOptions, AttachPartitionOptions, DetachPartitionOptions, StoredProcedureOptions, DropStoredProcedureOptions, ExecuteStoredProcedureOptions, SequenceOptions, DropSequenceOptions, PolicyOptions, DropPolicyOptions, StreamOptions } from '../../types';
+import { Readable } from 'stream';
+import { SQLiteAdvanced } from '../../sqlite-advanced';
+/**
+ * A single `ON CONFLICT (...) DO ...` target for multi-target upserts. SQLite
+ * allows chaining several of these in one INSERT, each naming a different
+ * PRIMARY KEY/UNIQUE constraint, evaluated in order until one matches.
+ */
+export interface ConflictTarget {
+    /** Columns identifying the PRIMARY KEY/UNIQUE constraint to match. */
+    fields: string[];
+    /** Action to take when this target's constraint is violated. Defaults to 'DO UPDATE'. */
+    action?: 'DO NOTHING' | 'DO UPDATE';
+    /** Columns to update (defaults to all inserted columns) when action is 'DO UPDATE'. */
+    updateColumns?: string[];
+    /** Optional raw SQL WHERE clause restricting when the DO UPDATE applies. */
+    where?: string;
+}
+/**
+ * SQLite dialect class that implements the Dialect interface
+ */
+export declare class SQLiteDialect implements Dialect {
+    readonly name: string;
+    readonly library: string;
+    private connection;
+    private _isConnected;
+    private config;
+    private transactionDepth;
+    private _advanced;
+    constructor(config: SQLiteDialectOptions);
+    /**
+     * Connect to the SQLite database
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the SQLite database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get the current database connection
+     */
+    getConnection(): any;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get SQLite advanced features instance
+     */
+    get advanced(): SQLiteAdvanced;
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     */
+    replaceReplacements(sql: string, replacements?: Record<string, unknown> | unknown[]): string;
+    /**
+     * Execute a raw SQL query with retry support
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * 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: string, options?: StreamOptions): Readable;
+    /**
+     * Execute a function with retry logic for query execution
+     */
+    private executeWithRetry;
+    /**
+     * Escape a value for use in a query
+     */
+    escape(value: unknown): string;
+    /**
+     * Build a JSON extraction query for SQLite
+     * SQLite: json_extract(column, '$.path')
+     */
+    buildJsonExtract(column: string, path: string, asText?: boolean): string;
+    /**
+     * Build a JSON contains query for SQLite
+     * SQLite: uses json_each and json_extract for containment checks
+     */
+    buildJsonContains(column: string, value: unknown, path?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a JSON has key query for SQLite
+     * SQLite: json_each or json_extract for key existence
+     */
+    buildJsonHasKey(column: string, key: string, type?: 'one' | 'all'): string;
+    /**
+     * Build a JSON path query for SQLite
+     */
+    buildJsonPathQuery(column: string, path: string, value?: unknown, operator?: string): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * 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: string, options?: {
+        distinct?: boolean;
+    }): string;
+    /**
+     * 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: string, valueExpr: string): string;
+    /**
+     * 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.
+     */
+    private escapeAggregateExpr;
+    /**
+     * 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: string, patch: unknown): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Escape a string for SQL
+     */
+    private escapeString;
+    /**
+     * Escape an identifier (table name, column name, etc.)
+     */
+    escapeId(identifier: unknown): string;
+    /**
+     * Quote an identifier (column name, table name)
+     * Same as escapeId for SQLite
+     */
+    quoteIdentifier(identifier: string): string;
+    /**
+     * Quote a table name
+     * Same as escapeId for SQLite
+     * If schema is provided, returns schema.tableName (SQLite treats schemas as prefixes)
+     */
+    quoteTable(tableName: string, schema?: string): string;
+    /**
+     * Get the database version
+     */
+    getDatabaseVersion(): Promise<string>;
+    /**
+     * Generate SQL for creating a database
+     * SQLite uses ATTACH DATABASE for creating new database files
+     */
+    createDatabaseSQL(options: {
+        name: string;
+        encoding?: string;
+        lcCollate?: string;
+        lcCtype?: string;
+        template?: string;
+        tablespace?: string;
+        collate?: string;
+        isTemplate?: boolean;
+    }): string;
+    /**
+     * Generate SQL for dropping a database
+     * SQLite uses DETACH DATABASE for dropping database files
+     */
+    dropDatabaseSQL(name: string): string;
+    /**
+     * 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`)
+     */
+    attachDatabase(path: string, alias: string): Promise<void>;
+    /**
+     * 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()`
+     */
+    detachDatabase(alias: string): Promise<void>;
+    /**
+     * Generate SQL for creating a savepoint
+     */
+    createSavepointSQL(name?: string): string;
+    /**
+     * Generate SQL for releasing a savepoint
+     */
+    releaseSavepointSQL(name: string): string;
+    /**
+     * Generate SQL for rolling back to a savepoint
+     */
+    rollbackToSavepointSQL(name: string): string;
+    /**
+     * Create a new table
+     */
+    createTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        /**
+         * SQLite 3.37+ STRICT tables - enforces column type affinity strictly
+         * instead of SQLite's normally-flexible type system.
+         */
+        strict?: boolean;
+        /**
+         * WITHOUT ROWID tables - opts a table out of the implicit rowid, storing
+         * rows in the order of the PRIMARY KEY instead. Useful for tables with a
+         * natural composite/text primary key.
+         */
+        withoutRowid?: boolean;
+    }): Promise<void>;
+    /**
+     * Build constraint SQL for table creation
+     */
+    private buildConstraintSql;
+    /**
+     * Generate column definition SQL
+     */
+    private getColumnDefinitionSql;
+    /**
+     * Get default value SQL
+     */
+    private getDefaultValue;
+    /**
+     * Drop a table
+     */
+    dropTable(tableName: string, options?: DropTableOptions): Promise<void>;
+    /**
+     * Create a partitioned table (SQLite emulation)
+     * Creates base table + child partition tables + union view
+     */
+    createPartitionedTable(tableName: string, columns: Record<string, ColumnDefinition>, options?: TableOptions & {
+        partitionBy: {
+            type: 'range' | 'list' | 'hash' | 'key';
+            column: string | string[];
+        };
+        partitions?: {
+            name: string;
+            bound?: any;
+            tablespace?: string;
+            storageParameters?: Record<string, string | number>;
+        }[] | number;
+    }): Promise<void>;
+    /**
+     * Create a partition for an existing partitioned table (SQLite emulation)
+     */
+    createPartition(options: CreatePartitionOptions): Promise<void>;
+    /**
+     * Attach a partition to a partitioned table (SQLite emulation)
+     */
+    attachPartition(options: AttachPartitionOptions): Promise<void>;
+    /**
+     * Detach a partition from a partitioned table (SQLite emulation)
+     * Marks the partition as detached but keeps the table
+     */
+    detachPartition(options: DetachPartitionOptions): Promise<void>;
+    /**
+     * Drop a partition (SQLite emulation)
+     */
+    dropPartition(partitionName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * 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
+     */
+    addPartition(tableName: string, partitionName: string, partitionSpec: {
+        values?: string;
+        forValues?: string;
+    }): Promise<void>;
+    /**
+     * List partitions for a table (SQLite emulation)
+     */
+    listPartitions(tableName: string): Promise<Array<{
+        name: string;
+        parent_table: string;
+        bound: string | null;
+        is_detached: number;
+    }>>;
+    /**
+     * Check if a table has partitions (SQLite emulation)
+     */
+    hasPartition(tableName: string): Promise<boolean>;
+    /**
+     * Create a user (stub - not supported by SQLite)
+     */
+    createUser(_username: string, _options?: any): Promise<void>;
+    /**
+     * Drop a user (stub - not supported by SQLite)
+     */
+    dropUser(_username: string, _options?: any): Promise<void>;
+    /**
+     * List users (stub - not supported by SQLite)
+     */
+    listUsers(): Promise<Array<{
+        username: string;
+        host: string;
+    }>>;
+    /**
+     * Create a role (stub - not supported by SQLite)
+     */
+    createRole(_roleName: string, _options?: any): Promise<void>;
+    /**
+     * Drop a role (stub - not supported by SQLite)
+     */
+    dropRole(_roleName: string, _options?: any): Promise<void>;
+    /**
+     * List roles (stub - not supported by SQLite)
+     */
+    listRoles(): Promise<string[]>;
+    /**
+     * Grant privileges (stub - not supported by SQLite)
+     */
+    grant(_privilege: string, _on: string, _to: string): Promise<void>;
+    /**
+     * Revoke privileges (stub - not supported by SQLite)
+     */
+    revoke(_privilege: string, _on: string, _from: string): Promise<void>;
+    /**
+     * Add a column to a table
+     */
+    addColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Remove a column from a table
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * Change a column definition
+     */
+    changeColumn(tableName: string, columnName: string, definition: ColumnDefinition): Promise<void>;
+    /**
+     * Show all tables in the database
+     */
+    showTables(): Promise<string[]>;
+    /**
+     * Get table status (SQLite implementation)
+     */
+    getTableStatus(tableName?: string): Promise<Record<string, any>[]>;
+    /**
+     * Get table create statement (SQLite implementation)
+     */
+    getCreateTable(tableName: string): Promise<string>;
+    /**
+     * Get MariaDB-specific version info (not supported in SQLite)
+     * This method exists for compatibility when tests fall back to SQLite
+     */
+    getMariaDBVersionInfo(): Promise<{
+        version: string;
+        versionNumber: number;
+        storageEngine: string;
+    }>;
+    /**
+     * Show constraints for a table (SQLite)
+     */
+    showConstraints(tableName: string): Promise<any[]>;
+    /**
+     * Show indexes for a table
+     */
+    showIndexes(tableName: string): Promise<any[]>;
+    /**
+     * 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
+     */
+    createSchema(_schema: string): Promise<void>;
+    /**
+     * 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
+     */
+    dropSchema(_schema: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Show all schemas in the database
+     * SQLite doesn't have native schema support, returns default schema
+     */
+    showAllSchemas(): Promise<string[]>;
+    /**
+     * List all schemas (SQLite only has main)
+     */
+    listSchemas(): Promise<string[]>;
+    /**
+     * VACUUM the database - reclaims disk space and defragments
+     * @param options - VACUUM options
+     */
+    vacuum(options?: {
+        schema?: string;
+        shrinkTo?: number;
+        analyze?: boolean;
+    }): Promise<void>;
+    /**
+     * ANALYZE the database - updates statistics for query optimizer
+     * @param target - Optional table or index name
+     */
+    analyze(target?: string): Promise<void>;
+    /**
+     * Get database information using PRAGMA
+     */
+    getDatabaseInfo(): Promise<{
+        schemaVersion: number;
+        userVersion: number;
+        foreignKeys: boolean;
+        journalingMode: string;
+        synchronous: string;
+        cacheSize: number;
+        pageSize: number;
+    }>;
+    /**
+     * Create an FTS5 virtual table for full-text search
+     */
+    createFTS5Table(tableName: string, columns: {
+        name: string;
+        type?: string;
+        notindexed?: boolean;
+    }[], options?: {
+        tokenizer?: 'porter' | 'unicode61' | 'trigram' | 'ascii';
+        content?: string;
+        contentRowId?: string;
+        prefix?: number[] | 'all';
+    }): Promise<void>;
+    /**
+     * Perform full-text search
+     */
+    fullTextSearch(ftsTable: string, searchQuery: string, options?: {
+        columns?: string[];
+        orderBy?: {
+            column: string;
+            desc?: boolean;
+        }[];
+        limit?: number;
+        offset?: number;
+        highlight?: {
+            before?: string;
+            after?: string;
+            column?: string;
+        };
+        bm25?: boolean;
+    }): Promise<QueryResult>;
+    /**
+     * 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);
+     * ```
+     */
+    createStoredProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * 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.
+     */
+    dropStoredProcedure(procedureName: string, _options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     * SQLite does not support stored procedures - use application code instead.
+     */
+    dropProcedure(procedureName: string, options?: DropStoredProcedureOptions): Promise<void>;
+    /**
+     * 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]
+     * );
+     * ```
+     */
+    executeStoredProcedure(options: ExecuteStoredProcedureOptions): Promise<QueryResult>;
+    /**
+     * 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.
+     */
+    hasStoredProcedure(_procedureName: string, _schema?: string): Promise<boolean>;
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     * SQLite does not support stored procedures - use application code instead.
+     */
+    createProcedure(options: StoredProcedureOptions): Promise<void>;
+    /**
+     * Create a foreign data wrapper (SQLite - not supported)
+     * @param fdwName - Foreign data wrapper name
+     * @param options - Options including handler function
+     */
+    createForeignDataWrapper(_fdwName: string, _options?: {
+        handler?: string;
+    }): Promise<void>;
+    dropForeignDataWrapper(_fdwName: string, _options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    createForeignServer(_serverName: string, _fdwName: string, _options?: {
+        options?: Record<string, string>;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    dropForeignServer(_serverName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    createForeignTable(_tableName: string, _columns: Record<string, {
+        type: string;
+    }>, _options?: {
+        serverName?: string;
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    changeOwner(_newOwner: string, _tableName: string): Promise<void>;
+    addConstraint(_tableName: string, _options: {
+        type: 'UNIQUE' | 'CHECK' | 'PRIMARY KEY' | 'FOREIGN KEY';
+        fields: string[];
+        name?: string;
+        references?: {
+            table: string;
+            fields: string[];
+        };
+        check?: string;
+    }): Promise<void>;
+    removeConstraint(_tableName: string, _constraintName: string): Promise<void>;
+    createSecurityPolicy(_policyName: string, _tableName: string, _options?: {
+        predicate?: string;
+    }): Promise<void>;
+    dropSecurityPolicy(_policyName: string, _tableName: string): Promise<void>;
+    /**
+     * Create a trigger
+     */
+    createTrigger(triggerName: string, timing: 'BEFORE' | 'AFTER' | 'INSTEAD OF', events: ('INSERT' | 'UPDATE' | 'DELETE')[], tableName: string, body: string, options?: {
+        replace?: boolean;
+        forEachRow?: boolean;
+        whenCondition?: string;
+    }): Promise<void>;
+    /**
+     * Drop a trigger
+     */
+    dropTrigger(triggerName: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    hasTrigger(triggerName: string, tableName?: string): Promise<boolean>;
+    /**
+     * Create a sequence (simulated using AUTOINCREMENT table)
+     */
+    createSequence(options: SequenceOptions): Promise<void>;
+    /**
+     * Drop a sequence (simulated by dropping the sequence table)
+     */
+    dropSequence(sequenceName: string, options?: DropSequenceOptions): Promise<void>;
+    /**
+     * Get next value from a sequence
+     * (simulated by inserting and getting last_insert_rowid)
+     */
+    nextSequenceValue(sequenceName: string, schema?: string): Promise<number>;
+    /**
+     * Check if a sequence exists
+     * (simulated by checking if the sequence table exists)
+     */
+    hasSequence(sequenceName: string, schema?: string): Promise<boolean>;
+    /**
+     * List all sequences in the database (SQLite - simulated via tables)
+     * @returns Array of sequence names
+     */
+    listSequences(): Promise<string[]>;
+    /**
+     * Get the internal table name for a sequence
+     */
+    private _getSequenceTableName;
+    createPolicy(_options: PolicyOptions): Promise<void>;
+    dropPolicy(_policyName: string, _tableName: string, _options?: DropPolicyOptions): Promise<void>;
+    enableRLS(_tableName: string, _schema?: string): Promise<void>;
+    enableRowLevelSecurity(_tableName: string, _schema?: string): Promise<void>;
+    disableRLS(_tableName: string, _schema?: string): Promise<void>;
+    hasPolicy(_policyName: string, _tableName: string): Promise<boolean>;
+    commentTable(_tableName: string, _comment: string): Promise<void>;
+    commentColumn(_tableName: string, _columnName: string, _comment: string): Promise<void>;
+    createPartialIndex(tableName: string, indexName: string, fields: string[], where: string, options?: IndexOptions): Promise<void>;
+    createExpressionIndex(tableName: string, indexName: string, expression: string, options?: IndexOptions): Promise<void>;
+    createIdentityColumn(_tableName: string, _columnName: string, _options?: {
+        startWith?: number;
+        incrementBy?: number;
+        minvalue?: number;
+        maxvalue?: number;
+        cycle?: boolean;
+    }): Promise<void>;
+    createComputedColumn(tableName: string, columnName: string, expression: string, options?: {
+        persisted?: boolean;
+        type?: string;
+    }): Promise<void>;
+    /**
+     * Create a PostgreSQL extension (not supported in SQLite)
+     */
+    createExtension(_extensionName: string, _options?: CreateExtensionOptions): Promise<void>;
+    /**
+     * Drop a PostgreSQL extension (not supported in SQLite)
+     */
+    dropExtension(_extensionName: string, _options?: DropExtensionOptions): Promise<void>;
+    /**
+     * Get all installed PostgreSQL extensions (not supported in SQLite)
+     */
+    getExtensions(): Promise<ExtensionInfo[]>;
+    /**
+     * Check if a PostgreSQL extension is installed (not supported in SQLite)
+     */
+    hasExtension(_extensionName: string): Promise<boolean>;
+    buildCreateServerQuery(_name: string, _opts: FdwForeignServerOptions): string;
+    buildAlterServerQuery(_name: string, _opts: FdwAlterForeignServerOptions): string;
+    buildDropServerQuery(_name: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildCreateUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildAlterUserMappingQuery(_opts: FdwUserMappingOptions): string;
+    buildDropUserMappingQuery(_serverName: string, _user: string, _opts?: {
+        ifExists?: boolean;
+    }): string;
+    buildCreateForeignTableQuery(_tableName: string, _opts: FdwForeignTableOptions): string;
+    buildDropForeignTableQuery(_tableName: string, _opts?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
+    buildImportForeignSchemaQuery(_remoteSchema: string, _serverName: string, _opts?: FdwImportForeignSchemaOptions): string;
+    getServersQuery(): string;
+    /**
+     * 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
+     */
+    createView(viewName: string, query: string, options?: {
+        replace?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop a database view
+     * @param viewName - Name of the view to drop
+     * @param options - Drop options
+     */
+    dropView(viewName: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Show all views in the database
+     */
+    showViews(): Promise<string[]>;
+    /**
+     * Create a materialized view - Not supported by SQLite
+     */
+    createMaterializedView(_options: MaterializedViewOptions): Promise<void>;
+    /**
+     * Refresh a materialized view - Not supported by SQLite
+     */
+    refreshMaterializedView(_viewName: string, _options?: RefreshOptions): Promise<void>;
+    /**
+     * Drop a materialized view - Not supported by SQLite
+     */
+    dropMaterializedView(_viewName: string, _options?: DropMaterializedViewOptions): Promise<void>;
+    /**
+     * Check if a materialized view exists - Not supported by SQLite
+     */
+    hasMaterializedView(_viewName: string): Promise<boolean>;
+    /**
+     * Show all materialized views - Not supported by SQLite
+     */
+    showMaterializedViews(): Promise<string[]>;
+    /**
+     * Describe a table (get column information)
+     */
+    describeTable(tableName: string): Promise<TableDescription>;
+    /**
+     * 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.
+     */
+    private toColumnDefinition;
+    /**
+     * Rename a table
+     */
+    renameTable(oldName: string, newName: string): Promise<void>;
+    /**
+     * Add an index to a table
+     * Supports partial indexes (WHERE) and expression indexes (SQLite 3.9.0+)
+     */
+    addIndex(tableName: string, indexName: string, fields?: string[], options?: IndexOptions): Promise<void>;
+    /**
+     * Remove an index from a table
+     */
+    removeIndex(tableName: string, indexName: string): Promise<void>;
+    /**
+     * Create an index on a table with full options support
+     * Supports partial indexes (WHERE) and expression indexes (SQLite 3.9.0+)
+     */
+    createIndex(tableName: string, indexDef: {
+        name: string;
+        unique?: boolean;
+        type?: string;
+        using?: string;
+        fields: string[];
+        where?: WhereOptions;
+        expression?: string;
+    }): Promise<void>;
+    /**
+     * Drop an index from a table
+     */
+    dropIndex(tableName: string, indexName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a constraint on a table
+     * Note: SQLite has limited ALTER TABLE support for constraints
+     */
+    createConstraint(tableName: string, constraintDef: {
+        name: string;
+        type: 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK';
+        fields?: string[];
+        references?: {
+            table: string;
+            field: string;
+            onDelete?: string;
+            onUpdate?: string;
+        };
+        check?: string;
+    }): Promise<void>;
+    /**
+     * Drop a constraint from a table
+     * Note: SQLite has limited ALTER TABLE support for constraints
+     */
+    dropConstraint(tableName: string, constraintName: string, _options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): Promise<void>;
+    /**
+     * Recreate table with a new constraint (for createConstraint)
+     */
+    private recreateTableWithConstraint;
+    /**
+     * Begin a new transaction
+     */
+    startTransaction(options?: TransactionOptions): Promise<Transaction>;
+    /**
+     * Commit a transaction
+     */
+    commitTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Rollback a transaction
+     */
+    rollbackTransaction(transaction: Transaction): Promise<void>;
+    /**
+     * Get the SQL for a data type
+     */
+    getDataTypeSql(dataType: DataType, columnName?: string): string;
+    /**
+     * Build a WHERE clause from a WhereOptions object
+     */
+    buildWhereClause(where: WhereOptions, options?: {
+        replacements?: Record<string, unknown>;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an ORDER BY clause
+     */
+    buildOrderClause(order: Order, options?: {
+        replacements?: Record<string, unknown>;
+    }): string;
+    /**
+     * Build a LIMIT/OFFSET clause
+     */
+    buildLimitOffset(limit?: number | string, offset?: number | string): string;
+    /**
+     * Build an INSERT query
+     */
+    buildInsertQuery(tableName: string, values: Record<string, unknown>, options?: InsertOptions & {
+        /** Emit `ON CONFLICT (...) DO NOTHING` instead of `DO UPDATE`. */
+        doNothing?: boolean;
+        /**
+         * Multiple chained `ON CONFLICT` clauses targeting different unique
+         * constraints, e.g. `ON CONFLICT(a) DO NOTHING ON CONFLICT(b) DO UPDATE ...`.
+         * When provided, this takes precedence over `conflictFields`/`doNothing`.
+         */
+        conflictTargets?: ConflictTarget[];
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * 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 ...
+     */
+    private buildConflictClausesSql;
+    /**
+     * Build an UPSERT query (INSERT ... ON CONFLICT DO UPDATE)
+     * SQLite supports: INSERT OR REPLACE, INSERT OR IGNORE, and ON CONFLICT DO UPDATE
+     */
+    buildUpsertQuery(tableName: string, values: Record<string, unknown>, options?: UpsertQueryOptions & {
+        /** Emit `ON CONFLICT (...) DO NOTHING` instead of `DO UPDATE`. */
+        doNothing?: boolean;
+        /**
+         * Multiple chained `ON CONFLICT` clauses targeting different unique
+         * constraints, e.g. `ON CONFLICT(a) DO NOTHING ON CONFLICT(b) DO UPDATE ...`.
+         * When provided, this takes precedence over `conflictFields`/`doNothing`.
+         */
+        conflictTargets?: ConflictTarget[];
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * 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: string, fields: string | string[] | Record<string, number>, where: WhereOptions, options?: {
+        by?: number;
+    }): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build an UPDATE query
+     */
+    buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, options?: DUpdateOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a DELETE query
+     */
+    buildDeleteQuery(tableName: string, where: WhereOptions, options?: DeleteOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Check if a value is a function expression (fn('COUNT', ...))
+     */
+    private isFnExpression;
+    /**
+     * Check if a value is a column expression (col('name'))
+     */
+    private isColExpression;
+    /**
+     * Check if a value is a literal expression (literal('sql'))
+     */
+    /**
+     * Render a literal expression, substituting any `bindings` into its `?`
+     * placeholders with dialect-correct escaping. `literalExpr(sql)` with no
+     * bindings is unchanged; `literalExpr('x > ?', [v])` no longer requires the
+     * caller to concatenate the value into the string themselves.
+     */
+    private literalSql;
+    private isLiteralExpression;
+    /**
+     * Compile a function expression to SQL
+     */
+    private compileFnExpression;
+    /**
+     * Build SELECT clause with support for function expressions and aliases
+     * Handles: 'field', ['field'], ['field', 'alias'], [fn('COUNT', 'id'), 'count']
+     */
+    private buildSelectClause;
+    /**
+     * Build GROUP BY clause with support for function expressions and aliases
+     * Handles: 'field', ['field1', 'field2'], [[fn('COUNT', 'id'), 'count']]
+     */
+    private buildGroupByClause;
+    /**
+     * Build a WHERE clause condition using standard operators (Op.gt, Op.eq, etc.)
+     * Uses SQLite ? placeholders
+     */
+    private buildCondition;
+    /**
+     * Build a HAVING clause with support for standard Op operators
+     */
+    private buildHavingClause;
+    /**
+     * 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: CTEOption[]): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Build a SELECT query
+     */
+    buildSelectQuery(options: SelectOptions): {
+        sql: string;
+        values: unknown[];
+    };
+    /**
+     * Recreate table without a column (for removeColumn)
+     */
+    private recreateTableWithoutColumn;
+    /**
+     * Recreate table to modify a column
+     */
+    private recreateTableModifyColumn;
+    buildCreateUserQuery(_username: string, _options?: any): string;
+    buildAlterUserQuery(_username: string, _options?: any): string;
+    buildDropUserQuery(_username: string, _options?: any): string;
+    getUsersQuery(): string;
+    buildGrantQuery(_options: any): string;
+    buildRevokeQuery(_options: any): string;
+    buildShowGrantsQuery(_username: string, _host?: string): string;
+    buildFlushPrivilegesQuery(): string;
+    buildCreateRoleQuery(_roleName: string, _options?: any): string;
+    buildDropRoleQuery(_roleName: string, _options?: any): string;
+    buildGrantRoleQuery(_role: string, _to: any, _options?: any): string;
+    buildRevokeRoleQuery(_role: string, _from: any, _options?: any): string;
+    getRolesQuery(): string;
+    /**
+     * Bulk insert records into a table
+     */
+    bulkInsert(tableName: string, records: Record<string, any>[], _options?: any): Promise<QueryResult>;
+    /**
+     * Update every row matching `where` with `values` in a single statement.
+     */
+    bulkUpdate(tableName: string, values: Record<string, unknown>, where?: WhereOptions): Promise<unknown>;
+    /**
+     * Delete every row matching `where` (deletes all rows when `where` is empty).
+     */
+    bulkDelete(tableName: string, where?: WhereOptions): Promise<unknown>;
+    /**
+     * 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.
+     */
+    addForeignKey(tableName: string, columnName: string, referencedTableName: string, referencedColumnName: string, options?: {
+        name?: string;
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION';
+    }): Promise<void>;
+    /**
+     * Run a setter PRAGMA (one that returns no rows).
+     *
+     * On better-sqlite3 this must go through the synchronous `exec()` API:
+     * routing it through `query()` would call `stmt.all()` and throw
+     * "statement does not return data". Subclasses that don't have a
+     * synchronous connection (e.g. TursoDialect over the libSQL wire) override
+     * this to run the PRAGMA through their async driver instead.
+     */
+    protected setPragma(pragma: string): Promise<void>;
+    /**
+     * Rename a column
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    /**
+     * Create a fulltext index (SQLite supports FTS5)
+     */
+    createFulltextIndex(_tableName: string, indexName: string, fields: string[], _options?: {
+        parser?: string;
+        comment?: string;
+    }): Promise<void>;
+    /**
+     * Create a spatial index (SQLite supports spatial indexing via RTree)
+     */
+    createSpatialIndex(_tableName: string, indexName: string, fields: string[], _options?: {
+        storage?: string;
+        srid?: number;
+    }): Promise<void>;
+    /**
+     * Create user mapping (SQLite doesn't support user mappings)
+     */
+    createUserMapping(_userName: string, _serverName: string, _options?: any): Promise<void>;
+    /**
+     * Drop user mapping (SQLite doesn't support user mappings)
+     */
+    dropUserMapping(_userName: string, _serverName: string, _options?: any): Promise<void>;
+    /**
+     * ST_Distance - calculate distance between two geometries
+     * SQLite uses SpatiaLite extension or custom implementation
+     */
+    stDistance(geom1: string, geom2: string, _srid?: number): string;
+    /**
+     * ST_DWithin - check if geometries are within a given distance
+     */
+    stDWithin(geom1: string, geom2: string, distance: number, _srid?: number): string;
+    /**
+     * ST_Within - check if geometry A is within geometry B
+     */
+    stWithin(geom1: string, geom2: string, _srid?: number): string;
+    /**
+     * ST_Contains - check if geometry A contains geometry B
+     */
+    stContains(geom1: string, geom2: string, _srid?: number): string;
+    /**
+     * ST_Intersects - check if geometries intersect
+     */
+    stIntersects(geom1: string, geom2: string, _srid?: number): string;
+    /**
+     * ST_AsText - convert geometry to text representation
+     */
+    stAsText(geom: string): string;
+    /**
+     * ST_GeomFromText - create geometry from text
+     */
+    stGeomFromText(wkt: string, srid?: number): string;
+    /**
+     * 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: string, rowPath: string, columns: Array<{
+        name: string;
+        type?: string;
+        path?: string;
+        forOrdinality?: boolean;
+    }>, alias: string): string;
+}
+/**
+ * SQLite-specific transaction class
+ */
+export declare class SQLiteTransaction implements Transaction {
+    private connection;
+    private dialect?;
+    id: string;
+    finished: boolean;
+    options: TransactionOptions;
+    parent: Transaction | null;
+    savepoints: string[];
+    isOuter: boolean;
+    constructor(connection: Database.Database, depth: number, options?: TransactionOptions, dialect?: {
+        commitTransaction(tx: Transaction): Promise<void>;
+        rollbackTransaction(tx: Transaction): Promise<void>;
+    } | undefined);
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export interface SQLiteDialectOptions extends DialectOptions {
+    storage?: string;
+    readonly?: boolean;
+    fileMustExist?: boolean;
+    timeout?: number;
+    verbose?: (message?: unknown, ...additionalArgs: unknown[]) => void;
+}
+/**
+ * Create a new SQLite dialect instance
+ */
+export declare function createSQLiteDialect(options?: SQLiteDialectOptions): SQLiteDialect;
+export default SQLiteDialect;