kysely 0.16.11 → 0.17.2

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

@@ -4,10 +4,8 @@ import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
 import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
-import { RawBuilder } from './raw-builder/raw-builder.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
-import { ParseContext } from './parser/parse-context.js';
 import { InsertResult } from './query-builder/insert-result.js';
 import { DeleteResult } from './query-builder/delete-result.js';
 import { UpdateResult } from './query-builder/update-result.js';
@@ -73,9 +71,10 @@ export declare class QueryCreator<DB> {
      * Create a select query from raw sql:
      *
      * ```ts
-     * const items = await db.selectFrom(
-     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
-     *   )
+     * import { sql } from 'kysely'
+     *
+     * const items = await db
+     *   .selectFrom(sql<{ one: number }>`(select 1 as one)`.as('q'))
      *   .select('q.one')
      *   .execute()
      *
@@ -91,18 +90,20 @@ export declare class QueryCreator<DB> {
      * ) as q
      * ```
      *
-     * When you use `raw` you need to also provide the result type of the
-     * raw segment / query so that Kysely can figure out what columns are
-     * available for the query.
+     * When you use the `sql` tag you need to also provide the result type of the
+     * raw snippet / query so that Kysely can figure out what columns are
+     * available for the rest of the query.
      *
      * The `selectFrom` method also accepts an array for multiple tables. All
      * the above examples can also be used in an array.
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const items = await db.selectFrom([
      *     'person as p',
      *     db.selectFrom('pet').select('pet.species').as('a'),
-     *     db.raw<{ one: number }>('(select 1 as one)').as('q')
+     *     sql<{ one: number }>`(select 1 as one)`.as('q')
      *   ])
      *   .select(['p.id', 'a.species', 'q.one'])
      *   .execute()
@@ -299,128 +300,8 @@ export declare class QueryCreator<DB> {
      * ```
      */
     withSchema(schema: string): QueryCreator<DB>;
-    /**
-     * Provides a way to pass arbitrary SQL into your query and executing completely
-     * raw queries.
-     *
-     * You can use the strings `?` and `??` in the `sql` to bind parameters such as
-     * user input to the SQL. You should never EVER concatenate untrusted user
-     * input to the SQL string to avoid injection vulnerabilities. Instead use `?`
-     * in place of a value and pass the actual value in the `parameters` list. See
-     * the examples below.
-     *
-     * You should only use `raw` when there is no other way to get the job done. This is
-     * because Kysely is not able to use type inference when you use raw SQL. For example
-     * Kysely won't be able to automatically provide you with the correct query result
-     * type. However, there are ways to manually provide types when you use `raw` in most
-     * cases. See the examples below.
-     *
-     * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
-     * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
-     *
-     * ### Examples
-     *
-     * Example of using `raw` in a select statement:
-     *
-     * ```ts
-     * const [person] = await db.selectFrom('person')
-     *   .select(db.raw<string>('concat(first_name, ' ', last_name)').as('name'))
-     *   .where('id', '=', 1)
-     *   .execute()
-     *
-     * console.log(person.name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select concat(first_name, ' ', last_name) as "name"
-     * from "person" where "id" = 1
-     * ```
-     *
-     * The above example selects computed column `name` by concatenating the first name
-     * and last name together.
-     *
-     * There are couple of things worth noticing:
-     *
-     *   1. You need to provide the output type of your SQL segment for the `raw` method
-     *     so that Kysely knows what type to give for the `name` column. In this case it's
-     *     a `string` since that's the output type of the `concat` function in SQL.
-     *
-     *   2. You need to give an alias for the selection using the `as` method so that
-     *     Kysely is able to add a column to the output type. The alias needs to be
-     *     known at compile time! If you pass a string variable whose value is not known
-     *     at compile time, there is no way for Kysely or typescript to add a column to
-     *     the output type. In this case you need to use the `castTo` method on the query
-     *     to specify a return type for the query.
-     *
-     * We could've also used a `??` placeholder to provide `first_name` and `last_name` like
-     * this:
-     *
-     * ```ts
-     * db.raw<string>('concat(??, ' ', ??)', ['first_name', 'last_name'])
-     * ```
-     *
-     * or this:
-     *
-     * ```ts
-     * db.raw<string>('concat(??, ' ', ??)', ['person.first_name', 'person.last_name'])
-     * ```
-     *
-     * But it's often cleaner to just write the column names in the SQL. Again remember to
-     * never concatenate column names or any other untrusted user input to the SQL string or you
-     * are going to create an injection vulnerability. All user input should go to the parameters
-     * array, never to the SQL string directly. But if the column names or values are trusted
-     * and known at compile time, there is no reason to use parameters.
-     *
-     * Example of using `raw` in `where`:
-     *
-     * ```ts
-     * function getPersonsOlderThan(ageLimit: number) {
-     *   return await db.selectFrom('person')
-     *     .selectAll()
-     *     .where(
-     *       db.raw('now() - birth_date'),
-     *       '>',
-     *       db.raw('interval ? year', [ageLimit.toString()])
-     *     )
-     *     .execute()
-     * }
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where now() - birth_date > interval $1 year
-     * ```
-     *
-     * The function in the above example returns people that are older than the given number of
-     * years. The number of years in this example is an untrusted user input, and therefore we use
-     * a `?` placeholder for it.
-     *
-     * Example of creating a completely raw query from scratch:
-     *
-     * ```ts
-     * const result = await db.raw<Person>('select p.* from person p').execute()
-     * const persons = result.rows
-     * ```
-     *
-     * For a raw query, you need to specify the type of the returned __row__. In
-     * this case we know the resulting items will be of type `Person` se specify that.
-     * The result of `execute()` method is always an array. In this case the type of
-     * the `persons` variable is `Person[]`.
-     *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
-     *    placeholders. `?` for values and `??` for identifiers such as column names
-     *    or `column.table` references.
-     *
-     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
-     *    the sql string.
-     */
-    raw<T = unknown>(sql: string, parameters?: unknown[]): RawBuilder<T>;
 }
 export interface QueryCreatorProps {
     readonly executor: QueryExecutor;
-    readonly parseContext: ParseContext;
     readonly withNode?: WithNode;
 }

package/dist/esm/query-creator.js

@@ -8,7 +8,6 @@ import { InsertQueryNode } from './operation-node/insert-query-node.js';
 import { SelectQueryNode } from './operation-node/select-query-node.js';
 import { UpdateQueryNode } from './operation-node/update-query-node.js';
 import { parseTable, parseTableExpression, parseTableExpressionOrList, } from './parser/table-parser.js';
-import { RawBuilder } from './raw-builder/raw-builder.js';
 import { parseCommonTableExpression, } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { createQueryId } from './util/query-id.js';
@@ -23,8 +22,7 @@ export class QueryCreator {
         return new SelectQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#props.parseContext, from), this.#props.withNode),
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(from), this.#props.withNode),
         });
     }
     /**
@@ -69,7 +67,6 @@ export class QueryCreator {
         return new InsertQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),
         });
     }
@@ -96,8 +93,7 @@ export class QueryCreator {
         return new DeleteQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
-            queryNode: DeleteQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
+            queryNode: DeleteQueryNode.create(parseTableExpression(table), this.#props.withNode),
         });
     }
     /**
@@ -127,8 +123,7 @@ export class QueryCreator {
         return new UpdateQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
-            queryNode: UpdateQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
+            queryNode: UpdateQueryNode.create(parseTableExpression(table), this.#props.withNode),
         });
     }
     /**
@@ -173,7 +168,7 @@ export class QueryCreator {
      * ```
      */
     with(name, expression) {
-        const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
+        const cte = parseCommonTableExpression(name, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -187,7 +182,7 @@ export class QueryCreator {
      * See the {@link with} method for examples and more documentation.
      */
     withRecursive(name, expression) {
-        const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
+        const cte = parseCommonTableExpression(name, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -248,130 +243,4 @@ export class QueryCreator {
             executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
         });
     }
-    /**
-     * Provides a way to pass arbitrary SQL into your query and executing completely
-     * raw queries.
-     *
-     * You can use the strings `?` and `??` in the `sql` to bind parameters such as
-     * user input to the SQL. You should never EVER concatenate untrusted user
-     * input to the SQL string to avoid injection vulnerabilities. Instead use `?`
-     * in place of a value and pass the actual value in the `parameters` list. See
-     * the examples below.
-     *
-     * You should only use `raw` when there is no other way to get the job done. This is
-     * because Kysely is not able to use type inference when you use raw SQL. For example
-     * Kysely won't be able to automatically provide you with the correct query result
-     * type. However, there are ways to manually provide types when you use `raw` in most
-     * cases. See the examples below.
-     *
-     * Raw builder instances can be passed to pretty much anywhere: `select`, `where`,
-     * `*Join`, `groupBy`, `orderBy` etc. Just try it. If the method accepts it, it works.
-     *
-     * ### Examples
-     *
-     * Example of using `raw` in a select statement:
-     *
-     * ```ts
-     * const [person] = await db.selectFrom('person')
-     *   .select(db.raw<string>('concat(first_name, ' ', last_name)').as('name'))
-     *   .where('id', '=', 1)
-     *   .execute()
-     *
-     * console.log(person.name)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select concat(first_name, ' ', last_name) as "name"
-     * from "person" where "id" = 1
-     * ```
-     *
-     * The above example selects computed column `name` by concatenating the first name
-     * and last name together.
-     *
-     * There are couple of things worth noticing:
-     *
-     *   1. You need to provide the output type of your SQL segment for the `raw` method
-     *     so that Kysely knows what type to give for the `name` column. In this case it's
-     *     a `string` since that's the output type of the `concat` function in SQL.
-     *
-     *   2. You need to give an alias for the selection using the `as` method so that
-     *     Kysely is able to add a column to the output type. The alias needs to be
-     *     known at compile time! If you pass a string variable whose value is not known
-     *     at compile time, there is no way for Kysely or typescript to add a column to
-     *     the output type. In this case you need to use the `castTo` method on the query
-     *     to specify a return type for the query.
-     *
-     * We could've also used a `??` placeholder to provide `first_name` and `last_name` like
-     * this:
-     *
-     * ```ts
-     * db.raw<string>('concat(??, ' ', ??)', ['first_name', 'last_name'])
-     * ```
-     *
-     * or this:
-     *
-     * ```ts
-     * db.raw<string>('concat(??, ' ', ??)', ['person.first_name', 'person.last_name'])
-     * ```
-     *
-     * But it's often cleaner to just write the column names in the SQL. Again remember to
-     * never concatenate column names or any other untrusted user input to the SQL string or you
-     * are going to create an injection vulnerability. All user input should go to the parameters
-     * array, never to the SQL string directly. But if the column names or values are trusted
-     * and known at compile time, there is no reason to use parameters.
-     *
-     * Example of using `raw` in `where`:
-     *
-     * ```ts
-     * function getPersonsOlderThan(ageLimit: number) {
-     *   return await db.selectFrom('person')
-     *     .selectAll()
-     *     .where(
-     *       db.raw('now() - birth_date'),
-     *       '>',
-     *       db.raw('interval ? year', [ageLimit.toString()])
-     *     )
-     *     .execute()
-     * }
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where now() - birth_date > interval $1 year
-     * ```
-     *
-     * The function in the above example returns people that are older than the given number of
-     * years. The number of years in this example is an untrusted user input, and therefore we use
-     * a `?` placeholder for it.
-     *
-     * Example of creating a completely raw query from scratch:
-     *
-     * ```ts
-     * const result = await db.raw<Person>('select p.* from person p').execute()
-     * const persons = result.rows
-     * ```
-     *
-     * For a raw query, you need to specify the type of the returned __row__. In
-     * this case we know the resulting items will be of type `Person` se specify that.
-     * The result of `execute()` method is always an array. In this case the type of
-     * the `persons` variable is `Person[]`.
-     *
-     * @param sql - The raw SQL. Special strings `?` and `??` can be used as parameter
-     *    placeholders. `?` for values and `??` for identifiers such as column names
-     *    or `column.table` references.
-     *
-     * @param params - The parameters that will be bound to the `?` and `??` placeholders in
-     *    the sql string.
-     */
-    raw(sql, parameters) {
-        return new RawBuilder({
-            queryId: createQueryId(),
-            executor: this.#props.executor,
-            sql,
-            parameters,
-        });
-    }
 }

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

@@ -1,19 +1,33 @@
 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';
-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, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    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
      * the output of {@link transformQuery} into this method but you can
      * 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.
+     */
+    withPlugins(plugins: ReadonlyArray<KyselyPlugin>): DefaultQueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.
@@ -27,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,39 +1,37 @@
 /// <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;
-    constructor(compiler, connectionProvider, plugins = []) {
+    constructor(compiler, adapter, connectionProvider, plugins = []) {
         super(plugins);
         this.#compiler = compiler;
+        this.#adapter = adapter;
         this.#connectionProvider = connectionProvider;
     }
+    get adapter() {
+        return this.#adapter;
+    }
     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]);
     }
     withPlugin(plugin) {
-        return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, [
-            ...this.plugins,
-            plugin,
-        ]);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [...this.plugins, plugin]);
     }
     withPluginAtFront(plugin) {
-        return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, [
-            plugin,
-            ...this.plugins,
-        ]);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, [plugin, ...this.plugins]);
     }
     withConnectionProvider(connectionProvider) {
-        return new DefaultQueryExecutor(this.#compiler, connectionProvider, [
-            ...this.plugins,
-        ]);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, connectionProvider, [...this.plugins]);
     }
     withoutPlugins() {
-        return new DefaultQueryExecutor(this.#compiler, this.#connectionProvider, []);
+        return new DefaultQueryExecutor(this.#compiler, this.#adapter, this.#connectionProvider, []);
     }
 }

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

@@ -1,29 +1,42 @@
-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
      * the output of {@link transformQuery} into this method but you can
      * 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.
      */
     withPlugin(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    withPlugins(plugins: ReadonlyArray<KyselyPlugin>): NoopQueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * first plugin.
@@ -32,5 +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,15 +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() {
@@ -18,6 +21,9 @@ export class NoopQueryExecutor extends QueryExecutor {
     withPlugin(plugin) {
         return new NoopQueryExecutor([...this.plugins, plugin]);
     }
+    withPlugins(plugins) {
+        return new NoopQueryExecutor([...this.plugins, ...plugins]);
+    }
     withPluginAtFront(plugin) {
         return new NoopQueryExecutor([plugin, ...this.plugins]);
     }
@@ -25,3 +31,4 @@ export class NoopQueryExecutor extends QueryExecutor {
         return new NoopQueryExecutor([]);
     }
 }
+export const NOOP_QUERY_EXECUTOR = new NoopQueryExecutor();

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;
+}