kysely 0.16.11 → 0.17.2

package/dist/cjs/query-builder/delete-query-builder.d.ts

@@ -10,7 +10,6 @@ import { AnyRawBuilder, MergePartial, SingleResultType } from '../util/type-util
 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 { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
 import { JoinInterface } from './join-interface.js';
@@ -47,7 +46,13 @@ export declare class DeleteQueryBuilder<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
+     *
+     * ```ts
+     * sql`your operator`
+     * ```
+     *
+     * The next example uses the `>` operator:
      *
      * ```ts
      * const persons = await db
@@ -63,8 +68,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * select * from "person" where "id" > $1
      * ```
      *
-     * The `where` methods don't change the type of the query. You can add
-     * conditional `where`s easily by doing something like this:
+     * `where` methods don't change the type of the query. You can add
+     * conditional statements easily by doing something like this:
      *
      * ```ts
      * let query = db
@@ -72,6 +77,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   .selectAll()
      *
      * if (firstName) {
+     *   // The query builder is immutable. Remember to reassign
+     *   // the result back to the query variable.
      *   query = query.where('first_name', '=', firstName)
      * }
      *
@@ -79,8 +86,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ```
      *
      * This is true for basically all methods execpt the `select` and
-     * `returning` methods, which DO change the return type of the
-     * query.
+     * `returning`, that __do__ change the return type of the query.
      *
      * Both the first and third argument can also be subqueries.
      * A subquery is defined by passing a function and calling
@@ -117,7 +123,7 @@ export declare class DeleteQueryBuilder<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
@@ -133,15 +139,17 @@ export declare class DeleteQueryBuilder<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 + '%',
      *   )
@@ -176,24 +184,25 @@ export declare class DeleteQueryBuilder<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()
      * ```
      */
@@ -327,13 +336,14 @@ export declare class DeleteQueryBuilder<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()
@@ -341,7 +351,7 @@ export declare class DeleteQueryBuilder<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()
      * ```
@@ -358,16 +368,16 @@ export declare class DeleteQueryBuilder<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})`
      *   )
      * ```
      *
@@ -565,6 +575,8 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * Return arbitrary expressions:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
@@ -573,7 +585,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      *   })
      *   .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()
@@ -736,5 +748,4 @@ export interface DeleteQueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: DeleteQueryNode;
     readonly executor: QueryExecutor;
-    readonly parseContext: ParseContext;
 }

package/dist/cjs/query-builder/delete-query-builder.js

@@ -20,79 +20,79 @@ class DeleteQueryBuilder {
     where(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(args)),
         });
     }
     orWhereRef(lhs, op, rhs) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(lhs, op, rhs)),
         });
     }
     whereExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(arg)),
         });
     }
     whereNotExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
         });
     }
     orWhereExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(arg)),
         });
     }
     orWhereNotExists(arg) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
         });
     }
     innerJoin(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'InnerJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('InnerJoin', args)),
         });
     }
     leftJoin(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'LeftJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('LeftJoin', args)),
         });
     }
     rightJoin(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'RightJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('RightJoin', args)),
         });
     }
     fullJoin(...args) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)(this.#props.parseContext, 'FullJoin', args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('FullJoin', args)),
         });
     }
     returning(selection) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(selection)),
         });
     }
     returningAll() {
@@ -138,7 +138,7 @@ class DeleteQueryBuilder {
     orderBy(orderBy, direction) {
         return new DeleteQueryBuilder({
             ...this.#props,
-            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithOrderByItem(this.#props.queryNode, (0, order_by_parser_js_1.parseOrderBy)(this.#props.parseContext, orderBy, direction)),
+            queryNode: delete_query_node_js_1.DeleteQueryNode.cloneWithOrderByItem(this.#props.queryNode, (0, order_by_parser_js_1.parseOrderBy)(orderBy, direction)),
         });
     }
     /**
@@ -265,7 +265,7 @@ class DeleteQueryBuilder {
         const compildQuery = this.compile();
         const query = compildQuery.query;
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
-        if (this.#props.parseContext.adapter.supportsReturning && query.returning) {
+        if (this.#props.executor.adapter.supportsReturning && query.returning) {
             return result.rows;
         }
         else {

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

@@ -1,10 +1,9 @@
 import { SelectQueryBuilder } from './select-query-builder.js';
 import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
-import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
-import { ParseContext } from '../parser/parse-context.js';
 import { FunctionBuilder } from './function-builder.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
 export declare class ExpressionBuilder<DB, TB extends keyof DB> {
     #private;
     constructor(props: ExpressionBuilderProps);
@@ -90,10 +89,6 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * See {@link QueryCreator.withSchema}
      */
     withSchema(schema: string): ExpressionBuilder<DB, TB>;
-    /**
-     * See {@link QueryCreator.raw}.
-     */
-    raw<T = unknown>(sql: string, parameters?: unknown[]): RawBuilder<T>;
     /**
      * This can be used to reference columns.
      *
@@ -115,21 +110,17 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      *   )
      * ```
      *
-     * In the next example we use `ref` in a raw expression. Unless you
+     * In the next example we use `ref` in a raw sql expression. Unless you
      * want to be as type-safe as possible, this is probably overkill:
      *
      * ```ts
      * db.update('pet').set({
-     *   name: (eb) => eb.raw('concat(?, ?)', [
-     *     eb.ref('pet.name'),
-     *     suffix,
-     *   ])
+     *   name: (eb) => sql`concat(${eb.ref('pet.name')}, ${suffix})`
      * })
      * ```
      */
     ref<RE extends StringReference<DB, TB>>(reference: RE): RawBuilder<ExtractTypeFromReferenceExpression<DB, TB, RE>>;
 }
 export interface ExpressionBuilderProps {
-    readonly executor: NoopQueryExecutor;
-    readonly parseContext: ParseContext;
+    readonly executor: QueryExecutor;
 }

package/dist/cjs/query-builder/expression-builder.js

@@ -6,9 +6,11 @@ const select_query_node_js_1 = require("../operation-node/select-query-node.js")
 const table_parser_js_1 = require("../parser/table-parser.js");
 const with_schema_plugin_js_1 = require("../plugin/with-schema/with-schema-plugin.js");
 const query_id_js_1 = require("../util/query-id.js");
-const object_utils_js_1 = require("../util/object-utils.js");
 const function_builder_js_1 = require("./function-builder.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
 const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
 class ExpressionBuilder {
     #props;
     constructor(props) {
@@ -46,14 +48,13 @@ class ExpressionBuilder {
      * ```
      */
     get fn() {
-        return new function_builder_js_1.FunctionBuilder({ executor: this.#props.executor });
+        return new function_builder_js_1.FunctionBuilder();
     }
     selectFrom(table) {
         return new select_query_builder_js_1.SelectQueryBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#props.executor,
-            parseContext: this.#props.parseContext,
-            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(this.#props.parseContext, table)),
+            queryNode: select_query_node_js_1.SelectQueryNode.create((0, table_parser_js_1.parseTableExpressionOrList)(table)),
         });
     }
     /**
@@ -65,17 +66,6 @@ class ExpressionBuilder {
             executor: this.#props.executor.withPluginAtFront(new with_schema_plugin_js_1.WithSchemaPlugin(schema)),
         });
     }
-    /**
-     * See {@link QueryCreator.raw}.
-     */
-    raw(sql, parameters) {
-        return new raw_builder_js_1.RawBuilder({
-            queryId: (0, query_id_js_1.createQueryId)(),
-            executor: this.#props.executor,
-            sql,
-            parameters,
-        });
-    }
     /**
      * This can be used to reference columns.
      *
@@ -97,20 +87,21 @@ class ExpressionBuilder {
      *   )
      * ```
      *
-     * In the next example we use `ref` in a raw expression. Unless you
+     * In the next example we use `ref` in a raw sql expression. Unless you
      * want to be as type-safe as possible, this is probably overkill:
      *
      * ```ts
      * db.update('pet').set({
-     *   name: (eb) => eb.raw('concat(?, ?)', [
-     *     eb.ref('pet.name'),
-     *     suffix,
-     *   ])
+     *   name: (eb) => sql`concat(${eb.ref('pet.name')}, ${suffix})`
      * })
      * ```
      */
     ref(reference) {
-        return this.raw('??', [reference]);
+        return new raw_builder_js_1.RawBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            plugins: this.#props.executor.plugins,
+            rawNode: raw_node_js_1.RawNode.createWithChild((0, reference_parser_js_1.parseStringReference)(reference)),
+        });
     }
 }
 exports.ExpressionBuilder = ExpressionBuilder;

package/dist/cjs/query-builder/function-builder.d.ts

@@ -1,10 +1,9 @@
 import { StringReference, ExtractTypeFromReferenceExpression } from '../parser/reference-parser.js';
-import { QueryExecutor } from '../query-executor/query-executor.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 /**
  * Helpers for type safe SQL function calls.
  *
- * You can always use {@link Kysely.raw} to call functions and build arbitrary
+ * You can always use the {@link sql} tag to call functions and build arbitrary
  * expressions. This module simply has shortcuts for most common function calls.
  *
  * ### Examples
@@ -35,7 +34,7 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
  */
 export declare class FunctionBuilder<DB, TB extends keyof DB> {
     #private;
-    constructor(props: FunctionBuilderProps);
+    constructor();
     /**
      * Calls the `max` function for the column given as the argument.
      *
@@ -132,6 +131,3 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      */
     count<O extends number | string | bigint, C extends StringReference<DB, TB> = any>(column: C): RawBuilder<O>;
 }
-export interface FunctionBuilderProps {
-    readonly executor: QueryExecutor;
-}

package/dist/cjs/query-builder/function-builder.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionBuilder = void 0;
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const reference_parser_js_1 = require("../parser/reference-parser.js");
 const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
-const object_utils_js_1 = require("../util/object-utils.js");
 const query_id_js_1 = require("../util/query-id.js");
 /**
  * Helpers for type safe SQL function calls.
  *
- * You can always use {@link Kysely.raw} to call functions and build arbitrary
+ * You can always use the {@link sql} tag to call functions and build arbitrary
  * expressions. This module simply has shortcuts for most common function calls.
  *
  * ### Examples
@@ -37,9 +38,7 @@ const query_id_js_1 = require("../util/query-id.js");
  * ```
  */
 class FunctionBuilder {
-    #props;
-    constructor(props) {
-        this.#props = (0, object_utils_js_1.freeze)(props);
+    constructor() {
         this.min = this.min.bind(this);
         this.max = this.max.bind(this);
         this.avg = this.avg.bind(this);
@@ -154,9 +153,7 @@ class FunctionBuilder {
     #oneArgFunction(fn, column) {
         return new raw_builder_js_1.RawBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
-            executor: this.#props.executor,
-            sql: `${fn}(??)`,
-            parameters: [column],
+            rawNode: raw_node_js_1.RawNode.create([`${fn}(`, ')'], [(0, reference_parser_js_1.parseStringReference)(column)]),
         });
     }
 }

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -8,7 +8,6 @@ import { MutationObject } from '../parser/update-set-parser.js';
 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 { InsertResult } from './insert-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { ReturningRow } from '../parser/returning-parser.js';
@@ -25,7 +24,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * This method takes an object whose keys are column names and values are
      * values to insert. In addition to the column's type, the values can be
-     * {@link Kysely.raw | raw} instances or select queries.
+     * raw {@link sql} snippets or select queries.
      *
      * You must provide all fields you haven't explicitly marked as nullable
      * or optional using {@link Generated} or {@link ColumnType}.
@@ -106,16 +105,18 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * insert into "person" ("first_name", "last_name") values ($1, $2) returning "id"
      * ```
      *
-     * In addition to primitives, the values can also be `raw` expressions or
+     * In addition to primitives, the values can also be raw sql expressions or
      * select queries:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',
-     *     last_name: db.raw('? || ?', ['Ani', 'ston']),
-     *     age: db.selectFrom('person').select(raw('avg(age)')),
+     *     last_name: sql`${'Ani'} || ${'ston'}`,
+     *     age: db.selectFrom('person').select(sql`avg(age)`),
      *   })
      *   .executeTakeFirst()
      *
@@ -271,6 +272,8 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * the unique index is an expression index:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db
      *   .insertInto('pet')
      *   .values({
@@ -278,7 +281,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *     species: 'cat',
      *   })
      *   .onConflict((oc) => oc
-     *     .expression(db.raw('lower(name)'))
+     *     .expression(sql`lower(name)`)
      *     .doUpdateSet({ species: 'hamster' })
      *   )
      *   .execute()
@@ -423,6 +426,8 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * Return arbitrary expressions:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const { id, full_name, first_pet_id } = await db
      *   .insertInto('person')
      *   .values({
@@ -431,7 +436,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   })
      *   .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()
@@ -541,5 +546,4 @@ export interface InsertQueryBuilderProps {
     readonly queryId: QueryId;
     readonly queryNode: InsertQueryNode;
     readonly executor: QueryExecutor;
-    readonly parseContext: ParseContext;
 }

package/dist/cjs/query-builder/insert-query-builder.js

@@ -21,7 +21,7 @@ class InsertQueryBuilder {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
     values(args) {
-        const [columns, values] = (0, insert_values_parser_js_1.parseInsertObjectOrList)(this.#props.parseContext, args);
+        const [columns, values] = (0, insert_values_parser_js_1.parseInsertObjectOrList)(args);
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
@@ -82,7 +82,7 @@ class InsertQueryBuilder {
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
-                values: (0, complex_expression_parser_js_1.parseComplexExpression)(this.#props.parseContext, expression),
+                values: (0, complex_expression_parser_js_1.parseComplexExpression)(expression),
             }),
         });
     }
@@ -176,6 +176,8 @@ class InsertQueryBuilder {
      * the unique index is an expression index:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * await db
      *   .insertInto('pet')
      *   .values({
@@ -183,7 +185,7 @@ class InsertQueryBuilder {
      *     species: 'cat',
      *   })
      *   .onConflict((oc) => oc
-     *     .expression(db.raw('lower(name)'))
+     *     .expression(sql`lower(name)`)
      *     .doUpdateSet({ species: 'hamster' })
      *   )
      *   .execute()
@@ -271,7 +273,6 @@ class InsertQueryBuilder {
             queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
                 onConflict: callback(new on_conflict_builder_js_1.OnConflictBuilder({
                     onConflictNode: on_conflict_node_js_1.OnConflictNode.create(),
-                    parseContext: this.#props.parseContext,
                 })).toOperationNode(),
             }),
         });
@@ -298,14 +299,14 @@ class InsertQueryBuilder {
         return new InsertQueryBuilder({
             ...this.#props,
             queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onDuplicateKey: on_duplicate_key_node_js_1.OnDuplicateKeyNode.create((0, update_set_parser_js_1.parseUpdateObject)(this.#props.parseContext, updates)),
+                onDuplicateKey: on_duplicate_key_node_js_1.OnDuplicateKeyNode.create((0, update_set_parser_js_1.parseUpdateObject)(updates)),
             }),
         });
     }
     returning(selection) {
         return new InsertQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(this.#props.parseContext, selection)),
+            queryNode: query_node_js_1.QueryNode.cloneWithReturning(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(selection)),
         });
     }
     returningAll() {
@@ -415,7 +416,7 @@ class InsertQueryBuilder {
         const compildQuery = this.compile();
         const query = compildQuery.query;
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
-        if (this.#props.parseContext.adapter.supportsReturning && query.returning) {
+        if (this.#props.executor.adapter.supportsReturning && query.returning) {
             return result.rows;
         }
         else {

package/dist/cjs/query-builder/join-builder.d.ts

@@ -1,7 +1,6 @@
 import { JoinNode } from '../operation-node/join-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList } from '../parser/filter-parser.js';
-import { ParseContext } from '../parser/parse-context.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
@@ -71,5 +70,4 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
 }
 export interface JoinBuilderProps {
     readonly joinNode: JoinNode;
-    readonly parseContext: ParseContext;
 }