kysely 0.16.11 → 0.17.0

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

@@ -11,13 +11,13 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOnFilter(args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOnFilter(args)),
         });
     }
     /**
@@ -29,7 +29,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferenceFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -41,7 +41,7 @@ export class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferenceFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -53,7 +53,7 @@ export class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExistFilter(arg)),
         });
     }
     /**
@@ -65,7 +65,7 @@ export class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExistFilter(arg)),
         });
     }
     /**
@@ -77,7 +77,7 @@ export class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExistFilter(arg)),
         });
     }
     /**
@@ -89,7 +89,7 @@ export class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(arg)),
         });
     }
     toOperationNode() {

package/dist/esm/query-builder/on-conflict-builder.d.ts

@@ -2,7 +2,6 @@ import { OnConflictNode } from '../operation-node/on-conflict-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ComplexExpression } from '../parser/complex-expression-parser.js';
 import { WhereGrouper, FilterOperator, FilterValueExpressionOrList } from '../parser/filter-parser.js';
-import { ParseContext } from '../parser/parse-context.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { MutationObject } from '../parser/update-set-parser.js';
 import { AnyColumn, AnyRawBuilder } from '../util/type-utils.js';
@@ -70,7 +69,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `db.raw('your operator')`.
+     * you can always use `sql\`your operator\``.
      *
      * ```ts
      * const persons = await db
@@ -140,7 +139,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *
      * A `where in` query can be built by using the `in` operator and an array
      * of values. The values in the array can also be subqueries or raw
-     * instances.
+     * {@link sql} expressions.
      *
      * ```ts
      * const persons = await db
@@ -156,15 +155,17 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always pass {@link Kysely.raw | raw}
+     * If everything else fails, you can always use the {@link sql} tag
      * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     db.raw('coalesce(first_name, last_name)'),
+     *     sql`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -199,24 +200,25 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * ```
      *
      * In all examples above the columns were known at compile time
-     * (except for the `raw` expressions). By default kysely only allows
-     * you to refer to columns that exist in the database **and** can be
-     * referred to in the current query and context.
+     * (except for the raw {@link sql} expressions). By default kysely only
+     * allows you to refer to columns that exist in the database **and**
+     * can be referred to in the current query and context.
      *
      * Sometimes you may want to refer to columns that come from the user
      * input and thus are not available at compile time.
      *
-     * You have two options, `db.raw` or `db.dynamic`. The example below
+     * You have two options, the {@link sql} tag or `db.dynamic`. The example below
      * uses both:
      *
      * ```ts
+     * import { sql } from 'kysely'
      * const { ref } = db.dynamic
      *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(db.raw('??', [columnFromUserInput]), '=', 2)
+     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */
@@ -381,7 +383,6 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
-    readonly parseContext: ParseContext;
 }
 export declare type OnConflictDatabase<DB, TB extends keyof DB> = {
     [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
@@ -425,7 +426,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `db.raw('your operator')`.
+     * you can always use `sql\`your operator\``.
      *
      * ```ts
      * const persons = await db
@@ -495,7 +496,7 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      *
      * A `where in` query can be built by using the `in` operator and an array
      * of values. The values in the array can also be subqueries or raw
-     * instances.
+     * {@link sql} expressions.
      *
      * ```ts
      * const persons = await db
@@ -511,15 +512,17 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always pass {@link Kysely.raw | raw}
+     * If everything else fails, you can always use the {@link sql} tag
      * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     db.raw('coalesce(first_name, last_name)'),
+     *     sql`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -554,24 +557,25 @@ export declare class OnConflictUpdateBuilder<DB, TB extends keyof DB> implements
      * ```
      *
      * In all examples above the columns were known at compile time
-     * (except for the `raw` expressions). By default kysely only allows
-     * you to refer to columns that exist in the database **and** can be
-     * referred to in the current query and context.
+     * (except for the raw {@link sql} expressions). By default kysely only
+     * allows you to refer to columns that exist in the database **and**
+     * can be referred to in the current query and context.
      *
      * Sometimes you may want to refer to columns that come from the user
      * input and thus are not available at compile time.
      *
-     * You have two options, `db.raw` or `db.dynamic`. The example below
+     * You have two options, the {@link sql} tag or `db.dynamic`. The example below
      * uses both:
      *
      * ```ts
+     * import { sql } from 'kysely'
      * const { ref } = db.dynamic
      *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(db.raw('??', [columnFromUserInput]), '=', 2)
+     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */

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

@@ -78,7 +78,7 @@ export class OnConflictBuilder {
     where(...args) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseWhereFilter(args)),
         });
     }
     /**
@@ -89,13 +89,13 @@ export class OnConflictBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseWhereFilter(args)),
         });
     }
     /**
@@ -106,7 +106,7 @@ export class OnConflictBuilder {
     orWhereRef(lhs, op, rhs) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -117,7 +117,7 @@ export class OnConflictBuilder {
     whereExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseExistFilter(arg)),
         });
     }
     /**
@@ -128,7 +128,7 @@ export class OnConflictBuilder {
     whereNotExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
         });
     }
     /**
@@ -139,7 +139,7 @@ export class OnConflictBuilder {
     orWhereExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseExistFilter(arg)),
         });
     }
     /**
@@ -150,7 +150,7 @@ export class OnConflictBuilder {
     orWhereNotExists(arg) {
         return new OnConflictBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
         });
     }
     /**
@@ -212,7 +212,7 @@ export class OnConflictBuilder {
         return new OnConflictUpdateBuilder({
             ...this.#props,
             onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
-                updates: parseUpdateObject(this.#props.parseContext, updates),
+                updates: parseUpdateObject(updates),
             }),
         });
     }
@@ -236,7 +236,7 @@ export class OnConflictUpdateBuilder {
     where(...args) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseWhereFilter(args)),
         });
     }
     /**
@@ -247,13 +247,13 @@ export class OnConflictUpdateBuilder {
     whereRef(lhs, op, rhs) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseWhereFilter(args)),
         });
     }
     /**
@@ -264,7 +264,7 @@ export class OnConflictUpdateBuilder {
     orWhereRef(lhs, op, rhs) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseReferenceFilter(lhs, op, rhs)),
         });
     }
     /**
@@ -275,7 +275,7 @@ export class OnConflictUpdateBuilder {
     whereExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseExistFilter(arg)),
         });
     }
     /**
@@ -286,7 +286,7 @@ export class OnConflictUpdateBuilder {
     whereNotExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
         });
     }
     /**
@@ -297,7 +297,7 @@ export class OnConflictUpdateBuilder {
     orWhereExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseExistFilter(arg)),
         });
     }
     /**
@@ -308,7 +308,7 @@ export class OnConflictUpdateBuilder {
     orWhereNotExists(arg) {
         return new OnConflictUpdateBuilder({
             ...this.#props,
-            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseNotExistFilter(arg)),
         });
     }
     toOperationNode() {

package/dist/esm/query-builder/returning-interface.d.ts

@@ -45,6 +45,8 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      * Return arbitrary expressions:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
@@ -53,7 +55,7 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      *   })
      *   .returning([
      *     'id as id',
-     *     db.raw<string>(`concat(first_name, ' ', last_name)`).as('full_name'),
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name'),
      *     (qb) => qb.selectFrom('pets').select('pet.id').limit(1).as('first_pet_id')
      *   ])
      *   .executeTakeFirst()

package/dist/esm/query-builder/select-query-builder.d.ts

@@ -12,7 +12,6 @@ import { OrderByDirectionExpression, OrderByExpression } from '../parser/order-b
 import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
-import { ParseContext } from '../parser/parse-context.js';
 import { UnionExpression } from '../parser/union-parser.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
@@ -46,7 +45,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use `db.raw('your operator')`.
+     * you can always use `sql\`your operator\``.
      *
      * ```ts
      * const persons = await db
@@ -116,7 +115,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *
      * A `where in` query can be built by using the `in` operator and an array
      * of values. The values in the array can also be subqueries or raw
-     * instances.
+     * {@link sql} expressions.
      *
      * ```ts
      * const persons = await db
@@ -132,15 +131,17 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always pass {@link Kysely.raw | raw}
+     * If everything else fails, you can always use the {@link sql} tag
      * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(
-     *     db.raw('coalesce(first_name, last_name)'),
+     *     sql`coalesce(first_name, last_name)`,
      *     'like',
      *     '%' + name + '%',
      *   )
@@ -175,24 +176,25 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * In all examples above the columns were known at compile time
-     * (except for the `raw` expressions). By default kysely only allows
-     * you to refer to columns that exist in the database **and** can be
-     * referred to in the current query and context.
+     * (except for the raw {@link sql} expressions). By default kysely only
+     * allows you to refer to columns that exist in the database **and**
+     * can be referred to in the current query and context.
      *
      * Sometimes you may want to refer to columns that come from the user
      * input and thus are not available at compile time.
      *
-     * You have two options, `db.raw` or `db.dynamic`. The example below
+     * You have two options, the {@link sql} tag or `db.dynamic`. The example below
      * uses both:
      *
      * ```ts
+     * import { sql } from 'kysely'
      * const { ref } = db.dynamic
      *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(db.raw('??', [columnFromUserInput]), '=', 2)
+     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */
@@ -326,13 +328,14 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
     /**
      * Adds a `where exists` clause to the query.
      *
-     * You can either use a subquery or a raw instance.
+     * You can either use a subquery or a raw {@link sql} snippet.
      *
      * ### Examples
      *
      * The query below selets all persons that own a pet named Catto:
      *
      * ```ts
+     * const petName = 'Catto'
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
@@ -340,7 +343,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     .selectFrom('pet')
      *     .select('pet.id')
      *     .whereRef('person.id', '=', 'pet.owner_id')
-     *     .where('pet.name', '=', 'Catto')
+     *     .where('pet.name', '=', petName)
      *   )
      *   .execute()
      * ```
@@ -357,16 +360,16 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * )
      * ```
      *
-     * The same query as in the previous example but with using raw:
+     * The same query as in the previous example but with using raw {@link sql}:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const petName = 'Catto'
      * db.selectFrom('person')
      *   .selectAll()
      *   .whereExists(
-     *     db.raw(
-     *       '(select pet.id from pet where person.id = pet.owner_id and pet.name = ?)',
-     *       ['Catto']
-     *     )
+     *     sql`(select pet.id from pet where person.id = pet.owner_id and pet.name = ${petName})`
      *   )
      * ```
      *
@@ -449,7 +452,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * 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 {@link Kysely.raw | raw}
+     * 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
@@ -536,11 +539,13 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * from "person"
      * ```
      *
-     * You can also select subqueries and raw expressions. Note that you
+     * You can also select subqueries and raw sql expressions. Note that you
      * always need to give a name for the selections using the `as`
      * method:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db.selectFrom('person')
      *   .select([
      *     (qb) => qb
@@ -549,7 +554,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *       .select('pet.name')
      *       .limit(1)
      *       .as('pet_name')
-     *     db.raw<string>("concat(first_name, ' ', last_name)").as('full_name')
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
      *   ])
      *   .execute()
      *
@@ -571,7 +576,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * from "person"
      * ```
      *
-     * In case you use `raw` you need to specify the type of the expression
+     * 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.
@@ -889,10 +894,12 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * order by "id" asc, "fn" desc
      * ```
      *
-     * The order by expression can also be a `raw` expression or a subquery
+     * 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()
@@ -902,7 +909,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *     .limit(1)
      *   )
      *   .orderBy(
-     *     db.raw('concat(first_name, last_name)')
+     *     sql`concat(first_name, last_name)`
      *   )
      *   .execute()
      * ```
@@ -953,11 +960,13 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ### Examples
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db
      *   .selectFrom('person')
      *   .select([
      *     'first_name',
-     *     db.raw('max(id)').as('max_id')
+     *     sql`max(id)`.as('max_id')
      *   ])
      *   .groupBy('first_name')
      *   .execute()
@@ -974,12 +983,14 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * `groupBy` also accepts an array:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db
      *   .selectFrom('person')
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     db.raw('max(id)').as('max_id')
+     *     sql`max(id)`.as('max_id')
      *   ])
      *   .groupBy([
      *     'first_name',
@@ -997,18 +1008,20 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * The group by expressions can also be subqueries or
-     * raw expressions:
+     * raw sql expressions:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db
      *   .selectFrom('person')
      *   .select([
      *     'first_name',
      *     'last_name',
-     *     db.raw('max(id)').as('max_id')
+     *     sql`max(id)`.as('max_id')
      *   ])
      *   .groupBy([
-     *     db.raw('concat(first_name, last_name)'),
+     *     sql`concat(first_name, last_name)`,
      *     (qb) => qb.selectFrom('pet').select('id').limit(1)
      *   ])
      *   .execute()
@@ -1242,7 +1255,6 @@ export interface SelectQueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: SelectQueryNode;
     readonly executor: QueryExecutor;
-    readonly parseContext: ParseContext;
 }
 /**
  * {@link SelectQueryBuilder} with an alias. The result of calling {@link SelectQueryBuilder.as}.