kysely 0.27.5 → 0.28.0

package/dist/cjs/dialect/mssql/mssql-query-compiler.d.ts

@@ -4,6 +4,7 @@ import { DropColumnNode } from '../../operation-node/drop-column-node.js';
 import { OffsetNode } from '../../operation-node/offset-node.js';
 import { MergeQueryNode } from '../../operation-node/merge-query-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+import { CollateNode } from '../../operation-node/collate-node.js';
 export declare class MssqlQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
     protected visitOffset(node: OffsetNode): void;
@@ -11,5 +12,6 @@ export declare class MssqlQueryCompiler extends DefaultQueryCompiler {
     protected visitAddColumn(node: AddColumnNode): void;
     protected visitDropColumn(node: DropColumnNode): void;
     protected visitMergeQuery(node: MergeQueryNode): void;
+    protected visitCollate(node: CollateNode): void;
     protected announcesNewColumnDataType(): boolean;
 }

package/dist/cjs/dialect/mssql/mssql-query-compiler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MssqlQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
+const COLLATION_CHAR_REGEX = /^[a-z0-9_]$/i;
 class MssqlQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return `@${this.numParameters}`;
@@ -65,6 +66,16 @@ class MssqlQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompile
         super.visitMergeQuery(node);
         this.append(';');
     }
+    visitCollate(node) {
+        this.append('collate ');
+        const { name } = node.collation;
+        for (const char of name) {
+            if (!COLLATION_CHAR_REGEX.test(char)) {
+                throw new Error(`Invalid collation: ${name}`);
+            }
+        }
+        this.append(name);
+    }
     announcesNewColumnDataType() {
         return false;
     }

package/dist/cjs/dialect/mysql/mysql-driver.d.ts

@@ -1,6 +1,7 @@
 import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { MysqlDialectConfig, MysqlPoolConnection } from './mysql-dialect-config.js';
 declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class MysqlDriver implements Driver {
@@ -29,6 +30,9 @@ export declare class MysqlDriver implements Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Releases a connection back to the pool.
      */

package/dist/cjs/dialect/mysql/mysql-driver.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlDriver = void 0;
+const savepoint_parser_js_1 = require("../../parser/savepoint-parser.js");
 const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+const query_id_js_1 = require("../../util/query-id.js");
 const stack_trace_utils_js_1 = require("../../util/stack-trace-utils.js");
 const PRIVATE_RELEASE_METHOD = Symbol();
 class MysqlDriver {
@@ -48,9 +50,17 @@ class MysqlDriver {
         });
     }
     async beginTransaction(connection, settings) {
-        if (settings.isolationLevel) {
+        if (settings.isolationLevel || settings.accessMode) {
+            const parts = [];
+            if (settings.isolationLevel) {
+                parts.push(`isolation level ${settings.isolationLevel}`);
+            }
+            if (settings.accessMode) {
+                parts.push(settings.accessMode);
+            }
+            const sql = `set transaction ${parts.join(', ')}`;
             // On MySQL this sets the isolation level of the next transaction.
-            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw(`set transaction isolation level ${settings.isolationLevel}`));
+            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw(sql));
         }
         await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('begin'));
     }
@@ -60,6 +70,15 @@ class MysqlDriver {
     async rollbackTransaction(connection) {
         await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
     }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('savepoint', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('rollback to', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('release savepoint', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
     async releaseConnection(connection) {
         connection[PRIVATE_RELEASE_METHOD]();
     }
@@ -90,22 +109,18 @@ class MysqlConnection {
             const result = await this.#executeQuery(compiledQuery);
             if (isOkPacket(result)) {
                 const { insertId, affectedRows, changedRows } = result;
-                const numAffectedRows = affectedRows !== undefined && affectedRows !== null
-                    ? BigInt(affectedRows)
-                    : undefined;
-                const numChangedRows = changedRows !== undefined && changedRows !== null
-                    ? BigInt(changedRows)
-                    : undefined;
                 return {
                     insertId: insertId !== undefined &&
                         insertId !== null &&
                         insertId.toString() !== '0'
                         ? BigInt(insertId)
                         : undefined,
-                    // TODO: remove.
-                    numUpdatedOrDeletedRows: numAffectedRows,
-                    numAffectedRows,
-                    numChangedRows,
+                    numAffectedRows: affectedRows !== undefined && affectedRows !== null
+                        ? BigInt(affectedRows)
+                        : undefined,
+                    numChangedRows: changedRows !== undefined && changedRows !== null
+                        ? BigInt(changedRows)
+                        : undefined,
                     rows: [],
                 };
             }

package/dist/cjs/dialect/postgres/postgres-driver.d.ts

@@ -1,6 +1,7 @@
 import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { PostgresCursorConstructor, PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
 declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class PostgresDriver implements Driver {
@@ -29,6 +30,9 @@ export declare class PostgresDriver implements Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Releases a connection back to the pool.
      */

package/dist/cjs/dialect/postgres/postgres-driver.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresDriver = void 0;
+const savepoint_parser_js_1 = require("../../parser/savepoint-parser.js");
 const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+const query_id_js_1 = require("../../util/query-id.js");
 const stack_trace_utils_js_1 = require("../../util/stack-trace-utils.js");
 const PRIVATE_RELEASE_METHOD = Symbol();
 class PostgresDriver {
@@ -38,8 +40,15 @@ class PostgresDriver {
         return connection;
     }
     async beginTransaction(connection, settings) {
-        if (settings.isolationLevel) {
-            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw(`start transaction isolation level ${settings.isolationLevel}`));
+        if (settings.isolationLevel || settings.accessMode) {
+            let sql = 'start transaction';
+            if (settings.isolationLevel) {
+                sql += ` isolation level ${settings.isolationLevel}`;
+            }
+            if (settings.accessMode) {
+                sql += ` ${settings.accessMode}`;
+            }
+            await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw(sql));
         }
         else {
             await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('begin'));
@@ -51,6 +60,15 @@ class PostgresDriver {
     async rollbackTransaction(connection) {
         await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
     }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('savepoint', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('rollback to', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('release', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
     async releaseConnection(connection) {
         connection[PRIVATE_RELEASE_METHOD]();
     }
@@ -72,23 +90,15 @@ class PostgresConnection {
     }
     async executeQuery(compiledQuery) {
         try {
-            const result = await this.#client.query(compiledQuery.sql, [
-                ...compiledQuery.parameters,
-            ]);
-            if (result.command === 'INSERT' ||
-                result.command === 'UPDATE' ||
-                result.command === 'DELETE' ||
-                result.command === 'MERGE') {
-                const numAffectedRows = BigInt(result.rowCount);
-                return {
-                    // TODO: remove.
-                    numUpdatedOrDeletedRows: numAffectedRows,
-                    numAffectedRows,
-                    rows: result.rows ?? [],
-                };
-            }
+            const { command, rowCount, rows } = await this.#client.query(compiledQuery.sql, [...compiledQuery.parameters]);
             return {
-                rows: result.rows ?? [],
+                numAffectedRows: command === 'INSERT' ||
+                    command === 'UPDATE' ||
+                    command === 'DELETE' ||
+                    command === 'MERGE'
+                    ? BigInt(rowCount)
+                    : undefined,
+                rows: rows ?? [],
             };
         }
         catch (err) {

package/dist/cjs/dialect/postgres/postgres-introspector.js

@@ -39,23 +39,13 @@ class PostgresIntrospector {
             'typ.typname as type',
             'dtns.nspname as type_schema',
             (0, sql_js_1.sql) `col_description(a.attrelid, a.attnum)`.as('column_description'),
-            // Detect if the column is auto incrementing by finding the sequence
-            // that is created for `serial` and `bigserial` columns.
-            this.#db
-                .selectFrom('pg_class')
-                .select((0, sql_js_1.sql) `true`.as('auto_incrementing'))
-                // Make sure the sequence is in the same schema as the table.
-                .whereRef('relnamespace', '=', 'c.relnamespace')
-                .where('relkind', '=', 'S')
-                .where('relname', '=', (0, sql_js_1.sql) `c.relname || '_' || a.attname || '_seq'`)
-                .as('auto_incrementing'),
+            (0, sql_js_1.sql) `pg_get_serial_sequence(ns.nspname || '.' || c.relname, a.attname)`.as('auto_incrementing'),
+        ])
+            .where('c.relkind', 'in', [
+            'r' /*regular table*/,
+            'v' /*view*/,
+            'p' /*partitioned table*/,
         ])
-            // r == normal table
-            .where((eb) => eb.or([
-            eb('c.relkind', '=', 'r'),
-            eb('c.relkind', '=', 'v'),
-            eb('c.relkind', '=', 'p'),
-        ]))
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns
@@ -95,7 +85,7 @@ class PostgresIntrospector {
                 dataType: it.type,
                 dataTypeSchema: it.type_schema,
                 isNullable: !it.not_null,
-                isAutoIncrementing: !!it.auto_incrementing,
+                isAutoIncrementing: it.auto_incrementing !== null,
                 hasDefaultValue: it.has_default,
                 comment: it.column_description ?? undefined,
             }));

package/dist/cjs/dialect/sqlite/sqlite-driver.d.ts

@@ -1,5 +1,6 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
 import { Driver } from '../../driver/driver.js';
+import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { SqliteDialectConfig } from './sqlite-dialect-config.js';
 export declare class SqliteDriver implements Driver {
     #private;
@@ -27,6 +28,9 @@ export declare class SqliteDriver implements Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Releases a connection back to the pool.
      */

package/dist/cjs/dialect/sqlite/sqlite-driver.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqliteDriver = void 0;
 const select_query_node_js_1 = require("../../operation-node/select-query-node.js");
+const savepoint_parser_js_1 = require("../../parser/savepoint-parser.js");
 const compiled_query_js_1 = require("../../query-compiler/compiled-query.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+const query_id_js_1 = require("../../util/query-id.js");
 class SqliteDriver {
     #config;
     #connectionMutex = new ConnectionMutex();
@@ -36,6 +38,15 @@ class SqliteDriver {
     async rollbackTransaction(connection) {
         await connection.executeQuery(compiled_query_js_1.CompiledQuery.raw('rollback'));
     }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('savepoint', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('rollback to', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery((0, savepoint_parser_js_1.parseSavepointCommand)('release', savepointName), (0, query_id_js_1.createQueryId)()));
+    }
     async releaseConnection() {
         this.#connectionMutex.unlock();
     }
@@ -57,19 +68,14 @@ class SqliteConnection {
                 rows: stmt.all(parameters),
             });
         }
-        else {
-            const { changes, lastInsertRowid } = stmt.run(parameters);
-            const numAffectedRows = changes !== undefined && changes !== null ? BigInt(changes) : undefined;
-            return Promise.resolve({
-                // TODO: remove.
-                numUpdatedOrDeletedRows: numAffectedRows,
-                numAffectedRows,
-                insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
-                    ? BigInt(lastInsertRowid)
-                    : undefined,
-                rows: [],
-            });
-        }
+        const { changes, lastInsertRowid } = stmt.run(parameters);
+        return Promise.resolve({
+            numAffectedRows: changes !== undefined && changes !== null ? BigInt(changes) : undefined,
+            insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
+                ? BigInt(lastInsertRowid)
+                : undefined,
+            rows: [],
+        });
     }
     async *streamQuery(compiledQuery, _chunkSize) {
         const { sql, parameters, query } = compiledQuery;

package/dist/cjs/dialect/sqlite/sqlite-introspector.js

@@ -13,59 +13,81 @@ class SqliteIntrospector {
         return [];
     }
     async getTables(options = { withInternalKyselyTables: false }) {
-        let query = this.#db
+        return await this.#getTableMetadata(options);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+    #tablesQuery(qb, options) {
+        let tablesQuery = qb
             .selectFrom('sqlite_master')
             .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
-            .select('name')
-            .orderBy('name')
-            .$castTo();
+            .select(['name', 'sql', 'type'])
+            .orderBy('name');
         if (!options.withInternalKyselyTables) {
-            query = query
+            tablesQuery = tablesQuery
                 .where('name', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
                 .where('name', '!=', migrator_js_1.DEFAULT_MIGRATION_LOCK_TABLE);
         }
-        const tables = await query.execute();
-        return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+        return tablesQuery;
     }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
-    async #getTableMetadata(table) {
-        const db = this.#db;
-        // Get the SQL that was used to create the table.
-        const tableDefinition = await db
-            .selectFrom('sqlite_master')
-            .where('name', '=', table)
-            .select(['sql', 'type'])
-            .$castTo()
-            .executeTakeFirstOrThrow();
-        // Try to find the name of the column that has `autoincrement` 🤦
-        const autoIncrementCol = tableDefinition.sql
-            ?.split(/[\(\),]/)
-            ?.find((it) => it.toLowerCase().includes('autoincrement'))
-            ?.trimStart()
-            ?.split(/\s+/)?.[0]
-            ?.replace(/["`]/g, '');
-        const columns = await db
-            .selectFrom((0, sql_js_1.sql) `pragma_table_info(${table})`.as('table_info'))
-            .select(['name', 'type', 'notnull', 'dflt_value'])
-            .orderBy('cid')
+    async #getTableMetadata(options) {
+        const tablesResult = await this.#tablesQuery(this.#db, options).execute();
+        const tableMetadata = await this.#db
+            .with('table_list', (qb) => this.#tablesQuery(qb, options))
+            .selectFrom([
+            'table_list as tl',
+            (0, sql_js_1.sql) `pragma_table_info(tl.name)`.as('p'),
+        ])
+            .select([
+            'tl.name as table',
+            'p.cid',
+            'p.name',
+            'p.type',
+            'p.notnull',
+            'p.dflt_value',
+            'p.pk',
+        ])
+            .orderBy(['tl.name', 'p.cid'])
             .execute();
-        return {
-            name: table,
-            isView: tableDefinition.type === 'view',
-            columns: columns.map((col) => ({
-                name: col.name,
-                dataType: col.type,
-                isNullable: !col.notnull,
-                isAutoIncrementing: col.name === autoIncrementCol,
-                hasDefaultValue: col.dflt_value != null,
-                comment: undefined,
-            })),
-        };
+        const columnsByTable = {};
+        for (const row of tableMetadata) {
+            columnsByTable[row.table] ??= [];
+            columnsByTable[row.table].push(row);
+        }
+        return tablesResult.map(({ name, sql, type }) => {
+            // // Try to find the name of the column that has `autoincrement` 🤦
+            let autoIncrementCol = sql
+                ?.split(/[\(\),]/)
+                ?.find((it) => it.toLowerCase().includes('autoincrement'))
+                ?.trimStart()
+                ?.split(/\s+/)?.[0]
+                ?.replace(/["`]/g, '');
+            const columns = columnsByTable[name] ?? [];
+            // Otherwise, check for an INTEGER PRIMARY KEY
+            // https://www.sqlite.org/autoinc.html
+            if (!autoIncrementCol) {
+                const pkCols = columns.filter((r) => r.pk > 0);
+                if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === 'integer') {
+                    autoIncrementCol = pkCols[0].name;
+                }
+            }
+            return {
+                name: name,
+                isView: type === 'view',
+                columns: columns.map((col) => ({
+                    name: col.name,
+                    dataType: col.type,
+                    isNullable: !col.notnull,
+                    isAutoIncrementing: col.name === autoIncrementCol,
+                    hasDefaultValue: col.dflt_value != null,
+                    comment: undefined,
+                })),
+            };
+        });
     }
 }
 exports.SqliteIntrospector = SqliteIntrospector;

package/dist/cjs/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -1,6 +1,8 @@
 import { DefaultInsertValueNode } from '../../operation-node/default-insert-value-node.js';
+import { OrActionNode } from '../../operation-node/or-action-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
+    protected visitOrAction(node: OrActionNode): void;
     protected getCurrentParameterPlaceholder(): string;
     protected getLeftExplainOptionsWrapper(): string;
     protected getRightExplainOptionsWrapper(): string;

package/dist/cjs/dialect/sqlite/sqlite-query-compiler.js

@@ -4,6 +4,10 @@ exports.SqliteQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
 const ID_WRAP_REGEX = /"/g;
 class SqliteQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
+    visitOrAction(node) {
+        this.append('or ');
+        this.append(node.action);
+    }
     getCurrentParameterPlaceholder() {
         return '?';
     }

package/dist/cjs/driver/database-connection.d.ts

@@ -9,10 +9,6 @@ export interface DatabaseConnection {
     streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
 }
 export interface QueryResult<O> {
-    /**
-     * @deprecated use {@link QueryResult.numAffectedRows} instead.
-     */
-    readonly numUpdatedOrDeletedRows?: bigint;
     /**
      * This is defined for insert, update, delete and merge queries and contains
      * the number of rows the query inserted/updated/deleted.

package/dist/cjs/driver/driver.d.ts

@@ -1,3 +1,4 @@
+import { QueryCompiler } from '../query-compiler/query-compiler.js';
 import { ArrayItemType } from '../util/type-utils.js';
 import { DatabaseConnection } from './database-connection.js';
 /**
@@ -28,6 +29,18 @@ export interface Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Establishses a new savepoint within a transaction.
+     */
+    savepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Rolls back to a savepoint within a transaction.
+     */
+    rollbackToSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a savepoint within a transaction.
+     */
+    releaseSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Releases a connection back to the pool.
      */
@@ -38,7 +51,11 @@ export interface Driver {
     destroy(): Promise<void>;
 }
 export interface TransactionSettings {
+    readonly accessMode?: AccessMode;
     readonly isolationLevel?: IsolationLevel;
 }
+export declare const TRANSACTION_ACCESS_MODES: readonly ["read only", "read write"];
+export type AccessMode = ArrayItemType<typeof TRANSACTION_ACCESS_MODES>;
 export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable", "snapshot"];
 export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;
+export declare function validateTransactionSettings(settings: TransactionSettings): void;

package/dist/cjs/driver/driver.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRANSACTION_ISOLATION_LEVELS = void 0;
+exports.TRANSACTION_ISOLATION_LEVELS = exports.TRANSACTION_ACCESS_MODES = void 0;
+exports.validateTransactionSettings = validateTransactionSettings;
+exports.TRANSACTION_ACCESS_MODES = ['read only', 'read write'];
 exports.TRANSACTION_ISOLATION_LEVELS = [
     'read uncommitted',
     'read committed',
@@ -8,3 +10,13 @@ exports.TRANSACTION_ISOLATION_LEVELS = [
     'serializable',
     'snapshot',
 ];
+function validateTransactionSettings(settings) {
+    if (settings.accessMode &&
+        !exports.TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) {
+        throw new Error(`invalid transaction access mode ${settings.accessMode}`);
+    }
+    if (settings.isolationLevel &&
+        !exports.TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
+        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
+    }
+}

package/dist/cjs/driver/dummy-driver.d.ts

@@ -69,4 +69,7 @@ export declare class DummyDriver implements Driver {
      * Destroys the driver and releases all resources.
      */
     destroy(): Promise<void>;
+    releaseSavepoint(): Promise<void>;
+    rollbackToSavepoint(): Promise<void>;
+    savepoint(): Promise<void>;
 }

package/dist/cjs/driver/dummy-driver.js

@@ -60,6 +60,15 @@ class DummyDriver {
     async destroy() {
         // Nothing to do here.
     }
+    async releaseSavepoint() {
+        // Nothing to do here.
+    }
+    async rollbackToSavepoint() {
+        // Nothing to do here.
+    }
+    async savepoint() {
+        // Nothing to do here.
+    }
 }
 exports.DummyDriver = DummyDriver;
 class DummyConnection {

package/dist/cjs/driver/runtime-driver.d.ts

@@ -1,3 +1,4 @@
+import { QueryCompiler } from '../query-compiler/query-compiler.js';
 import { Log } from '../util/log.js';
 import { DatabaseConnection } from './database-connection.js';
 import { Driver, TransactionSettings } from './driver.js';
@@ -36,6 +37,9 @@ export declare class RuntimeDriver implements Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Destroys the driver and releases all resources.
      */