diff --git a/scripts/generate-site-examples.js b/scripts/generate-site-examples.js
index e450443e3..53b1c453b 100644
--- a/scripts/generate-site-examples.js
+++ b/scripts/generate-site-examples.js
@@ -25,27 +25,27 @@ const CODE_LINE_REGEX = /\*(.*)/
 const moreExamplesByCategory = {
   select: {
     'select method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#select',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#select',
     'selectAll method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#selectAll',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#selectAll',
     'selectFrom method':
       'https://kysely-org.github.io/kysely/classes/Kysely.html#selectFrom',
   },
   where: {
     'where method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#where',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#where',
     'whereRef method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#whereRef',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#whereRef',
   },
   join: {
     'innerJoin method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#innerJoin',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#innerJoin',
     'leftJoin method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#leftJoin',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#leftJoin',
     'rightJoin method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#rightJoin',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#rightJoin',
     'fullJoin method':
-      'https://kysely-org.github.io/kysely/classes/SelectQueryBuilder.html#fullJoin',
+      'https://kysely-org.github.io/kysely/interfaces/SelectQueryBuilder.html#fullJoin',
   },
   insert: {
     'values method':
diff --git a/src/expression/expression-builder.ts b/src/expression/expression-builder.ts
index def83fe44..b4711452d 100644
--- a/src/expression/expression-builder.ts
+++ b/src/expression/expression-builder.ts
@@ -1,4 +1,7 @@
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js'
+import {
+  SelectQueryBuilder,
+  createSelectQueryBuilder,
+} from '../query-builder/select-query-builder.js'
 import { SelectQueryNode } from '../operation-node/select-query-node.js'
 import {
   parseTableExpressionOrList,
@@ -771,7 +774,7 @@ export function createExpressionBuilder<DB, TB extends keyof DB>(
     eb: undefined! as ExpressionBuilder<DB, TB>,
 
     selectFrom(table: TableExpressionOrList<DB, TB>): any {
-      return new SelectQueryBuilder({
+      return createSelectQueryBuilder({
         queryId: createQueryId(),
         executor: executor,
         queryNode: SelectQueryNode.create(parseTableExpressionOrList(table)),
diff --git a/src/parser/parse-utils.ts b/src/parser/parse-utils.ts
index da565ff84..f440b99f3 100644
--- a/src/parser/parse-utils.ts
+++ b/src/parser/parse-utils.ts
@@ -3,7 +3,10 @@ import { OverNode } from '../operation-node/over-node.js'
 import { SelectQueryNode } from '../operation-node/select-query-node.js'
 import { JoinBuilder } from '../query-builder/join-builder.js'
 import { OverBuilder } from '../query-builder/over-builder.js'
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js'
+import {
+  SelectQueryBuilder,
+  createSelectQueryBuilder as newSelectQueryBuilder,
+} from '../query-builder/select-query-builder.js'
 import { QueryCreator } from '../query-creator.js'
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js'
 import { createQueryId } from '../util/query-id.js'
@@ -14,7 +17,7 @@ import {
 } from './table-parser.js'
 
 export function createSelectQueryBuilder(): SelectQueryBuilder<any, any, any> {
-  return new SelectQueryBuilder({
+  return newSelectQueryBuilder({
     queryId: createQueryId(),
     executor: NOOP_QUERY_EXECUTOR,
     queryNode: SelectQueryNode.create(parseTableExpressionOrList([])),
diff --git a/src/query-builder/delete-query-builder.ts b/src/query-builder/delete-query-builder.ts
index 7d98da63c..32c697dbb 100644
--- a/src/query-builder/delete-query-builder.ts
+++ b/src/query-builder/delete-query-builder.ts
@@ -83,6 +83,7 @@ export class DeleteQueryBuilder<DB, TB extends keyof DB, O>
   ): DeleteQueryBuilder<DB, TB, O>
 
   where(factory: WhereExpressionFactory<DB, TB>): DeleteQueryBuilder<DB, TB, O>
+
   where(expression: Expression<any>): DeleteQueryBuilder<DB, TB, O>
 
   where(...args: any[]): any {
diff --git a/src/query-builder/having-interface.ts b/src/query-builder/having-interface.ts
index 99246c277..288429717 100644
--- a/src/query-builder/having-interface.ts
+++ b/src/query-builder/having-interface.ts
@@ -19,6 +19,7 @@ export interface HavingInterface<DB, TB extends keyof DB> {
   ): HavingInterface<DB, TB>
 
   having(factory: HavingExpressionFactory<DB, TB>): HavingInterface<DB, TB>
+
   having(expression: Expression<any>): HavingInterface<DB, TB>
 
   /**
diff --git a/src/query-builder/select-query-builder.ts b/src/query-builder/select-query-builder.ts
index acd6d9b32..a92b7cecc 100644
--- a/src/query-builder/select-query-builder.ts
+++ b/src/query-builder/select-query-builder.ts
@@ -68,26 +68,13 @@ import { KyselyTypeError } from '../util/type-error.js'
 import { Selectable } from '../util/column-type.js'
 import { Streamable } from '../util/streamable.js'
 
-export class SelectQueryBuilder<DB, TB extends keyof DB, O>
-  implements
-    WhereInterface<DB, TB>,
+export interface SelectQueryBuilder<DB, TB extends keyof DB, O>
+  extends WhereInterface<DB, TB>,
     HavingInterface<DB, TB>,
     Expression<O>,
     Compilable<O>,
     Explainable,
-    Streamable<O>
-{
-  readonly #props: SelectQueryBuilderProps
-
-  constructor(props: SelectQueryBuilderProps) {
-    this.#props = freeze(props)
-  }
-
-  /** @private */
-  get expressionType(): O | undefined {
-    return undefined
-  }
-
+    Streamable<O> {
   where<RE extends ReferenceExpression<DB, TB>>(
     lhs: RE,
     op: ComparisonOperatorExpression,
@@ -95,31 +82,14 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
   ): SelectQueryBuilder<DB, TB, O>
 
   where(factory: WhereExpressionFactory<DB, TB>): SelectQueryBuilder<DB, TB, O>
-  where(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>
 
-  where(...args: any[]): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithWhere(
-        this.#props.queryNode,
-        parseValueBinaryOperationOrExpression(args)
-      ),
-    })
-  }
+  where(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>
 
   whereRef(
     lhs: ReferenceExpression<DB, TB>,
     op: ComparisonOperatorExpression,
     rhs: ReferenceExpression<DB, TB>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithWhere(
-        this.#props.queryNode,
-        parseReferentialBinaryOperation(lhs, op, rhs)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O>
 
   having<RE extends ReferenceExpression<DB, TB>>(
     lhs: RE,
@@ -133,29 +103,11 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
 
   having(expression: Expression<any>): SelectQueryBuilder<DB, TB, O>
 
-  having(...args: any[]): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithHaving(
-        this.#props.queryNode,
-        parseValueBinaryOperationOrExpression(args)
-      ),
-    })
-  }
-
   havingRef(
     lhs: ReferenceExpression<DB, TB>,
     op: ComparisonOperatorExpression,
     rhs: ReferenceExpression<DB, TB>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithHaving(
-        this.#props.queryNode,
-        parseReferentialBinaryOperation(lhs, op, rhs)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds a select statement to the query.
@@ -345,15 +297,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    */
   select<SE extends SelectExpression<DB, TB>>(
     selection: SelectArg<DB, TB, SE>
-  ): SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSelections(
-        this.#props.queryNode,
-        parseSelectArg(selection)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>>
 
   /**
    * Adds `distinct on` expressions to the select clause.
@@ -388,16 +332,6 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     selection: RE
   ): SelectQueryBuilder<DB, TB, O>
 
-  distinctOn(selection: ReferenceExpressionOrList<DB, TB>): any {
-    return new SelectQueryBuilder({
-      ...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.
    *
@@ -417,15 +351,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * from `person`
    * ```
    */
-  modifyFront(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithFrontModifier(
-        this.#props.queryNode,
-        SelectModifierNode.createWithExpression(modifier.toOperationNode())
-      ),
-    })
-  }
+  modifyFront(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O>
 
   /**
    * This can be used to add any additional SQL to the end of the query.
@@ -450,15 +376,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * for update
    * ```
    */
-  modifyEnd(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithEndModifier(
-        this.#props.queryNode,
-        SelectModifierNode.createWithExpression(modifier.toOperationNode())
-      ),
-    })
-  }
+  modifyEnd(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Makes the selection distinct.
@@ -480,93 +398,37 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * select distinct "first_name" from "person"
    * ```
    */
-  distinct(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithFrontModifier(
-        this.#props.queryNode,
-        SelectModifierNode.create('Distinct')
-      ),
-    })
-  }
+  distinct(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds the `for update` modifier to a select query on supported databases.
    */
-  forUpdate(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithEndModifier(
-        this.#props.queryNode,
-        SelectModifierNode.create('ForUpdate')
-      ),
-    })
-  }
+  forUpdate(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds the `for share` modifier to a select query on supported databases.
    */
-  forShare(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithEndModifier(
-        this.#props.queryNode,
-        SelectModifierNode.create('ForShare')
-      ),
-    })
-  }
+  forShare(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds the `for key share` modifier to a select query on supported databases.
    */
-  forKeyShare(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithEndModifier(
-        this.#props.queryNode,
-        SelectModifierNode.create('ForKeyShare')
-      ),
-    })
-  }
+  forKeyShare(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds the `for no key update` modifier to a select query on supported databases.
    */
-  forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithEndModifier(
-        this.#props.queryNode,
-        SelectModifierNode.create('ForNoKeyUpdate')
-      ),
-    })
-  }
+  forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds the `skip locked` modifier to a select query on supported databases.
    */
-  skipLocked(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithEndModifier(
-        this.#props.queryNode,
-        SelectModifierNode.create('SkipLocked')
-      ),
-    })
-  }
+  skipLocked(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds the `nowait` modifier to a select query on supported databases.
    */
-  noWait(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithEndModifier(
-        this.#props.queryNode,
-        SelectModifierNode.create('NoWait')
-      ),
-    })
-  }
+  noWait(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds a `select *` or `select table.*` clause to the query.
@@ -632,16 +494,6 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
 
   selectAll(): SelectQueryBuilder<DB, TB, O & AllSelection<DB, TB>>
 
-  selectAll(table?: any): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSelections(
-        this.#props.queryNode,
-        parseSelectAll(table)
-      ),
-    })
-  }
-
   /**
    * Joins another table to the query using an inner join.
    *
@@ -760,22 +612,19 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     TE extends TableExpression<DB, TB>,
     K1 extends JoinReferenceExpression<DB, TB, TE>,
     K2 extends JoinReferenceExpression<DB, TB, TE>
-  >(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
+  >(
+    table: TE,
+    k1: K1,
+    k2: K2
+  ): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
 
   innerJoin<
     TE extends TableExpression<DB, TB>,
     FN extends JoinCallbackExpression<DB, TB, TE>
-  >(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
-
-  innerJoin(...args: any): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithJoin(
-        this.#props.queryNode,
-        parseJoin('InnerJoin', args)
-      ),
-    })
-  }
+  >(
+    table: TE,
+    callback: FN
+  ): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
 
   /**
    * Just like {@link innerJoin} but adds a left join instead of an inner join.
@@ -784,22 +633,19 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     TE extends TableExpression<DB, TB>,
     K1 extends JoinReferenceExpression<DB, TB, TE>,
     K2 extends JoinReferenceExpression<DB, TB, TE>
-  >(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
+  >(
+    table: TE,
+    k1: K1,
+    k2: K2
+  ): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
 
   leftJoin<
     TE extends TableExpression<DB, TB>,
     FN extends JoinCallbackExpression<DB, TB, TE>
-  >(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
-
-  leftJoin(...args: any): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithJoin(
-        this.#props.queryNode,
-        parseJoin('LeftJoin', args)
-      ),
-    })
-  }
+  >(
+    table: TE,
+    callback: FN
+  ): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
 
   /**
    * Just like {@link innerJoin} but adds a right join instead of an inner join.
@@ -808,22 +654,19 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     TE extends TableExpression<DB, TB>,
     K1 extends JoinReferenceExpression<DB, TB, TE>,
     K2 extends JoinReferenceExpression<DB, TB, TE>
-  >(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>
+  >(
+    table: TE,
+    k1: K1,
+    k2: K2
+  ): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>
 
   rightJoin<
     TE extends TableExpression<DB, TB>,
     FN extends JoinCallbackExpression<DB, TB, TE>
-  >(table: TE, callback: FN): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>
-
-  rightJoin(...args: any): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithJoin(
-        this.#props.queryNode,
-        parseJoin('RightJoin', args)
-      ),
-    })
-  }
+  >(
+    table: TE,
+    callback: FN
+  ): SelectQueryBuilderWithRightJoin<DB, TB, O, TE>
 
   /**
    * Just like {@link innerJoin} but adds a full join instead of an inner join.
@@ -832,22 +675,19 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     TE extends TableExpression<DB, TB>,
     K1 extends JoinReferenceExpression<DB, TB, TE>,
     K2 extends JoinReferenceExpression<DB, TB, TE>
-  >(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>
+  >(
+    table: TE,
+    k1: K1,
+    k2: K2
+  ): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>
 
   fullJoin<
     TE extends TableExpression<DB, TB>,
     FN extends JoinCallbackExpression<DB, TB, TE>
-  >(table: TE, callback: FN): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>
-
-  fullJoin(...args: any): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithJoin(
-        this.#props.queryNode,
-        parseJoin('FullJoin', args)
-      ),
-    })
-  }
+  >(
+    table: TE,
+    callback: FN
+  ): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>
 
   /**
    * Just like {@link innerJoin} but adds a lateral join instead of an inner join.
@@ -872,22 +712,19 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     TE extends TableExpression<DB, TB>,
     K1 extends JoinReferenceExpression<DB, TB, TE>,
     K2 extends JoinReferenceExpression<DB, TB, TE>
-  >(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
+  >(
+    table: TE,
+    k1: K1,
+    k2: K2
+  ): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
 
   innerJoinLateral<
     TE extends TableExpression<DB, TB>,
     FN extends JoinCallbackExpression<DB, TB, TE>
-  >(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
-
-  innerJoinLateral(...args: any): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithJoin(
-        this.#props.queryNode,
-        parseJoin('LateralInnerJoin', args)
-      ),
-    })
-  }
+  >(
+    table: TE,
+    callback: FN
+  ): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>
 
   /**
    * Just like {@link innerJoin} but adds a lateral left join instead of an inner join.
@@ -911,22 +748,19 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
     TE extends TableExpression<DB, TB>,
     K1 extends JoinReferenceExpression<DB, TB, TE>,
     K2 extends JoinReferenceExpression<DB, TB, TE>
-  >(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
+  >(
+    table: TE,
+    k1: K1,
+    k2: K2
+  ): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
 
   leftJoinLateral<
     TE extends TableExpression<DB, TB>,
     FN extends JoinCallbackExpression<DB, TB, TE>
-  >(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
-
-  leftJoinLateral(...args: any): any {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithJoin(
-        this.#props.queryNode,
-        parseJoin('LateralLeftJoin', args)
-      ),
-    })
-  }
+  >(
+    table: TE,
+    callback: FN
+  ): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>
 
   /**
    * Adds an `order by` clause to the query.
@@ -1018,15 +852,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
   orderBy(
     orderBy: OrderByExpression<DB, TB, O>,
     direction?: OrderByDirectionExpression
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithOrderByItem(
-        this.#props.queryNode,
-        parseOrderBy(orderBy, direction)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds a `group by` clause to the query.
@@ -1126,15 +952,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * group by "first_name"
    * ```
    */
-  groupBy(groupBy: GroupByArg<DB, TB, O>): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithGroupByItems(
-        this.#props.queryNode,
-        parseGroupBy(groupBy)
-      ),
-    })
-  }
+  groupBy(groupBy: GroupByArg<DB, TB, O>): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds a limit clause to the query.
@@ -1160,15 +978,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    *   .limit(10)
    * ```
    */
-  limit(limit: number): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithLimit(
-        this.#props.queryNode,
-        LimitNode.create(limit)
-      ),
-    })
-  }
+  limit(limit: number): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Adds an offset clause to the query.
@@ -1185,15 +995,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    *   .limit(10)
    * ```
    */
-  offset(offset: number): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithOffset(
-        this.#props.queryNode,
-        OffsetNode.create(offset)
-      ),
-    })
-  }
+  offset(offset: number): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Combines another select query or raw expression to this query using `union`.
@@ -1221,17 +1023,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    *   .orderBy('name')
    * ```
    */
-  union(
-    expression: SetOperandExpression<DB, O>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSetOperation(
-        this.#props.queryNode,
-        parseSetOperation('union', expression, false)
-      ),
-    })
-  }
+  union(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Combines another select query or raw expression to this query using `union all`.
@@ -1261,15 +1053,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    */
   unionAll(
     expression: SetOperandExpression<DB, O>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSetOperation(
-        this.#props.queryNode,
-        parseSetOperation('union', expression, true)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Combines another select query or raw expression to this query using `intersect`.
@@ -1299,15 +1083,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    */
   intersect(
     expression: SetOperandExpression<DB, O>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSetOperation(
-        this.#props.queryNode,
-        parseSetOperation('intersect', expression, false)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Combines another select query or raw expression to this query using `intersect all`.
@@ -1337,15 +1113,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    */
   intersectAll(
     expression: SetOperandExpression<DB, O>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSetOperation(
-        this.#props.queryNode,
-        parseSetOperation('intersect', expression, true)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Combines another select query or raw expression to this query using `except`.
@@ -1373,17 +1141,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    *   .orderBy('name')
    * ```
    */
-  except(
-    expression: SetOperandExpression<DB, O>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSetOperation(
-        this.#props.queryNode,
-        parseSetOperation('except', expression, false)
-      ),
-    })
-  }
+  except(expression: SetOperandExpression<DB, O>): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Combines another select query or raw expression to this query using `except all`.
@@ -1413,15 +1171,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    */
   exceptAll(
     expression: SetOperandExpression<DB, O>
-  ): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithSetOperation(
-        this.#props.queryNode,
-        parseSetOperation('except', expression, true)
-      ),
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Gives an alias for the query. This method is only useful for sub queries.
@@ -1442,9 +1192,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * pets[0].owner_first_name
    * ```
    */
-  as<A extends string>(alias: A): AliasedSelectQueryBuilder<DB, TB, O, A> {
-    return new AliasedSelectQueryBuilder(this, alias)
-  }
+  as<A extends string>(alias: A): AliasedSelectQueryBuilder<DB, TB, O, A>
 
   /**
    * Clears all select clauses from the query.
@@ -1464,19 +1212,9 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * select "id", "gender" from "person"
    * ```
    */
-  clearSelect(): SelectQueryBuilder<DB, TB, {}> {
-    return new SelectQueryBuilder<DB, TB, {}>({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithoutSelections(this.#props.queryNode),
-    })
-  }
+  clearSelect(): SelectQueryBuilder<DB, TB, {}>
 
-  clearWhere(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder<DB, TB, O>({
-      ...this.#props,
-      queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
-    })
-  }
+  clearWhere(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Clears limit clause from the query.
@@ -1496,12 +1234,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * select * from "person"
    * ```
    */
-  clearLimit(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder<DB, TB, O>({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithoutLimit(this.#props.queryNode),
-    })
-  }
+  clearLimit(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Clears offset clause from the query.
@@ -1522,12 +1255,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * select * from "person" limit 10
    * ```
    */
-  clearOffset(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder<DB, TB, O>({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithoutOffset(this.#props.queryNode),
-    })
-  }
+  clearOffset(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Clears all `order by` clauses from the query.
@@ -1547,12 +1275,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * select * from "person"
    * ```
    */
-  clearOrderBy(): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder<DB, TB, O>({
-      ...this.#props,
-      queryNode: SelectQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
-    })
-  }
+  clearOrderBy(): SelectQueryBuilder<DB, TB, O>
 
   /**
    * Simply calls the provided function passing `this` as the only argument. `$call` returns
@@ -1577,9 +1300,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    *   .execute()
    * ```
    */
-  $call<T>(func: (qb: this) => T): T {
-    return func(this)
-  }
+  $call<T>(func: (qb: this) => T): T
 
   /**
    * Call `func(this)` if `condition` is true.
@@ -1649,15 +1370,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
   $if<O2>(
     condition: boolean,
     func: (qb: this) => SelectQueryBuilder<any, any, O & O2>
-  ): SelectQueryBuilder<DB, TB, O & Partial<O2>> {
-    if (condition) {
-      return func(this)
-    }
-
-    return new SelectQueryBuilder({
-      ...this.#props,
-    })
-  }
+  ): SelectQueryBuilder<DB, TB, O & Partial<O2>>
 
   /**
    * Change the output type of the query.
@@ -1665,9 +1378,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * You should only use this method as the last resort if the types
    * don't support your use case.
    */
-  $castTo<T>(): SelectQueryBuilder<DB, TB, T> {
-    return new SelectQueryBuilder(this.#props)
-  }
+  $castTo<T>(): SelectQueryBuilder<DB, TB, T>
 
   /**
    * Narrows (parts of) the output type of the query.
@@ -1709,9 +1420,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * functionThatExpectsPersonWithNonNullValue(person)
    * ```
    */
-  $narrowType<T>(): SelectQueryBuilder<DB, TB, NarrowPartial<O, T>> {
-    return new SelectQueryBuilder(this.#props)
-  }
+  $narrowType<T>(): SelectQueryBuilder<DB, TB, NarrowPartial<O, T>>
 
   /**
    * Asserts that query's output row type equals the given type `T`.
@@ -1754,58 +1463,29 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    */
   $assertType<T extends O>(): O extends T
     ? SelectQueryBuilder<DB, TB, T>
-    : KyselyTypeError<`$assertType() call failed: The type passed in is not equal to the output type of the query.`> {
-    return new SelectQueryBuilder(this.#props) as unknown as any
-  }
+    : KyselyTypeError<`$assertType() call failed: The type passed in is not equal to the output type of the query.`>
 
   /**
    * Returns a copy of this SelectQueryBuilder instance with the given plugin installed.
    */
-  withPlugin(plugin: KyselyPlugin): SelectQueryBuilder<DB, TB, O> {
-    return new SelectQueryBuilder({
-      ...this.#props,
-      executor: this.#props.executor.withPlugin(plugin),
-    })
-  }
+  withPlugin(plugin: KyselyPlugin): SelectQueryBuilder<DB, TB, O>
 
-  toOperationNode(): SelectQueryNode {
-    return this.#props.executor.transformQuery(
-      this.#props.queryNode,
-      this.#props.queryId
-    )
-  }
+  toOperationNode(): SelectQueryNode
 
-  compile(): CompiledQuery<Simplify<O>> {
-    return this.#props.executor.compileQuery(
-      this.toOperationNode(),
-      this.#props.queryId
-    )
-  }
+  compile(): CompiledQuery<Simplify<O>>
 
   /**
    * Executes the query and returns an array of rows.
    *
    * Also see the {@link executeTakeFirst} and {@link executeTakeFirstOrThrow} methods.
    */
-  async execute(): Promise<Simplify<O>[]> {
-    const compiledQuery = this.compile()
-
-    const result = await this.#props.executor.executeQuery<O>(
-      compiledQuery,
-      this.#props.queryId
-    )
-
-    return result.rows
-  }
+  execute(): Promise<Simplify<O>[]>
 
   /**
    * Executes the query and returns the first result or undefined if
    * the query returned no result.
    */
-  async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
-    const [result] = await this.execute()
-    return result as SimplifySingleResult<O>
-  }
+  executeTakeFirst(): Promise<SimplifySingleResult<O>>
 
   /**
    * Executes the query and returns the first result or throws if
@@ -1815,101 +1495,600 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
    * provide a custom error class, or callback to throw a different
    * error.
    */
-  async executeTakeFirstOrThrow(
-    errorConstructor:
-      | NoResultErrorConstructor
-      | ((node: QueryNode) => Error) = NoResultError
-  ): Promise<Simplify<O>> {
-    const result = await this.executeTakeFirst()
-
-    if (result === undefined) {
-      const error = isNoResultErrorConstructor(errorConstructor)
-        ? new errorConstructor(this.toOperationNode())
-        : errorConstructor(this.toOperationNode())
+  executeTakeFirstOrThrow(
+    errorConstructor?: NoResultErrorConstructor | ((node: QueryNode) => Error)
+  ): Promise<Simplify<O>>
 
-      throw error
-    }
+  stream(chunkSize?: number): AsyncIterableIterator<O>
 
-    return result as O
-  }
+  explain<ER extends Record<string, any> = Record<string, any>>(
+    format?: ExplainFormat,
+    options?: Expression<any>
+  ): Promise<ER[]>
+}
 
-  async *stream(chunkSize: number = 100): AsyncIterableIterator<O> {
-    const compiledQuery = this.compile()
+class SelectQueryBuilderImpl<DB, TB extends keyof DB, O>
+  implements SelectQueryBuilder<DB, TB, O>
+{
+  readonly #props: SelectQueryBuilderProps
 
-    const stream = this.#props.executor.stream<O>(
-      compiledQuery,
-      chunkSize,
-      this.#props.queryId
-    )
+  constructor(props: SelectQueryBuilderProps) {
+    this.#props = freeze(props)
+  }
 
-    for await (const item of stream) {
-      yield* item.rows
-    }
+  get expressionType(): O | undefined {
+    return undefined
   }
 
-  async explain<ER extends Record<string, any> = Record<string, any>>(
-    format?: ExplainFormat,
-    options?: Expression<any>
-  ): Promise<ER[]> {
-    const builder = new SelectQueryBuilder<DB, TB, ER>({
+  where(...args: any[]): any {
+    return new SelectQueryBuilderImpl({
       ...this.#props,
-      queryNode: QueryNode.cloneWithExplain(
+      queryNode: QueryNode.cloneWithWhere(
         this.#props.queryNode,
-        format,
-        options
+        parseValueBinaryOperationOrExpression(args)
       ),
     })
+  }
 
-    return await builder.execute()
+  whereRef(
+    lhs: ReferenceExpression<DB, TB>,
+    op: ComparisonOperatorExpression,
+    rhs: ReferenceExpression<DB, TB>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithWhere(
+        this.#props.queryNode,
+        parseReferentialBinaryOperation(lhs, op, rhs)
+      ),
+    })
   }
-}
 
-preventAwait(
-  SelectQueryBuilder,
-  "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`."
-)
+  having(...args: any[]): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithHaving(
+        this.#props.queryNode,
+        parseValueBinaryOperationOrExpression(args)
+      ),
+    })
+  }
 
-export interface SelectQueryBuilderProps {
-  readonly queryId: QueryId
-  readonly queryNode: SelectQueryNode
-  readonly executor: QueryExecutor
-}
+  havingRef(
+    lhs: ReferenceExpression<DB, TB>,
+    op: ComparisonOperatorExpression,
+    rhs: ReferenceExpression<DB, TB>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithHaving(
+        this.#props.queryNode,
+        parseReferentialBinaryOperation(lhs, op, rhs)
+      ),
+    })
+  }
 
-/**
- * {@link SelectQueryBuilder} with an alias. The result of calling {@link SelectQueryBuilder.as}.
- */
-export class AliasedSelectQueryBuilder<
-  DB,
-  TB extends keyof DB,
-  O = undefined,
-  A extends string = never
-> implements AliasedExpression<O, A>
-{
-  readonly #queryBuilder: SelectQueryBuilder<DB, TB, O>
-  readonly #alias: A
+  select<SE extends SelectExpression<DB, TB>>(
+    selection: SelectArg<DB, TB, SE>
+  ): SelectQueryBuilder<DB, TB, O & Selection<DB, TB, SE>> {
+    return new SelectQueryBuilderImpl<DB, TB, O & Selection<DB, TB, SE>>({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSelections(
+        this.#props.queryNode,
+        parseSelectArg(selection)
+      ),
+    })
+  }
 
-  constructor(queryBuilder: SelectQueryBuilder<DB, TB, O>, alias: A) {
-    this.#queryBuilder = queryBuilder
-    this.#alias = alias
+  distinctOn(selection: ReferenceExpressionOrList<DB, TB>): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithDistinctOn(
+        this.#props.queryNode,
+        parseReferenceExpressionOrList(selection)
+      ),
+    })
   }
 
-  /** @private */
-  get expression(): Expression<O> {
-    return this.#queryBuilder
+  modifyFront(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithFrontModifier(
+        this.#props.queryNode,
+        SelectModifierNode.createWithExpression(modifier.toOperationNode())
+      ),
+    })
   }
 
-  /** @private */
-  get alias(): A {
-    return this.#alias
+  modifyEnd(modifier: Expression<any>): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.createWithExpression(modifier.toOperationNode())
+      ),
+    })
   }
 
-  toOperationNode(): AliasNode {
-    return AliasNode.create(
-      this.#queryBuilder.toOperationNode(),
-      IdentifierNode.create(this.#alias)
-    )
+  distinct(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithFrontModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('Distinct')
+      ),
+    })
   }
-}
+
+  forUpdate(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('ForUpdate')
+      ),
+    })
+  }
+
+  forShare(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('ForShare')
+      ),
+    })
+  }
+
+  forKeyShare(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('ForKeyShare')
+      ),
+    })
+  }
+
+  forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('ForNoKeyUpdate')
+      ),
+    })
+  }
+
+  skipLocked(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('SkipLocked')
+      ),
+    })
+  }
+
+  noWait(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithEndModifier(
+        this.#props.queryNode,
+        SelectModifierNode.create('NoWait')
+      ),
+    })
+  }
+
+  selectAll(table?: any): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSelections(
+        this.#props.queryNode,
+        parseSelectAll(table)
+      ),
+    })
+  }
+
+  innerJoin(...args: any): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithJoin(
+        this.#props.queryNode,
+        parseJoin('InnerJoin', args)
+      ),
+    })
+  }
+
+  leftJoin(...args: any): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithJoin(
+        this.#props.queryNode,
+        parseJoin('LeftJoin', args)
+      ),
+    })
+  }
+
+  rightJoin(...args: any): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithJoin(
+        this.#props.queryNode,
+        parseJoin('RightJoin', args)
+      ),
+    })
+  }
+
+  fullJoin(...args: any): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithJoin(
+        this.#props.queryNode,
+        parseJoin('FullJoin', args)
+      ),
+    })
+  }
+
+  innerJoinLateral(...args: any): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithJoin(
+        this.#props.queryNode,
+        parseJoin('LateralInnerJoin', args)
+      ),
+    })
+  }
+
+  leftJoinLateral(...args: any): any {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithJoin(
+        this.#props.queryNode,
+        parseJoin('LateralLeftJoin', args)
+      ),
+    })
+  }
+
+  orderBy(
+    orderBy: OrderByExpression<DB, TB, O>,
+    direction?: OrderByDirectionExpression
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithOrderByItem(
+        this.#props.queryNode,
+        parseOrderBy(orderBy, direction)
+      ),
+    })
+  }
+
+  groupBy(groupBy: GroupByArg<DB, TB, O>): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithGroupByItems(
+        this.#props.queryNode,
+        parseGroupBy(groupBy)
+      ),
+    })
+  }
+
+  limit(limit: number): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithLimit(
+        this.#props.queryNode,
+        LimitNode.create(limit)
+      ),
+    })
+  }
+
+  offset(offset: number): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithOffset(
+        this.#props.queryNode,
+        OffsetNode.create(offset)
+      ),
+    })
+  }
+
+  union(
+    expression: SetOperandExpression<DB, O>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSetOperation(
+        this.#props.queryNode,
+        parseSetOperation('union', expression, false)
+      ),
+    })
+  }
+
+  unionAll(
+    expression: SetOperandExpression<DB, O>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSetOperation(
+        this.#props.queryNode,
+        parseSetOperation('union', expression, true)
+      ),
+    })
+  }
+
+  intersect(
+    expression: SetOperandExpression<DB, O>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSetOperation(
+        this.#props.queryNode,
+        parseSetOperation('intersect', expression, false)
+      ),
+    })
+  }
+
+  intersectAll(
+    expression: SetOperandExpression<DB, O>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSetOperation(
+        this.#props.queryNode,
+        parseSetOperation('intersect', expression, true)
+      ),
+    })
+  }
+
+  except(
+    expression: SetOperandExpression<DB, O>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSetOperation(
+        this.#props.queryNode,
+        parseSetOperation('except', expression, false)
+      ),
+    })
+  }
+
+  exceptAll(
+    expression: SetOperandExpression<DB, O>
+  ): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithSetOperation(
+        this.#props.queryNode,
+        parseSetOperation('except', expression, true)
+      ),
+    })
+  }
+
+  as<A extends string>(alias: A): AliasedSelectQueryBuilder<DB, TB, O, A> {
+    return new AliasedSelectQueryBuilderImpl(this, alias)
+  }
+
+  clearSelect(): SelectQueryBuilder<DB, TB, {}> {
+    return new SelectQueryBuilderImpl<DB, TB, {}>({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithoutSelections(this.#props.queryNode),
+    })
+  }
+
+  clearWhere(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl<DB, TB, O>({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithoutWhere(this.#props.queryNode),
+    })
+  }
+
+  clearLimit(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl<DB, TB, O>({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithoutLimit(this.#props.queryNode),
+    })
+  }
+
+  clearOffset(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl<DB, TB, O>({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithoutOffset(this.#props.queryNode),
+    })
+  }
+
+  clearOrderBy(): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl<DB, TB, O>({
+      ...this.#props,
+      queryNode: SelectQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
+    })
+  }
+
+  $call<T>(func: (qb: this) => T): T {
+    return func(this)
+  }
+
+  $if<O2>(
+    condition: boolean,
+    func: (qb: this) => SelectQueryBuilder<any, any, O & O2>
+  ): SelectQueryBuilder<DB, TB, O & Partial<O2>> {
+    if (condition) {
+      return func(this)
+    }
+
+    return new SelectQueryBuilderImpl<DB, TB, O & Partial<O2>>({
+      ...this.#props,
+    })
+  }
+
+  $castTo<T>(): SelectQueryBuilder<DB, TB, T> {
+    return new SelectQueryBuilderImpl(this.#props)
+  }
+
+  $narrowType<T>(): SelectQueryBuilder<DB, TB, NarrowPartial<O, T>> {
+    return new SelectQueryBuilderImpl(this.#props)
+  }
+
+  $assertType<T extends O>(): O extends T
+    ? SelectQueryBuilder<DB, TB, T>
+    : KyselyTypeError<`$assertType() call failed: The type passed in is not equal to the output type of the query.`> {
+    return new SelectQueryBuilderImpl(this.#props) as unknown as any
+  }
+
+  withPlugin(plugin: KyselyPlugin): SelectQueryBuilder<DB, TB, O> {
+    return new SelectQueryBuilderImpl({
+      ...this.#props,
+      executor: this.#props.executor.withPlugin(plugin),
+    })
+  }
+
+  toOperationNode(): SelectQueryNode {
+    return this.#props.executor.transformQuery(
+      this.#props.queryNode,
+      this.#props.queryId
+    )
+  }
+
+  compile(): CompiledQuery<Simplify<O>> {
+    return this.#props.executor.compileQuery(
+      this.toOperationNode(),
+      this.#props.queryId
+    )
+  }
+
+  async execute(): Promise<Simplify<O>[]> {
+    const compiledQuery = this.compile()
+
+    const result = await this.#props.executor.executeQuery<O>(
+      compiledQuery,
+      this.#props.queryId
+    )
+
+    return result.rows
+  }
+
+  async executeTakeFirst(): Promise<SimplifySingleResult<O>> {
+    const [result] = await this.execute()
+    return result as SimplifySingleResult<O>
+  }
+
+  async executeTakeFirstOrThrow(
+    errorConstructor:
+      | NoResultErrorConstructor
+      | ((node: QueryNode) => Error) = NoResultError
+  ): Promise<Simplify<O>> {
+    const result = await this.executeTakeFirst()
+
+    if (result === undefined) {
+      const error = isNoResultErrorConstructor(errorConstructor)
+        ? new errorConstructor(this.toOperationNode())
+        : errorConstructor(this.toOperationNode())
+
+      throw error
+    }
+
+    return result as O
+  }
+
+  async *stream(chunkSize: number = 100): AsyncIterableIterator<O> {
+    const compiledQuery = this.compile()
+
+    const stream = this.#props.executor.stream<O>(
+      compiledQuery,
+      chunkSize,
+      this.#props.queryId
+    )
+
+    for await (const item of stream) {
+      yield* item.rows
+    }
+  }
+
+  async explain<ER extends Record<string, any> = Record<string, any>>(
+    format?: ExplainFormat,
+    options?: Expression<any>
+  ): Promise<ER[]> {
+    const builder = new SelectQueryBuilderImpl<DB, TB, ER>({
+      ...this.#props,
+      queryNode: QueryNode.cloneWithExplain(
+        this.#props.queryNode,
+        format,
+        options
+      ),
+    })
+
+    return await builder.execute()
+  }
+}
+
+preventAwait(
+  SelectQueryBuilderImpl,
+  "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`."
+)
+
+export function createSelectQueryBuilder<DB, TB extends keyof DB, O>(
+  props: SelectQueryBuilderProps
+): SelectQueryBuilder<DB, TB, O> {
+  return new SelectQueryBuilderImpl(props)
+}
+
+export interface SelectQueryBuilderProps {
+  readonly queryId: QueryId
+  readonly queryNode: SelectQueryNode
+  readonly executor: QueryExecutor
+}
+
+export interface AliasedSelectQueryBuilder<
+  DB,
+  TB extends keyof DB,
+  O = undefined,
+  A extends string = never
+> extends AliasedExpression<O, A> {
+  get selectQueryBuilder(): SelectQueryBuilder<DB, TB, O>
+}
+
+/**
+ * {@link SelectQueryBuilder} with an alias. The result of calling {@link SelectQueryBuilder.as}.
+ */
+class AliasedSelectQueryBuilderImpl<
+  DB,
+  TB extends keyof DB,
+  O = undefined,
+  A extends string = never
+> implements AliasedSelectQueryBuilder<DB, TB, O, A>
+{
+  readonly #queryBuilder: SelectQueryBuilder<DB, TB, O>
+  readonly #alias: A
+
+  constructor(queryBuilder: SelectQueryBuilder<DB, TB, O>, alias: A) {
+    this.#queryBuilder = queryBuilder
+    this.#alias = alias
+  }
+
+  get expression(): Expression<O> {
+    return this.#queryBuilder
+  }
+
+  get alias(): A {
+    return this.#alias
+  }
+
+  get selectQueryBuilder(): SelectQueryBuilder<DB, TB, O> {
+    return this.#queryBuilder
+  }
+
+  toOperationNode(): AliasNode {
+    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."
+)
 
 export type SelectQueryBuilderWithInnerJoin<
   DB,
diff --git a/src/query-builder/where-interface.ts b/src/query-builder/where-interface.ts
index 6953e1895..d25d810af 100644
--- a/src/query-builder/where-interface.ts
+++ b/src/query-builder/where-interface.ts
@@ -314,6 +314,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
   ): WhereInterface<DB, TB>
 
   where(factory: WhereExpressionFactory<DB, TB>): WhereInterface<DB, TB>
+
   where(expression: Expression<any>): WhereInterface<DB, TB>
 
   /**
diff --git a/src/query-creator.ts b/src/query-creator.ts
index 5b733f43e..c6b2346a3 100644
--- a/src/query-creator.ts
+++ b/src/query-creator.ts
@@ -1,4 +1,7 @@
-import { SelectQueryBuilder } from './query-builder/select-query-builder.js'
+import {
+  SelectQueryBuilder,
+  createSelectQueryBuilder,
+} from './query-builder/select-query-builder.js'
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js'
 import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js'
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js'
@@ -176,7 +179,7 @@ export class QueryCreator<DB> {
   ): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>
 
   selectFrom(from: TableExpressionOrList<any, any>): any {
-    return new SelectQueryBuilder({
+    return createSelectQueryBuilder({
       queryId: createQueryId(),
       executor: this.#props.executor,
       queryNode: SelectQueryNode.create(
diff --git a/src/raw-builder/raw-builder.ts b/src/raw-builder/raw-builder.ts
index 102fc7957..1afe4658a 100644
--- a/src/raw-builder/raw-builder.ts
+++ b/src/raw-builder/raw-builder.ts
@@ -4,7 +4,7 @@ import { RawNode } from '../operation-node/raw-node.js'
 import { CompiledQuery } from '../query-compiler/compiled-query.js'
 import { preventAwait } from '../util/prevent-await.js'
 import { QueryExecutor } from '../query-executor/query-executor.js'
-import { freeze, isFunction, isObject } from '../util/object-utils.js'
+import { freeze } from '../util/object-utils.js'
 import { KyselyPlugin } from '../plugin/kysely-plugin.js'
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js'
 import { QueryExecutorProvider } from '../query-executor/query-executor-provider.js'
@@ -19,17 +19,11 @@ import { isOperationNodeSource } from '../operation-node/operation-node-source.j
  * You shouldn't need to create `RawBuilder` instances directly. Instead you should
  * use the {@link sql} template tag.
  */
-export class RawBuilder<O> implements Expression<O> {
-  readonly #props: RawBuilderProps
-
-  constructor(props: RawBuilderProps) {
-    this.#props = freeze(props)
-  }
-
-  /** @private */
-  get expressionType(): O | undefined {
-    return undefined
-  }
+export interface RawBuilder<O> extends Expression<O> {
+  /**
+   * @private Without this SelectQueryBuilder extends RawBuilder and things break.
+   */
+  get isRawBuilder(): true
 
   /**
    * Returns an aliased version of the SQL expression.
@@ -86,9 +80,6 @@ export class RawBuilder<O> implements Expression<O> {
    */
   as<A extends string>(alias: A): AliasedRawBuilder<O, A>
   as<A extends string>(alias: Expression<any>): AliasedRawBuilder<O, A>
-  as(alias: string | Expression<unknown>): AliasedRawBuilder<O, string> {
-    return new AliasedRawBuilder(this, alias)
-  }
 
   /**
    * Change the output type of the raw expression.
@@ -96,22 +87,64 @@ export class RawBuilder<O> implements Expression<O> {
    * This method call doesn't change the SQL in any way. This methods simply
    * returns a copy of this `RawBuilder` with a new output type.
    */
-  $castTo<T>(): RawBuilder<T> {
-    return new RawBuilder({ ...this.#props })
-  }
+  $castTo<T>(): RawBuilder<T>
 
   /**
-   * @deprecated Use `$castTo` instead.
+   * Adds a plugin for this SQL snippet.
    */
-  castTo<T>(): RawBuilder<T> {
-    return this.$castTo<T>()
-  }
+  withPlugin(plugin: KyselyPlugin): RawBuilder<O>
 
   /**
-   * Adds a plugin for this SQL snippet.
+   * Compiles the builder to a `CompiledQuery`.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * const { sql } = sql`select * from ${sql.table('person')}`.compile(db)
+   * console.log(sql)
+   * ```
    */
+  compile(executorProvider: QueryExecutorProvider): CompiledQuery<O>
+
+  /**
+   * Executes the raw query.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * const result = await sql`select * from ${sql.table('person')}`.execute(db)
+   * ```
+   */
+  execute(executorProvider: QueryExecutorProvider): Promise<QueryResult<O>>
+
+  toOperationNode(): RawNode
+}
+
+class RawBuilderImpl<O> implements RawBuilder<O> {
+  readonly #props: RawBuilderProps
+
+  constructor(props: RawBuilderProps) {
+    this.#props = freeze(props)
+  }
+
+  get expressionType(): O | undefined {
+    return undefined
+  }
+
+  get isRawBuilder(): true {
+    return true
+  }
+
+  as(alias: string | Expression<unknown>): AliasedRawBuilder<O, string> {
+    return new AliasedRawBuilderImpl(this, alias)
+  }
+
+  $castTo<T>(): RawBuilder<T> {
+    return new RawBuilderImpl({ ...this.#props })
+  }
+
   withPlugin(plugin: KyselyPlugin): RawBuilder<O> {
-    return new RawBuilder({
+    return new RawBuilderImpl({
       ...this.#props,
       plugins:
         this.#props.plugins !== undefined
@@ -162,27 +195,31 @@ export class RawBuilder<O> implements Expression<O> {
   }
 }
 
-export function isRawBuilder(obj: unknown): obj is RawBuilder<unknown> {
-  return (
-    isObject(obj) &&
-    isFunction(obj.as) &&
-    isFunction(obj.$castTo) &&
-    isFunction(obj.withPlugin) &&
-    isFunction(obj.toOperationNode) &&
-    isFunction(obj.execute)
-  )
+export interface RawBuilderProps {
+  readonly queryId: QueryId
+  readonly rawNode: RawNode
+  readonly plugins?: ReadonlyArray<KyselyPlugin>
+}
+
+export function createRawBuilder<O>(props: RawBuilderProps): RawBuilder<O> {
+  return new RawBuilderImpl(props)
 }
 
 preventAwait(
-  RawBuilder,
+  RawBuilderImpl,
   "don't await RawBuilder instances directly. To execute the query you need to call `execute`"
 )
 
 /**
  * {@link RawBuilder} with an alias. The result of calling {@link RawBuilder.as}.
  */
-export class AliasedRawBuilder<O = unknown, A extends string = never>
-  implements AliasedExpression<O, A>
+export interface AliasedRawBuilder<O = unknown, A extends string = never>
+  extends AliasedExpression<O, A> {
+  get rawBuilder(): RawBuilder<O>
+}
+
+class AliasedRawBuilderImpl<O = unknown, A extends string = never>
+  implements AliasedRawBuilder<O, A>
 {
   readonly #rawBuilder: RawBuilder<O>
   readonly #alias: A | Expression<unknown>
@@ -192,16 +229,18 @@ export class AliasedRawBuilder<O = unknown, A extends string = never>
     this.#alias = alias
   }
 
-  /** @private */
   get expression(): Expression<O> {
     return this.#rawBuilder
   }
 
-  /** @private */
   get alias(): A | Expression<unknown> {
     return this.#alias
   }
 
+  get rawBuilder(): RawBuilder<O> {
+    return this.#rawBuilder
+  }
+
   toOperationNode(): AliasNode {
     return AliasNode.create(
       this.#rawBuilder.toOperationNode(),
@@ -212,8 +251,7 @@ export class AliasedRawBuilder<O = unknown, A extends string = never>
   }
 }
 
-export interface RawBuilderProps {
-  readonly queryId: QueryId
-  readonly rawNode: RawNode
-  readonly plugins?: ReadonlyArray<KyselyPlugin>
-}
+preventAwait(
+  AliasedRawBuilderImpl,
+  "don't await AliasedRawBuilder instances directly. AliasedRawBuilder should never be executed directly since it's always a part of another query."
+)
diff --git a/src/raw-builder/sql.ts b/src/raw-builder/sql.ts
index fd9c731e7..1973d85a6 100644
--- a/src/raw-builder/sql.ts
+++ b/src/raw-builder/sql.ts
@@ -6,7 +6,7 @@ import { parseStringReference } from '../parser/reference-parser.js'
 import { parseTable } from '../parser/table-parser.js'
 import { parseValueExpression } from '../parser/value-parser.js'
 import { createQueryId } from '../util/query-id.js'
-import { RawBuilder } from './raw-builder.js'
+import { RawBuilder, createRawBuilder } from './raw-builder.js'
 
 export interface Sql {
   /**
@@ -374,7 +374,7 @@ export const sql: Sql = Object.assign(
     sqlFragments: TemplateStringsArray,
     ...parameters: unknown[]
   ): RawBuilder<T> => {
-    return new RawBuilder({
+    return createRawBuilder({
       queryId: createQueryId(),
       rawNode: RawNode.create(
         sqlFragments,
@@ -384,14 +384,14 @@ export const sql: Sql = Object.assign(
   },
   {
     ref<R = unknown>(columnReference: string): RawBuilder<R> {
-      return new RawBuilder({
+      return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.createWithChild(parseStringReference(columnReference)),
       })
     },
 
     val<V>(value: V): RawBuilder<V> {
-      return new RawBuilder({
+      return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.createWithChild(parseValueExpression(value)),
       })
@@ -402,7 +402,7 @@ export const sql: Sql = Object.assign(
     },
 
     table(tableReference: string): RawBuilder<unknown> {
-      return new RawBuilder({
+      return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.createWithChild(parseTable(tableReference)),
       })
@@ -414,14 +414,14 @@ export const sql: Sql = Object.assign(
       fragments[0] = ''
       fragments[fragments.length - 1] = ''
 
-      return new RawBuilder({
+      return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create)),
       })
     },
 
     lit<V>(value: V): RawBuilder<V> {
-      return new RawBuilder({
+      return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.createWithChild(ValueNode.createImmediate(value)),
       })
@@ -432,7 +432,7 @@ export const sql: Sql = Object.assign(
     },
 
     raw<R = unknown>(sql: string): RawBuilder<R> {
-      return new RawBuilder({
+      return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.createWithSql(sql),
       })
@@ -453,7 +453,7 @@ export const sql: Sql = Object.assign(
         }
       }
 
-      return new RawBuilder({
+      return createRawBuilder({
         queryId: createQueryId(),
         rawNode: RawNode.createWithChildren(nodes),
       })