kysely 0.17.0 → 0.17.3

package/dist/esm/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/esm/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/esm/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/esm/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/esm/query-builder/expression-builder.js

@@ -7,8 +7,8 @@ import { createQueryId } from '../util/query-id.js';
 import { FunctionBuilder } from './function-builder.js';
 import { parseStringReference, } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { RawNode } from '../index-nodeless.js';
 import { freeze } from '../util/object-utils.js';
+import { RawNode } from '../operation-node/raw-node.js';
 export class ExpressionBuilder {
     #props;
     constructor(props) {

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

@@ -1,5 +1,5 @@
 /// <reference types="./function-builder.d.ts" />
-import { RawNode } from '../index-nodeless.js';
+import { RawNode } from '../operation-node/raw-node.js';
 import { parseStringReference, } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { createQueryId } from '../util/query-id.js';

package/dist/esm/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/esm/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/esm/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/esm/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/esm/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/esm/query-executor/default-query-executor.js

@@ -1,6 +1,6 @@
 /// <reference types="./default-query-executor.d.ts" />
-import { QueryExecutor } from './query-executor.js';
-export class DefaultQueryExecutor extends QueryExecutor {
+import { QueryExecutorBase } from './query-executor-base.js';
+export class DefaultQueryExecutor extends QueryExecutorBase {
     #compiler;
     #adapter;
     #connectionProvider;
@@ -16,10 +16,8 @@ export class DefaultQueryExecutor extends 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/esm/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;

package/dist/esm/query-executor/noop-query-executor.js

@@ -1,18 +1,18 @@
 /// <reference types="./noop-query-executor.d.ts" />
-import { QueryExecutor } from './query-executor.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 class NoopQueryExecutor extends QueryExecutor {
+export class NoopQueryExecutor extends QueryExecutorBase {
     get adapter() {
         throw new Error('this query cannot be compiled to SQL');
     }
     compileQuery() {
         throw new Error('this query cannot be compiled to SQL');
     }
-    async executeQueryImpl() {
+    provideConnection() {
         throw new Error('this query cannot be executed');
     }
     withConnectionProvider() {

package/dist/esm/query-executor/query-executor-base.d.ts

@@ -0,0 +1,62 @@
+import { ConnectionProvider } from '../driver/connection-provider.js';
+import { DatabaseConnection, QueryResult } from '../driver/database-connection.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { RootOperationNode } from '../query-compiler/query-compiler.js';
+import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { QueryId } from '../util/query-id.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { QueryExecutor } from './query-executor.js';
+export declare abstract class QueryExecutorBase implements QueryExecutor {
+    #private;
+    constructor(plugins?: ReadonlyArray<KyselyPlugin>);
+    abstract get adapter(): DialectAdapter;
+    /**
+     * Returns all installed plugins.
+     */
+    get plugins(): ReadonlyArray<KyselyPlugin>;
+    /**
+     * Given the query the user has built (expressed as an operation node tree)
+     * this method runs it through all plugins' `transformQuery` methods and
+     * returns the result.
+     */
+    transformQuery<T extends RootOperationNode>(node: T, queryId: QueryId): T;
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
+    abstract compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    abstract provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method.
+     */
+    executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
+    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
+    abstract withPlugin(plugin: KyselyPlugin): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    abstract withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
+    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
+    abstract withoutPlugins(): QueryExecutorBase;
+}

package/dist/esm/query-executor/query-executor-base.js

@@ -0,0 +1,43 @@
+/// <reference types="./query-executor-base.d.ts" />
+import { freeze } from '../util/object-utils.js';
+const NO_PLUGINS = freeze([]);
+export class QueryExecutorBase {
+    #plugins;
+    constructor(plugins = NO_PLUGINS) {
+        this.#plugins = plugins;
+    }
+    get plugins() {
+        return this.#plugins;
+    }
+    transformQuery(node, queryId) {
+        for (const plugin of this.#plugins) {
+            const transformedNode = plugin.transformQuery({ node, queryId });
+            // We need to do a runtime check here. There is no good way
+            // to write types that enforce this constraint.
+            if (transformedNode.kind === node.kind) {
+                node = transformedNode;
+            }
+            else {
+                throw new Error([
+                    `KyselyPlugin.transformQuery must return a node`,
+                    `of the same kind that was given to it.`,
+                    `The plugin was given a ${node.kind}`,
+                    `but it returned a ${transformedNode.kind}`,
+                ].join(' '));
+            }
+        }
+        return node;
+    }
+    async executeQuery(compiledQuery, queryId) {
+        return await this.provideConnection(async (connection) => {
+            const result = await connection.executeQuery(compiledQuery);
+            return this.#transformResult(result, queryId);
+        });
+    }
+    async #transformResult(result, queryId) {
+        for (const plugin of this.#plugins) {
+            result = await plugin.transformResult({ result, queryId });
+        }
+        return result;
+    }
+}

package/dist/esm/query-executor/query-executor.d.ts

@@ -6,15 +6,19 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.js';
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
 /**
- * This class abstracts away the details of how to compile a query into SQL
+ * This interface abstracts away the details of how to compile a query into SQL
  * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */
-export declare abstract class QueryExecutor {
-    #private;
-    constructor(plugins?: KyselyPlugin[]);
-    abstract get adapter(): DialectAdapter;
+export interface QueryExecutor extends ConnectionProvider {
+    /**
+     * Returns the adapter for the current dialect.
+     */
+    get adapter(): DialectAdapter;
+    /**
+     * Returns all installed plugins.
+     */
     get plugins(): ReadonlyArray<KyselyPlugin>;
     /**
      * Given the query the user has built (expressed as an operation node tree)
@@ -27,37 +31,33 @@ export declare abstract class QueryExecutor {
      * the output of {@link transformQuery} into this method but you can
      * compile any query using this method.
      */
-    abstract compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
     /**
      * Executes a compiled query and runs the result through all plugins'
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
-    /**
-     * Executes a compiled query.
-     */
-    protected abstract executeQueryImpl<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.
      */
-    abstract withPlugin(plugin: KyselyPlugin): QueryExecutor;
+    withPlugin(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor with a list of plugins added
      * as the last plugins.
      */
-    abstract withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
+    withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * first plugin.
      */
-    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
+    withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor without any plugins.
      */
-    abstract withoutPlugins(): QueryExecutor;
+    withoutPlugins(): QueryExecutor;
 }