kysely 0.17.0 → 0.17.3

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

@@ -162,6 +162,25 @@ export interface MysqlDialectConfig {
      * If keep-alive is enabled users can supply an initial delay.
      */
     keepAliveInitialDelay?: number;
+    charsetNumber?: number;
+    compress?: boolean;
+    authSwitchHandler?: (data: any, callback: () => void) => any;
+    connectAttributes?: {
+        [param: string]: any;
+    };
+    decimalNumbers?: boolean;
+    isServer?: boolean;
+    maxPreparedStatements?: number;
+    namedPlaceholders?: boolean;
+    nestTables?: boolean | string;
+    passwordSha1?: string;
+    pool?: any;
+    stream?: any;
+    uri?: string;
+    Promise?: any;
+    authPlugins?: {
+        [key: string]: any;
+    };
     /**
      * Called once for each created connection.
      *

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

@@ -4,5 +4,5 @@ export interface ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/cjs/driver/default-connection-provider.d.ts

@@ -8,5 +8,5 @@ export declare class DefaultConnectionProvider implements ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/cjs/driver/default-connection-provider.js

@@ -6,10 +6,10 @@ class DefaultConnectionProvider {
     constructor(driver) {
         this.#driver = driver;
     }
-    async withConnection(runner) {
+    async provideConnection(consumer) {
         const connection = await this.#driver.acquireConnection();
         try {
-            return await runner(connection);
+            return await consumer(connection);
         }
         finally {
             await this.#driver.releaseConnection(connection);

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

@@ -27,6 +27,14 @@ import { Driver } from './driver.js';
  *   },
  * })
  * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
  */
 export declare class DummyDriver implements Driver {
     /**

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

@@ -28,6 +28,14 @@ exports.DummyDriver = void 0;
  *   },
  * })
  * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
  */
 class DummyDriver {
     async init() {

package/dist/cjs/driver/single-connection-provider.d.ts

@@ -7,5 +7,5 @@ export declare class SingleConnectionProvider implements ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/cjs/driver/single-connection-provider.js

@@ -7,11 +7,11 @@ class SingleConnectionProvider {
     constructor(connection) {
         this.#connection = connection;
     }
-    async withConnection(runner) {
+    async provideConnection(consumer) {
         while (this.#runningPromise) {
             await this.#runningPromise;
         }
-        const promise = this.#run(runner);
+        const promise = this.#run(consumer);
         this.#runningPromise = promise
             .then(() => {
             this.#runningPromise = undefined;

package/dist/cjs/kysely.js

@@ -338,18 +338,14 @@ class ConnectionBuilder {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
     async execute(callback) {
-        const connection = await this.#props.driver.acquireConnection();
-        const connectionProvider = new single_connection_provider_js_1.SingleConnectionProvider(connection);
-        const db = new Kysely({
-            ...this.#props,
-            executor: this.#props.executor.withConnectionProvider(connectionProvider),
-        });
-        try {
+        return this.#props.executor.provideConnection(async (connection) => {
+            const executor = this.#props.executor.withConnectionProvider(new single_connection_provider_js_1.SingleConnectionProvider(connection));
+            const db = new Kysely({
+                ...this.#props,
+                executor,
+            });
             return await callback(db);
-        }
-        finally {
-            await this.#props.driver.releaseConnection(connection);
-        }
+        });
     }
 }
 exports.ConnectionBuilder = ConnectionBuilder;
@@ -369,25 +365,23 @@ class TransactionBuilder {
         const { isolationLevel, ...kyselyProps } = this.#props;
         const settings = { isolationLevel };
         validateTransactionSettings(settings);
-        const connection = await this.#props.driver.acquireConnection();
-        const connectionProvider = new single_connection_provider_js_1.SingleConnectionProvider(connection);
-        const transaction = new Transaction({
-            ...kyselyProps,
-            executor: this.#props.executor.withConnectionProvider(connectionProvider),
+        return this.#props.executor.provideConnection(async (connection) => {
+            const executor = this.#props.executor.withConnectionProvider(new single_connection_provider_js_1.SingleConnectionProvider(connection));
+            const transaction = new Transaction({
+                ...kyselyProps,
+                executor,
+            });
+            try {
+                await this.#props.driver.beginTransaction(connection, settings);
+                const result = await callback(transaction);
+                await this.#props.driver.commitTransaction(connection);
+                return result;
+            }
+            catch (error) {
+                await this.#props.driver.rollbackTransaction(connection);
+                throw error;
+            }
         });
-        try {
-            await this.#props.driver.beginTransaction(connection, settings);
-            const result = await callback(transaction);
-            await this.#props.driver.commitTransaction(connection);
-            return result;
-        }
-        catch (error) {
-            await this.#props.driver.rollbackTransaction(connection);
-            throw error;
-        }
-        finally {
-            await this.#props.driver.releaseConnection(connection);
-        }
     }
 }
 exports.TransactionBuilder = TransactionBuilder;

package/dist/cjs/parser/complex-expression-parser.d.ts

@@ -1,7 +1,7 @@
-import { RawBuilder } from '../index-nodeless.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
 export declare type ComplexExpression<DB, TB extends keyof DB, V = any> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | RawBuilder<V> | RawBuilderFactory<DB, TB>;
 export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;

package/dist/cjs/plugin/deduplicate-joins/deduplicate-joins-transformer.d.ts

@@ -1,6 +1,7 @@
-import { DeleteQueryNode, UpdateQueryNode } from '../../index-nodeless.js';
+import { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 import { SelectQueryNode } from '../../operation-node/select-query-node.js';
+import { UpdateQueryNode } from '../../operation-node/update-query-node.js';
 export declare class DeduplicateJoinsTransformer extends OperationNodeTransformer {
     #private;
     protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;

package/dist/cjs/query-builder/delete-query-builder.d.ts

@@ -46,7 +46,13 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -62,8 +68,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -71,6 +77,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -78,8 +86,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling

package/dist/cjs/query-builder/expression-builder.d.ts

@@ -3,7 +3,7 @@ import { TableExpression, TableExpressionDatabase, TableExpressionTables } from
 import { FunctionBuilder } from './function-builder.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { QueryExecutor } from '../index-nodeless.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
 export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);

package/dist/cjs/query-builder/expression-builder.js

@@ -9,8 +9,8 @@ const query_id_js_1 = require("../util/query-id.js");
 const function_builder_js_1 = require("./function-builder.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
-const index_nodeless_js_1 = require("../index-nodeless.js");
 const object_utils_js_1 = require("../util/object-utils.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
 class ExpressionBuilder {
     #props;
     constructor(props) {
@@ -100,7 +100,7 @@ class ExpressionBuilder {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             plugins: this.#props.executor.plugins,
-            rawNode: index_nodeless_js_1.RawNode.createWithChild((0, reference_parser_js_1.parseStringReference)(reference)),
+            rawNode: raw_node_js_1.RawNode.createWithChild((0, reference_parser_js_1.parseStringReference)(reference)),
         });
     }
 }

package/dist/cjs/query-builder/function-builder.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionBuilder = void 0;
-const index_nodeless_js_1 = require("../index-nodeless.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 const query_id_js_1 = require("../util/query-id.js");
@@ -153,7 +153,7 @@ class FunctionBuilder {
     #oneArgFunction(fn, column) {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
-            rawNode: index_nodeless_js_1.RawNode.create([`${fn}(`, ')'], [(0, reference_parser_js_1.parseStringReference)(column)]),
+            rawNode: raw_node_js_1.RawNode.create([`${fn}(`, ')'], [(0, reference_parser_js_1.parseStringReference)(column)]),
         });
     }
 }

package/dist/cjs/query-builder/on-conflict-builder.d.ts

@@ -69,7 +69,13 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -85,8 +91,8 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -94,6 +100,8 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -101,8 +109,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling
@@ -426,7 +433,13 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -442,8 +455,8 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -451,6 +464,8 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -458,8 +473,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling

package/dist/cjs/query-builder/select-query-builder.d.ts

@@ -45,7 +45,13 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -61,8 +67,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -70,6 +76,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -77,8 +85,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -46,7 +46,13 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -62,8 +68,8 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -71,6 +77,8 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -78,8 +86,7 @@ export declare class UpdateQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling

package/dist/cjs/query-builder/where-interface.d.ts

@@ -26,7 +26,13 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `sql\`your operator\``.
+     * you can always use
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -42,8 +48,8 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -51,6 +57,8 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -58,8 +66,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling

package/dist/cjs/query-executor/default-query-executor.d.ts

@@ -1,13 +1,16 @@
 import { ConnectionProvider } from '../driver/connection-provider.js';
-import { QueryResult } from '../driver/database-connection.js';
+import { DatabaseConnection } from '../driver/database-connection.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { RootOperationNode, QueryCompiler } from '../query-compiler/query-compiler.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { QueryExecutor } from './query-executor.js';
-import { DialectAdapter } from '../index-nodeless.js';
-export declare class DefaultQueryExecutor extends QueryExecutor {
+import { QueryExecutorBase } from './query-executor-base.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
+export declare class DefaultQueryExecutor extends QueryExecutorBase {
     #private;
     constructor(compiler: QueryCompiler, adapter: DialectAdapter, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    /**
+     * Returns the adapter for the current dialect.
+     */
     get adapter(): DialectAdapter;
     /**
      * Compiles the transformed query into SQL. You usually want to pass
@@ -15,7 +18,11 @@ export declare class DefaultQueryExecutor extends QueryExecutor {
      * compile any query using this method.
      */
     compileQuery(node: RootOperationNode): CompiledQuery;
-    protected executeQueryImpl<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
     /**
      * Returns a copy of this executor with a list of plugins added
      * as the last plugins.
@@ -34,9 +41,9 @@ export declare class DefaultQueryExecutor extends QueryExecutor {
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    withConnectionProvider(connectionProvider: ConnectionProvider): DefaultQueryExecutor;
     /**
      * Returns a copy of this executor without any plugins.
      */
-    withoutPlugins(): QueryExecutor;
+    withoutPlugins(): DefaultQueryExecutor;
 }

package/dist/cjs/query-executor/default-query-executor.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultQueryExecutor = void 0;
-const query_executor_js_1 = require("./query-executor.js");
-class DefaultQueryExecutor extends query_executor_js_1.QueryExecutor {
+const query_executor_base_js_1 = require("./query-executor-base.js");
+class DefaultQueryExecutor extends query_executor_base_js_1.QueryExecutorBase {
     #compiler;
     #adapter;
     #connectionProvider;
@@ -18,10 +18,8 @@ class DefaultQueryExecutor extends query_executor_js_1.QueryExecutor {
     compileQuery(node) {
         return this.#compiler.compileQuery(node);
     }
-    async executeQueryImpl(compiledQuery) {
-        return this.#connectionProvider.withConnection((connection) => {
-            return connection.executeQuery(compiledQuery);
-        });
+    provideConnection(consumer) {
+        return this.#connectionProvider.provideConnection(consumer);
     }
     withPlugins(plugins) {
         return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [...this.plugins, ...plugins]);

package/dist/cjs/query-executor/noop-query-executor.d.ts

@@ -1,14 +1,16 @@
-import { QueryResult } from '../driver/database-connection.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
-import { QueryExecutor } from './query-executor.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { QueryExecutorBase } from './query-executor-base.js';
 /**
  * A {@link QueryExecutor} subclass that can be used when you don't
  * have a {@link QueryCompiler}, {@link ConnectionProvider} or any
  * other needed things to actually execute queries.
  */
-export declare class NoopQueryExecutor extends QueryExecutor {
+export declare class NoopQueryExecutor extends QueryExecutorBase {
+    /**
+     * Returns the adapter for the current dialect.
+     */
     get adapter(): DialectAdapter;
     /**
      * Compiles the transformed query into SQL. You usually want to pass
@@ -16,11 +18,15 @@ export declare class NoopQueryExecutor extends QueryExecutor {
      * compile any query using this method.
      */
     compileQuery(): CompiledQuery;
-    protected executeQueryImpl<R>(): Promise<QueryResult<R>>;
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    provideConnection<T>(): Promise<T>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    withConnectionProvider(): QueryExecutor;
+    withConnectionProvider(): NoopQueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.
@@ -39,6 +45,6 @@ export declare class NoopQueryExecutor extends QueryExecutor {
     /**
      * Returns a copy of this executor without any plugins.
      */
-    withoutPlugins(): QueryExecutor;
+    withoutPlugins(): NoopQueryExecutor;
 }
 export declare const NOOP_QUERY_EXECUTOR: NoopQueryExecutor;