@fadhilp/stateql 0.1.2 → 0.2.2

package/dist/src/adapters.js

@@ -1,7 +1,17 @@
-import { existsSync, statSync } from "node:fs";
-import { DatabaseSync } from "node:sqlite";
+import { fork } from "node:child_process";
+import { createConnection as createMySqlConnection, } from "mysql2";
 import { Client, types as pgTypes } from "pg";
-import { hash, parseJson, toJsonSafe } from "./util.js";
+import { parseJson, toJsonSafe } from "./util.js";
+export class AdapterExecutionError extends Error {
+    reason;
+    outcomeUnknown;
+    constructor(message, reason, outcomeUnknown) {
+        super(message);
+        this.reason = reason;
+        this.outcomeUnknown = outcomeUnknown;
+        this.name = "AdapterExecutionError";
+    }
+}
 export class BatchWriteError extends Error {
     outcomeUnknown;
     constructor(message, outcomeUnknown) {
@@ -10,7 +20,21 @@ export class BatchWriteError extends Error {
         this.name = "BatchWriteError";
     }
 }
-export async function createAdapter(connection) {
+export class AdapterWriteError extends Error {
+    outcomeUnknown;
+    constructor(message, outcomeUnknown) {
+        super(message);
+        this.outcomeUnknown = outcomeUnknown;
+        this.name = "AdapterWriteError";
+    }
+}
+export function createAdapterContext(timeoutMs, signal) {
+    return {
+        deadline: Date.now() + timeoutMs,
+        ...(signal ? { signal } : {}),
+    };
+}
+export async function createAdapter(connection, context) {
     const source = connection.secret_env
         ? process.env[connection.secret_env]
         : connection.source;
@@ -18,201 +42,451 @@ export async function createAdapter(connection) {
         throw new Error(`Environment variable ${connection.secret_env ?? "(missing)"} is not set.`);
     }
     if (connection.driver === "sqlite") {
-        return new SQLiteAdapter(source, Boolean(connection.read_only));
+        return new SQLiteAdapter(source, Boolean(connection.read_only), context);
     }
-    return new PostgresAdapter(source, Boolean(connection.read_only));
+    if (connection.driver === "postgres") {
+        return new PostgresAdapter(source, Boolean(connection.read_only), context);
+    }
+    return new MySqlAdapter(source, Boolean(connection.read_only), context);
 }
 class SQLiteAdapter {
     source;
     readOnly;
+    context;
     confidence = "database_reported";
-    db;
-    constructor(source, readOnly) {
+    child;
+    pending = new Map();
+    nextId = 1;
+    closed = false;
+    constructor(source, readOnly, context) {
         this.source = source;
         this.readOnly = readOnly;
-        this.db = new DatabaseSync(source, {
-            readOnly,
-            enableForeignKeyConstraints: true,
+        this.context = context;
+        this.child = fork(new URL("./sqlite-process.js", import.meta.url), [], {
+            execArgv: [],
+            stdio: ["ignore", "ignore", "ignore", "ipc"],
+            serialization: "advanced",
+        });
+        this.child.on("message", (message) => {
+            const call = this.pending.get(message.id);
+            if (!call)
+                return;
+            if (message.error) {
+                call.reject(call.batch
+                    ? new BatchWriteError(message.error.message, message.error.outcomeUnknown ?? true)
+                    : message.error.outcomeUnknown === undefined
+                        ? new Error(message.error.message)
+                        : new AdapterWriteError(message.error.message, message.error.outcomeUnknown));
+            }
+            else {
+                call.resolve(message.result);
+            }
+        });
+        this.child.on("error", (error) => this.failPending(error));
+        this.child.on("exit", (code, signal) => {
+            if (!this.closed) {
+                this.failPending(new Error(`SQLite execution process exited unexpectedly (${signal ?? code ?? "unknown"}).`));
+            }
         });
-        this.db.exec("PRAGMA busy_timeout = 5000");
     }
     async read(sql, params) {
-        const statement = this.db.prepare(sql);
-        const rows = bindAll(statement, params);
-        return {
-            rows: toJsonSafe(rows),
-            columns: statement.columns().map((column) => ({
-                name: column.name,
-                type: column.type?.toLowerCase() ?? inferType(rows, column.name),
-            })),
-        };
+        return this.call("read", [sql, params], false, false);
+    }
+    async write(sql, params) {
+        return this.call("write", [sql, params], true, false);
+    }
+    async writeBatch(operations, isolation) {
+        return this.call("writeBatch", [operations, isolation], true, true);
+    }
+    async signature() {
+        return this.call("signature", [], false, false);
+    }
+    async inspect(kind, table) {
+        return this.call("inspect", [kind, table], false, false);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.child.exitCode !== null || this.child.signalCode !== null)
+            return;
+        await new Promise((resolve) => {
+            const done = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            const timer = setTimeout(() => {
+                try {
+                    this.child.kill("SIGKILL");
+                }
+                catch {
+                    // Process already exited.
+                }
+                resolve();
+            }, 1_000);
+            timer.unref();
+            this.child.once("exit", done);
+            try {
+                this.child.disconnect();
+            }
+            catch {
+                try {
+                    this.child.kill("SIGKILL");
+                }
+                catch {
+                    // Process already exited.
+                }
+            }
+        });
+    }
+    async call(operation, args, outcomeUnknown, batch) {
+        throwIfStopped(this.context, false);
+        if (this.closed)
+            throw new Error("SQLite adapter is closed.");
+        const id = this.nextId++;
+        const result = new Promise((resolve, reject) => {
+            this.pending.set(id, { batch, resolve, reject });
+            try {
+                this.child.send({
+                    id,
+                    source: this.source,
+                    readOnly: this.readOnly,
+                    operation,
+                    args,
+                    busyTimeoutMs: Math.min(5_000, remainingMilliseconds(this.context)),
+                }, (error) => {
+                    if (error)
+                        reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        try {
+            return (await withContext(result, this.context, () => this.terminate(), outcomeUnknown));
+        }
+        finally {
+            this.pending.delete(id);
+        }
+    }
+    terminate() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            this.child.kill("SIGKILL");
+        }
+        catch {
+            // Process already exited.
+        }
+    }
+    failPending(error) {
+        for (const call of this.pending.values())
+            call.reject(error);
+        this.pending.clear();
+    }
+}
+class PostgresAdapter {
+    readOnly;
+    context;
+    confidence = "ttl_based";
+    client;
+    connected = false;
+    ending;
+    constructor(source, readOnly, context) {
+        this.readOnly = readOnly;
+        this.context = context;
+        const timeout = Math.min(2_147_483_647, remainingMilliseconds(context));
+        this.client = new Client({
+            connectionString: source,
+            connectionTimeoutMillis: timeout,
+            statement_timeout: timeout,
+        });
+    }
+    async read(sql, params) {
+        await this.connect();
+        await this.query("BEGIN READ ONLY", [], false);
+        try {
+            await this.setLocalDeadline();
+            const result = await this.query(sql, postgresParams(params), false);
+            await this.query("COMMIT", [], false);
+            return {
+                rows: toJsonSafe(result.rows),
+                columns: result.fields.map((field) => ({
+                    name: field.name,
+                    type: pgTypes.getTypeParser(field.dataTypeID).name ||
+                        `oid_${field.dataTypeID}`,
+                })),
+            };
+        }
+        catch (error) {
+            await this.rollbackQuietly();
+            throw error;
+        }
     }
     async write(sql, params) {
         if (this.readOnly)
             throw new Error("Connection is read-only.");
-        const result = bindRun(this.db.prepare(sql), params);
-        return { affectedRows: Number(result.changes) };
+        try {
+            await this.connect();
+            await this.query("BEGIN", [], false);
+        }
+        catch (error) {
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), false);
+        }
+        let committing = false;
+        try {
+            await this.setLocalDeadline();
+            const result = await this.query(sql, postgresParams(params), true);
+            committing = true;
+            await this.query("COMMIT", [], true);
+            return { affectedRows: result.rowCount ?? 0 };
+        }
+        catch (error) {
+            const rolledBack = await this.rollbackQuietly();
+            if (!committing && rolledBack) {
+                if (error instanceof AdapterExecutionError) {
+                    throw new AdapterExecutionError(error.message, error.reason, false);
+                }
+                throw new AdapterWriteError(errorText(error), false);
+            }
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), true);
+        }
     }
     async writeBatch(operations, isolation) {
         if (this.readOnly)
             throw new Error("Connection is read-only.");
-        if (isolation !== "serializable") {
-            throw new Error(`SQLite does not support isolation level "${isolation}".`);
+        await this.connect();
+        const level = isolation.toUpperCase();
+        if (!POSTGRES_ISOLATION_LEVELS.has(level)) {
+            throw new Error(`Unsupported PostgreSQL isolation level "${isolation}".`);
         }
-        const results = [];
         try {
-            this.db.exec("BEGIN");
+            await this.query(`BEGIN ISOLATION LEVEL ${level}`, [], false);
         }
         catch (error) {
             throw new BatchWriteError(errorText(error), false);
         }
+        const results = [];
         try {
             for (const operation of operations) {
-                results.push(await this.write(operation.sql, parseJson(operation.parameters, [])));
+                await this.setLocalDeadline();
+                const result = await this.query(operation.sql, postgresParams(parseJson(operation.parameters, [])), true);
+                results.push({ affectedRows: result.rowCount ?? 0 });
             }
         }
         catch (error) {
-            try {
-                this.db.exec("ROLLBACK");
-            }
-            catch {
-                throw new BatchWriteError(errorText(error), true);
+            if (await this.rollbackQuietly()) {
+                throw new BatchWriteError(errorText(error), false);
             }
-            throw new BatchWriteError(errorText(error), false);
+            throw new BatchWriteError(errorText(error), true);
         }
         try {
-            this.db.exec("COMMIT");
+            await this.query("COMMIT", [], true);
             return results;
         }
         catch (error) {
-            try {
-                this.db.exec("ROLLBACK");
-                throw new BatchWriteError(errorText(error), false);
-            }
-            catch (rollbackError) {
-                if (rollbackError instanceof BatchWriteError)
-                    throw rollbackError;
-                throw new BatchWriteError(errorText(error), true);
-            }
+            await this.rollbackQuietly();
+            throw new BatchWriteError(errorText(error), true);
         }
     }
     async signature() {
-        if (this.source === ":memory:")
-            return "memory";
-        const stats = statSync(this.source, { bigint: true });
-        const walPath = `${this.source}-wal`;
-        const wal = existsSync(walPath)
-            ? statSync(walPath, { bigint: true })
-            : undefined;
-        return hash({
-            size: stats.size.toString(),
-            modified: stats.mtimeNs.toString(),
-            walSize: wal?.size.toString() ?? "0",
-            walModified: wal?.mtimeNs.toString() ?? "0",
-        });
+        throwIfStopped(this.context, false);
+        return "ttl";
     }
     async inspect(kind, table) {
+        await this.connect();
+        await this.query("BEGIN READ ONLY", [], false);
+        try {
+            const result = await this.inspectTransaction(kind, table);
+            await this.query("COMMIT", [], false);
+            return result;
+        }
+        catch (error) {
+            await this.rollbackQuietly();
+            throw error;
+        }
+    }
+    async close() {
+        if (!this.ending) {
+            this.ending = this.client.end().catch(() => undefined);
+        }
+        await this.ending;
+    }
+    async inspectTransaction(kind, table) {
         if (kind === "schema") {
-            const tables = this.db
-                .prepare(`SELECT name, type
-           FROM sqlite_master
-           WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
-           ORDER BY name`)
-                .all();
-            return { schema: "main", tables };
+            await this.setLocalDeadline();
+            const result = await this.query(`SELECT table_schema AS schema, table_name AS name, table_type AS type
+         FROM information_schema.tables
+         WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+         ORDER BY table_schema, table_name`, [], false);
+            return { tables: result.rows };
         }
         if (!table)
             throw new Error(`Table is required for inspect ${kind}.`);
-        const quoted = quoteSqliteLiteral(table);
-        const columns = this.db
-            .prepare(`PRAGMA table_info(${quoted})`)
-            .all();
-        if (columns.length === 0)
+        const [schema, name] = table.includes(".")
+            ? table.split(".", 2)
+            : ["public", table];
+        await this.setLocalDeadline();
+        const columns = await this.query(`SELECT column_name AS name, data_type AS type,
+              is_nullable = 'YES' AS nullable
+       FROM information_schema.columns
+       WHERE table_schema = $1 AND table_name = $2
+       ORDER BY ordinal_position`, [schema, name], false);
+        if (columns.rows.length === 0) {
             throw new Error(`Table "${table}" was not found.`);
-        const indexes = this.db
-            .prepare(`PRAGMA index_list(${quoted})`)
-            .all();
-        const foreignKeys = this.db
-            .prepare(`PRAGMA foreign_key_list(${quoted})`)
-            .all();
+        }
         if (kind === "columns")
-            return { table, columns };
+            return { table: name, schema, columns: columns.rows };
+        await this.setLocalDeadline();
+        const indexes = await this.query(`SELECT indexname AS name, indexdef AS definition
+       FROM pg_indexes WHERE schemaname = $1 AND tablename = $2
+       ORDER BY indexname`, [schema, name], false);
+        await this.setLocalDeadline();
+        const constraints = await this.query(`SELECT constraint_name AS name, constraint_type AS type
+       FROM information_schema.table_constraints
+       WHERE table_schema = $1 AND table_name = $2
+       ORDER BY constraint_name`, [schema, name], false);
         if (kind === "indexes")
-            return { table, indexes };
+            return { table: name, schema, indexes: indexes.rows };
         if (kind === "constraints") {
-            return {
-                table,
-                primary_key: columns
-                    .filter((column) => Number(column.pk) > 0)
-                    .map((column) => column.name),
-                foreign_keys: foreignKeys,
-            };
+            return { table: name, schema, constraints: constraints.rows };
         }
         if (kind !== "table")
             throw new Error(`Unknown inspection kind "${kind}".`);
         return {
-            table,
-            schema: "main",
-            columns: columns.map((column) => ({
-                name: column.name,
-                type: String(column.type).toLowerCase(),
-                nullable: column.notnull === 0 && Number(column.pk) === 0,
-                primary_key: Number(column.pk) > 0,
-            })),
-            indexes: indexes.length,
-            foreign_keys: foreignKeys.length,
+            table: name,
+            schema,
+            columns: columns.rows,
+            indexes: indexes.rows.length,
+            constraints: constraints.rows.length,
         };
     }
-    async close() {
-        this.db.close();
+    async connect() {
+        if (this.connected)
+            return;
+        throwIfStopped(this.context, false);
+        await withContext(this.client.connect(), this.context, () => this.stop(), false);
+        this.connected = true;
+        if (this.readOnly) {
+            await this.query("SET default_transaction_read_only = on", [], false);
+        }
+    }
+    async setLocalDeadline() {
+        await this.query(`SET LOCAL statement_timeout = ${remainingMilliseconds(this.context)}`, [], false);
+    }
+    async query(sql, params, outcomeUnknown) {
+        throwIfStopped(this.context, outcomeUnknown);
+        try {
+            return await withContext(this.client.query(sql, params), this.context, () => this.stop(), outcomeUnknown);
+        }
+        catch (error) {
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            if (postgresErrorCode(error) === "57014") {
+                throw stoppedError(this.context, outcomeUnknown);
+            }
+            throw error;
+        }
+    }
+    async rollbackQuietly() {
+        if (this.ending)
+            return false;
+        try {
+            await this.query("ROLLBACK", [], false);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    stop() {
+        if (!this.ending) {
+            this.ending = this.client.end().catch(() => undefined);
+        }
     }
 }
-class PostgresAdapter {
+class MySqlAdapter {
+    source;
     readOnly;
+    context;
     confidence = "ttl_based";
+    rawClient;
     client;
     connected = false;
-    constructor(source, readOnly) {
+    closed = false;
+    constructor(source, readOnly, context) {
+        this.source = source;
         this.readOnly = readOnly;
-        this.client = new Client({ connectionString: source });
+        this.context = context;
     }
     async read(sql, params) {
-        await this.connect();
-        await this.client.query("BEGIN READ ONLY");
+        await this.query("START TRANSACTION READ ONLY", [], false, false);
         try {
-            const result = await this.client.query(sql, postgresParams(params));
-            await this.client.query("COMMIT");
+            const [result, fields] = await this.query(sql, mysqlParams(params), false, true);
+            await this.query("COMMIT", [], false, false);
             return {
-                rows: toJsonSafe(result.rows),
-                columns: result.fields.map((field) => ({
+                rows: toJsonSafe(mysqlRows(result)),
+                columns: fields.map((field) => ({
                     name: field.name,
-                    type: pgTypes.getTypeParser(field.dataTypeID).name ||
-                        `oid_${field.dataTypeID}`,
+                    type: mysqlFieldType(field),
                 })),
             };
         }
         catch (error) {
-            await this.client.query("ROLLBACK");
+            await this.rollbackQuietly();
             throw error;
         }
     }
     async write(sql, params) {
         if (this.readOnly)
             throw new Error("Connection is read-only.");
-        await this.connect();
-        const result = await this.client.query(sql, postgresParams(params));
-        return { affectedRows: result.rowCount ?? 0 };
+        let values;
+        try {
+            values = mysqlParams(params);
+        }
+        catch (error) {
+            throw new AdapterWriteError(errorText(error), false);
+        }
+        try {
+            await this.query("START TRANSACTION", [], false, false);
+        }
+        catch (error) {
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), false);
+        }
+        try {
+            const [result] = await this.query(sql, values, true, true);
+            await this.query("COMMIT", [], true, false);
+            return { affectedRows: mysqlAffectedRows(result) };
+        }
+        catch (error) {
+            await this.rollbackQuietly();
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), true);
+        }
     }
     async writeBatch(operations, isolation) {
         if (this.readOnly)
             throw new Error("Connection is read-only.");
-        await this.connect();
+        const unsupported = operations.find((operation) => !MYSQL_TRANSACTIONAL_STATEMENTS.has(operation.statement_type));
+        if (unsupported) {
+            throw new BatchWriteError(`MySQL transactions cannot atomically include ${unsupported.statement_type.toUpperCase()} statements.`, false);
+        }
         const level = isolation.toUpperCase();
-        if (!POSTGRES_ISOLATION_LEVELS.has(level)) {
-            throw new Error(`Unsupported PostgreSQL isolation level "${isolation}".`);
+        if (!MYSQL_ISOLATION_LEVELS.has(level)) {
+            throw new Error(`Unsupported MySQL isolation level "${isolation}".`);
         }
         try {
-            await this.client.query(`BEGIN ISOLATION LEVEL ${level}`);
+            await this.query(`SET TRANSACTION ISOLATION LEVEL ${level}`, [], false, false);
+            await this.query("START TRANSACTION", [], false, false);
         }
         catch (error) {
             throw new BatchWriteError(errorText(error), false);
@@ -220,127 +494,303 @@ class PostgresAdapter {
         const results = [];
         try {
             for (const operation of operations) {
-                results.push(await this.write(operation.sql, parseJson(operation.parameters, [])));
+                const [result] = await this.query(operation.sql, mysqlParams(parseJson(operation.parameters, [])), true, true);
+                results.push({ affectedRows: mysqlAffectedRows(result) });
             }
         }
         catch (error) {
-            try {
-                await this.client.query("ROLLBACK");
-            }
-            catch {
-                throw new BatchWriteError(errorText(error), true);
+            if (await this.rollbackQuietly()) {
+                throw new BatchWriteError(errorText(error), false);
             }
-            throw new BatchWriteError(errorText(error), false);
+            throw new BatchWriteError(errorText(error), true);
         }
         try {
-            await this.client.query("COMMIT");
+            await this.query("COMMIT", [], true, false);
             return results;
         }
         catch (error) {
-            try {
-                await this.client.query("ROLLBACK");
-            }
-            catch {
-                // COMMIT response was lost; rollback cannot establish outcome.
-            }
+            await this.rollbackQuietly();
             throw new BatchWriteError(errorText(error), true);
         }
     }
     async signature() {
+        throwIfStopped(this.context, false);
         return "ttl";
     }
     async inspect(kind, table) {
-        await this.connect();
+        await this.query("START TRANSACTION READ ONLY", [], false, false);
+        try {
+            const result = await this.inspectTransaction(kind, table);
+            await this.query("COMMIT", [], false, false);
+            return result;
+        }
+        catch (error) {
+            await this.rollbackQuietly();
+            throw error;
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.connected = false;
+        if (!this.client)
+            return;
+        await this.client.end().catch(() => undefined);
+    }
+    async inspectTransaction(kind, table) {
         if (kind === "schema") {
-            const result = await this.client.query(`SELECT table_schema AS schema, table_name AS name, table_type AS type
+            const [result] = await this.query(`SELECT TABLE_SCHEMA AS schema, TABLE_NAME AS name, TABLE_TYPE AS type
          FROM information_schema.tables
-         WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
-         ORDER BY table_schema, table_name`);
-            return { tables: result.rows };
+         WHERE TABLE_SCHEMA = DATABASE()
+         ORDER BY TABLE_NAME`, [], false, false);
+            return { tables: mysqlRows(result) };
         }
         if (!table)
             throw new Error(`Table is required for inspect ${kind}.`);
-        const [schema, name] = table.includes(".")
-            ? table.split(".", 2)
-            : ["public", table];
-        const columns = await this.client.query(`SELECT column_name AS name, data_type AS type,
-              is_nullable = 'YES' AS nullable
+        const separator = table.indexOf(".");
+        const schema = separator === -1
+            ? await this.databaseName()
+            : table.slice(0, separator);
+        const name = separator === -1 ? table : table.slice(separator + 1);
+        if (!schema || !name)
+            throw new Error(`Invalid table name "${table}".`);
+        const [columnResult] = await this.query(`SELECT COLUMN_NAME AS name, DATA_TYPE AS type,
+              IS_NULLABLE = 'YES' AS nullable
        FROM information_schema.columns
-       WHERE table_schema = $1 AND table_name = $2
-       ORDER BY ordinal_position`, [schema, name]);
-        if (columns.rows.length === 0) {
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+       ORDER BY ORDINAL_POSITION`, [schema, name], false, true);
+        const columns = mysqlRows(columnResult).map((column) => ({
+            ...column,
+            nullable: Boolean(column.nullable),
+        }));
+        if (columns.length === 0) {
             throw new Error(`Table "${table}" was not found.`);
         }
         if (kind === "columns")
-            return { table: name, schema, columns: columns.rows };
-        const indexes = await this.client.query(`SELECT indexname AS name, indexdef AS definition
-       FROM pg_indexes WHERE schemaname = $1 AND tablename = $2
-       ORDER BY indexname`, [schema, name]);
-        const constraints = await this.client.query(`SELECT constraint_name AS name, constraint_type AS type
+            return { table: name, schema, columns };
+        const [indexResult] = await this.query(`SELECT INDEX_NAME AS name, NON_UNIQUE AS non_unique,
+              INDEX_TYPE AS index_type,
+              GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX SEPARATOR ', ') AS columns
+       FROM information_schema.statistics
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+       GROUP BY INDEX_NAME, NON_UNIQUE, INDEX_TYPE
+       ORDER BY INDEX_NAME`, [schema, name], false, true);
+        const indexes = mysqlRows(indexResult).map((index) => ({
+            name: String(index.name),
+            definition: `${Number(index.non_unique) === 0 ? "UNIQUE " : ""}${String(index.index_type)} (${String(index.columns)})`,
+        }));
+        const [constraintResult] = await this.query(`SELECT CONSTRAINT_NAME AS name, CONSTRAINT_TYPE AS type
        FROM information_schema.table_constraints
-       WHERE table_schema = $1 AND table_name = $2
-       ORDER BY constraint_name`, [schema, name]);
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+       ORDER BY CONSTRAINT_NAME`, [schema, name], false, true);
+        const constraints = mysqlRows(constraintResult);
         if (kind === "indexes")
-            return { table: name, schema, indexes: indexes.rows };
+            return { table: name, schema, indexes };
         if (kind === "constraints") {
-            return { table: name, schema, constraints: constraints.rows };
+            return { table: name, schema, constraints };
         }
         if (kind !== "table")
             throw new Error(`Unknown inspection kind "${kind}".`);
         return {
             table: name,
             schema,
-            columns: columns.rows,
-            indexes: indexes.rows.length,
-            constraints: constraints.rows.length,
+            columns,
+            indexes: indexes.length,
+            constraints: constraints.length,
         };
     }
-    async close() {
-        if (this.connected)
-            await this.client.end();
+    async databaseName() {
+        const [result] = await this.query("SELECT DATABASE() AS database_name", [], false, false);
+        const row = mysqlRows(result)[0];
+        if (!row?.database_name)
+            throw new Error("MySQL connection has no database selected.");
+        return String(row.database_name);
     }
     async connect() {
         if (this.connected)
             return;
-        await this.client.connect();
-        this.connected = true;
-        if (this.readOnly) {
-            await this.client.query("SET default_transaction_read_only = on");
+        throwIfStopped(this.context, false);
+        if (this.closed)
+            throw new Error("MySQL adapter is closed.");
+        const rawClient = createMySqlConnection({
+            uri: this.source,
+            connectTimeout: remainingMilliseconds(this.context),
+            multipleStatements: false,
+            namedPlaceholders: false,
+            supportBigNumbers: true,
+            bigNumberStrings: true,
+            dateStrings: true,
+        });
+        this.rawClient = rawClient;
+        this.client = rawClient.promise();
+        try {
+            await withContext(this.client.connect(), this.context, () => this.stop(), false);
+            this.connected = true;
+            if (this.readOnly) {
+                await this.runQuery("SET SESSION TRANSACTION READ ONLY", [], false, false);
+            }
+        }
+        catch (error) {
+            this.stop();
+            throw error;
+        }
+    }
+    async query(sql, params, outcomeUnknown, prepared) {
+        await this.connect();
+        return this.runQuery(sql, params, outcomeUnknown, prepared);
+    }
+    async runQuery(sql, params, outcomeUnknown, prepared) {
+        throwIfStopped(this.context, outcomeUnknown);
+        if (!this.client || this.closed)
+            throw new Error("MySQL adapter is closed.");
+        const result = prepared
+            ? this.client.execute(sql, params)
+            : this.client.query(sql, params);
+        return withContext(result, this.context, () => this.stop(), outcomeUnknown);
+    }
+    async rollbackQuietly() {
+        if (this.closed || !this.connected)
+            return false;
+        try {
+            await this.query("ROLLBACK", [], false, false);
+            return true;
+        }
+        catch {
+            return false;
         }
     }
+    stop() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.connected = false;
+        this.rawClient?.destroy();
+    }
 }
-const POSTGRES_ISOLATION_LEVELS = new Set([
+const MYSQL_ISOLATION_LEVELS = new Set([
     "SERIALIZABLE",
     "REPEATABLE READ",
     "READ COMMITTED",
     "READ UNCOMMITTED",
 ]);
-function bindAll(statement, params) {
-    if (Array.isArray(params))
-        return statement.all(...params);
-    return statement.all(params);
+const MYSQL_TRANSACTIONAL_STATEMENTS = new Set([
+    "delete",
+    "insert",
+    "replace",
+    "update",
+]);
+function mysqlParams(params) {
+    if (!Array.isArray(params)) {
+        throw new Error("MySQL parameters must be a JSON array.");
+    }
+    return params.map((value) => {
+        if (value === undefined ||
+            Array.isArray(value) ||
+            (typeof value === "object" &&
+                value !== null &&
+                !(value instanceof Date) &&
+                !Buffer.isBuffer(value) &&
+                !(value instanceof Uint8Array))) {
+            throw new Error("MySQL parameter values must be scalar.");
+        }
+        return value;
+    });
 }
-function bindRun(statement, params) {
-    if (Array.isArray(params))
-        return statement.run(...params);
-    return statement.run(params);
+function mysqlRows(result) {
+    if (!Array.isArray(result)) {
+        throw new Error("MySQL statement did not return rows.");
+    }
+    return result;
 }
+function mysqlAffectedRows(result) {
+    if (Array.isArray(result) || !("affectedRows" in result)) {
+        throw new Error("MySQL statement did not return a write result.");
+    }
+    return Number(result.affectedRows);
+}
+function mysqlFieldType(field) {
+    return String(field.typeName ?? field.columnType ?? field.type ?? "unknown").toLowerCase();
+}
+const POSTGRES_ISOLATION_LEVELS = new Set([
+    "SERIALIZABLE",
+    "REPEATABLE READ",
+    "READ COMMITTED",
+    "READ UNCOMMITTED",
+]);
 function postgresParams(params) {
     if (Array.isArray(params))
         return params;
     throw new Error("PostgreSQL parameters must be a JSON array.");
 }
-function errorText(error) {
-    return error instanceof Error ? error.message : String(error);
+function remainingMilliseconds(context) {
+    return Math.max(1, Math.ceil(context.deadline - Date.now()));
+}
+function throwIfStopped(context, outcomeUnknown) {
+    if (context.signal?.aborted || context.deadline <= Date.now()) {
+        throw stoppedError(context, outcomeUnknown);
+    }
 }
-function inferType(rows, name) {
-    const value = rows.find((row) => row[name] !== null)?.[name];
-    if (value === undefined)
-        return "unknown";
-    if (Buffer.isBuffer(value))
-        return "binary";
-    return typeof value;
+function stoppedError(context, outcomeUnknown) {
+    const aborted = context.signal?.aborted ?? false;
+    return new AdapterExecutionError(aborted ? "Database operation cancelled." : "Database operation timed out.", aborted ? "aborted" : "timeout", outcomeUnknown);
 }
-function quoteSqliteLiteral(value) {
-    return `'${value.replaceAll("'", "''")}'`;
+function withContext(promise, context, onStop, outcomeUnknown) {
+    try {
+        throwIfStopped(context, outcomeUnknown);
+    }
+    catch (error) {
+        try {
+            onStop();
+        }
+        catch {
+            // Preserve deadline/cancellation error.
+        }
+        return Promise.reject(error);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            context.signal?.removeEventListener("abort", stop);
+            action();
+        };
+        const stop = () => {
+            finish(() => {
+                try {
+                    onStop();
+                }
+                catch {
+                    // Preserve deadline/cancellation error.
+                }
+                reject(stoppedError(context, outcomeUnknown));
+            });
+        };
+        const stopped = () => Boolean(context.signal?.aborted) || context.deadline <= Date.now();
+        const timer = setTimeout(stop, remainingMilliseconds(context));
+        context.signal?.addEventListener("abort", stop, { once: true });
+        promise.then((value) => {
+            if (stopped())
+                stop();
+            else
+                finish(() => resolve(value));
+        }, (error) => {
+            if (stopped())
+                stop();
+            else
+                finish(() => reject(error));
+        });
+    });
+}
+function postgresErrorCode(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" ? code : undefined;
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
 }