kysely 0.27.0 → 0.27.2

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

@@ -138,7 +138,7 @@ export interface FunctionModule<DB, TB extends keyof DB> {
      * from "person"
      * ```
      */
-    agg<O, RE extends ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): AggregateFunctionBuilder<DB, TB, O>;
+    agg<O, RE extends ReferenceExpression<DB, TB> = ReferenceExpression<DB, TB>>(name: string, args?: ReadonlyArray<RE>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Calls the `avg` function for the column or expression given as the argument.
      *

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

@@ -1,7 +1,7 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { SelectExpression, SelectCallback } from '../parser/select-parser.js';
-import { InsertObjectOrList, InsertObjectOrListFactory } from '../parser/insert-values-parser.js';
+import { InsertExpression } from '../parser/insert-values-parser.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { NarrowPartial, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
@@ -184,8 +184,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * }))
      * ```
      */
-    values(insert: InsertObjectOrList<DB, TB>): InsertQueryBuilder<DB, TB, O>;
-    values(insert: InsertObjectOrListFactory<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    values(insert: InsertExpression<DB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Sets the columns to insert.
      *
@@ -240,6 +239,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * ```
      */
     expression(expression: ExpressionOrFactory<DB, TB, any>): InsertQueryBuilder<DB, TB, O>;
+    /**
+     * Creates an `insert into "person" default values` query.
+     */
+    defaultValues(): InsertQueryBuilder<DB, TB, O>;
     /**
      * Changes an `insert into` query to an `insert ignore into` query.
      *
@@ -563,10 +566,10 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `InsertQueryBuilder` with a new output type.
      */
-    $castTo<T>(): InsertQueryBuilder<DB, TB, T>;
+    $castTo<C>(): InsertQueryBuilder<DB, TB, C>;
     /**
      * Narrows (parts of) the output type of the query.
      *

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

@@ -20,6 +20,166 @@ class InsertQueryBuilder {
     constructor(props) {
         this.#props = (0, object_utils_js_1.freeze)(props);
     }
+    /**
+     * Sets the values to insert for an {@link Kysely.insertInto | insert} query.
+     *
+     * 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
+     * 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}.
+     *
+     * The return value of an `insert` query is an instance of {@link InsertResult}. The
+     * {@link InsertResult.insertId | insertId} field holds the auto incremented primary
+     * key if the database returned one.
+     *
+     * On PostgreSQL and some other dialects, you need to call `returning` to get
+     * something out of the query.
+     *
+     * Also see the {@link expression} method for inserting the result of a select
+     * query or any other expression.
+     *
+     * ### Examples
+     *
+     * <!-- siteExample("insert", "Single row", 10) -->
+     *
+     * Insert a single row:
+     *
+     * ```ts
+     * const result = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston',
+     *     age: 40
+     *   })
+     *   .executeTakeFirst()
+     *
+     * // `insertId` is only available on dialects that
+     * // automatically return the id of the inserted row
+     * // such as MySQL and SQLite. On PostgreSQL, for example,
+     * // you need to add a `returning` clause to the query to
+     * // get anything out. See the "returning data" example.
+     * console.log(result.insertId)
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * insert into `person` (`first_name`, `last_name`, `age`) values (?, ?, ?)
+     * ```
+     *
+     * <!-- siteExample("insert", "Multiple rows", 20) -->
+     *
+     * On dialects that support it (for example PostgreSQL) you can insert multiple
+     * rows by providing an array. Note that the return value is once again very
+     * dialect-specific. Some databases may only return the id of the *last* inserted
+     * row and some return nothing at all unless you call `returning`.
+     *
+     * ```ts
+     * await db
+     *   .insertInto('person')
+     *   .values([{
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston',
+     *     age: 40,
+     *   }, {
+     *     first_name: 'Arnold',
+     *     last_name: 'Schwarzenegger',
+     *     age: 70,
+     *   }])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name", "age") values (($1, $2, $3), ($4, $5, $6))
+     * ```
+     *
+     * <!-- siteExample("insert", "Returning data", 30) -->
+     *
+     * On supported dialects like PostgreSQL you need to chain `returning` to the query to get
+     * the inserted row's columns (or any other expression) as the return value. `returning`
+     * works just like `select`. Refer to `select` method's examples and documentation for
+     * more info.
+     *
+     * ```ts
+     * const result = await db
+     *   .insertInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston',
+     *     age: 40,
+     *   })
+     *   .returning(['id', 'first_name as name'])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name", "age") values ($1, $2, $3) returning "id", "first_name" as "name"
+     * ```
+     *
+     * <!-- siteExample("insert", "Complex values", 40) -->
+     *
+     * In addition to primitives, the values can also be arbitrary expressions.
+     * You can build the expressions by using a callback and calling the methods
+     * on the expression builder passed to it:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const ani = "Ani"
+     * const ston = "ston"
+     *
+     * const result = await db
+     *   .insertInto('person')
+     *   .values(({ ref, selectFrom, fn }) => ({
+     *     first_name: 'Jennifer',
+     *     last_name: sql`concat(${ani}, ${ston})`,
+     *     middle_name: ref('first_name'),
+     *     age: selectFrom('person')
+     *       .select(fn.avg<number>('age')
+     *       .as('avg_age')),
+     *   }))
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" (
+     *   "first_name",
+     *   "last_name",
+     *   "middle_name",
+     *   "age"
+     * )
+     * values (
+     *   $1,
+     *   concat($2, $3),
+     *   "first_name",
+     *   (select avg("age") as "avg_age" from "person")
+     * )
+     * ```
+     *
+     * You can also use the callback version of subqueries or raw expressions:
+     *
+     * ```ts
+     * db.with('jennifer', (db) => db
+     *   .selectFrom('person')
+     *   .where('first_name', '=', 'Jennifer')
+     *   .select(['id', 'first_name', 'gender'])
+     *   .limit(1)
+     * ).insertInto('pet').values((eb) => ({
+     *   owner_id: eb.selectFrom('jennifer').select('id'),
+     *   name: eb.selectFrom('jennifer').select('first_name'),
+     *   species: 'cat',
+     * }))
+     * ```
+     */
     values(insert) {
         const [columns, values] = (0, insert_values_parser_js_1.parseInsertExpression)(insert);
         return new InsertQueryBuilder({
@@ -98,6 +258,17 @@ class InsertQueryBuilder {
             }),
         });
     }
+    /**
+     * Creates an `insert into "person" default values` query.
+     */
+    defaultValues() {
+        return new InsertQueryBuilder({
+            ...this.#props,
+            queryNode: insert_query_node_js_1.InsertQueryNode.cloneWith(this.#props.queryNode, {
+                defaultValues: true,
+            }),
+        });
+    }
     /**
      * Changes an `insert into` query to an `insert ignore into` query.
      *
@@ -398,8 +569,8 @@ class InsertQueryBuilder {
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `InsertQueryBuilder` with a new output type.
      */
     $castTo() {
         return new InsertQueryBuilder(this.#props);

package/dist/cjs/query-builder/json-path-builder.d.ts

@@ -232,7 +232,8 @@ export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `JSONPathBuilder` with a new output type.
      */
-    $castTo<T>(): JSONPathBuilder<T>;
+    $castTo<C>(): JSONPathBuilder<C>;
+    $notNull(): JSONPathBuilder<Exclude<O, null>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

package/dist/cjs/query-builder/json-path-builder.js

@@ -165,6 +165,9 @@ class TraversedJSONPathBuilder extends JSONPathBuilder {
     $castTo() {
         return new JSONPathBuilder(this.#node);
     }
+    $notNull() {
+        return new JSONPathBuilder(this.#node);
+    }
     toOperationNode() {
         return this.#node;
     }

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

@@ -25,6 +25,7 @@ import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ExpressionWrapper } from '../expression/expression-wrapper.js';
 import { SelectQueryBuilderExpression } from './select-query-builder-expression.js';
+import { ValueExpression } from '../parser/value-parser.js';
 export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInterface<DB, TB>, HavingInterface<DB, TB>, SelectQueryBuilderExpression<O>, Compilable<O>, Explainable, Streamable<O> {
     /**
      * Adds a `where` expression to the query.
@@ -674,19 +675,19 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Adds the `for update` modifier to a select query on supported databases.
      */
-    forUpdate(): SelectQueryBuilder<DB, TB, O>;
+    forUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for share` modifier to a select query on supported databases.
      */
-    forShare(): SelectQueryBuilder<DB, TB, O>;
+    forShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for key share` modifier to a select query on supported databases.
      */
-    forKeyShare(): SelectQueryBuilder<DB, TB, O>;
+    forKeyShare(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `for no key update` modifier to a select query on supported databases.
      */
-    forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O>;
+    forNoKeyUpdate(of?: TableOrList<TB>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds the `skip locked` modifier to a select query on supported databases.
      */
@@ -1161,7 +1162,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .limit(10)
      * ```
      */
-    limit(limit: number): SelectQueryBuilder<DB, TB, O>;
+    limit(limit: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds an offset clause to the query.
      *
@@ -1177,7 +1178,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      *   .limit(10)
      * ```
      */
-    offset(offset: number): SelectQueryBuilder<DB, TB, O>;
+    offset(offset: ValueExpression<DB, TB, number>): SelectQueryBuilder<DB, TB, O>;
     /**
      * Combines another select query or raw expression to this query using `union`.
      *
@@ -1549,10 +1550,10 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `SelectQueryBuilder` with a new output type.
      */
-    $castTo<T>(): SelectQueryBuilder<DB, TB, T>;
+    $castTo<C>(): SelectQueryBuilder<DB, TB, C>;
     /**
      * Changes the output type from an object to a tuple.
      *
@@ -1831,4 +1832,5 @@ type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = Se
 type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 }>;
+type TableOrList<TB extends keyof any> = (TB & string) | ReadonlyArray<TB & string>;
 export {};

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

@@ -4,6 +4,7 @@ exports.createSelectQueryBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const select_modifier_node_js_1 = require("../operation-node/select-modifier-node.js");
 const join_parser_js_1 = require("../parser/join-parser.js");
+const table_parser_js_1 = require("../parser/table-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
@@ -19,6 +20,7 @@ const identifier_node_js_1 = require("../operation-node/identifier-node.js");
 const set_operation_parser_js_1 = require("../parser/set-operation-parser.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const expression_wrapper_js_1 = require("../expression/expression-wrapper.js");
+const value_parser_js_1 = require("../parser/value-parser.js");
 class SelectQueryBuilderImpl {
     #props;
     constructor(props) {
@@ -84,28 +86,28 @@ class SelectQueryBuilderImpl {
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('Distinct')),
         });
     }
-    forUpdate() {
+    forUpdate(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForUpdate')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForUpdate', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
-    forShare() {
+    forShare(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForShare')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForShare', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
-    forKeyShare() {
+    forKeyShare(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForKeyShare')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForKeyShare', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
-    forNoKeyUpdate() {
+    forNoKeyUpdate(of) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForNoKeyUpdate')),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForNoKeyUpdate', of ? (0, object_utils_js_1.asArray)(of).map(table_parser_js_1.parseTable) : undefined)),
         });
     }
     skipLocked() {
@@ -177,13 +179,13 @@ class SelectQueryBuilderImpl {
     limit(limit) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create(limit)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithLimit(this.#props.queryNode, limit_node_js_1.LimitNode.create((0, value_parser_js_1.parseValueExpression)(limit))),
         });
     }
     offset(offset) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOffset(this.#props.queryNode, offset_node_js_1.OffsetNode.create(offset)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOffset(this.#props.queryNode, offset_node_js_1.OffsetNode.create((0, value_parser_js_1.parseValueExpression)(offset))),
         });
     }
     union(expression) {

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

@@ -8,7 +8,7 @@ import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { UpdateObject, UpdateObjectFactory, ExtractUpdateTypeFromReferenceExpression } from '../parser/update-set-parser.js';
+import { UpdateObjectExpression, ExtractUpdateTypeFromReferenceExpression } 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';
@@ -695,8 +695,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * where "id" = $5
      * ```
      */
-    set(update: UpdateObject<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
-    set(update: UpdateObjectFactory<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
+    set(update: UpdateObjectExpression<DB, TB, UT>): UpdateQueryBuilder<DB, UT, TB, O>;
     set<RE extends ReferenceExpression<DB, UT>>(key: RE, value: ValueExpression<DB, TB, ExtractUpdateTypeFromReferenceExpression<DB, UT, RE>>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Allows you to return data from modified rows.
@@ -829,10 +828,10 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `UpdateQueryBuilder` with a new output type.
      */
-    $castTo<T>(): UpdateQueryBuilder<DB, UT, TB, T>;
+    $castTo<C>(): UpdateQueryBuilder<DB, UT, TB, C>;
     /**
      * Narrows (parts of) the output type of the query.
      *

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

@@ -156,8 +156,8 @@ class UpdateQueryBuilder {
     /**
      * Change the output type of the query.
      *
-     * You should only use this method as the last resort if the types
-     * don't support your use case.
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `UpdateQueryBuilder` with a new output type.
      */
     $castTo() {
         return new UpdateQueryBuilder(this.#props);

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -164,6 +164,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.values);
         }
+        if (node.defaultValues) {
+            this.append(' ');
+            this.append('default values');
+        }
         if (node.onConflict) {
             this.append(' ');
             this.visitNode(node.onConflict);
@@ -869,6 +873,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         else {
             this.append(SELECT_MODIFIER_SQL[node.modifier]);
         }
+        if (node.of) {
+            this.append(' of ');
+            this.compileList(node.of, ', ');
+        }
     }
     visitCreateType(node) {
         this.append('create type ');

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -130,7 +130,17 @@ export interface RawBuilder<O> extends AliasableExpression<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>;
+    $castTo<C>(): RawBuilder<C>;
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull(): RawBuilder<Exclude<O, null>>;
     /**
      * Adds a plugin for this SQL snippet.
      */

package/dist/cjs/raw-builder/raw-builder.js

@@ -24,6 +24,9 @@ class RawBuilderImpl {
     $castTo() {
         return new RawBuilderImpl({ ...this.#props });
     }
+    $notNull() {
+        return new RawBuilderImpl(this.#props);
+    }
     withPlugin(plugin) {
         return new RawBuilderImpl({
             ...this.#props,

package/dist/cjs/raw-builder/sql.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sql = void 0;
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
@@ -12,7 +13,7 @@ const raw_builder_js_1 = require("./raw-builder.js");
 exports.sql = Object.assign((sqlFragments, ...parameters) => {
     return (0, raw_builder_js_1.createRawBuilder)({
         queryId: (0, query_id_js_1.createQueryId)(),
-        rawNode: raw_node_js_1.RawNode.create(sqlFragments, parameters?.map(value_parser_js_1.parseValueExpression) ?? []),
+        rawNode: raw_node_js_1.RawNode.create(sqlFragments, parameters?.map(parseParameter) ?? []),
     });
 }, {
     ref(columnReference) {
@@ -64,7 +65,7 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
         const nodes = new Array(2 * array.length - 1);
         const sep = separator.toOperationNode();
         for (let i = 0; i < array.length; ++i) {
-            nodes[2 * i] = (0, value_parser_js_1.parseValueExpression)(array[i]);
+            nodes[2 * i] = parseParameter(array[i]);
             if (i !== array.length - 1) {
                 nodes[2 * i + 1] = sep;
             }
@@ -75,3 +76,9 @@ exports.sql = Object.assign((sqlFragments, ...parameters) => {
         });
     },
 });
+function parseParameter(param) {
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(param)) {
+        return param.toOperationNode();
+    }
+    return (0, value_parser_js_1.parseValueExpression)(param);
+}

package/dist/cjs/util/object-utils.d.ts

@@ -16,7 +16,7 @@ export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer |
 export declare function isPlainObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
-export declare function asArray<T>(arg: T | T[]): T[];
+export declare function asArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
 export declare function asReadonlyArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
 export declare function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown>;
 export declare function noop<T>(obj: T): T;

package/dist/cjs/util/object-utils.js

@@ -74,7 +74,7 @@ function freeze(obj) {
 }
 exports.freeze = freeze;
 function asArray(arg) {
-    if (Array.isArray(arg)) {
+    if (isReadonlyArray(arg)) {
         return arg;
     }
     else {

package/dist/esm/dialect/mssql/mssql-introspector.js

@@ -65,12 +65,14 @@ export class MssqlIntrospector {
         const tableDictionary = {};
         for (const rawColumn of rawColumns) {
             const key = `${rawColumn.table_schema_name}.${rawColumn.table_name}`;
-            const table = (tableDictionary[key] ||= freeze({
-                columns: [],
-                isView: rawColumn.table_type === 'V ',
-                name: rawColumn.table_name,
-                schema: rawColumn.table_schema_name ?? undefined,
-            }));
+            const table = (tableDictionary[key] =
+                tableDictionary[key] ||
+                    freeze({
+                        columns: [],
+                        isView: rawColumn.table_type === 'V ',
+                        name: rawColumn.table_name,
+                        schema: rawColumn.table_schema_name ?? undefined,
+                    }));
             table.columns.push(freeze({
                 dataType: rawColumn.type_name,
                 dataTypeSchema: rawColumn.type_schema_name ?? undefined,

package/dist/esm/expression/expression-wrapper.d.ts

@@ -243,7 +243,17 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `ExpressionWrapper` with a new output type.
      */
-    $castTo<T>(): ExpressionWrapper<DB, TB, T>;
+    $castTo<C>(): ExpressionWrapper<DB, TB, C>;
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull(): ExpressionWrapper<DB, TB, Exclude<T, null>>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -397,7 +407,7 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `OrWrapper` with a new output type.
      */
-    $castTo<T extends SqlBool>(): OrWrapper<DB, TB, T>;
+    $castTo<C extends SqlBool>(): OrWrapper<DB, TB, C>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *
@@ -533,7 +543,7 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      * This method call doesn't change the SQL in any way. This methods simply
      * returns a copy of this `AndWrapper` with a new output type.
      */
-    $castTo<T extends SqlBool>(): AndWrapper<DB, TB, T>;
+    $castTo<C extends SqlBool>(): AndWrapper<DB, TB, C>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

package/dist/esm/expression/expression-wrapper.js

@@ -33,6 +33,18 @@ export class ExpressionWrapper {
     $castTo() {
         return new ExpressionWrapper(this.#node);
     }
+    /**
+     * Omit null from the expression's type.
+     *
+     * This function can be useful in cases where you know an expression can't be
+     * null, but Kysely is unable to infer it.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of `this` with a new output type.
+     */
+    $notNull() {
+        return new ExpressionWrapper(this.#node);
+    }
     toOperationNode() {
         return this.#node;
     }