kysely 0.26.1 → 0.26.3

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

@@ -14,1106 +14,270 @@ import { freeze } from '../util/object-utils.js';
 import { parseGroupBy } from '../parser/group-by-parser.js';
 import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
-import { parseSetOperation } from '../parser/set-operation-parser.js';
-import { parseFilter, parseReferentialComparison, } from '../parser/binary-operation-parser.js';
-export class SelectQueryBuilder {
+import { parseSetOperations, } from '../parser/set-operation-parser.js';
+import { parseValueBinaryOperationOrExpression, parseReferentialBinaryOperation, } from '../parser/binary-operation-parser.js';
+import { ExpressionWrapper } from '../expression/expression-wrapper.js';
+class SelectQueryBuilderImpl {
     #props;
     constructor(props) {
         this.#props = freeze(props);
     }
-    /** @private */
     get expressionType() {
         return undefined;
     }
+    get isSelectQueryBuilder() {
+        return true;
+    }
     where(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseFilter(args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     whereRef(lhs, op, rhs) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
     having(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseFilter(args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseValueBinaryOperationOrExpression(args)),
         });
     }
     havingRef(lhs, op, rhs) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferentialBinaryOperation(lhs, op, rhs)),
         });
     }
-    /**
-     * Adds a select statement to the query.
-     *
-     * When a column (or any expression) is selected, Kysely adds its type to the return
-     * type of the query. Kysely is smart enough to parse the selection names and types
-     * from aliased columns, subqueries, raw expressions etc.
-     *
-     * Kysely only allows you to select columns and expressions that exist and would
-     * produce valid SQL. However, Kysely is not perfect and there may be cases where
-     * the type inference doesn't work and you need to override it. You can always
-     * use the {@link Kysely.dynamic | dynamic} module and the {@link sql} tag
-     * to override the types.
-     *
-     * Select calls are additive. Calling `select('id').select('first_name')` is the
-     * same as calling `select(['id', 'first_name'])`.
-     *
-     * To select all columns of the query or specific tables see the
-     * {@link selectAll} method.
-     *
-     * See the {@link $if} method if you are looking for a way to add selections
-     * based on a runtime condition.
-     *
-     * ### Examples
-     *
-     * <!-- siteExample("select", "A single column", 10) -->
-     *
-     * Select a single column:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .select('id')
-     *   .where('first_name', '=', 'Arnold')
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "id" from "person" where "first_name" = $1
-     * ```
-     *
-     * <!-- siteExample("select", "Column with a table", 20) -->
-     *
-     * Select a single column and specify a table:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom(['person', 'pet'])
-     *   .select('person.id')
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."id" from "person", "pet"
-     * ```
-     *
-     * <!-- siteExample("select", "Multiple columns", 30) -->
-     *
-     * Select multiple columns:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .select(['person.id', 'first_name'])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "person"."id", "first_name" from "person"
-     * ```
-     *
-     * <!-- siteExample("select", "Aliases", 40) -->
-     *
-     * You can provide an alias for the selections by appending `as the_alias` to the selection.
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .select([
-     *     'first_name as fn',
-     *     'person.last_name as ln'
-     *   ])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select
-     *   "first_name" as "fn",
-     *   "person"."last_name" as "ln"
-     * from "person"
-     * ```
-     *
-     * <!-- siteExample("select", "Complex selections", 50) -->
-     *
-     * You can select arbitrary expression including subqueries and raw sql snippets.
-     * When you do that, you need to give a name for the selections using the `as` method:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * const persons = await db.selectFrom('person')
-     *   .select(({ eb, selectFrom, or }) => [
-     *     // Select a correlated subquery
-     *     selectFrom('pet')
-     *       .whereRef('person.id', '=', 'pet.owner_id')
-     *       .select('pet.name')
-     *       .orderBy('pet.name')
-     *       .limit(1)
-     *       .as('first_pet_name'),
-     *
-     *     // Build and select an expression using
-     *     // the expression builder
-     *     or([
-     *       eb('first_name', '=', 'Jennifer'),
-     *       eb('first_name', '=', 'Arnold')
-     *     ]).as('is_jennifer_or_arnold'),
-     *
-     *     // Select a raw sql expression
-     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
-     *   ])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select
-     *   (
-     *     select "pet"."name"
-     *     from "pet"
-     *     where "person"."id" = "pet"."owner_id"
-     *     order by "pet"."name"
-     *     limit $1
-     *   ) as "pet_name",
-     *   ("first_name" = $2 or "first_name" = $3) as "jennifer_or_arnold",
-     *   concat(first_name, ' ', last_name) as "full_name"
-     * from "person"
-     * ```
-     *
-     * In case you use the {@link sql} tag you need to specify the type of the expression
-     * (in this example `string`).
-     *
-     * All the examples above assume you know the column names at compile time.
-     * While it's better to build your code like that (that way you also know
-     * the types) sometimes it's not possible or you just prefer to write more
-     * dynamic code.
-     * <br><br>
-     * In this example, we use the `dynamic` module's methods to add selections
-     * dynamically:
-     *
-     * ```ts
-     * const { ref } = db.dynamic
-     *
-     * // Some column name provided by the user. Value not known at compile time.
-     * const columnFromUserInput = req.query.select;
-     *
-     * // A type that lists all possible values `columnFromUserInput` can have.
-     * // You can use `keyof Person` if any column of an interface is allowed.
-     * type PossibleColumns = 'last_name' | 'first_name' | 'birth_date'
-     *
-     * const spersons = await db
-     *   .selectFrom('person')
-     *   .select([
-     *     ref<PossibleColumns>(columnFromUserInput)
-     *     'id'
-     *   ])
-     *   .execute()
-     *
-     * // The resulting type contains all `PossibleColumns` as optional fields
-     * // because we cannot know which field was actually selected before
-     * // running the code.
-     * const lastName: string | undefined = persons[0].last_name
-     * const firstName: string | undefined = persons[0].first_name
-     * const birthDate: string | undefined = persons[0].birth_date
-     *
-     * // The result type also contains the compile time selection `id`.
-     * persons[0].id
-     * ```
-     */
     select(selection) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectArg(selection)),
         });
     }
     distinctOn(selection) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithDistinctOn(this.#props.queryNode, parseReferenceExpressionOrList(selection)),
         });
     }
-    /**
-     * This can be used to add any additional SQL to the front of the query __after__ the `select` keyword.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .modifyFront(sql`sql_no_cache`)
-     *   .select('first_name')
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (MySQL):
-     *
-     * ```sql
-     * select sql_no_cache `first_name`
-     * from `person`
-     * ```
-     */
     modifyFront(modifier) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.createWithExpression(modifier.toOperationNode())),
         });
     }
-    /**
-     * This can be used to add any additional SQL to the end of the query.
-     *
-     * Also see {@link forUpdate}, {@link forShare}, {@link forKeyShare}, {@link forNoKeyUpdate}
-     * {@link skipLocked} and  {@link noWait}.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select('first_name')
-     *   .modifyEnd(sql`for update`)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "first_name"
-     * from "person"
-     * for update
-     * ```
-     */
     modifyEnd(modifier) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.createWithExpression(modifier.toOperationNode())),
         });
     }
-    /**
-     * Makes the selection distinct.
-     *
-     * <!-- siteExample("select", "Distinct", 70) -->
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const persons = await db.selectFrom('person')
-     *   .select('first_name')
-     *   .distinct()
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select distinct "first_name" from "person"
-     * ```
-     */
     distinct() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, SelectModifierNode.create('Distinct')),
         });
     }
-    /**
-     * Adds the `for update` modifier to a select query on supported databases.
-     */
     forUpdate() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForUpdate')),
         });
     }
-    /**
-     * Adds the `for share` modifier to a select query on supported databases.
-     */
     forShare() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForShare')),
         });
     }
-    /**
-     * Adds the `for key share` modifier to a select query on supported databases.
-     */
     forKeyShare() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForKeyShare')),
         });
     }
-    /**
-     * Adds the `for no key update` modifier to a select query on supported databases.
-     */
     forNoKeyUpdate() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('ForNoKeyUpdate')),
         });
     }
-    /**
-     * Adds the `skip locked` modifier to a select query on supported databases.
-     */
     skipLocked() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('SkipLocked')),
         });
     }
-    /**
-     * Adds the `nowait` modifier to a select query on supported databases.
-     */
     noWait() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, SelectModifierNode.create('NoWait')),
         });
     }
     selectAll(table) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectAll(table)),
         });
     }
     innerJoin(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('InnerJoin', args)),
         });
     }
     leftJoin(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LeftJoin', args)),
         });
     }
     rightJoin(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('RightJoin', args)),
         });
     }
     fullJoin(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
         });
     }
     innerJoinLateral(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralInnerJoin', args)),
         });
     }
     leftJoinLateral(...args) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralLeftJoin', args)),
         });
     }
-    /**
-     * 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`).
-     *
-     * ### Examples
-     *
-     * ```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
-     * ```
-     *
-     * The order by expression can also be a raw sql expression or a subquery
-     * in addition to column references:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .orderBy((eb) => eb.selectFrom('pet')
-     *     .select('pet.name')
-     *     .whereRef('pet.owner_id', '=', 'person.id')
-     *     .limit(1)
-     *   )
-     *   .orderBy(
-     *     sql`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
-     * ```
-     *
-     * `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) {
-        return new SelectQueryBuilder({
+    orderBy(...args) {
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, parseOrderBy(orderBy, direction)),
+            queryNode: SelectQueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args)),
         });
     }
-    /**
-     * Adds a `group by` clause to the query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * await db
-     *   .selectFrom('person')
-     *   .select([
-     *     'first_name',
-     *     sql`max(id)`.as('max_id')
-     *   ])
-     *   .groupBy('first_name')
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "first_name", max(id)
-     * from "person"
-     * group by "first_name"
-     * ```
-     *
-     * `groupBy` also accepts an array:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * await db
-     *   .selectFrom('person')
-     *   .select([
-     *     'first_name',
-     *     'last_name',
-     *     sql`max(id)`.as('max_id')
-     *   ])
-     *   .groupBy([
-     *     'first_name',
-     *     'last_name'
-     *   ])
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "first_name", "last_name", max(id)
-     * from "person"
-     * group by "first_name", "last_name"
-     * ```
-     *
-     * The group by expressions can also be subqueries or
-     * raw sql expressions:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * await db
-     *   .selectFrom('person')
-     *   .select([
-     *     'first_name',
-     *     'last_name',
-     *     sql`max(id)`.as('max_id')
-     *   ])
-     *   .groupBy([
-     *     sql`concat(first_name, last_name)`,
-     *     (qb) => qb.selectFrom('pet').select('id').limit(1)
-     *   ])
-     *   .execute()
-     * ```
-     *
-     * `dynamic.ref` can be used to refer to columns not known at
-     * compile time:
-     *
-     * ```ts
-     * async function someQuery(groupBy: string) {
-     *   const { ref } = db.dynamic
-     *
-     *   return await db
-     *     .selectFrom('person')
-     *     .select('first_name')
-     *     .groupBy(ref(groupBy))
-     *     .execute()
-     * }
-     *
-     * someQuery('first_name')
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select "first_name"
-     * from "person"
-     * group by "first_name"
-     * ```
-     */
     groupBy(groupBy) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseGroupBy(groupBy)),
         });
     }
-    /**
-     * Adds a limit clause to the query.
-     *
-     * ### Examples
-     *
-     * Select the first 10 rows of the result:
-     *
-     * ```ts
-     * return await db
-     *   .selectFrom('person')
-     *   .select('first_name')
-     *   .limit(10)
-     * ```
-     *
-     * 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) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithLimit(this.#props.queryNode, LimitNode.create(limit)),
         });
     }
-    /**
-     * Adds an offset clause to the query.
-     *
-     * ### Examples
-     *
-     * 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) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...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.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .union(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
     union(expression) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, parseSetOperation('union', expression, false)),
+            queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations('union', 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.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .unionAll(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
     unionAll(expression) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, parseSetOperation('union', expression, true)),
+            queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations('union', expression, true)),
         });
     }
-    /**
-     * Combines another select query or raw expression to this query using `intersect`.
-     *
-     * The output row type of the combined query must match `this` query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .intersect(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
     intersect(expression) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, parseSetOperation('intersect', expression, false)),
+            queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations('intersect', expression, false)),
         });
     }
-    /**
-     * Combines another select query or raw expression to this query using `intersect all`.
-     *
-     * The output row type of the combined query must match `this` query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .intersectAll(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
     intersectAll(expression) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, parseSetOperation('intersect', expression, true)),
+            queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations('intersect', expression, true)),
         });
     }
-    /**
-     * Combines another select query or raw expression to this query using `except`.
-     *
-     * The output row type of the combined query must match `this` query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .except(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
     except(expression) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, parseSetOperation('except', expression, false)),
+            queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations('except', expression, false)),
         });
     }
-    /**
-     * Combines another select query or raw expression to this query using `except all`.
-     *
-     * The output row type of the combined query must match `this` query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name as name'])
-     *   .exceptAll(db.selectFrom('pet').select(['id', 'name']))
-     *   .orderBy('name')
-     * ```
-     */
     exceptAll(expression) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSetOperation(this.#props.queryNode, parseSetOperation('except', expression, true)),
+            queryNode: SelectQueryNode.cloneWithSetOperations(this.#props.queryNode, parseSetOperations('except', expression, true)),
         });
     }
-    /**
-     * Gives an alias for the query. This method is only useful for sub queries.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const pets = await db.selectFrom('pet')
-     *   .selectAll('pet')
-     *   .select(
-     *     (qb) => qb.selectFrom('person')
-     *       .select('first_name')
-     *       .whereRef('pet.owner_id', '=', 'person.id')
-     *       .as('owner_first_name')
-     *   )
-     *   .execute()
-     *
-     * pets[0].owner_first_name
-     * ```
-     */
     as(alias) {
-        return new AliasedSelectQueryBuilder(this, alias);
+        return new AliasedSelectQueryBuilderImpl(this, alias);
     }
-    /**
-     * Clears all select clauses from the query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select(['id', 'first_name'])
-     *   .clearSelect()
-     *   .select(['id', 'gender'])
-     * ```
-     *
-     * The generated SQL(PostgreSQL):
-     *
-     * ```sql
-     * select "id", "gender" from "person"
-     * ```
-     */
     clearSelect() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithoutSelections(this.#props.queryNode),
         });
     }
     clearWhere() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
         });
     }
-    /**
-     * Clears limit clause from the query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .limit(10)
-     *   .clearLimit()
-     * ```
-     *
-     * The generated SQL(PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * ```
-     */
     clearLimit() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithoutLimit(this.#props.queryNode),
         });
     }
-    /**
-     * Clears offset clause from the query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .limit(10)
-     *   .offset(20)
-     *   .clearOffset()
-     * ```
-     *
-     * The generated SQL(PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" limit 10
-     * ```
-     */
     clearOffset() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithoutOffset(this.#props.queryNode),
         });
     }
-    /**
-     * Clears all `order by` clauses from the query.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .orderBy('id')
-     *   .clearOrderBy()
-     * ```
-     *
-     * The generated SQL(PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * ```
-     */
     clearOrderBy() {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: SelectQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
         });
     }
-    /**
-     * Simply calls the provided function passing `this` as the only argument. `$call` returns
-     * what the provided function returns.
-     *
-     * If you want to conditionally call a method on `this`, see
-     * the {@link $if} method.
-     *
-     * ### Examples
-     *
-     * The next example uses a helper function `log` to log a query:
-     *
-     * ```ts
-     * function log<T extends Compilable>(qb: T): T {
-     *   console.log(qb.compile())
-     *   return qb
-     * }
-     *
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .$call(log)
-     *   .execute()
-     * ```
-     */
     $call(func) {
         return func(this);
     }
-    /**
-     * Call `func(this)` if `condition` is true.
-     *
-     * NOTE: This method has an impact on typescript performance and it should only be used
-     * when necessary. Remember that you can call most methods like `where` conditionally
-     * like this:
-     *
-     * ```ts
-     * let query = db.selectFrom('person').selectAll()
-     *
-     * if (firstName) {
-     *   query = query.where('first_name', '=', firstName)
-     * }
-     *
-     * if (lastName) {
-     *   query = query.where('last_name', '=', lastName)
-     * }
-     *
-     * const result = await query.execute()
-     * ```
-     *
-     * This method is mainly useful with optional selects. Any `select` or `selectAll`
-     * method called inside the callback add optional fields to the result type. This is
-     * because we can't know if those selections were actually made before running the code.
-     *
-     * Also see [this recipe](https://github.com/koskimas/kysely/tree/master/site/docs/recipes/conditional-selects.md)
-     *
-     * ### Examples
-     *
-     * ```ts
-     * async function getPerson(id: number, withLastName: boolean) {
-     *   return await db
-     *     .selectFrom('person')
-     *     .select(['id', 'first_name'])
-     *     .$if(withLastName, (qb) => qb.select('last_name'))
-     *     .where('id', '=', id)
-     *     .executeTakeFirstOrThrow()
-     * }
-     * ```
-     *
-     * Any selections added inside the `if` callback will be added as optional fields to the
-     * output type since we can't know if the selections were actually made before running
-     * the code. In the example above the return type of the `getPerson` function is:
-     *
-     * ```ts
-     * {
-     *   id: number
-     *   first_name: string
-     *   last_name?: string
-     * }
-     * ```
-     *
-     * You can also call any other methods inside the callback:
-     *
-     * ```ts
-     * db.selectFrom('person')
-     *   .select('person.id')
-     *   .$if(filterByFirstName, (qb) => qb.where('first_name', '=', firstName))
-     *   .$if(filterByPetCount, (qb) => qb
-     *     .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *     .having((eb) => eb.fn.count('pet.id'), '>', petCountLimit)
-     *     .groupBy('person.id')
-     *   )
-     * ```
-     */
     $if(condition, func) {
         if (condition) {
             return func(this);
         }
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
         });
     }
-    /**
-     * 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 SelectQueryBuilder(this.#props);
+        return new SelectQueryBuilderImpl(this.#props);
     }
-    /**
-     * Narrows (parts of) the output type of the query.
-     *
-     * Kysely tries to be as type-safe as possible, but in some cases we have to make
-     * compromises for better maintainability and compilation performance. At present,
-     * Kysely doesn't narrow the output type of the query when using {@link where}, {@link having}
-     * or {@link JoinQueryBuilder.on}.
-     *
-     * This utility method is very useful for these situations, as it removes unncessary
-     * runtime assertion/guard code. Its input type is limited to the output type
-     * of the query, so you can't add a column that doesn't exist, or change a column's
-     * type to something that doesn't exist in its union type.
-     *
-     * ### Examples
-     *
-     * Turn this code:
-     *
-     * ```ts
-     * const person = await db.selectFrom('person')
-     *   .where('nullable_column', 'is not', null)
-     *   .selectAll()
-     *   .executeTakeFirstOrThrow()
-     *
-     * if (person.nullable_column) {
-     *   functionThatExpectsPersonWithNonNullValue(person)
-     * }
-     * ```
-     *
-     * Into this:
-     *
-     * ```ts
-     * const person = await db.selectFrom('person')
-     *   .where('nullable_column', 'is not', null)
-     *   .selectAll()
-     *   .$narrowType<{ nullable_column: string }>()
-     *   .executeTakeFirstOrThrow()
-     *
-     * functionThatExpectsPersonWithNonNullValue(person)
-     * ```
-     */
     $narrowType() {
-        return new SelectQueryBuilder(this.#props);
+        return new SelectQueryBuilderImpl(this.#props);
     }
-    /**
-     * Asserts that query's output row type equals the given type `T`.
-     *
-     * This method can be used to simplify excessively complex types to make typescript happy
-     * and much faster.
-     *
-     * Kysely uses complex type magic to achieve its type safety. This complexity is sometimes too much
-     * for typescript and you get errors like this:
-     *
-     * ```
-     * error TS2589: Type instantiation is excessively deep and possibly infinite.
-     * ```
-     *
-     * In these case you can often use this method to help typescript a little bit. When you use this
-     * method to assert the output type of a query, Kysely can drop the complex output type that
-     * consists of multiple nested helper types and replace it with the simple asserted type.
-     *
-     * Using this method doesn't reduce type safety at all. You have to pass in a type that is
-     * structurally equal to the current type.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const result = await db
-     *   .with('first_and_last', (qb) => qb
-     *     .selectFrom('person')
-     *     .select(['first_name', 'last_name'])
-     *     .$assertType<{ first_name: string, last_name: string }>()
-     *   )
-     *   .with('age', (qb) => qb
-     *     .selectFrom('person')
-     *     .select('age')
-     *     .$assertType<{ age: number }>()
-     *   )
-     *   .selectFrom(['first_and_last', 'age'])
-     *   .selectAll()
-     *   .executeTakeFirstOrThrow()
-     * ```
-     */
     $assertType() {
-        return new SelectQueryBuilder(this.#props);
+        return new SelectQueryBuilderImpl(this.#props);
+    }
+    $asTuple() {
+        return new ExpressionWrapper(this.toOperationNode());
     }
-    /**
-     * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
-     */
     withPlugin(plugin) {
-        return new SelectQueryBuilder({
+        return new SelectQueryBuilderImpl({
             ...this.#props,
             executor: this.#props.executor.withPlugin(plugin),
         });
@@ -1124,32 +288,15 @@ export class SelectQueryBuilder {
     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 compiledQuery = this.compile();
         const result = await this.#props.executor.executeQuery(compiledQuery, this.#props.queryId);
         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, or callback to throw a different
-     * error.
-     */
     async executeTakeFirstOrThrow(errorConstructor = NoResultError) {
         const result = await this.executeTakeFirst();
         if (result === undefined) {
@@ -1168,33 +315,38 @@ export class SelectQueryBuilder {
         }
     }
     async explain(format, options) {
-        const builder = new SelectQueryBuilder({
+        const builder = new SelectQueryBuilderImpl({
             ...this.#props,
             queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options),
         });
         return await builder.execute();
     }
 }
-preventAwait(SelectQueryBuilder, "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
+preventAwait(SelectQueryBuilderImpl, "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
+export function createSelectQueryBuilder(props) {
+    return new SelectQueryBuilderImpl(props);
+}
 /**
  * {@link SelectQueryBuilder} with an alias. The result of calling {@link SelectQueryBuilder.as}.
  */
-export class AliasedSelectQueryBuilder {
+class AliasedSelectQueryBuilderImpl {
     #queryBuilder;
     #alias;
     constructor(queryBuilder, alias) {
         this.#queryBuilder = queryBuilder;
         this.#alias = alias;
     }
-    /** @private */
     get expression() {
         return this.#queryBuilder;
     }
-    /** @private */
     get alias() {
         return this.#alias;
     }
+    get isAliasedSelectQueryBuilder() {
+        return true;
+    }
     toOperationNode() {
         return AliasNode.create(this.#queryBuilder.toOperationNode(), IdentifierNode.create(this.#alias));
     }
 }
+preventAwait(AliasedSelectQueryBuilderImpl, "don't await AliasedSelectQueryBuilder instances directly. AliasedSelectQueryBuilder should never be executed directly since it's always a part of another query.");