kysely 0.27.6 → 0.28.1

package/dist/cjs/schema/refresh-materialized-view-builder.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshMaterializedViewBuilder = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const refresh_materialized_view_node_js_1 = require("../operation-node/refresh-materialized-view-node.js");
+class RefreshMaterializedViewBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    /**
+     * Adds the "concurrently" modifier.
+     *
+     * Use this to refresh the view without locking out concurrent selects on the materialized view.
+     *
+     * WARNING!
+     * This cannot be used with the "with no data" modifier.
+     */
+    concurrently() {
+        return new RefreshMaterializedViewBuilder({
+            ...this.#props,
+            node: refresh_materialized_view_node_js_1.RefreshMaterializedViewNode.cloneWith(this.#props.node, {
+                concurrently: true,
+                withNoData: false,
+            }),
+        });
+    }
+    /**
+     * Adds the "with data" modifier.
+     *
+     * If specified (or defaults) the backing query is executed to provide the new data, and the materialized view is left in a scannable state
+     */
+    withData() {
+        return new RefreshMaterializedViewBuilder({
+            ...this.#props,
+            node: refresh_materialized_view_node_js_1.RefreshMaterializedViewNode.cloneWith(this.#props.node, {
+                withNoData: false,
+            }),
+        });
+    }
+    /**
+     * Adds the "with no data" modifier.
+     *
+     * If specified, no new data is generated and the materialized view is left in an unscannable state.
+     *
+     * WARNING!
+     * This cannot be used with the "concurrently" modifier.
+     */
+    withNoData() {
+        return new RefreshMaterializedViewBuilder({
+            ...this.#props,
+            node: refresh_materialized_view_node_js_1.RefreshMaterializedViewNode.cloneWith(this.#props.node, {
+                withNoData: true,
+                concurrently: false,
+            }),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+exports.RefreshMaterializedViewBuilder = RefreshMaterializedViewBuilder;

package/dist/cjs/schema/schema.d.ts

@@ -11,6 +11,7 @@ import { DropViewBuilder } from './drop-view-builder.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { CreateTypeBuilder } from './create-type-builder.js';
 import { DropTypeBuilder } from './drop-type-builder.js';
+import { RefreshMaterializedViewBuilder } from './refresh-materialized-view-builder.js';
 /**
  * Provides methods for building database schema.
  */
@@ -158,6 +159,19 @@ export declare class SchemaModule {
      * ```
      */
     createView(viewName: string): CreateViewBuilder;
+    /**
+     * Refresh a materialized view.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .refreshMaterializedView('my_view')
+     *   .concurrently()
+     *   .execute()
+     * ```
+     */
+    refreshMaterializedView(viewName: string): RefreshMaterializedViewBuilder;
     /**
      * Drop a view.
      *

package/dist/cjs/schema/schema.js

@@ -27,6 +27,8 @@ const drop_type_builder_js_1 = require("./drop-type-builder.js");
 const create_type_node_js_1 = require("../operation-node/create-type-node.js");
 const drop_type_node_js_1 = require("../operation-node/drop-type-node.js");
 const identifier_parser_js_1 = require("../parser/identifier-parser.js");
+const refresh_materialized_view_builder_js_1 = require("./refresh-materialized-view-builder.js");
+const refresh_materialized_view_node_js_1 = require("../operation-node/refresh-materialized-view-node.js");
 /**
  * Provides methods for building database schema.
  */
@@ -224,6 +226,25 @@ class SchemaModule {
             node: create_view_node_js_1.CreateViewNode.create(viewName),
         });
     }
+    /**
+     * Refresh a materialized view.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .refreshMaterializedView('my_view')
+     *   .concurrently()
+     *   .execute()
+     * ```
+     */
+    refreshMaterializedView(viewName) {
+        return new refresh_materialized_view_builder_js_1.RefreshMaterializedViewBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#executor,
+            node: refresh_materialized_view_node_js_1.RefreshMaterializedViewNode.create(viewName),
+        });
+    }
     /**
      * Drop a view.
      *

package/dist/cjs/schema/unique-constraint-builder.d.ts

@@ -3,12 +3,21 @@ import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.j
 export declare class UniqueConstraintNodeBuilder implements OperationNodeSource {
     #private;
     constructor(node: UniqueConstraintNode);
-    toOperationNode(): UniqueConstraintNode;
     /**
      * Adds `nulls not distinct` to the unique constraint definition
      *
      * Supported by PostgreSQL dialect only
      */
     nullsNotDistinct(): UniqueConstraintNodeBuilder;
+    deferrable(): UniqueConstraintNodeBuilder;
+    notDeferrable(): UniqueConstraintNodeBuilder;
+    initiallyDeferred(): UniqueConstraintNodeBuilder;
+    initiallyImmediate(): UniqueConstraintNodeBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): UniqueConstraintNode;
 }
 export type UniqueConstraintNodeBuilderCallback = (builder: UniqueConstraintNodeBuilder) => UniqueConstraintNodeBuilder;

package/dist/cjs/schema/unique-constraint-builder.js

@@ -2,15 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueConstraintNodeBuilder = void 0;
 const unique_constraint_node_js_1 = require("../operation-node/unique-constraint-node.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 class UniqueConstraintNodeBuilder {
     #node;
     constructor(node) {
         this.#node = node;
     }
-    toOperationNode() {
-        return this.#node;
-    }
     /**
      * Adds `nulls not distinct` to the unique constraint definition
      *
@@ -19,6 +15,31 @@ class UniqueConstraintNodeBuilder {
     nullsNotDistinct() {
         return new UniqueConstraintNodeBuilder(unique_constraint_node_js_1.UniqueConstraintNode.cloneWith(this.#node, { nullsNotDistinct: true }));
     }
+    deferrable() {
+        return new UniqueConstraintNodeBuilder(unique_constraint_node_js_1.UniqueConstraintNode.cloneWith(this.#node, { deferrable: true }));
+    }
+    notDeferrable() {
+        return new UniqueConstraintNodeBuilder(unique_constraint_node_js_1.UniqueConstraintNode.cloneWith(this.#node, { deferrable: false }));
+    }
+    initiallyDeferred() {
+        return new UniqueConstraintNodeBuilder(unique_constraint_node_js_1.UniqueConstraintNode.cloneWith(this.#node, {
+            initiallyDeferred: true,
+        }));
+    }
+    initiallyImmediate() {
+        return new UniqueConstraintNodeBuilder(unique_constraint_node_js_1.UniqueConstraintNode.cloneWith(this.#node, {
+            initiallyDeferred: false,
+        }));
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#node;
+    }
 }
 exports.UniqueConstraintNodeBuilder = UniqueConstraintNodeBuilder;
-(0, prevent_await_js_1.preventAwait)(UniqueConstraintNodeBuilder, "don't await UniqueConstraintNodeBuilder instances directly.");

package/dist/cjs/util/infer-result.d.ts

@@ -44,5 +44,5 @@ import { Simplify } from './type-utils.js';
  * ```
  */
 export type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
-type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult | MergeResult ? O : Simplify<O>[];
+type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult | MergeResult ? O[] : Simplify<O>[];
 export {};

package/dist/cjs/util/log.d.ts

@@ -4,6 +4,7 @@ export declare const LOG_LEVELS: readonly ["query", "error"];
 export type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
 export interface QueryLogEvent {
     readonly level: 'query';
+    readonly isStream?: boolean;
     readonly query: CompiledQuery;
     readonly queryDurationMillis: number;
 }

package/dist/cjs/util/log.js

@@ -39,8 +39,9 @@ class Log {
 exports.Log = Log;
 function defaultLogger(event) {
     if (event.level === 'query') {
-        console.log(`kysely:query: ${event.query.sql}`);
-        console.log(`kysely:query: duration: ${event.queryDurationMillis.toFixed(1)}ms`);
+        const prefix = `kysely:query:${event.isStream ? 'stream:' : ''}`;
+        console.log(`${prefix} ${event.query.sql}`);
+        console.log(`${prefix} duration: ${event.queryDurationMillis.toFixed(1)}ms`);
     }
     else if (event.level === 'error') {
         if (event.error instanceof Error) {

package/dist/cjs/util/provide-controlled-connection.d.ts

@@ -0,0 +1,7 @@
+import { ConnectionProvider } from '../driver/connection-provider.js';
+import { DatabaseConnection } from '../driver/database-connection.js';
+export interface ControlledConnection {
+    readonly connection: DatabaseConnection;
+    readonly release: () => void;
+}
+export declare function provideControlledConnection(connectionProvider: ConnectionProvider): Promise<ControlledConnection>;

package/dist/cjs/util/provide-controlled-connection.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.provideControlledConnection = provideControlledConnection;
+const deferred_js_1 = require("./deferred.js");
+const object_utils_js_1 = require("./object-utils.js");
+async function provideControlledConnection(connectionProvider) {
+    const connectionDefer = new deferred_js_1.Deferred();
+    const connectionReleaseDefer = new deferred_js_1.Deferred();
+    connectionProvider
+        .provideConnection(async (connection) => {
+        connectionDefer.resolve(connection);
+        return await connectionReleaseDefer.promise;
+    })
+        .catch((ex) => connectionDefer.reject(ex));
+    // Create composite of the connection and the release method instead of
+    // modifying the connection or creating a new nesting `DatabaseConnection`.
+    // This way we don't accidentally override any methods of 3rd party
+    // connections and don't return wrapped connections to drivers that
+    // expect a certain specific connection class.
+    return (0, object_utils_js_1.freeze)({
+        connection: await connectionDefer.promise,
+        release: connectionReleaseDefer.resolve,
+    });
+}

package/dist/esm/dialect/mssql/mssql-dialect-config.d.ts

@@ -1,4 +1,12 @@
+import { KyselyTypeError } from '../../util/type-error.js';
 export interface MssqlDialectConfig {
+    /**
+     * When `true`, connections are reset to their initial states when released
+     * back to the pool, resulting in additional requests to the database.
+     *
+     * Defaults to `false`.
+     */
+    resetConnectionsOnRelease?: boolean;
     /**
      * This dialect uses the `tarn` package to manage the connection pool to your
      * database. To use it as a peer dependency and not bundle it with Kysely's code,
@@ -54,26 +62,30 @@ export interface MssqlDialectConfig {
      * ```
      */
     tedious: Tedious;
+    /**
+     * When `true`, connections are validated before being acquired from the pool,
+     * resulting in additional requests to the database.
+     *
+     * Defaults to `true`.
+     */
+    validateConnections?: boolean;
 }
 export interface Tedious {
     connectionFactory: () => TediousConnection | Promise<TediousConnection>;
     ISOLATION_LEVEL: TediousIsolationLevel;
     Request: TediousRequestClass;
-    TYPES: TediousTypes;
     /**
-     * Controls whether connections are reset to their initial states when released back to the pool. Resetting a connection performs additional requests to the database.
-     * See {@link https://tediousjs.github.io/tedious/api-connection.html#function_reset | connection.reset}.
-     *
-     * Defaults to `true`.
+     * @deprecated use {@link MssqlDialectConfig.resetConnectionsOnRelease} instead.
      */
-    resetConnectionOnRelease?: boolean;
+    resetConnectionOnRelease?: KyselyTypeError<'deprecated: use `MssqlDialectConfig.resetConnectionsOnRelease` instead'>;
+    TYPES: TediousTypes;
 }
 export interface TediousConnection {
-    beginTransaction(callback: (error?: Error | null, transactionDescriptor?: any) => void, name?: string, isolationLevel?: number): void;
+    beginTransaction(callback: (err: Error | null | undefined, transactionDescriptor?: any) => void, name?: string | undefined, isolationLevel?: number | undefined): void;
     cancel(): boolean;
     close(): void;
-    commitTransaction(callback: (error?: Error | null) => void, name?: string): void;
-    connect(callback?: (error?: Error) => void): void;
+    commitTransaction(callback: (err: Error | null | undefined) => void, name?: string | undefined): void;
+    connect(connectListener: (err?: Error) => void): void;
     execSql(request: TediousRequest): void;
     off(event: 'error', listener: (error: unknown) => void): this;
     off(event: string, listener: (...args: any[]) => void): this;
@@ -81,9 +93,9 @@ export interface TediousConnection {
     on(event: string, listener: (...args: any[]) => void): this;
     once(event: 'end', listener: () => void): this;
     once(event: string, listener: (...args: any[]) => void): this;
-    reset(callback: (error?: Error | null) => void): void;
-    rollbackTransaction(callback: (error?: Error | null) => void, name?: string): void;
-    saveTransaction(callback: (error?: Error | null) => void, name: string): void;
+    reset(callback: (err: Error | null | undefined) => void): void;
+    rollbackTransaction(callback: (err: Error | null | undefined) => void, name?: string | undefined): void;
+    saveTransaction(callback: (err: Error | null | undefined) => void, name: string): void;
 }
 export type TediousIsolationLevel = Record<string, number>;
 export interface TediousRequestClass {
@@ -132,11 +144,9 @@ export interface Tarn {
      */
     options: Omit<TarnPoolOptions<any>, 'create' | 'destroy' | 'validate'> & {
         /**
-         * Controls whether connections are validated before being acquired from the pool. Connection validation performs additional requests to the database.
-         *
-         * Defaults to `true`.
+         * @deprecated use {@link MssqlDialectConfig.validateConnections} instead.
          */
-        validateConnections?: boolean;
+        validateConnections?: KyselyTypeError<'deprecated: use `MssqlDialectConfig.validateConnections` instead'>;
     };
     /**
      * Tarn.js' Pool class.

package/dist/esm/dialect/mssql/mssql-driver.d.ts

@@ -2,7 +2,7 @@ import { DatabaseConnection, QueryResult } from '../../driver/database-connectio
 import { Driver, TransactionSettings } from '../../driver/driver.js';
 import { MssqlDialectConfig, Tedious, TediousConnection } from './mssql-dialect-config.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-declare const PRIVATE_RELEASE_METHOD: unique symbol;
+declare const PRIVATE_RESET_METHOD: unique symbol;
 declare const PRIVATE_DESTROY_METHOD: unique symbol;
 export declare class MssqlDriver implements Driver {
     #private;
@@ -30,6 +30,8 @@ export declare class MssqlDriver implements Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: MssqlConnection): Promise<void>;
+    savepoint(connection: MssqlConnection, savepointName: string): Promise<void>;
+    rollbackToSavepoint(connection: MssqlConnection, savepointName: string): Promise<void>;
     /**
      * Releases a connection back to the pool.
      */
@@ -46,10 +48,11 @@ declare class MssqlConnection implements DatabaseConnection {
     commitTransaction(): Promise<void>;
     connect(): Promise<this>;
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
-    rollbackTransaction(): Promise<void>;
+    rollbackTransaction(savepointName?: string): Promise<void>;
+    savepoint(savepointName: string): Promise<void>;
     streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     validate(): Promise<boolean>;
-    [PRIVATE_RELEASE_METHOD](): Promise<void>;
+    [PRIVATE_RESET_METHOD](): Promise<void>;
     [PRIVATE_DESTROY_METHOD](): Promise<void>;
 }
 export {};

package/dist/esm/dialect/mssql/mssql-driver.js

@@ -4,15 +4,15 @@ import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { extendStackTrace } from '../../util/stack-trace-utils.js';
 import { randomString } from '../../util/random-string.js';
 import { Deferred } from '../../util/deferred.js';
-const PRIVATE_RELEASE_METHOD = Symbol();
+const PRIVATE_RESET_METHOD = Symbol();
 const PRIVATE_DESTROY_METHOD = Symbol();
 export class MssqlDriver {
     #config;
     #pool;
     constructor(config) {
         this.#config = freeze({ ...config });
-        const { tarn, tedious } = this.#config;
-        const { validateConnections, ...poolOptions } = tarn.options;
+        const { tarn, tedious, validateConnections } = this.#config;
+        const { validateConnections: deprecatedValidateConnections, ...poolOptions } = tarn.options;
         this.#pool = new tarn.Pool({
             ...poolOptions,
             create: async () => {
@@ -24,7 +24,8 @@ export class MssqlDriver {
             },
             // @ts-ignore `tarn` accepts a function that returns a promise here, but
             // the types are not aligned and it type errors.
-            validate: validateConnections === false
+            validate: validateConnections === false ||
+                deprecatedValidateConnections === false
                 ? undefined
                 : (connection) => connection.validate(),
         });
@@ -44,8 +45,17 @@ export class MssqlDriver {
     async rollbackTransaction(connection) {
         await connection.rollbackTransaction();
     }
+    async savepoint(connection, savepointName) {
+        await connection.savepoint(savepointName);
+    }
+    async rollbackToSavepoint(connection, savepointName) {
+        await connection.rollbackTransaction(savepointName);
+    }
     async releaseConnection(connection) {
-        await connection[PRIVATE_RELEASE_METHOD]();
+        if (this.#config.resetConnectionsOnRelease ||
+            this.#config.tedious.resetConnectionOnRelease) {
+            await connection[PRIVATE_RESET_METHOD]();
+        }
         this.#pool.release(connection);
     }
     async destroy() {
@@ -115,13 +125,21 @@ class MssqlConnection {
             throw extendStackTrace(err, new Error());
         }
     }
-    async rollbackTransaction() {
+    async rollbackTransaction(savepointName) {
         await new Promise((resolve, reject) => this.#connection.rollbackTransaction((error) => {
             if (error)
                 reject(error);
             else
                 resolve(undefined);
-        }));
+        }, savepointName));
+    }
+    async savepoint(savepointName) {
+        await new Promise((resolve, reject) => this.#connection.saveTransaction((error) => {
+            if (error)
+                reject(error);
+            else
+                resolve(undefined);
+        }, savepointName));
     }
     async *streamQuery(compiledQuery, chunkSize) {
         if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
@@ -190,18 +208,15 @@ class MssqlConnection {
             }
         });
     }
-    async [PRIVATE_RELEASE_METHOD]() {
-        // TODO: flip this to `if (!this.#tedious.resetConnectionOnRelease) {}` in a future PR.
-        if (this.#tedious.resetConnectionOnRelease !== false) {
-            await new Promise((resolve, reject) => {
-                this.#connection.reset((error) => {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve(undefined);
-                });
+    async [PRIVATE_RESET_METHOD]() {
+        await new Promise((resolve, reject) => {
+            this.#connection.reset((error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(undefined);
             });
-        }
+        });
     }
     [PRIVATE_DESTROY_METHOD]() {
         return new Promise((resolve) => {
@@ -218,7 +233,6 @@ class MssqlRequest {
     #streamChunkSize;
     #subscribers;
     #tedious;
-    #error;
     #rowCount;
     constructor(props) {
         const { compiledQuery, onDone, streamChunkSize, tedious } = props;

package/dist/esm/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/esm/dialect/mssql/mssql-query-compiler.js

@@ -1,5 +1,6 @@
 /// <reference types="./mssql-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const COLLATION_CHAR_REGEX = /^[a-z0-9_]$/i;
 export class MssqlQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return `@${this.numParameters}`;
@@ -63,6 +64,16 @@ export class MssqlQueryCompiler extends DefaultQueryCompiler {
         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/esm/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/esm/dialect/mysql/mysql-driver.js

@@ -1,6 +1,8 @@
 /// <reference types="./mysql-driver.d.ts" />
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { isFunction, isObject, freeze } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
 import { extendStackTrace } from '../../util/stack-trace-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class MysqlDriver {
@@ -46,9 +48,17 @@ export 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(CompiledQuery.raw(`set transaction isolation level ${settings.isolationLevel}`));
+            await connection.executeQuery(CompiledQuery.raw(sql));
         }
         await connection.executeQuery(CompiledQuery.raw('begin'));
     }
@@ -58,6 +68,15 @@ export class MysqlDriver {
     async rollbackTransaction(connection) {
         await connection.executeQuery(CompiledQuery.raw('rollback'));
     }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release savepoint', savepointName), createQueryId()));
+    }
     async releaseConnection(connection) {
         connection[PRIVATE_RELEASE_METHOD]();
     }
@@ -87,22 +106,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/esm/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.
      */