kysely 0.11.4 → 0.13.0

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

@@ -1,1061 +0,0 @@
-import { AliasNode } from '../operation-node/alias-node.js';
-import { parseJoin, } from '../parser/join-parser.js';
-import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
-import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
-import { parseInsertObjectOrList, } from '../parser/insert-values-parser.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { InsertQueryNode } from '../operation-node/insert-query-node.js';
-import { QueryNode, } from '../operation-node/query-node.js';
-import { parseOrderBy, } from '../parser/order-by-parser.js';
-import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { parseUpdateObject, } from '../parser/update-set-parser.js';
-import { preventAwait } from '../util/prevent-await.js';
-import { LimitNode } from '../operation-node/limit-node.js';
-import { OffsetNode } from '../operation-node/offset-node.js';
-import { parseOnConflictDoNothing, parseOnConflictUpdate, } from '../parser/on-conflict-parser.js';
-import { freeze } from '../util/object-utils.js';
-import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
-import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
-import { parseGroupBy } from '../parser/group-by-parser.js';
-import { parseUnion } from '../parser/union-parser.js';
-import { InsertResult } from './insert-result.js';
-import { UpdateResult } from './update-result.js';
-import { DeleteResult } from './delete-result.js';
-/**
- * The main query builder class.
- *
- * @typeParam DB - A type whose keys are table names/aliases and values are interfaces that
- *    define the table's columns and their types. This type defines the tables, subqueries
- *    etc. that are available to the query. This type contains all tables, even the ones
- *    that have not actually been joined to the query. the `TB` parameter defines the
- *    table names/aliases that have been joined to the query.
- *
- * @typeParam TB - The names/aliases of the tables that have been joined to the query
- *    using `from`, `with` any join method and so on. This type is a union of `DB`
- *    type's keys. For example `'person' | 'pet'`.
- *
- * @typePAram O - The query output row type.
- */
-export class QueryBuilder {
-    #props;
-    constructor(props) {
-        this.#props = freeze(props);
-    }
-    where(...args) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
-        });
-    }
-    /**
-     * Adds a `where` clause where both sides of the operator are references
-     * to columns.
-     *
-     * The normal `where` method treats the right hand side argument as a
-     * value by default. `whereRef` treats it as a column reference. This method is
-     * expecially useful with joins and correclated subqueries.
-     *
-     * @example
-     * Usage with a join:
-     *
-     * ```ts
-     * db.selectFrom(['person', 'pet'])
-     *   .selectAll()
-     *   .whereRef('person.first_name', '=', 'pet.name')
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person", "pet" where "person"."first_name" = "pet"."name"
-     * ```
-     *
-     * @example
-     * Usage in a subquery:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll('person')
-     *   .select((qb) => qb
-     *     .subQuery('pet')
-     *     .select('name')
-     *     .whereRef('pet.owner_id', '=', 'person.id')
-     *     .limit(1)
-     *     .as('pet_name')
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person".*, (
-     *   select "name"
-     *   from "pet"
-     *   where "pet"."owner_id" = "person"."id"
-     *   limit $1
-     * ) as "pet_name"
-     * from "person"
-     */
-    whereRef(lhs, op, rhs) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
-        });
-    }
-    orWhere(...args) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
-        });
-    }
-    /**
-     * Adds an `or where` clause to the query. Otherwise works just like
-     * {@link QueryBuilder.whereRef | whereRef}.
-     *
-     * Also see {@link QueryBuilder.orWhere | orWhere} and {@link QueryBuilder.where | where}.
-     */
-    orWhereRef(lhs, op, rhs) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
-        });
-    }
-    /**
-     * Adds a `where exists` clause to the query.
-     *
-     * You can either use a subquery or a raw instance.
-     *
-     * @example
-     * The query below selets all persons that own a pet named Catto:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .whereExists((qb) => qb
-     *     .subQuery('pet')
-     *     .select('pet.id')
-     *     .whereRef('person.id', '=', 'pet.owner_id')
-     *     .where('pet.name', '=', 'Catto')
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * where exists (
-     *   select "pet"."id"
-     *   from "pet"
-     *   where "person"."id" = "pet"."owner_id"
-     *   and "pet"."name" = $1
-     * )
-     * ```
-     *
-     * @example
-     * The same query as in the previous example but with using raw:
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .whereExists(
-     *     db.raw(
-     *       '(select pet.id from pet where person.id = pet.owner_id and pet.name = ?)',
-     *       ['Catto']
-     *     )
-     *   )
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * where exists (
-     *   select pet.id
-     *   from pet
-     *   where person.id = pet.owner_id
-     *   and pet.name = $1
-     * )
-     * ```
-     */
-    whereExists(arg) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.whereExists | whereExists} but creates a `not exists` clause.
-     */
-    whereNotExists(arg) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.whereExists | whereExists} but creates a `or exists` clause.
-     */
-    orWhereExists(arg) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.whereExists | whereExists} but creates a `or not exists` clause.
-     */
-    orWhereNotExists(arg) {
-        assertCanHaveWhereClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    having(...args) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseHavingFilter(this.#props.parseContext, args)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.whereRef | whereRef} but adds a `having` statement
-     * instead of a `where` statement.
-     */
-    havingRef(lhs, op, rhs) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
-        });
-    }
-    orHaving(...args) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseHavingFilter(this.#props.parseContext, args)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.orWhereRef | orWhereRef} but adds a `having` statement
-     * instead of a `where` statement.
-     */
-    orHavingRef(lhs, op, rhs) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.whereExists | whereExists} but adds a `having` statement
-     * instead of a `where` statement.
-     */
-    havingExists(arg) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.whereNotExists | whereNotExists} but adds a `having` statement
-     * instead of a `where` statement.
-     */
-    havingNotExist(arg) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.orWhereExists | orWhereExists} but adds a `having` statement
-     * instead of a `where` statement.
-     */
-    orHavingExists(arg) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    /**
-     * Just like {@link QueryBuilder.orWhereNotExists | orWhereNotExists} but adds a `having` statement
-     * instead of a `where` statement.
-     */
-    orHavingNotExists(arg) {
-        assertCanHaveHavingClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
-        });
-    }
-    select(selection) {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
-        });
-    }
-    distinctOn(selection) {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
-        });
-    }
-    /**
-     * Makes the selection distinct.
-     *
-     * @example
-     * ```ts
-     * await db.selectFrom('person')
-     *   .select('first_name')
-     *   .distinct()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select distinct "first_name" from "person"
-     * ```
-     */
-    distinct() {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithDistinct(this.#props.queryNode),
-        });
-    }
-    /**
-     * Adds the `for update` option to a select query on supported databases.
-     */
-    forUpdate() {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForUpdate'),
-        });
-    }
-    /**
-     * Adds the `for share` option to a select query on supported databases.
-     */
-    forShare() {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForShare'),
-        });
-    }
-    /**
-     * Adds the `for key share` option to a select query on supported databases.
-     */
-    forKeyShare() {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForKeyShare'),
-        });
-    }
-    /**
-     * Adds the `for no key update` option to a select query on supported databases.
-     */
-    forNoKeyUpdate() {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForNoKeyUpdate'),
-        });
-    }
-    /**
-     * Adds the `skip locked` option to a select query on supported databases.
-     */
-    skipLocked() {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'SkipLocked'),
-        });
-    }
-    /**
-     * Adds the `nowait` option to a select query on supported databases.
-     */
-    noWait() {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'NoWait'),
-        });
-    }
-    selectAll(table) {
-        assertCanHaveSelectClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectAll(table)),
-        });
-    }
-    innerJoin(...args) {
-        assertCanHaveJoins(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'InnerJoin', args)),
-        });
-    }
-    leftJoin(...args) {
-        assertCanHaveJoins(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'LeftJoin', args)),
-        });
-    }
-    rightJoin(...args) {
-        assertCanHaveJoins(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'RightJoin', args)),
-        });
-    }
-    fullJoin(...args) {
-        assertCanHaveJoins(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'FullJoin', args)),
-        });
-    }
-    values(args) {
-        assertCanHaveInsertValues(this.#props.queryNode);
-        const [columns, values] = parseInsertObjectOrList(this.#props.parseContext, args);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                columns,
-                values,
-            }),
-        });
-    }
-    onConflictDoNothing(target) {
-        assertCanHaveOnConflict(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onConflict: parseOnConflictDoNothing(target),
-            }),
-        });
-    }
-    /**
-     * Changes an `insert into` query to an `insert ignore into` query.
-     *
-     * If you use the ignore modifier, ignorable errors that occur while executing the
-     * insert statement are ignored. For example, without ignore, a row that duplicates
-     * an existing unique index or primary key value in the table causes a duplicate-key
-     * error and the statement is aborted. With ignore, the row is discarded and no error
-     * occurs.
-     *
-     * This is only supported on some dialects like MySQL. On most dialects you should
-     * use the {@link onConflictDoNothing} method.
-     *
-     * @example
-     * ```ts
-     * await db.insertInto('person')
-     *   .ignore()
-     *   .values(values)
-     *   .execute()
-     * ```
-     */
-    ignore() {
-        assertCanHaveInsertIgnore(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                ignore: true,
-            }),
-        });
-    }
-    onConflictUpdate(target, updates) {
-        assertCanHaveOnConflict(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onConflict: parseOnConflictUpdate(this.#props.parseContext, target, updates),
-            }),
-        });
-    }
-    /**
-     * Adds `on duplicate key update` to an insert query.
-     *
-     * If you specify `on duplicate key update`, and a row is inserted that would cause
-     * a duplicate value in a unique index or primary key, an update of the old row occurs.
-     *
-     * This is only implemented by some dialects like MySQL. On most dialects you should
-     * use {@link onConflictUpdate} instead.
-     *
-     * @example
-     * ```ts
-     * await db
-     *   .insertInto('person')
-     *   .values(values)
-     *   .onDuplicateKeyUpdate({ species: 'hamster' })
-     * ```
-     */
-    onDuplicateKeyUpdate(updates) {
-        assertCanHaveOnDuplicateKey(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onDuplicateKey: OnDuplicateKeyNode.create(parseUpdateObject(this.#props.parseContext, updates)),
-            }),
-        });
-    }
-    /**
-     * Sets the values to update for an {@link Kysely.updateTable | update} query.
-     *
-     * This method takes an object whose keys are column names and values are
-     * values to update. In addition to the column's type, the values can be `raw`
-     * instances or select queries.
-     *
-     * The return value of an update query is an instance of {@link UpdateResult}.
-     * You can use the {@link QueryBuilder.returning | returning} method on
-     * supported databases to get out the updated rows.
-     *
-     * @example
-     * Update a row in `person` table:
-     *
-     * ```ts
-     * const result = await db
-     *   .updateTable('person')
-     *   .set({
-     *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
-     *   })
-     *   .where('id', '=', 1)
-     *   .executeTakeFirst()
-     *
-     * console.log(result.numUpdatedRows)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * update "person" set "first_name" = $1, "last_name" = $2 where "id" = $3
-     * ```
-     *
-     * @example
-     * On postgresql you ca chain `returning` to the query to get
-     * the updated rows' columns (or any other expression) as the
-     * return value:
-     *
-     * ```ts
-     * const row = await db
-     *   .updateTable('person')
-     *   .set({
-     *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
-     *   })
-     *   .where('id', '=', 1)
-     *   .returning('id')
-     *   .executeTakeFirstOrThrow()
-     *
-     * row.id
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * update "person" set "first_name" = $1, "last_name" = $2 where "id" = $3 returning "id"
-     * ```
-     *
-     * @example
-     * In addition to primitives, the values can also be `raw` expressions or
-     * select queries:
-     *
-     * ```ts
-     * const result = await db
-     *   .updateTable('person')
-     *   .set({
-     *     first_name: 'Jennifer',
-     *     last_name: db.raw('? || ?', ['Ani', 'ston']),
-     *     age: db.selectFrom('person').select(raw('avg(age)')),
-     *   })
-     *   .where('id', '=', 1)
-     *   .executeTakeFirst()
-     *
-     * console.log(result.numUpdatedRows)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * update "person" set
-     * "first_name" = $1,
-     * "last_name" = $2 || $3,
-     * "age" = (select avg(age) from "person")
-     * where "id" = $4
-     * ```
-     */
-    set(row) {
-        assertCanHaveUpdates(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateObject(this.#props.parseContext, row)),
-        });
-    }
-    returning(selection) {
-        assertCanHaveReturningClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
-        });
-    }
-    /**
-     * Adds a `returning *` to an insert/update/delete query on databases
-     * that support `returning` such as PostgreSQL.
-     */
-    returningAll() {
-        assertCanHaveReturningClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll()),
-        });
-    }
-    /**
-     * Adds an `order by` clause to the query.
-     *
-     * `orderBy` calls are additive. To order by multiple columns, call `orderBy`
-     * multiple times.
-     *
-     * The first argument is the expression to order by and the second is the
-     * order (`asc` or `desc`).
-     *
-     * @example
-     * ```ts
-     * await db
-     *   .selectFrom('person')
-     *   .select('person.first_name as fn')
-     *   .orderBy('id')
-     *   .orderBy('fn', 'desc')
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."first_name" as "fn"
-     * from "person"
-     * order by "id" asc, "fn" desc
-     * ```
-     *
-     * @example
-     * The order by expression can also be a `raw` expression or a subquery
-     * in addition to column references:
-     *
-     * ```ts
-     * await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .orderBy((qb) => qb.subQuery('pet')
-     *     .select('pet.name')
-     *     .whereRef('pet.owner_id', '=', 'person.id')
-     *     .limit(1)
-     *   )
-     *   .orderBy(
-     *     db.raw('concat(first_name, last_name)')
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select *
-     * from "person"
-     * order by
-     *   ( select "pet"."name"
-     *     from "pet"
-     *     where "pet"."owner_id" = "person"."id"
-     *     limit 1
-     *   ) asc,
-     *   concat(first_name, last_name) asc
-     * ```
-     *
-     * @example
-     * `dynamic.ref` can be used to refer to columns not known at
-     * compile time:
-     *
-     * ```ts
-     * async function someQuery(orderBy: string) {
-     *   const { ref } = db.dynamic
-     *
-     *   return await db
-     *     .selectFrom('person')
-     *     .select('person.first_name as fn')
-     *     .orderBy(ref(orderBy))
-     *     .execute()
-     * }
-     *
-     * someQuery('fn')
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."first_name" as "fn"
-     * from "person"
-     * order by "fn" asc
-     * ```
-     */
-    orderBy(orderBy, direction) {
-        assertCanHaveOrderByClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, parseOrderBy(this.#props.parseContext, orderBy, direction)),
-        });
-    }
-    groupBy(orderBy) {
-        assertCanHaveGroupByClause(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseGroupBy(this.#props.parseContext, orderBy)),
-        });
-    }
-    /**
-     * Adds a limit clause to the query.
-     *
-     * @example
-     * Select the first 10 rows of the result:
-     *
-     * ```ts
-     * return await db
-     *   .selectFrom('person')
-     *   .select('first_name')
-     *   .limit(10)
-     * ```
-     *
-     * @example
-     * Select rows from index 10 to index 19 of the result:
-     *
-     * ```ts
-     * return await db
-     *   .selectFrom('person')
-     *   .select('first_name')
-     *   .offset(10)
-     *   .limit(10)
-     * ```
-     */
-    limit(limit) {
-        assertCanHaveLimit(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(limit)),
-        });
-    }
-    /**
-     * Adds an offset clause to the query.
-     *
-     * @example
-     * Select rows from index 10 to index 19 of the result:
-     *
-     * ```ts
-     * return await db
-     *   .selectFrom('person')
-     *   .select('first_name')
-     *   .offset(10)
-     *   .limit(10)
-     * ```
-     */
-    offset(offset) {
-        assertCanHaveOffset(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOffset(this.#props.queryNode, OffsetNode.create(offset)),
-        });
-    }
-    /**
-     * Combines another select query or raw expression to this query using `union`.
-     *
-     * The output row type of the combined query must match `this` query.
-     *
-     * @xample
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .union(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
-    union(expression) {
-        assertCanHaveUnion(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithUnion(this.#props.queryNode, parseUnion(expression, false)),
-        });
-    }
-    /**
-     * Combines another select query or raw expression to this query using `union all`.
-     *
-     * The output row type of the combined query must match `this` query.
-     *
-     * @xample
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .unionAll(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
-    unionAll(expression) {
-        assertCanHaveUnion(this.#props.queryNode);
-        return new QueryBuilder({
-            ...this.#props,
-            queryNode: SelectQueryNode.cloneWithUnion(this.#props.queryNode, parseUnion(expression, true)),
-        });
-    }
-    /**
-     * Simply calls the given function passing `this` as the only argument.
-     *
-     * This method can be useful when adding optional method calls:
-     *
-     * @example
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .call((qb) => {
-     *     if (something) {
-     *       return qb.where('something', '=', something)
-     *     } else {
-     *       return qb.where('somethingElse', '=', somethingElse)
-     *     }
-     *   })
-     *   .execute()
-     * ```
-     *
-     * The next example uses a helper funtion `log` to log a query:
-     *
-     * @example
-     * ```ts
-     * function log<T extends AnyQueryBuilder>(qb: T): T {
-     *   console.log(qb.compile())
-     *   return qb
-     * }
-     *
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .call(log)
-     *   .execute()
-     * ```
-     */
-    call(func) {
-        return func(this);
-    }
-    /**
-     * Gives an alias for the query. This method is only useful for sub queries.
-     *
-     * @example
-     * ```ts
-     * await db.selectFrom('pet')
-     *   .selectAll('pet')
-     *   .select(
-     *     (qb) => qb.subQuery('person')
-     *       .select('first_name')
-     *       .whereRef('pet.owner_id', '=', 'person.id')
-     *       .as('owner_first_name')
-     *   )
-     *   .execute()
-     * ```
-     */
-    as(alias) {
-        return new AliasedQueryBuilder(this, alias);
-    }
-    /**
-     * Change the output type of the query.
-     *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
-     */
-    castTo() {
-        return new QueryBuilder(this.#props);
-    }
-    toOperationNode() {
-        return this.#props.executor.transformQuery(this.#props.queryNode, this.#props.queryId);
-    }
-    compile() {
-        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
-    }
-    /**
-     * Executes the query and returns an array of rows.
-     *
-     * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
-     */
-    async execute() {
-        const compildQuery = this.compile();
-        const query = compildQuery.query;
-        const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
-        if (this.#props.parseContext.adapter.supportsReturning &&
-            QueryNode.isMutating(query) &&
-            query.returning) {
-            return result.rows;
-        }
-        else if (InsertQueryNode.is(query)) {
-            return [new InsertResult(result.insertId)];
-        }
-        else if (UpdateQueryNode.is(query)) {
-            return [new UpdateResult(result.numUpdatedOrDeletedRows)];
-        }
-        else if (DeleteQueryNode.is(query)) {
-            return [new DeleteResult(result.numUpdatedOrDeletedRows)];
-        }
-        else {
-            return result.rows;
-        }
-    }
-    /**
-     * Executes the query and returns the first result or undefined if
-     * the query returned no result.
-     */
-    async executeTakeFirst() {
-        const [result] = await this.execute();
-        return result;
-    }
-    /**
-     * Executes the query and returns the first result or throws if
-     * the query returned no result.
-     *
-     * By default an instance of {@link NoResultError} is thrown, but you can
-     * provide a custom error class as the only argument to throw a different
-     * error.
-     */
-    async executeTakeFirstOrThrow(errorConstructor = NoResultError) {
-        const result = await this.executeTakeFirst();
-        if (result === undefined) {
-            throw new errorConstructor(this.toOperationNode());
-        }
-        return result;
-    }
-}
-preventAwait(QueryBuilder, "don't await QueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
-/**
- * {@link QueryBuilder} with an alias. The result of calling {@link QueryBuilder.as}.
- */
-export class AliasedQueryBuilder {
-    #queryBuilder;
-    #alias;
-    constructor(queryBuilder, alias) {
-        this.#queryBuilder = queryBuilder;
-        this.#alias = alias;
-    }
-    /**
-     * @private
-     *
-     * This needs to be here just so that the typings work. Without this
-     * the generated .d.ts file contains no reference to the type param A
-     * which causes this type to be equal to AliasedQueryBuilder with any A
-     * as long as D, TB and O are the same.
-     */
-    get alias() {
-        return this.#alias;
-    }
-    toOperationNode() {
-        const node = this.#queryBuilder.toOperationNode();
-        if (SelectQueryNode.is(node)) {
-            return AliasNode.create(node, this.#alias);
-        }
-        throw new Error('only select queries can be aliased');
-    }
-}
-export class NoResultError extends Error {
-    /**
-     * The operation node tree of the query that was executed.
-     */
-    node;
-    constructor(node) {
-        super('no result');
-        this.node = node;
-    }
-}
-function assertCanHaveWhereClause(node) {
-    if (!QueryNode.isFilterable(node)) {
-        throw new Error('only select, delete and update queries can have a where clause');
-    }
-}
-function assertCanHaveHavingClause(node) {
-    if (!SelectQueryNode.is(node)) {
-        throw new Error('only select queries can have a having clause');
-    }
-}
-function assertCanHaveSelectClause(node) {
-    if (!SelectQueryNode.is(node)) {
-        throw new Error('only a select query can have selections');
-    }
-}
-function assertCanHaveJoins(node) {
-    if (!QueryNode.isFilterable(node)) {
-        throw new Error('only select, delete and update queries can have joins');
-    }
-}
-function assertCanHaveInsertValues(node) {
-    if (!InsertQueryNode.is(node)) {
-        throw new Error('only an insert query can have insert values');
-    }
-}
-function assertCanHaveInsertIgnore(node) {
-    if (!InsertQueryNode.is(node)) {
-        throw new Error('only an insert query can have the ignore clause');
-    }
-}
-function assertCanHaveOnConflict(node) {
-    if (!InsertQueryNode.is(node)) {
-        throw new Error('only an insert query can have an on conflict clause');
-    }
-}
-function assertCanHaveOnDuplicateKey(node) {
-    if (!InsertQueryNode.is(node)) {
-        throw new Error('only an insert query can have an on duplicate key clause');
-    }
-}
-function assertCanHaveUpdates(node) {
-    if (!UpdateQueryNode.is(node)) {
-        throw new Error('only an update query can set values');
-    }
-}
-function assertCanHaveReturningClause(node) {
-    if (!QueryNode.isMutating(node)) {
-        throw new Error('only insert, delete and update queries can have a returning clause');
-    }
-}
-function assertCanHaveOrderByClause(node) {
-    if (!SelectQueryNode.is(node)) {
-        throw new Error('only a select query can have an order by clause');
-    }
-}
-function assertCanHaveGroupByClause(node) {
-    if (!SelectQueryNode.is(node)) {
-        throw new Error('only a select query can have a group by clause');
-    }
-}
-function assertCanHaveLimit(node) {
-    if (!SelectQueryNode.is(node)) {
-        throw new Error('only a select query can have a limit');
-    }
-}
-function assertCanHaveOffset(node) {
-    if (!SelectQueryNode.is(node)) {
-        throw new Error('only a select query can have an offset');
-    }
-}
-function assertCanHaveUnion(node) {
-    if (!SelectQueryNode.is(node)) {
-        throw new Error('only a select query can have an union');
-    }
-}