kysely 0.11.3 → 0.12.2

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -44,6 +44,7 @@ import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { WithNode } from './with-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { HavingNode } from './having-node.js';
 import { CreateSchemaNode } from './create-schema-node.js';
 import { DropSchemaNode } from './drop-schema-node.js';
@@ -63,6 +64,7 @@ import { DropViewNode } from './drop-view-node.js';
 import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
+import { ValuesNode } from './values-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -109,6 +111,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitCheckConstraint(node: CheckConstraintNode): void;
     protected abstract visitWith(node: WithNode): void;
     protected abstract visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected abstract visitCommonTableExpressionName(node: CommonTableExpressionNameNode): void;
     protected abstract visitHaving(node: HavingNode): void;
     protected abstract visitCreateSchema(node: CreateSchemaNode): void;
     protected abstract visitDropSchema(node: DropSchemaNode): void;
@@ -132,4 +135,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
     protected abstract visitOn(node: OnNode): void;
+    protected abstract visitValues(node: ValuesNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -52,6 +52,7 @@ export class OperationNodeVisitor {
         CheckConstraintNode: this.visitCheckConstraint.bind(this),
         WithNode: this.visitWith.bind(this),
         CommonTableExpressionNode: this.visitCommonTableExpression.bind(this),
+        CommonTableExpressionNameNode: this.visitCommonTableExpressionName.bind(this),
         HavingNode: this.visitHaving.bind(this),
         CreateSchemaNode: this.visitCreateSchema.bind(this),
         DropSchemaNode: this.visitDropSchema.bind(this),
@@ -69,6 +70,7 @@ export class OperationNodeVisitor {
         GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
         DefaultValueNode: this.visitDefaultValue.bind(this),
         OnNode: this.visitOn.bind(this),
+        ValuesNode: this.visitValues.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/query-node.d.ts

@@ -14,8 +14,6 @@ export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | Up
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
-    isMutating(node: OperationNode): node is MutatingQueryNode;
-    isFilterable(node: OperationNode): node is FilterableQueryNode;
     cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: FilterExpressionNode): T;
     cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: FilterExpressionNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;

package/dist/esm/operation-node/query-node.js

@@ -15,16 +15,6 @@ export const QueryNode = freeze({
             UpdateQueryNode.is(node) ||
             SelectQueryNode.is(node));
     },
-    isMutating(node) {
-        return (DeleteQueryNode.is(node) ||
-            InsertQueryNode.is(node) ||
-            UpdateQueryNode.is(node));
-    },
-    isFilterable(node) {
-        return (SelectQueryNode.is(node) ||
-            DeleteQueryNode.is(node) ||
-            UpdateQueryNode.is(node));
-    },
     cloneWithWhere(node, filter) {
         return freeze({
             ...node,

package/dist/esm/operation-node/values-node.d.ts

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+import { PrimitiveValueListNode } from './primitive-value-list-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type ValuesItemNode = ValueListNode | PrimitiveValueListNode;
+export interface ValuesNode extends OperationNode {
+    readonly kind: 'ValuesNode';
+    readonly values: ReadonlyArray<ValuesItemNode>;
+}
+/**
+ * @internal
+ */
+export declare const ValuesNode: Readonly<{
+    is(node: OperationNode): node is ValuesNode;
+    create(values: ReadonlyArray<ValuesItemNode>): ValuesNode;
+}>;

package/dist/esm/operation-node/values-node.js

@@ -0,0 +1,15 @@
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const ValuesNode = freeze({
+    is(node) {
+        return node.kind === 'ValuesNode';
+    },
+    create(values) {
+        return freeze({
+            kind: 'ValuesNode',
+            values: freeze(values),
+        });
+    },
+});

package/dist/esm/operation-node/with-node.d.ts

@@ -1,14 +1,16 @@
 import { OperationNode } from './operation-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+export declare type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
 export interface WithNode extends OperationNode {
     readonly kind: 'WithNode';
     readonly expressions: ReadonlyArray<CommonTableExpressionNode>;
+    readonly recursive?: boolean;
 }
 /**
  * @internal
  */
 export declare const WithNode: Readonly<{
     is(node: OperationNode): node is WithNode;
-    create(expression: CommonTableExpressionNode): WithNode;
+    create(expression: CommonTableExpressionNode, params?: WithNodeParams | undefined): WithNode;
     cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): WithNode;
 }>;

package/dist/esm/operation-node/with-node.js

@@ -6,10 +6,11 @@ export const WithNode = freeze({
     is(node) {
         return node.kind === 'WithNode';
     },
-    create(expression) {
+    create(expression, params) {
         return freeze({
             kind: 'WithNode',
             expressions: freeze([expression]),
+            ...params,
         });
     },
     cloneWithExpression(withNode, expression) {

package/dist/esm/package.json

@@ -1,3 +1 @@
-{
-    "type": "module"
-}
+{"type":"module"}

package/dist/esm/parser/complex-expression-parser.d.ts

@@ -0,0 +1,9 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, AnyRawBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
+import { ParseContext } from './parse-context.js';
+export declare type ComplexExpression<DB, TB extends keyof DB> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
+export declare function parseComplexExpression(ctx: ParseContext, exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
+export declare function parseAliasedComplexExpression(ctx: ParseContext, exp: AliasedComplexExpression<any, any>): AliasNode;

package/dist/esm/parser/complex-expression-parser.js

@@ -0,0 +1,20 @@
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { isFunction } from '../util/object-utils.js';
+export function parseComplexExpression(ctx, exp) {
+    if (isOperationNodeSource(exp)) {
+        return exp.toOperationNode();
+    }
+    else if (isFunction(exp)) {
+        return exp(ctx.createExpressionBuilder()).toOperationNode();
+    }
+    throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
+}
+export function parseAliasedComplexExpression(ctx, exp) {
+    if (isOperationNodeSource(exp)) {
+        return exp.toOperationNode();
+    }
+    else if (isFunction(exp)) {
+        return exp(ctx.createExpressionBuilder()).toOperationNode();
+    }
+    throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
+}

package/dist/esm/parser/filter-parser.d.ts

@@ -1,15 +1,24 @@
 import { FilterNode } from '../operation-node/filter-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 import { Operator } from '../operation-node/operator-node.js';
-import { ReferenceExpression } from './reference-parser.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
+import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
 import { FilterExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ParseContext } from './parse-context.js';
-export declare type ExistsExpression<DB, TB extends keyof DB> = AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+import { WhereInterface } from '../query-builder/where-interface.js';
+import { HavingInterface } from '../query-builder/having-interface.js';
+export declare type FilterValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export declare type FilterValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export declare type ExistsExpression<DB, TB extends keyof DB> = ValueExpression<DB, TB, never>;
+export declare type WhereGrouper<DB, TB extends keyof DB> = (qb: WhereInterface<DB, TB>) => WhereInterface<DB, TB>;
+export declare type HavingGrouper<DB, TB extends keyof DB> = (qb: HavingInterface<DB, TB>) => HavingInterface<DB, TB>;
 export declare type FilterOperator = Operator | AnyRawBuilder;
+declare type FilterType = 'where' | 'having' | 'on';
 export declare function parseWhereFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseHavingFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseOnFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseReferenceFilter(ctx: ParseContext, lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
 export declare function parseExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
 export declare function parseNotExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseFilter(ctx: ParseContext, type: 'where' | 'having' | 'on', args: any[]): FilterExpressionNode;
+export declare function parseFilter(ctx: ParseContext, type: FilterType, args: any[]): FilterExpressionNode;
+export {};

package/dist/esm/parser/filter-parser.js

@@ -6,7 +6,6 @@ import { OperatorNode, OPERATORS, } from '../operation-node/operator-node.js';
 import { ParensNode } from '../operation-node/parens-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
 import { parseValueExpressionOrList, } from './value-parser.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
 export function parseWhereFilter(ctx, args) {
     return parseFilter(ctx, 'where', args);
@@ -31,18 +30,9 @@ export function parseFilter(ctx, type, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1) {
-        const arg = args[0];
-        if (isFunction(arg)) {
-            return GROUP_PARSERS[type](ctx, arg);
-        }
-        else if (isOperationNodeSource(arg)) {
-            const node = arg.toOperationNode();
-            if (RawNode.is(node)) {
-                return node;
-            }
-        }
+        return parseOneArgFilter(ctx, type, args[0]);
     }
-    throw new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
+    throw createFilterError(type, args);
 }
 function parseThreeArgFilter(ctx, left, op, right) {
     if ((op === 'is' || op === 'is not') && (isNull(right) || isBoolean(right))) {
@@ -54,10 +44,8 @@ function parseIsFilter(ctx, left, op, right) {
     return FilterNode.create(parseReferenceExpression(ctx, left), parseFilterOperator(op), ValueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
-    if (isString(op)) {
-        if (OPERATORS.includes(op)) {
-            return OperatorNode.create(op);
-        }
+    if (isString(op) && OPERATORS.includes(op)) {
+        return OperatorNode.create(op);
     }
     else if (isOperationNodeSource(op)) {
         return op.toOperationNode();
@@ -65,17 +53,26 @@ function parseFilterOperator(op) {
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
 function parseExistExpression(ctx, type, arg) {
-    const node = isFunction(arg)
-        ? arg(ctx.createExpressionBuilder()).toOperationNode()
-        : arg.toOperationNode();
-    if (!SelectQueryNode.is(node) && !RawNode.is(node)) {
-        throw new Error('invalid where exists arg');
+    return FilterNode.create(undefined, OperatorNode.create(type), parseValueExpressionOrList(ctx, arg));
+}
+function parseOneArgFilter(ctx, type, arg) {
+    if (isFunction(arg)) {
+        return GROUP_PARSERS[type](ctx, arg);
     }
-    return FilterNode.create(undefined, OperatorNode.create(type), node);
+    else if (isOperationNodeSource(arg)) {
+        const node = arg.toOperationNode();
+        if (RawNode.is(node)) {
+            return node;
+        }
+    }
+    throw createFilterError(type, arg);
+}
+function createFilterError(type, args) {
+    return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
 }
 const GROUP_PARSERS = freeze({
     where(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder([]));
+        const query = callback(ctx.createSelectQueryBuilder());
         const queryNode = query.toOperationNode();
         if (!queryNode.where) {
             throw new Error('no `where` methods called insided a group callback');
@@ -83,7 +80,7 @@ const GROUP_PARSERS = freeze({
         return ParensNode.create(queryNode.where.where);
     },
     having(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder([]));
+        const query = callback(ctx.createSelectQueryBuilder());
         const queryNode = query.toOperationNode();
         if (!queryNode.having) {
             throw new Error('no `having` methods called insided a group callback');

package/dist/esm/parser/insert-values-parser.d.ts

@@ -1,15 +1,12 @@
 import { ColumnNode } from '../operation-node/column-node.js';
-import { InsertValuesNode } from '../operation-node/insert-query-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, GeneratedPlaceholder } from '../util/type-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
+import { GeneratedPlaceholder } from '../util/type-utils.js';
+import { ParseContext } from './parse-context.js';
+import { ValueExpression } from './value-parser.js';
+import { ValuesNode } from '../operation-node/values-node.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
-    [C in keyof DB[TB]]: InsertValueExpression<DB[TB][C]>;
+    [C in keyof DB[TB]]: InsertValueExpression<DB, TB, DB[TB][C]>;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-declare type InsertValueExpression<T> = T | AnyQueryBuilder | AnyRawBuilder | GeneratedPlaceholder;
-export declare function parseInsertObjectOrList(args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
-export declare function parseInsertValueExpression(value: InsertValueExpression<PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;
+declare type InsertValueExpression<DB, TB extends keyof DB, T> = ValueExpression<DB, TB, T> | GeneratedPlaceholder;
+export declare function parseInsertObjectOrList(ctx: ParseContext, args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
 export {};

package/dist/esm/parser/insert-values-parser.js

@@ -1,51 +1,44 @@
 import { ColumnNode } from '../operation-node/column-node.js';
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
-import { QueryNode } from '../operation-node/query-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
 import { isGeneratedPlaceholder } from '../util/generated-placeholder.js';
-import { isPrimitive } from '../util/object-utils.js';
-export function parseInsertObjectOrList(args) {
-    return parseInsertColumnsAndValues(Array.isArray(args) ? args : [args]);
+import { freeze, isPrimitive } from '../util/object-utils.js';
+import { parseValueExpression } from './value-parser.js';
+import { ValuesNode } from '../operation-node/values-node.js';
+export function parseInsertObjectOrList(ctx, args) {
+    return parseInsertColumnsAndValues(ctx, Array.isArray(args) ? args : [args]);
 }
-function parseInsertColumnsAndValues(rows) {
-    const columns = [];
-    const values = [];
+function parseInsertColumnsAndValues(ctx, rows) {
+    const columns = parseColumnNamesAndIndexes(rows);
+    return [
+        freeze([...columns.keys()].map(ColumnNode.create)),
+        ValuesNode.create(rows.map((row) => parseRowValues(ctx, row, columns))),
+    ];
+}
+function parseColumnNamesAndIndexes(rows) {
+    const columns = new Map();
     for (const row of rows) {
-        for (const column of Object.keys(row)) {
-            const value = row[column];
-            if (!columns.includes(column) && !isGeneratedPlaceholder(value)) {
-                columns.push(column);
+        const cols = Object.keys(row);
+        for (const col of cols) {
+            if (!columns.has(col) && !isGeneratedPlaceholder(row[col])) {
+                columns.set(col, columns.size);
             }
         }
     }
-    for (const row of rows) {
-        const rowValues = columns.map(() => null);
-        for (const column of Object.keys(row)) {
-            const columnIdx = columns.indexOf(column);
-            if (columnIdx !== -1) {
-                rowValues[columnIdx] = row[column];
-            }
-        }
-        if (rowValues.every(isPrimitive)) {
-            values.push(PrimitiveValueListNode.create(rowValues));
-        }
-        else {
-            values.push(ValueListNode.create(rowValues.map(parseInsertValueExpression)));
-        }
-    }
-    return [columns.map(ColumnNode.create), values];
+    return columns;
 }
-export function parseInsertValueExpression(value) {
-    if (isPrimitive(value)) {
-        return ValueNode.create(value);
-    }
-    else if (isOperationNodeSource(value)) {
-        const node = value.toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
+function parseRowValues(ctx, row, columns) {
+    const rowColumns = Object.keys(row);
+    const rowValues = new Array(columns.size).fill(null);
+    for (const col of rowColumns) {
+        const columnIdx = columns.get(col);
+        const value = row[col];
+        if (columnIdx !== undefined && !isGeneratedPlaceholder(value)) {
+            rowValues[columnIdx] = value;
         }
     }
-    throw new Error(`unsupported value for insert object ${JSON.stringify(value)}`);
+    if (rowValues.every(isPrimitive)) {
+        return PrimitiveValueListNode.create(rowValues);
+    }
+    return ValueListNode.create(rowValues.map((it) => parseValueExpression(ctx, it)));
 }

package/dist/esm/parser/order-by-parser.d.ts

@@ -3,6 +3,6 @@ import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type OrderByDirection = 'asc' | 'desc';
-export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | keyof O;
+export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
 export declare type OrderByDirectionExpression = OrderByDirection | AnyRawBuilder;
 export declare function parseOrderBy(ctx: ParseContext, orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

package/dist/esm/parser/parse-context.d.ts

@@ -1,7 +1,7 @@
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
 import { JoinType } from '../operation-node/join-node.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { TableExpression } from './table-parser.js';
@@ -14,11 +14,7 @@ export interface ParseContext {
     /**
      * Creates a select query builder with a {@link NoopQueryExecutor}.
      */
-    createSelectQueryBuilder(tables: ReadonlyArray<TableExpression<any, any>>): QueryBuilder<any, any>;
-    /**
-     * Creates an instance of a join builder.
-     */
-    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+    createSelectQueryBuilder(): SelectQueryBuilder<any, any, any>;
     /**
      * Creates an expression builder for building stuff like subqueries.
      * {@link NoopQueryExecutor} is used as the executor and the queries
@@ -29,13 +25,31 @@ export interface ParseContext {
      * Creates a query creator with a {@link NoopQueryExecutor}.
      */
     createQueryCreator(): QueryCreator<any>;
+    /**
+     * Creates an instance of a join builder.
+     */
+    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
 }
 export declare class DefaultParseContext implements ParseContext {
     #private;
     constructor(adapter: DialectAdapter);
     get adapter(): DialectAdapter;
-    createSelectQueryBuilder(tables: ReadonlyArray<TableExpression<any, any>>): QueryBuilder<any, any>;
-    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+    /**
+     * Creates a select query builder with a {@link NoopQueryExecutor}.
+     */
+    createSelectQueryBuilder(): SelectQueryBuilder<any, any, any>;
+    /**
+     * Creates an expression builder for building stuff like subqueries.
+     * {@link NoopQueryExecutor} is used as the executor and the queries
+     * built using the returned builder can never be executed.
+     */
     createExpressionBuilder(): ExpressionBuilder<any, any>;
+    /**
+     * Creates a query creator with a {@link NoopQueryExecutor}.
+     */
     createQueryCreator(): QueryCreator<any>;
+    /**
+     * Creates an instance of a join builder.
+     */
+    createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
 }

package/dist/esm/parser/parse-context.js

@@ -1,7 +1,7 @@
 import { JoinNode } from '../operation-node/join-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ExpressionBuilder } from '../query-builder/expression-builder.js';
 import { QueryCreator } from '../query-creator.js';
 import { NoopQueryExecutor } from '../query-executor/noop-query-executor.js';
@@ -17,18 +17,12 @@ export class DefaultParseContext {
     get adapter() {
         return this.#adapter;
     }
-    createSelectQueryBuilder(tables) {
-        return new QueryBuilder({
+    createSelectQueryBuilder() {
+        return new SelectQueryBuilder({
             queryId: createQueryId(),
             executor: this.#noopExecutor,
             parseContext: this,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this, tables)),
-        });
-    }
-    createJoinBuilder(joinType, table) {
-        return new JoinBuilder({
-            joinNode: JoinNode.create(joinType, parseTableExpression(this, table)),
-            parseContext: this,
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this, [])),
         });
     }
     createExpressionBuilder() {
@@ -43,4 +37,10 @@ export class DefaultParseContext {
             parseContext: this,
         });
     }
+    createJoinBuilder(joinType, table) {
+        return new JoinBuilder({
+            joinNode: JoinNode.create(joinType, parseTableExpression(this, table)),
+            parseContext: this,
+        });
+    }
 }

package/dist/esm/parser/reference-parser.d.ts

@@ -3,18 +3,19 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { PrimitiveValue } from '../util/object-utils.js';
-import { AnyColumn, AnyColumnWithTable, AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory, RowType, ValueType } from '../util/type-utils.js';
-import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { AnyColumn, AnyColumnWithTable, RowType, ValueType } from '../util/type-utils.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { ParseContext } from './parse-context.js';
-export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
+import { ComplexExpression } from './complex-expression-parser.js';
+import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any> | ComplexExpression<DB, TB>;
 export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
-export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends QueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => QueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
-declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;
+export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends SelectQueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
+declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, R = RowType<DB, TB>> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends keyof R ? R[RE] : PrimitiveValue;
 export declare function parseReferenceExpressionOrList(ctx: ParseContext, arg: ReferenceExpressionOrList<any, any>): ReferenceExpressionNode[];
-export declare function parseReferenceExpression(ctx: ParseContext, arg: ReferenceExpression<any, any>): ReferenceExpressionNode;
+export declare function parseReferenceExpression(ctx: ParseContext, exp: ReferenceExpression<any, any>): ReferenceExpressionNode;
 export declare function parseStringReference(ref: string): ColumnNode | ReferenceNode;
 export declare function parseAliasedStringReference(ref: string): ColumnNode | ReferenceNode | AliasNode;
 export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;

package/dist/esm/parser/reference-parser.js

@@ -1,10 +1,10 @@
 import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
-import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { isFunction, isReadonlyArray, isString, } from '../util/object-utils.js';
-import { QueryNode } from '../operation-node/query-node.js';
+import { isReadonlyArray, isString, } from '../util/object-utils.js';
+import { parseComplexExpression, } from './complex-expression-parser.js';
+import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
 export function parseReferenceExpressionOrList(ctx, arg) {
     if (isReadonlyArray(arg)) {
         return arg.map((it) => parseReferenceExpression(ctx, it));
@@ -13,23 +13,14 @@ export function parseReferenceExpressionOrList(ctx, arg) {
         return [parseReferenceExpression(ctx, arg)];
     }
 }
-export function parseReferenceExpression(ctx, arg) {
-    if (isString(arg)) {
-        return parseStringReference(arg);
+export function parseReferenceExpression(ctx, exp) {
+    if (isString(exp)) {
+        return parseStringReference(exp);
     }
-    else if (isOperationNodeSource(arg)) {
-        const node = arg.toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
-    }
-    else if (isFunction(arg)) {
-        const node = arg(ctx.createExpressionBuilder()).toOperationNode();
-        if (!QueryNode.isMutating(node)) {
-            return node;
-        }
+    else if (isDynamicReferenceBuilder(exp)) {
+        return exp.toOperationNode();
     }
-    throw new Error(`invalid reference expression ${JSON.stringify(arg)}`);
+    return parseComplexExpression(ctx, exp);
 }
 export function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';

package/dist/esm/parser/returning-parser.d.ts

@@ -1,9 +1,5 @@
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
-import { QueryBuilder } from '../query-builder/query-builder.js';
 import { UpdateResult } from '../query-builder/update-result.js';
 import { Selection } from './select-parser.js';
-/**
- * `returning` method output query builder type
- */
-export declare type QueryBuilderWithReturning<DB, TB extends keyof DB, O, S> = QueryBuilder<DB, TB, O extends InsertResult ? Selection<DB, TB, S> : O extends DeleteResult ? Selection<DB, TB, S> : O extends UpdateResult ? Selection<DB, TB, S> : O & Selection<DB, TB, S>>;
+export declare type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;