kysely 0.23.5 → 0.24.0

package/README.md

@@ -3,7 +3,7 @@
 [![Discord](https://img.shields.io/discord/890118421587578920)](https://discord.gg/xyBJ3GwvAm)
 [![Tests](https://github.com/koskimas/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/koskimas/kysely)
 
-# [Kysely](https://koskimas.github.io/kysely/index.html)
+# [Kysely](https://kysely-org.github.io/kysely/index.html)
 
 Kysely (pronounce “Key-Seh-Lee”) is a type-safe and autocompletion-friendly typescript SQL query builder. Inspired by
 [knex](http://knexjs.org/). Mainly developed for [node.js](https://nodejs.org/en/) but also runs on [deno](https://deno.land/)
@@ -21,8 +21,8 @@ column names, aliases and types from selected subqueries, joined subqueries, `wi
 much anything you can think of.
 
 Of course there are cases where things cannot be typed at compile time, and Kysely offers escape
-hatches for these situations. See the [sql template tag](https://koskimas.github.io/kysely/interfaces/Sql.html) 
-and the [DynamicModule](https://koskimas.github.io/kysely/classes/DynamicModule.html#ref) for more info.
+hatches for these situations. See the [sql template tag](https://kysely-org.github.io/kysely/interfaces/Sql.html) 
+and the [DynamicModule](https://kysely-org.github.io/kysely/classes/DynamicModule.html#ref) for more info.
 
 All API documentation is written in the typing files and you can simply `cmd-click` on the module, class
 or method you're using to see it. The same documentation is also hosted [here](https://github.com/koskimas/kysely).
@@ -69,7 +69,7 @@ npm install kysely better-sqlite3
 ```
 
 More dialects will be added soon. Kysely also has a simple interface
-for [3rd party dialects](https://koskimas.github.io/kysely/interfaces/Dialect.html).
+for [3rd party dialects](https://kysely-org.github.io/kysely/interfaces/Dialect.html).
 
 ### 3rd party dialects
 
@@ -80,6 +80,7 @@ for [3rd party dialects](https://koskimas.github.io/kysely/interfaces/Dialect.ht
  - [SurrealDB](https://github.com/igalklebanov/kysely-surrealdb)
  - [sqld](https://github.com/libsql/kysely-libsql)
  - [Neon](https://github.com/seveibar/kysely-neon)
+ - [AWS S3 Select](https://github.com/igalklebanov/kysely-s3-select)
 
 # Minimal example
 
@@ -189,16 +190,29 @@ type UpdateablePerson = Updateable<PersonTable>
 
 # Generating types
 
-If you want to generate the table types automatically from the database schema please
-check out [this awesome project](https://github.com/RobinBlomberg/kysely-codegen).
+To work with Kysely, you're required to provide a database schema type definition to the Kysely constructor.
+
+In many cases, defining your database schema definitions manually is good enough.
+
+However, when building production applications, its best to stay aligned with the 
+database schema, by automatically generating the database schema type definitions.
+
+There are several ways to do this using 3rd party libraries:
+
+- [kysely-codegen](https://github.com/RobinBlomberg/kysely-codegen) - This library 
+generates Kysely database schema type definitions by connecting to and introspecting 
+your database. This library works with all built-in dialects.
+
+- [prisma-kysely](https://github.com/valtyr/prisma-kysely) - This library generates 
+Kysely database schema type definitions from your existing Prisma schemas.
 
 # Query examples
 
 ## Select queries
 
 You can find examples of select queries in the documentation of the 
-[select method](https://koskimas.github.io/kysely/classes/SelectQueryBuilder.html#select) and
-the [where method](https://koskimas.github.io/kysely/classes/SelectQueryBuilder.html#where)
+[select method](https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#select) and
+the [where method](https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#where)
 among other places.
 
 ### Stream select query results
@@ -242,32 +256,36 @@ async function demo() {
 
 ## Update queries
 
-See the [set method](https://koskimas.github.io/kysely/classes/UpdateQueryBuilder.html#set) and the
-[updateTable method](https://koskimas.github.io/kysely/classes/Kysely.html#updateTable)
+See the [set method](https://kysely-org.github.io/kysely/classes/UpdateQueryBuilder.html#set) and the
+[updateTable method](https://kysely-org.github.io/kysely/classes/Kysely.html#updateTable)
 documentation.
 
 ## Insert queries
 
-See the [values method](https://koskimas.github.io/kysely/classes/InsertQueryBuilder.html#values) and the
-[insertInto method](https://koskimas.github.io/kysely/classes/Kysely.html#insertInto)
+See the [values method](https://kysely-org.github.io/kysely/classes/InsertQueryBuilder.html#values) and the
+[insertInto method](https://kysely-org.github.io/kysely/classes/Kysely.html#insertInto)
 documentation.
 
 ## Delete queries
 
-See the [deleteFrom method](https://koskimas.github.io/kysely/classes/Kysely.html#deleteFrom)
+See the [deleteFrom method](https://kysely-org.github.io/kysely/classes/Kysely.html#deleteFrom)
 documentation.
 
 # Recipes
 
-The [recipes](https://github.com/koskimas/kysely/tree/master/recipes) folder contains a bunch of small tutorials
+The [recipes](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/) folder contains a bunch of small tutorials
 or "recipes" for common use cases.
 
-* [Conditional selects](https://github.com/koskimas/kysely/tree/master/recipes/conditional-selects.md)
-* [Deduplicate joins](https://github.com/koskimas/kysely/tree/master/recipes/deduplicate-joins.md)
-* [Extending kysely](https://github.com/koskimas/kysely/tree/master/recipes/extending-kysely.md)
-* [Raw SQL](https://github.com/koskimas/kysely/tree/master/recipes/raw-sql.md)
-* [Schemas](https://github.com/koskimas/kysely/tree/master/recipes/schemas.md)
-* [Dealing with the `Type instantiation is excessively deep and possibly infinite` error](https://github.com/koskimas/kysely/tree/master/recipes/excessively-deep-types.md)
+* [Expressions](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/expressions.md)
+* [Conditional selects](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/conditional-selects.md)
+* [Dealing with the `Type instantiation is excessively deep and possibly infinite` error](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/excessively-deep-types.md)
+* [Deduplicate joins](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/deduplicate-joins.md)
+* [Extending kysely](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/extending-kysely.md)
+* [Introspecting relation metadata](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/introspecting-relation-metadata.md)
+* [Raw SQL](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/raw-sql.md)
+* [Relations](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/relations.md)
+* [Schemas](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/schemas.md)
+* [Splitting build, compile and execute code](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/splitting-build-compile-and-execute-code.md)
 
 # Migrations
 
@@ -292,7 +310,7 @@ when you go back to previous version. The only argument for the functions is an
 Migrations should never depend on the current code of your app because they need to work even when the app
 changes. Migrations need to be "frozen in time".
 
-The migrations can use the [Kysely.schema](https://koskimas.github.io/kysely/classes/SchemaModule.html)
+The migrations can use the [Kysely.schema](https://kysely-org.github.io/kysely/classes/SchemaModule.html)
 module to modify the schema. Migrations can also run normal queries to modify data.
 
 Execution order of the migrations is the alpabetical order of their names. An excellent way to name your
@@ -301,8 +319,8 @@ where multiple team members may add migrations at the same time in parallel comm
 about the other migrations.
 
 You don't need to store your migrations as separate files if you don't want to. You can easily
-implement your own [MigrationProvider](https://koskimas.github.io/kysely/interfaces/MigrationProvider.html)
-and give it to the [Migrator](https://koskimas.github.io/kysely/classes/Migrator.html) class
+implement your own [MigrationProvider](https://kysely-org.github.io/kysely/interfaces/MigrationProvider.html)
+and give it to the [Migrator](https://kysely-org.github.io/kysely/classes/Migrator.html) class
 when you instantiate one.
 
 ### PostgreSQL migration example
@@ -390,7 +408,7 @@ await migrator.migrateToLatest(pathToMigrationsFolder)
 ```
 
 to run all migrations that have not yet been run. See the
-[Migrator](https://koskimas.github.io/kysely/classes/Migrator.html)
+[Migrator](https://kysely-org.github.io/kysely/classes/Migrator.html)
 class's documentation for more info.
 
 Kysely doesn't have a CLI for running migrations and probably never will. This is because Kysely's
@@ -572,3 +590,7 @@ a library for typescript from the ground up produces much better and simpler typ
 # How to contribute to Kysely
 
 See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+# Sponsors
+
+<a href="https://vercel.com/?utm_source=kysely&utm_campaign=oss"><img src="https://kysely.dev/img/powered-by-vercel.svg" alt="Powered by Vercel" /></a>

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

@@ -19,10 +19,10 @@ class MysqlAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
         // is released using `release_lock`. This way we know that the lock is either
         // released by us after successfull or failed migrations OR it's released by
         // MySQL if the process gets killed for some reason.
-        await (0, sql_js_1.sql) `select get_lock(${sql_js_1.sql.literal(LOCK_ID)}, ${sql_js_1.sql.literal(LOCK_TIMEOUT_SECONDS)})`.execute(db);
+        await (0, sql_js_1.sql) `select get_lock(${sql_js_1.sql.lit(LOCK_ID)}, ${sql_js_1.sql.lit(LOCK_TIMEOUT_SECONDS)})`.execute(db);
     }
     async releaseMigrationLock(db) {
-        await (0, sql_js_1.sql) `select release_lock(${sql_js_1.sql.literal(LOCK_ID)})`.execute(db);
+        await (0, sql_js_1.sql) `select release_lock(${sql_js_1.sql.lit(LOCK_ID)})`.execute(db);
     }
 }
 exports.MysqlAdapter = MysqlAdapter;

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

@@ -42,7 +42,7 @@ declare class MysqlConnection implements DatabaseConnection {
     #private;
     constructor(rawConnection: MysqlPoolConnection);
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
-    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
+    streamQuery<O>(compiledQuery: CompiledQuery, _chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     [PRIVATE_RELEASE_METHOD](): void;
 }
 export {};

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

@@ -127,7 +127,7 @@ class MysqlConnection {
             });
         });
     }
-    async *streamQuery(compiledQuery, chunkSize) {
+    async *streamQuery(compiledQuery, _chunkSize) {
         const stream = this.#rawConnection
             .query(compiledQuery.sql, compiledQuery.parameters)
             .stream({

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

@@ -14,7 +14,7 @@ class PostgresAdapter extends dialect_adapter_base_js_1.DialectAdapterBase {
     }
     async acquireMigrationLock(db) {
         // Acquire a transaction level advisory lock.
-        await (0, sql_js_1.sql) `select pg_advisory_xact_lock(${sql_js_1.sql.literal(LOCK_ID)})`.execute(db);
+        await (0, sql_js_1.sql) `select pg_advisory_xact_lock(${sql_js_1.sql.lit(LOCK_ID)})`.execute(db);
     }
     async releaseMigrationLock() {
         // Nothing to do here. `pg_advisory_xact_lock` is automatically released at the

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

@@ -27,6 +27,7 @@ import { SqliteDialectConfig } from './sqlite-dialect-config.js';
  * new SqliteDialect({
  *   database: async () => new Database('db.sqlite')
  * })
+ * ```
  */
 export declare class SqliteDialect implements Dialect {
     #private;

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

@@ -28,6 +28,7 @@ const object_utils_js_1 = require("../../util/object-utils.js");
  * new SqliteDialect({
  *   database: async () => new Database('db.sqlite')
  * })
+ * ```
  */
 class SqliteDialect {
     #config;

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

@@ -76,7 +76,7 @@ class RuntimeDriver {
                 return await executeQuery.call(connection, compiledQuery);
             }
             catch (error) {
-                this.#logError(error);
+                this.#logError(error, compiledQuery, startTime);
                 throw error;
             }
             finally {
@@ -84,10 +84,12 @@ class RuntimeDriver {
             }
         };
     }
-    #logError(error) {
+    #logError(error, compiledQuery, startTime) {
         this.#log.error(() => ({
             level: 'error',
             error,
+            query: compiledQuery,
+            queryDurationMillis: this.#calculateDurationMillis(startTime),
         }));
     }
     #logQuery(compiledQuery, startTime) {

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

@@ -0,0 +1,386 @@
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { TableExpression, From, FromTables, ExtractTableAlias, AnyAliasedTable, PickTableWithAlias } from '../parser/table-parser.js';
+import { FunctionModule } from '../query-builder/function-module.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { BinaryOperatorExpression, ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { Expression } from './expression.js';
+import { ExpressionWrapper } from './expression-wrapper.js';
+import { ComparisonOperator, UnaryOperator } from '../operation-node/operator-node.js';
+import { SqlBool } from '../util/type-utils.js';
+import { ExtractTypeFromValueExpressionOrList } from '../parser/value-parser.js';
+export interface ExpressionBuilder<DB, TB extends keyof DB> {
+    /**
+     * Returns a {@link FunctionModule} that can be used to write type safe function
+     * calls.
+     *
+     * The difference between this and {@link Kysely.fn} is that this one is more
+     * type safe. You can only refer to columns visible to the part of the query
+     * you are building. {@link Kysely.fn} allows you to refer to columns in any
+     * table of the database even if it doesn't produce valid SQL.
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .select((eb) => [
+     *     'person.id',
+     *     eb.fn.count('pet.id').as('pet_count')
+     *   ])
+     *   .groupBy('person.id')
+     *   .having(count('pet.id'), '>', 10)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."id", count("pet"."id") as "pet_count"
+     * from "person"
+     * inner join "pet" on "pet"."owner_id" = "person"."id"
+     * group by "person"."id"
+     * having count("pet"."id") > $1
+     * ```
+     */
+    get fn(): FunctionModule<DB, TB>;
+    /**
+     * Creates a subquery.
+     *
+     * The query builder returned by this method is typed in a way that you can refer to
+     * all tables of the parent query in addition to the subquery's tables.
+     *
+     * This method accepts all the same inputs as {@link QueryCreator.selectFrom}.
+     *
+     * ### Examples
+     *
+     * This example shows that you can refer to both `pet.owner_id` and `person.id`
+     * columns from the subquery. This is needed to be able to create correlated
+     * subqueries:
+     *
+     * ```ts
+     * const result = await db.selectFrom('pet')
+     *   .select((eb) => [
+     *     'pet.name',
+     *     eb.selectFrom('person')
+     *       .whereRef('person.id', '=', 'pet.owner_id')
+     *       .select('person.first_name')
+     *       .as('owner_name')
+     *   ])
+     *   .execute()
+     *
+     * console.log(result[0].owner_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   "pet"."name",
+     *   ( select "person"."first_name"
+     *     from "person"
+     *     where "person"."id" = "pet"."owner_id"
+     *   ) as "owner_name"
+     * from "pet"
+     * ```
+     *
+     * You can use a normal query in place of `(qb) => qb.selectFrom(...)` but in
+     * that case Kysely typings wouldn't allow you to reference `pet.owner_id`
+     * because `pet` is not joined to that query.
+     */
+    selectFrom<TE extends keyof DB & string>(from: TE[]): SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}>;
+    selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, TB | ExtractTableAlias<DB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    /**
+     * This can be used to reference columns.
+     *
+     * ### Examples
+     *
+     * By default the third argument of {@link bxp} and {@link cmpr} is a value.
+     * This function can be used to pass in a column reference instead:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ or, cmpr, ref }) => or([
+     *     cmpr('first_name', '=', ref('last_name')),
+     *     cmpr('first_name', '=', ref('middle_name'))
+     *   ]))
+     * ```
+     *
+     * In the next example we use the `ref` method to reference
+     * columns of the virtual table `excluded` in a type-safe way
+     * to create an upsert operation:
+     *
+     * ```ts
+     * db.insertInto('person')
+     *   .values(person)
+     *   .onConflict((oc) => oc
+     *     .column('id')
+     *     .doUpdateSet(({ ref }) => ({
+     *       first_name: ref('excluded.first_name'),
+     *       last_name: ref('excluded.last_name')
+     *     }))
+     *   )
+     * ```
+     *
+     * In the next example we use `ref` in a raw sql expression. Unless you
+     * want to be as type-safe as possible, this is probably overkill:
+     *
+     * ```ts
+     * db.update('pet').set((eb) => ({
+     *   name: sql`concat(${eb.ref('pet.name')}, ${suffix})`
+     * }))
+     * ```
+     */
+    ref<RE extends StringReference<DB, TB>>(reference: RE): ExpressionWrapper<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Returns a value expression.
+     *
+     * This can be used to pass in a value where a reference is taken by default.
+     *
+     * This function returns an {@link Expression} and can be used pretty much anywhere.
+     *
+     * ### Examples
+     *
+     * The {@link cmpr} function takes a reference by default as the first argument. `val` could
+     * be used to pass in a value instead:
+     *
+     * ```ts
+     * cmpr(val(38), '=', ref('age'))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * $1 = "age"
+     * ```
+     */
+    val<VE>(value: VE): ExpressionWrapper<ExtractTypeFromValueExpressionOrList<VE>>;
+    /**
+     * Creates a binary comparison expression.
+     *
+     * This function returns an {@link Expression} and can be used pretty much anywhere.
+     * See the examples for a couple of possible use cases.
+     *
+     * @see {@link bxp}
+     *
+     * ### Examples
+     *
+     * In this example we use `cmpr` and {@link or} to create a `WHERE expr1 OR expr2 OR expr3`
+     * statement:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ or, cmpr }) => or([
+     *     cmpr('first_name', '=', 'Jennifer'),
+     *     cmpr('fist_name', '=', 'Arnold'),
+     *     cmpr('fist_name', '=', 'Sylvester')
+     *   ]))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*
+     * from "person"
+     * where "first_name" = $1
+     * or "first_name" = $2
+     * or "first_name" = $3
+     * ```
+     *
+     * By default the third argument is a value. {@link ref} can be used to
+     * pass in a column reference instead:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ or, cmpr, ref }) => or([
+     *     cmpr('first_name', '=', ref('last_name')),
+     *     cmpr('first_name', '=', ref('middle_name'))
+     *   ]))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*
+     * from "person"
+     * where "first_name" = "last_name"
+     * or "first_name" = "middle_name"
+     * ```
+     */
+    cmpr<O extends SqlBool = SqlBool, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): ExpressionWrapper<O>;
+    /**
+     * Creates a binary expression.
+     *
+     * See {@link cmpr} for creating binary comparison operations.
+     *
+     * This function returns an {@link Expression} and can be used pretty much anywhere.
+     * See the examples for a couple of possible use cases.
+     *
+     * ### Examples
+     *
+     * In the following example `bxp` is used to increment an integer column:
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .set((eb) => ({
+     *     age: eb.bxp('age', '+', 1)
+     *   }))
+     *   .where('id', '=', id)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "age" = "age" + $1
+     * where "id" = $2
+     * ```
+     *
+     * By default the third argument is a value. {@link ref} can be used to
+     * pass in a column reference instead:
+     *
+     * ```ts
+     * db.updateTable('person')
+     *   .set((eb) => ({
+     *     age: eb.bxp('age', '+', eb.ref('age'))
+     *   }))
+     *   .where('id', '=', id)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person"
+     * set "age" = "age" + "age"
+     * where "id" = $1
+     * ```
+     */
+    bxp<RE extends ReferenceExpression<DB, TB>, OP extends BinaryOperatorExpression>(lhs: RE, op: OP, rhs: OperandValueExpression<DB, TB, RE>): ExpressionWrapper<OP extends ComparisonOperator ? SqlBool : ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Creates an unary expression.
+     *
+     * This function returns an {@link Expression} and can be used pretty much anywhere.
+     * See the examples for a couple of possible use cases.
+     *
+     * @see {@link not}, {@link exists} and {@link neg}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select((eb) => [
+     *     'first_name',
+     *     eb.unary('-', 'age').as('negative_age')
+     *   ])
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name", -"age"
+     * from "person"
+     * ```
+     */
+    unary<RE extends ReferenceExpression<DB, TB>>(op: UnaryOperator, expr: RE): ExpressionWrapper<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Creates a `not` operation.
+     *
+     * A shortcut for `unary('not', expr)`.
+     *
+     * @see {@link unary}
+     */
+    not<RE extends ReferenceExpression<DB, TB>>(expr: RE): ExpressionWrapper<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Creates an `exists` operation.
+     *
+     * A shortcut for `unary('exists', expr)`.
+     *
+     * @see {@link unary}
+     */
+    exists<RE extends ReferenceExpression<DB, TB>>(expr: RE): ExpressionWrapper<SqlBool>;
+    /**
+     * Creates a negation operation.
+     *
+     * A shortcut for `unary('-', expr)`.
+     *
+     * @see {@link unary}
+     */
+    neg<RE extends ReferenceExpression<DB, TB>>(expr: RE): ExpressionWrapper<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+    /**
+     * Combines two or more expressions using the logical `and` operator.
+     *
+     * This function returns an {@link Expression} and can be used pretty much anywhere.
+     * See the examples for a couple of possible use cases.
+     *
+     * ### Examples
+     *
+     * In this example we use `and` with {@link cmpr} to create a `WHERE expr1 AND expr2 AND expr3`
+     * statement:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ and, cmpr }) => and([
+     *     cmpr('first_name', '=', 'Jennifer'),
+     *     cmpr('fist_name', '=', 'Arnold'),
+     *     cmpr('fist_name', '=', 'Sylvester')
+     *   ]))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*
+     * from "person"
+     * where "first_name" = $1
+     * and "first_name" = $2
+     * and "first_name" = $3
+     * ```
+     */
+    and(expres: ReadonlyArray<Expression<SqlBool>>): ExpressionWrapper<SqlBool>;
+    /**
+     * Combines two or more expressions using the logical `or` operator.
+     *
+     * This function returns an {@link Expression} and can be used pretty much anywhere.
+     * See the examples for a couple of possible use cases.
+     *
+     * ### Examples
+     *
+     * In this example we use `or` with {@link cmpr} to create a `WHERE expr1 OR expr2 OR expr3`
+     * statement:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .selectAll('person')
+     *   .where(({ or, cmpr }) => or([
+     *     cmpr('first_name', '=', 'Jennifer'),
+     *     cmpr('fist_name', '=', 'Arnold'),
+     *     cmpr('fist_name', '=', 'Sylvester')
+     *   ]))
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person".*
+     * from "person"
+     * where "first_name" = $1
+     * or "first_name" = $2
+     * or "first_name" = $3
+     * ```
+     */
+    or(expres: ReadonlyArray<Expression<SqlBool>>): ExpressionWrapper<SqlBool>;
+    /**
+     * See {@link QueryCreator.withSchema}
+     *
+     * @deprecated Will be removed in kysely 0.25.0.
+     */
+    withSchema(schema: string): ExpressionBuilder<DB, TB>;
+}
+export declare function createExpressionBuilder<DB, TB extends keyof DB>(executor?: QueryExecutor): ExpressionBuilder<DB, TB>;
+export declare function expressionBuilder<DB, TB extends keyof DB>(_: SelectQueryBuilder<DB, TB, any>): ExpressionBuilder<DB, TB>;
+export declare function expressionBuilder<DB, TB extends keyof DB>(): ExpressionBuilder<DB, TB>;