kysely 0.27.6 → 0.28.0

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

@@ -8,7 +8,6 @@ import { parseReferenceExpressionOrList, } from '../parser/reference-parser.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { parseOrderBy, } from '../parser/order-by-parser.js';
-import { preventAwait } from '../util/prevent-await.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { OffsetNode } from '../operation-node/offset-node.js';
 import { asArray, freeze } from '../util/object-utils.js';
@@ -129,45 +128,45 @@ class SelectQueryBuilderImpl {
         });
     }
     innerJoin(...args) {
-        return new SelectQueryBuilderImpl({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('InnerJoin', args)),
-        });
+        return this.#join('InnerJoin', args);
     }
     leftJoin(...args) {
-        return new SelectQueryBuilderImpl({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LeftJoin', args)),
-        });
+        return this.#join('LeftJoin', args);
     }
     rightJoin(...args) {
-        return new SelectQueryBuilderImpl({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('RightJoin', args)),
-        });
+        return this.#join('RightJoin', args);
     }
     fullJoin(...args) {
-        return new SelectQueryBuilderImpl({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
-        });
+        return this.#join('FullJoin', args);
+    }
+    crossJoin(...args) {
+        return this.#join('CrossJoin', args);
     }
     innerJoinLateral(...args) {
-        return new SelectQueryBuilderImpl({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralInnerJoin', args)),
-        });
+        return this.#join('LateralInnerJoin', args);
     }
     leftJoinLateral(...args) {
+        return this.#join('LateralLeftJoin', args);
+    }
+    crossJoinLateral(...args) {
+        return this.#join('LateralCrossJoin', args);
+    }
+    crossApply(...args) {
+        return this.#join('CrossApply', args);
+    }
+    outerApply(...args) {
+        return this.#join('OuterApply', args);
+    }
+    #join(joinType, args) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralLeftJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args)),
         });
     }
     orderBy(...args) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args)),
+            queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args)),
         });
     }
     groupBy(groupBy) {
@@ -266,7 +265,7 @@ class SelectQueryBuilderImpl {
     clearOrderBy() {
         return new SelectQueryBuilderImpl({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithoutOrderBy(this.#props.queryNode),
+            queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode),
         });
     }
     clearGroupBy() {
@@ -298,6 +297,9 @@ class SelectQueryBuilderImpl {
     $asTuple() {
         return new ExpressionWrapper(this.toOperationNode());
     }
+    $asScalar() {
+        return new ExpressionWrapper(this.toOperationNode());
+    }
     withPlugin(plugin) {
         return new SelectQueryBuilderImpl({
             ...this.#props,
@@ -344,7 +346,6 @@ class SelectQueryBuilderImpl {
         return await builder.execute();
     }
 }
-preventAwait(SelectQueryBuilderImpl, "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");
 export function createSelectQueryBuilder(props) {
     return new SelectQueryBuilderImpl(props);
 }
@@ -371,4 +372,3 @@ class AliasedSelectQueryBuilderImpl {
         return AliasNode.create(this.#queryBuilder.toOperationNode(), IdentifierNode.create(this.#alias));
     }
 }
-preventAwait(AliasedSelectQueryBuilderImpl, "don't await AliasedSelectQueryBuilder instances directly. AliasedSelectQueryBuilder should never be executed directly since it's always a part of another query.");

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

@@ -15,7 +15,7 @@ import { QueryId } from '../util/query-id.js';
 import { UpdateResult } from './update-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { WhereInterface } from './where-interface.js';
-import { ReturningInterface } from './returning-interface.js';
+import { MultiTableReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Explainable, ExplainFormat } from '../util/explainable.js';
 import { AliasedExpression, Expression } from '../expression/expression.js';
@@ -25,7 +25,9 @@ import { Streamable } from '../util/streamable.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
 import { ValueExpression } from '../parser/value-parser.js';
 import { OutputCallback, OutputExpression, OutputInterface, OutputPrefix, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
-export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
+import { OrderByInterface } from './order-by-interface.js';
+import { DirectedOrderByStringReference, OrderByExpression, OrderByModifiers } from '../parser/order-by-parser.js';
+export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, MultiTableReturningInterface<DB, TB, O>, OutputInterface<DB, TB, O>, OrderByInterface<DB, TB, never>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: UpdateQueryBuilderProps);
     /**
@@ -599,6 +601,50 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      */
     fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
     fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): UpdateQueryBuilderWithFullJoin<DB, UT, TB, O, TE>;
+    /**
+     * @description This is only supported by some dialects like MySQL or SQLite with `SQLITE_ENABLE_UPDATE_DELETE_LIMIT`.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers?: OrderByModifiers): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * @description This is only supported by some dialects like MySQL or SQLite with `SQLITE_ENABLE_UPDATE_DELETE_LIMIT`.
+     * @deprecated It does ~2-2.6x more compile-time instantiations compared to multiple chained `orderBy(expr, modifiers?)` calls (in `order by` clauses with reasonable item counts), and has broken autocompletion.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}> | DirectedOrderByStringReference<DB, TB, {}>>(exprs: ReadonlyArray<OE>): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * @description This is only supported by some dialects like MySQL or SQLite with `SQLITE_ENABLE_UPDATE_DELETE_LIMIT`.
+     * @deprecated It does ~2.9x more compile-time instantiations compared to a `orderBy(expr, direction)` call.
+     */
+    orderBy<OE extends DirectedOrderByStringReference<DB, TB, {}>>(expr: OE): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * @description This is only supported by some dialects like MySQL or SQLite with `SQLITE_ENABLE_UPDATE_DELETE_LIMIT`.
+     * @deprecated Use `orderBy(expr, (ob) => ...)` instead.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers: Expression<any>): UpdateQueryBuilder<DB, UT, TB, O>;
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * See {@link orderBy} for adding an `order by` clause or item to a query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const query = db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .orderBy('id', 'desc')
+     *
+     * const results = await query
+     *   .clearOrderBy()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearOrderBy(): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a limit clause to the update query for supported databases, such as MySQL.
      *
@@ -651,8 +697,6 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   })
      *   .where('id', '=', 1)
      *   .executeTakeFirst()
-     *
-     * console.log(result.numUpdatedRows)
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -676,8 +720,6 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   }))
      *   .where('id', '=', 1)
      *   .executeTakeFirst()
-     *
-     * console.log(result.numUpdatedRows)
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -762,6 +804,43 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * "last_name" = $3 || $4
      * where "id" = $5
      * ```
+     *
+     * <!-- siteExample("update", "MySQL joins", 30) -->
+     *
+     * MySQL allows you to join tables directly to the "main" table and update
+     * rows of all joined tables. This is possible by passing all tables to the
+     * `updateTable` method as a list and adding the `ON` conditions as `WHERE`
+     * statements. You can then use the `set(column, value)` variant to update
+     * columns using table qualified names.
+     *
+     * The `UpdateQueryBuilder` also has `innerJoin` etc. join methods, but those
+     * can only be used as part of a PostgreSQL `update set from join` query.
+     * Due to type complexity issues, we unfortunately can't make the same
+     * methods work in both cases.
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable(['person', 'pet'])
+     *   .set('person.first_name', 'Updated person')
+     *   .set('pet.name', 'Updated doggo')
+     *   .whereRef('person.id', '=', 'pet.owner_id')
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * update
+     *   `person`,
+     *   `pet`
+     * set
+     *   `person`.`first_name` = ?,
+     *   `pet`.`name` = ?
+     * where
+     *   `person`.`id` = `pet`.`owner_id`
+     *   and `person`.`id` = ?
+     * ```
      */
     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>;
@@ -769,7 +848,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * Allows you to return data from modified rows.
      *
      * On supported databases like PostgreSQL, this method can be chained to
-     * `insert`, `update` and `delete` queries to return data.
+     * `insert`, `update`, `delete` and `merge` queries to return data.
      *
      * Note that on SQLite you need to give aliases for the expressions to avoid
      * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
@@ -828,8 +907,8 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
     returning<CB extends SelectCallback<DB, TB>>(callback: CB): UpdateQueryBuilder<DB, UT, TB, ReturningCallbackRow<DB, TB, O, CB>>;
     returning<SE extends SelectExpression<DB, TB>>(selection: SE): UpdateQueryBuilder<DB, UT, TB, ReturningRow<DB, TB, O, SE>>;
     /**
-     * Adds a `returning *` to an insert/update/delete query on databases
-     * that support `returning` such as PostgreSQL.
+     * Adds a `returning *` or `returning table.*` to an insert/update/delete/merge
+     * query on databases that support `returning` such as PostgreSQL.
      *
      * Also see the {@link returning} method.
      */

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

@@ -5,7 +5,6 @@ import { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { parseUpdate, } from '../parser/update-set-parser.js';
-import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
 import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
@@ -13,6 +12,7 @@ import { parseReferentialBinaryOperation, parseValueBinaryOperationOrExpression,
 import { parseValueExpression, } from '../parser/value-parser.js';
 import { LimitNode } from '../operation-node/limit-node.js';
 import { parseTop } from '../parser/top-parser.js';
+import { parseOrderBy, } from '../parser/order-by-parser.js';
 export class UpdateQueryBuilder {
     #props;
     constructor(props) {
@@ -88,27 +88,33 @@ export class UpdateQueryBuilder {
         });
     }
     innerJoin(...args) {
-        return new UpdateQueryBuilder({
-            ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('InnerJoin', args)),
-        });
+        return this.#join('InnerJoin', args);
     }
     leftJoin(...args) {
+        return this.#join('LeftJoin', args);
+    }
+    rightJoin(...args) {
+        return this.#join('RightJoin', args);
+    }
+    fullJoin(...args) {
+        return this.#join('FullJoin', args);
+    }
+    #join(joinType, args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LeftJoin', args)),
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin(joinType, args)),
         });
     }
-    rightJoin(...args) {
+    orderBy(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('RightJoin', args)),
+            queryNode: QueryNode.cloneWithOrderByItems(this.#props.queryNode, parseOrderBy(args)),
         });
     }
-    fullJoin(...args) {
+    clearOrderBy() {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
+            queryNode: QueryNode.cloneWithoutOrderBy(this.#props.queryNode),
         });
     }
     /**
@@ -458,10 +464,7 @@ export class UpdateQueryBuilder {
             return result.rows;
         }
         return [
-            new UpdateResult(
-            // TODO: remove numUpdatedOrDeletedRows.
-            // TODO: https://github.com/kysely-org/kysely/pull/431#discussion_r1172330899
-            result.numAffectedRows ?? result.numUpdatedOrDeletedRows ?? BigInt(0), result.numChangedRows),
+            new UpdateResult(result.numAffectedRows ?? BigInt(0), result.numChangedRows),
         ];
     }
     /**
@@ -505,4 +508,3 @@ export class UpdateQueryBuilder {
         return await builder.execute();
     }
 }
-preventAwait(UpdateQueryBuilder, "don't await UpdateQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

package/dist/esm/query-compiler/compiled-query.d.ts

@@ -1,6 +1,8 @@
+import { QueryId } from '../util/query-id.js';
 import { RootOperationNode } from './query-compiler.js';
 export interface CompiledQuery<O = unknown> {
     readonly query: RootOperationNode;
+    readonly queryId: QueryId;
     readonly sql: string;
     readonly parameters: ReadonlyArray<unknown>;
 }

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

@@ -1,12 +1,14 @@
 /// <reference types="./compiled-query.d.ts" />
 import { RawNode } from '../operation-node/raw-node.js';
 import { freeze } from '../util/object-utils.js';
+import { createQueryId } from '../util/query-id.js';
 export const CompiledQuery = freeze({
     raw(sql, parameters = []) {
         return freeze({
             sql,
             query: RawNode.createWithSql(sql),
             parameters: freeze(parameters),
+            queryId: createQueryId(),
         });
     },
 });

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -35,7 +35,7 @@ import { SelectAllNode } from '../operation-node/select-all-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { SelectionNode } from '../operation-node/selection-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { PrimaryKeyConstraintNode } from '../operation-node/primary-constraint-node.js';
+import { PrimaryKeyConstraintNode } from '../operation-node/primary-key-constraint-node.js';
 import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { ValueListNode } from '../operation-node/value-list-node.js';
@@ -95,10 +95,15 @@ import { CastNode } from '../operation-node/cast-node.js';
 import { FetchNode } from '../operation-node/fetch-node.js';
 import { TopNode } from '../operation-node/top-node.js';
 import { OutputNode } from '../operation-node/output-node.js';
+import { RefreshMaterializedViewNode } from '../operation-node/refresh-materialized-view-node.js';
+import { OrActionNode } from '../operation-node/or-action-node.js';
+import { CollateNode } from '../operation-node/collate-node.js';
+import { QueryId } from '../util/query-id.js';
+import { RenameConstraintNode } from '../operation-node/rename-constraint-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
-    compileQuery(node: RootOperationNode): CompiledQuery;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
     protected getSql(): string;
     protected visitSelectQuery(node: SelectQueryNode): void;
     protected visitFrom(node: FromNode): void;
@@ -151,6 +156,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitCreateSchema(node: CreateSchemaNode): void;
     protected visitDropSchema(node: DropSchemaNode): void;
     protected visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
+    protected buildDeferrable(node: {
+        deferrable?: boolean;
+        initiallyDeferred?: boolean;
+    }): void;
     protected visitUniqueConstraint(node: UniqueConstraintNode): void;
     protected visitCheckConstraint(node: CheckConstraintNode): void;
     protected visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
@@ -166,8 +175,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitModifyColumn(node: ModifyColumnNode): void;
     protected visitAddConstraint(node: AddConstraintNode): void;
     protected visitDropConstraint(node: DropConstraintNode): void;
+    protected visitRenameConstraint(node: RenameConstraintNode): void;
     protected visitSetOperation(node: SetOperationNode): void;
     protected visitCreateView(node: CreateViewNode): void;
+    protected visitRefreshMaterializedView(node: RefreshMaterializedViewNode): void;
     protected visitDropView(node: DropViewNode): void;
     protected visitGenerated(node: GeneratedNode): void;
     protected visitDefaultValue(node: DefaultValueNode): void;
@@ -198,6 +209,8 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitFetch(node: FetchNode): void;
     protected visitOutput(node: OutputNode): void;
     protected visitTop(node: TopNode): void;
+    protected visitOrAction(node: OrActionNode): void;
+    protected visitCollate(node: CollateNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
@@ -208,8 +221,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getExplainOptionsDelimiter(): string;
     protected getRightExplainOptionsWrapper(): string;
     protected sanitizeIdentifier(identifier: string): string;
+    protected sanitizeStringLiteral(value: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
+    protected appendStringLiteral(value: string): void;
     protected sortSelectModifiers(arr: SelectModifierNode[]): ReadonlyArray<SelectModifierNode>;
     protected compileColumnAlterations(columnAlterations: readonly AlterTableColumnAlterationNode[]): void;
     /**

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

@@ -9,19 +9,22 @@ import { freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { SetOperationNode } from '../operation-node/set-operation-node.js';
 import { MergeQueryNode } from '../operation-node/merge-query-node.js';
+import { logOnce } from '../util/log-once.js';
+const LIT_WRAP_REGEX = /'/g;
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sql = '';
     #parameters = [];
     get numParameters() {
         return this.#parameters.length;
     }
-    compileQuery(node) {
+    compileQuery(node, queryId) {
         this.#sql = '';
         this.#parameters = [];
         this.nodeStack.splice(0, this.nodeStack.length);
         this.visitNode(node);
         return freeze({
             query: node,
+            queryId,
             sql: this.getSql(),
             parameters: [...this.#parameters],
         });
@@ -159,9 +162,15 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
         }
         this.append(node.replace ? 'replace' : 'insert');
+        // TODO: remove in 0.29.
         if (node.ignore) {
+            logOnce('`InsertQueryNode.ignore` is deprecated. Use `InsertQueryNode.orAction` instead.');
             this.append(' ignore');
         }
+        if (node.orAction) {
+            this.append(' ');
+            this.visitNode(node.orAction);
+        }
         if (node.top) {
             this.append(' ');
             this.visitNode(node.top);
@@ -498,10 +507,18 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitOrderByItem(node) {
         this.visitNode(node.orderBy);
+        if (node.collation) {
+            this.append(' ');
+            this.visitNode(node.collation);
+        }
         if (node.direction) {
             this.append(' ');
             this.visitNode(node.direction);
         }
+        if (node.nulls) {
+            this.append(' nulls ');
+            this.append(node.nulls);
+        }
     }
     visitGroupBy(node) {
         this.append('group by ');
@@ -546,6 +563,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.from);
         }
         if (node.joins) {
+            if (!node.from) {
+                throw new Error("Joins in an update query are only supported as a part of a PostgreSQL 'update set from join' query. If you want to create a MySQL 'update join set' query, see https://kysely.dev/docs/examples/update/my-sql-joins");
+            }
             this.append(' ');
             this.compileList(node.joins, ' ');
         }
@@ -553,6 +573,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.where);
         }
+        if (node.orderBy) {
+            this.append(' ');
+            this.visitNode(node.orderBy);
+        }
         if (node.limit) {
             this.append(' ');
             this.visitNode(node.limit);
@@ -689,6 +713,25 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append('primary key (');
         this.compileList(node.columns);
         this.append(')');
+        this.buildDeferrable(node);
+    }
+    buildDeferrable(node) {
+        if (node.deferrable !== undefined) {
+            if (node.deferrable) {
+                this.append(' deferrable');
+            }
+            else {
+                this.append(' not deferrable');
+            }
+        }
+        if (node.initiallyDeferred !== undefined) {
+            if (node.initiallyDeferred) {
+                this.append(' initially deferred');
+            }
+            else {
+                this.append(' initially immediate');
+            }
+        }
     }
     visitUniqueConstraint(node) {
         if (node.name) {
@@ -703,6 +746,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.append(' (');
         this.compileList(node.columns);
         this.append(')');
+        this.buildDeferrable(node);
     }
     visitCheckConstraint(node) {
         if (node.name) {
@@ -732,6 +776,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' on update ');
             this.append(node.onUpdate);
         }
+        this.buildDeferrable(node);
     }
     visitList(node) {
         this.compileList(node.items);
@@ -780,6 +825,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.dropConstraint) {
             this.visitNode(node.dropConstraint);
         }
+        if (node.renameConstraint) {
+            this.visitNode(node.renameConstraint);
+        }
         if (node.columnAlterations) {
             this.compileColumnAlterations(node.columnAlterations);
         }
@@ -853,6 +901,12 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' restrict');
         }
     }
+    visitRenameConstraint(node) {
+        this.append('rename constraint ');
+        this.visitNode(node.oldName);
+        this.append(' to ');
+        this.visitNode(node.newName);
+    }
     visitSetOperation(node) {
         this.append(node.operator);
         this.append(' ');
@@ -888,6 +942,19 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.as);
         }
     }
+    visitRefreshMaterializedView(node) {
+        this.append('refresh materialized view ');
+        if (node.concurrently) {
+            this.append('concurrently ');
+        }
+        this.visitNode(node.name);
+        if (node.withNoData) {
+            this.append(' with no data');
+        }
+        else {
+            this.append(' with data');
+        }
+    }
     visitDropView(node) {
         this.append('drop ');
         if (node.materialized) {
@@ -988,6 +1055,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.orderBy);
         }
         this.append(')');
+        if (node.withinGroup) {
+            this.append(' within group (');
+            this.visitNode(node.withinGroup);
+            this.append(')');
+        }
         if (node.filter) {
             this.append(' filter(');
             this.visitNode(node.filter);
@@ -1125,6 +1197,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.compileList(node.whens, ' ');
         }
+        if (node.returning) {
+            this.append(' ');
+            this.visitNode(node.returning);
+        }
         if (node.output) {
             this.append(' ');
             this.visitNode(node.output);
@@ -1182,6 +1258,13 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(` ${node.modifiers}`);
         }
     }
+    visitOrAction(node) {
+        this.append(node.action);
+    }
+    visitCollate(node) {
+        this.append('collate ');
+        this.visitNode(node.collation);
+    }
     append(str) {
         this.#sql += str;
     }
@@ -1225,12 +1308,15 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         return sanitized;
     }
+    sanitizeStringLiteral(value) {
+        return value.replace(LIT_WRAP_REGEX, "''");
+    }
     addParameter(parameter) {
         this.#parameters.push(parameter);
     }
     appendImmediateValue(value) {
         if (isString(value)) {
-            this.append(`'${value}'`);
+            this.appendStringLiteral(value);
         }
         else if (isNumber(value) || isBoolean(value)) {
             this.append(value.toString());
@@ -1248,6 +1334,11 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             throw new Error(`invalid immediate value ${value}`);
         }
     }
+    appendStringLiteral(value) {
+        this.append("'");
+        this.append(this.sanitizeStringLiteral(value));
+        this.append("'");
+    }
     sortSelectModifiers(arr) {
         arr.sort((left, right) => left.modifier && right.modifier
             ? SELECT_MODIFIER_PRIORITY[left.modifier] -
@@ -1289,7 +1380,11 @@ const JOIN_TYPE_SQL = freeze({
     LeftJoin: 'left join',
     RightJoin: 'right join',
     FullJoin: 'full join',
+    CrossJoin: 'cross join',
     LateralInnerJoin: 'inner join lateral',
     LateralLeftJoin: 'left join lateral',
+    LateralCrossJoin: 'cross join lateral',
+    OuterApply: 'outer apply',
+    CrossApply: 'cross apply',
     Using: 'using',
 });