typeorm / typeorm / 19549987525

import { QueryRunnerAlreadyReleasedError } from "../../error/QueryRunnerAlreadyReleasedError"

import { QueryFailedError } from "../../error/QueryFailedError"

import { AbstractSqliteQueryRunner } from "../sqlite-abstract/AbstractSqliteQueryRunner"

import { Broadcaster } from "../../subscriber/Broadcaster"

import { BetterSqlite3Driver } from "./BetterSqlite3Driver"

import { QueryResult } from "../../query-runner/QueryResult"

import { BroadcasterResult } from "../../subscriber/BroadcasterResult"

/**

 * Runs queries on a single sqlite database connection.

 *

 * Does not support compose primary keys with autoincrement field.

 * todo: need to throw exception for this case.

 */

export class BetterSqlite3QueryRunner extends AbstractSqliteQueryRunner {

    /**

     * Database driver used by connection.

     */

    driver: BetterSqlite3Driver

    // -------------------------------------------------------------------------

    // Constructor

    // -------------------------------------------------------------------------

    constructor(driver: BetterSqlite3Driver) {

        super()

        this.driver = driver

        this.connection = driver.connection

        this.broadcaster = new Broadcaster(this)

        } else {

            this.cacheSize = 100

        }

    }

    private cacheSize: number

    private stmtCache = new Map<string, any>()

    private async getStmt(query: string) {

        if (this.cacheSize > 0) {

            let stmt = this.stmtCache.get(query)

            if (!stmt) {

                const databaseConnection = await this.connect()

                stmt = databaseConnection.prepare(query)

                this.stmtCache.set(query, stmt)

                while (this.stmtCache.size > this.cacheSize) {

                    // since es6 map keeps the insertion order,

                    // it comes to be FIFO cache

                    const key = this.stmtCache.keys().next().value!

                    this.stmtCache.delete(key)

                }

            }

            return stmt

    }

    /**

     * Called before migrations are run.

     */

    async beforeMigration(): Promise<void> {

        await this.query(`PRAGMA foreign_keys = OFF`)

    }

    /**

     * Called after migrations are run.

     */

    async afterMigration(): Promise<void> {

        await this.query(`PRAGMA foreign_keys = ON`)

    }

    /**

     * Executes a given SQL query.

     */

    async query(

        query: string,

        parameters: any[] = [],

        useStructuredResult = false,

    ): Promise<any> {

        const connection = this.driver.connection

        const broadcasterResult = new BroadcasterResult()

        this.driver.connection.logger.logQuery(query, parameters, this)

        this.broadcaster.broadcastBeforeQueryEvent(

            broadcasterResult,

            query,

            parameters,

        )

        const queryStartTime = Date.now()

        const stmt = await this.getStmt(query)

        try {

            const result = new QueryResult()

            if (stmt.reader) {

                const raw = stmt.all(...parameters)

                result.raw = raw

                if (Array.isArray(raw)) {

                    result.records = raw

                }

            } else {

                const raw = stmt.run(...parameters)

                result.affected = raw.changes

                result.raw = raw.lastInsertRowid

            }

            // log slow queries if maxQueryExecution time is set

            const maxQueryExecutionTime =

                this.driver.options.maxQueryExecutionTime

            const queryEndTime = Date.now()

            const queryExecutionTime = queryEndTime - queryStartTime

            if (

            )

            this.broadcaster.broadcastAfterQueryEvent(

                broadcasterResult,

                query,

                parameters,

                true,

                queryExecutionTime,

                result.raw,

                undefined,

            )

            if (!useStructuredResult) {

                return result.raw

            }

            return result

        } catch (err) {

            connection.logger.logQueryError(err, query, parameters, this)

            throw new QueryFailedError(query, parameters, err)

        }

    }

    // -------------------------------------------------------------------------

    // Protected Methods

    // -------------------------------------------------------------------------

    protected async loadTableRecords(

        tablePath: string,

        tableOrIndex: "table" | "index",

    ) {

        const [database, tableName] = this.splitTablePath(tablePath)

        const res = await this.query(

            `SELECT ${

            } as database, * FROM ${this.escapePath(

            )} WHERE "type" = '${tableOrIndex}' AND "${

                tableOrIndex === "table" ? "name" : "tbl_name"

            }" IN ('${tableName}')`,

        )

        return res

    }

    protected async loadPragmaRecords(tablePath: string, pragma: string) {

        const [database, tableName] = this.splitTablePath(tablePath)

        const res = await this.query(

            `PRAGMA ${

            }${pragma}("${tableName}")`,

        )

        return res

    }

}