kysely 0.7.2 → 0.7.6

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

@@ -1,7 +1,7 @@
 import { AliasNode } from '../operation-node/alias-node.js';
-import { parseJoinArgs, } from '../parser/join-parser.js';
-import { parseSelectExpressionOrList, parseSelectAllArgs, } from '../parser/select-parser.js';
-import { parseExistExpression, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistExpression, } from '../parser/filter-parser.js';
+import { parseJoin, } from '../parser/join-parser.js';
+import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
+import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
 import { parseInsertObjectOrList, } from '../parser/insert-values-parser.js';
 import { parseReferenceExpression, parseReferenceExpressionOrList, } from '../parser/reference-parser.js';
 import { OrderByItemNode, } from '../operation-node/order-by-item-node.js';
@@ -16,7 +16,6 @@ import { LimitNode } from '../operation-node/limit-node.js';
 import { OffsetNode } from '../operation-node/offset-node.js';
 import { parseOnConflictDoNothing, parseOnConflictUpdate, } from '../parser/on-conflict-parser.js';
 import { freeze } from '../util/object-utils.js';
-import { createParseContext } from '../parser/parse-context.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
 /**
@@ -43,7 +42,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseWhereFilter(this.#parseContext, args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -101,14 +100,14 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseWhereFilter(this.#parseContext, args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -121,7 +120,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -187,7 +186,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -197,7 +196,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -207,7 +206,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -217,14 +216,14 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     having(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseHavingFilter(this.#parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -235,14 +234,14 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orHaving(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseHavingFilter(this.#parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -253,7 +252,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseReferenceFilter(this.#parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -264,7 +263,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -275,7 +274,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -286,7 +285,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -297,21 +296,21 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseNotExistExpression(this.#parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     select(selection) {
         assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#parseContext, selection)),
+            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
         });
     }
     distinctOn(selection) {
         assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#parseContext, selection)),
+            queryNode: SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
         });
     }
     /**
@@ -402,35 +401,35 @@ export class QueryBuilder {
         assertCanHaveSelectClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectAllArgs(table)),
+            queryNode: SelectQueryNode.cloneWithSelections(this.#props.queryNode, parseSelectAll(table)),
         });
     }
     innerJoin(...args) {
         assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'InnerJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'InnerJoin', args)),
         });
     }
     leftJoin(...args) {
         assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'LeftJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'LeftJoin', args)),
         });
     }
     rightJoin(...args) {
         assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'RightJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'RightJoin', args)),
         });
     }
     fullJoin(...args) {
         assertCanHaveJoins(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoinArgs(this.#parseContext, 'FullJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(this.#props.parseContext, 'FullJoin', args)),
         });
     }
     values(args) {
@@ -487,7 +486,7 @@ export class QueryBuilder {
         return new QueryBuilder({
             ...this.#props,
             queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onConflict: parseOnConflictUpdate(this.#parseContext, target, updates),
+                onConflict: parseOnConflictUpdate(this.#props.parseContext, target, updates),
             }),
         });
     }
@@ -513,7 +512,7 @@ export class QueryBuilder {
         return new QueryBuilder({
             ...this.#props,
             queryNode: InsertQueryNode.cloneWith(this.#props.queryNode, {
-                onDuplicateKey: OnDuplicateKeyNode.create(parseUpdateObject(this.#parseContext, updates)),
+                onDuplicateKey: OnDuplicateKeyNode.create(parseUpdateObject(this.#props.parseContext, updates)),
             }),
         });
     }
@@ -603,14 +602,14 @@ export class QueryBuilder {
         assertCanHaveUpdates(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateObject(this.#parseContext, row)),
+            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateObject(this.#props.parseContext, row)),
         });
     }
     returning(selection) {
         assertCanHaveReturningClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(this.#parseContext, selection)),
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(this.#props.parseContext, selection)),
         });
     }
     /**
@@ -621,7 +620,7 @@ export class QueryBuilder {
         assertCanHaveReturningClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAllArgs()),
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectAll()),
         });
     }
     /**
@@ -714,14 +713,14 @@ export class QueryBuilder {
         assertCanHaveOrderByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, OrderByItemNode.create(parseReferenceExpression(this.#parseContext, orderBy), direction)),
+            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, OrderByItemNode.create(parseReferenceExpression(this.#props.parseContext, orderBy), direction)),
         });
     }
     groupBy(orderBy) {
         assertCanHaveGroupByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseReferenceExpressionOrList(this.#parseContext, orderBy).map(GroupByItemNode.create)),
+            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseReferenceExpressionOrList(this.#props.parseContext, orderBy).map(GroupByItemNode.create)),
         });
     }
     /**
@@ -820,7 +819,8 @@ export class QueryBuilder {
         const compildQuery = this.#props.executor.compileQuery(node, this.#props.queryId);
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
         if (InsertQueryNode.is(node)) {
-            if (this.#props.adapter.supportsReturning && node.returning) {
+            if (this.#props.parseContext.adapter.supportsReturning &&
+                node.returning) {
                 return result.rows;
             }
             else if (result.insertedPrimaryKey != null) {
@@ -831,7 +831,8 @@ export class QueryBuilder {
             }
         }
         else if (UpdateQueryNode.is(node) || DeleteQueryNode.is(node)) {
-            if (this.#props.adapter.supportsReturning && node.returning) {
+            if (this.#props.parseContext.adapter.supportsReturning &&
+                node.returning) {
                 return result.rows;
             }
             else if (result.numUpdatedOrDeletedRows != null) {
@@ -868,9 +869,6 @@ export class QueryBuilder {
         }
         return result;
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }
 preventAwait(QueryBuilder, "don't await QueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
 /**

package/dist/esm/query-builder/type-utils.d.ts

@@ -1,6 +1,6 @@
 import { AliasedRawBuilder, RawBuilder } from '../raw-builder/raw-builder.js';
 import { AliasedQueryBuilder, QueryBuilder } from './query-builder.js';
-import { SubQueryBuilder } from './sub-query-builder.js';
+import { ExpressionBuilder } from './expression-builder.js';
 export declare type ValueType<T> = T[keyof T];
 /**
  * Given a database type and a union of table names returns the row type
@@ -127,10 +127,10 @@ export declare type AnyQueryBuilder = QueryBuilder<any, any, any>;
 export declare type AnyAliasedQueryBuilder = AliasedQueryBuilder<any, any, any, any>;
 export declare type AnyRawBuilder = RawBuilder<any>;
 export declare type AnyAliasedRawBuilder = AliasedRawBuilder<any, any>;
-export declare type QueryBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => QueryBuilder<any, any, any>;
-export declare type AliasedQueryBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => AnyAliasedQueryBuilder;
-export declare type RawBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => AnyRawBuilder;
-export declare type AliasedRawBuilderFactory<DB, TB extends keyof DB> = (qb: SubQueryBuilder<DB, TB>) => AnyAliasedRawBuilder;
+export declare type QueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => QueryBuilder<any, any, any>;
+export declare type AliasedQueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedQueryBuilder;
+export declare type RawBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyRawBuilder;
+export declare type AliasedRawBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedRawBuilder;
 export interface InsertResultTypeTag {
     /** @internal */
     __isInsertResultTypeTag__: true;

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

@@ -2,7 +2,7 @@ import { DataTypeNode } from '../operation-node/data-type-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
-import { isEmpty, getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
+import { getLast, freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sqlFragments = [];
     #bindings = [];
@@ -32,7 +32,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append('select ');
-        if (node.distinctOnSelections && !isEmpty(node.distinctOnSelections)) {
+        if (node.distinctOnSelections) {
             this.compileDistinctOn(node.distinctOnSelections);
             this.append(' ');
         }
@@ -334,6 +334,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' on delete ');
             this.append(node.onDelete);
         }
+        if (node.onUpdate) {
+            this.append(' on update ');
+            this.append(node.onUpdate);
+        }
     }
     visitDropTable(node) {
         this.append('drop table ');
@@ -520,6 +524,14 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.compileList(node.columns);
         this.append(') ');
         this.visitNode(node.references);
+        if (node.onDelete) {
+            this.append(' on delete ');
+            this.append(node.onDelete);
+        }
+        if (node.onUpdate) {
+            this.append(' on update ');
+            this.append(node.onUpdate);
+        }
     }
     visitList(node) {
         this.compileList(node.items);

package/dist/esm/query-creator.d.ts

@@ -5,7 +5,7 @@ import { QueryExecutor } from './query-executor/query-executor.js';
 import { RawBuilder } from './raw-builder/raw-builder.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
-import { DialectAdapter } from './dialect/dialect-adapter.js';
+import { ParseContext } from './parser/parse-context.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -378,7 +378,7 @@ export declare class QueryCreator<DB> {
     raw<T = unknown>(sql: string, params?: any[]): RawBuilder<T>;
 }
 export interface QueryCreatorProps {
-    readonly adapter: DialectAdapter;
     readonly executor: QueryExecutor;
+    readonly parseContext: ParseContext;
     readonly withNode?: WithNode;
 }

package/dist/esm/query-creator.js

@@ -10,7 +10,6 @@ import { WithNode } from './operation-node/with-node.js';
 import { createQueryId } from './util/query-id.js';
 import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';
 import { freeze } from './util/object-utils.js';
-import { createParseContext } from './parser/parse-context.js';
 export class QueryCreator {
     #props;
     constructor(props) {
@@ -20,8 +19,8 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#parseContext, from), this.#props.withNode),
+            parseContext: this.#props.parseContext,
+            queryNode: SelectQueryNode.create(parseTableExpressionOrList(this.#props.parseContext, from), this.#props.withNode),
         });
     }
     /**
@@ -69,7 +68,7 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
+            parseContext: this.#props.parseContext,
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode),
         });
     }
@@ -91,8 +90,8 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: DeleteQueryNode.create(parseTableExpression(this.#parseContext, table), this.#props.withNode),
+            parseContext: this.#props.parseContext,
+            queryNode: DeleteQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
         });
     }
     /**
@@ -117,8 +116,8 @@ export class QueryCreator {
         return new QueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            adapter: this.#props.adapter,
-            queryNode: UpdateQueryNode.create(parseTableExpression(this.#parseContext, table), this.#props.withNode),
+            parseContext: this.#props.parseContext,
+            queryNode: UpdateQueryNode.create(parseTableExpression(this.#props.parseContext, table), this.#props.withNode),
         });
     }
     /**
@@ -144,7 +143,7 @@ export class QueryCreator {
      * ```
      */
     with(name, expression) {
-        const cte = parseCommonTableExpression(this.#parseContext, name, expression);
+        const cte = parseCommonTableExpression(this.#props.parseContext, name, expression);
         return new QueryCreator({
             ...this.#props,
             withNode: this.#props.withNode
@@ -322,7 +321,4 @@ export class QueryCreator {
             executor: this.#props.executor,
         });
     }
-    get #parseContext() {
-        return createParseContext(this.#props.adapter);
-    }
 }

package/dist/esm/schema/alter-table-builder.d.ts

@@ -2,15 +2,16 @@ import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { AlterTableNode } from '../operation-node/alter-table-node.js';
 import { ColumnDataType } from '../operation-node/data-type-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { OnDelete } from '../operation-node/references-node.js';
+import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
-import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { Compilable } from '../util/compilable.js';
 import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
 import { AnyRawBuilder } from '../query-builder/type-utils.js';
 import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
+import { DataTypeExpression } from '../parser/data-type-parser.js';
+import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
 export declare class AlterTableBuilder {
     #private;
     constructor(props: AlterTableBuilderProps);
@@ -19,13 +20,16 @@ export declare class AlterTableBuilder {
     alterColumn(column: string): AlterColumnBuilder;
     dropColumn(column: string): AlterTableExecutor;
     renameColumn(column: string, newColumn: string): AlterTableExecutor;
-    addColumn(columnName: string, dataType: ColumnDataType | RawBuilder): AlterTableAddColumnBuilder;
+    addColumn(columnName: string, dataType: DataTypeExpression): AlterTableAddColumnBuilder;
     /**
      * Creates an `alter table modify column` query. The `modify column` statement
      * is only implemeted by MySQL and oracle AFAIK. On other databases you
      * should use the `alterColumn` method.
      */
-    modifyColumn(columnName: string, dataType: ColumnDataType | RawBuilder): AlterTableModifyColumnBuilder;
+    modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
+    addUniqueConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
+    addCheckConstraint(constraintName: string, checkExpression: string): AlterTableExecutor;
+    addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
     readonly queryId: QueryId;
@@ -53,13 +57,14 @@ export declare class AlterTableExecutor implements OperationNodeSource, Compilab
 }
 export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 }
-export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder> {
+export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
     increments(): AlterTableAddColumnBuilder;
     primaryKey(): AlterTableAddColumnBuilder;
     references(ref: string): AlterTableAddColumnBuilder;
-    onDelete(onDelete: OnDelete): AlterTableAddColumnBuilder;
+    onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
+    onUpdate(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
     unique(): AlterTableAddColumnBuilder;
     notNull(): AlterTableAddColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
@@ -71,13 +76,14 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
 export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps {
     readonly columnBuilder: ColumnDefinitionBuilder;
 }
-export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder> {
+export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder>, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
     increments(): AlterTableModifyColumnBuilder;
     primaryKey(): AlterTableModifyColumnBuilder;
     references(ref: string): AlterTableModifyColumnBuilder;
-    onDelete(onDelete: OnDelete): AlterTableModifyColumnBuilder;
+    onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): AlterTableModifyColumnBuilder;
     unique(): AlterTableModifyColumnBuilder;
     notNull(): AlterTableModifyColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
@@ -89,3 +95,15 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
 export interface AlterTableModifyColumnBuilderProps extends AlterTableBuilderProps {
     readonly columnBuilder: ColumnDefinitionBuilder;
 }
+export declare class AlterTableAddForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<AlterTableAddForeignKeyConstraintBuilder>, OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
+    onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableAddForeignKeyConstraintBuilderProps extends AlterTableBuilderProps {
+    readonly constraintBuilder: ForeignKeyConstraintBuilder;
+}