kysely 0.26.2 → 0.27.0

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

@@ -173,8 +173,8 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * )
      * ```
      */
-    or<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
-    or(expression: OperandExpression<SqlBool>): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
+    or<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
+    or<E extends OperandExpression<SqlBool>>(expression: E): T extends SqlBool ? OrWrapper<DB, TB, SqlBool> : KyselyTypeError<'or() method can only be called on boolean expressions'>;
     /**
      * Combines `this` and another expression using `AND`.
      *
@@ -235,8 +235,8 @@ export declare class ExpressionWrapper<DB, TB extends keyof DB, T> implements Al
      * )
      * ```
      */
-    and<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
-    and(expression: OperandExpression<SqlBool>): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
+    and<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
+    and<E extends OperandExpression<SqlBool>>(expression: E): T extends SqlBool ? AndWrapper<DB, TB, SqlBool> : KyselyTypeError<'and() method can only be called on boolean expressions'>;
     /**
      * Change the output type of the expression.
      *
@@ -389,8 +389,8 @@ export declare class OrWrapper<DB, TB extends keyof DB, T extends SqlBool> imple
      *
      * See {@link ExpressionWrapper.or} for examples.
      */
-    or<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): OrWrapper<DB, TB, T>;
-    or(expression: OperandExpression<SqlBool>): OrWrapper<DB, TB, T>;
+    or<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): OrWrapper<DB, TB, T>;
+    or<E extends OperandExpression<SqlBool>>(expression: E): OrWrapper<DB, TB, T>;
     /**
      * Change the output type of the expression.
      *
@@ -525,8 +525,8 @@ export declare class AndWrapper<DB, TB extends keyof DB, T extends SqlBool> impl
      *
      * See {@link ExpressionWrapper.and} for examples.
      */
-    and<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): AndWrapper<DB, TB, T>;
-    and(expression: OperandExpression<SqlBool>): AndWrapper<DB, TB, T>;
+    and<RE extends ReferenceExpression<DB, TB>, VE extends OperandValueExpressionOrList<DB, TB, RE>>(lhs: RE, op: ComparisonOperatorExpression, rhs: VE): AndWrapper<DB, TB, T>;
+    and<E extends OperandExpression<SqlBool>>(expression: E): AndWrapper<DB, TB, T>;
     /**
      * Change the output type of the expression.
      *

package/dist/esm/helpers/mssql.d.ts

@@ -0,0 +1,152 @@
+import { Expression } from '../expression/expression.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Simplify } from '../util/type-utils.js';
+/**
+ * An MS SQL Server helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *         .modifyEnd(sql`offset 0 rows`)
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce((select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *     offset 0 rows
+ *   ) as "agg" for json path, include_null_values), '[]')
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>[]>;
+/**
+ * An MS SQL Server helper for turning a subquery into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', 1)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = @1
+ *   ) as "agg" for json path, include_null_values, without_array_wrapper
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O> | null>;
+/**
+ * The MS SQL Server `json_query` function, single argument variant.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: eb.fn('concat', ['first_name', eb.val(' '), 'last_name'])
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", json_query(
+ *   '{"first":"'+"first_name"+',"last":"'+"last_name"+',"full":"'+concat("first_name", ' ', "last_name")+'"}'
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
+    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+}>>;

package/dist/esm/helpers/mssql.js

@@ -0,0 +1,155 @@
+/// <reference types="./mssql.d.ts" />
+import { sql } from '../raw-builder/sql.js';
+/**
+ * An MS SQL Server helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *         .modifyEnd(sql`offset 0 rows`)
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce((select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *     offset 0 rows
+ *   ) as "agg" for json path, include_null_values), '[]')
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export function jsonArrayFrom(expr) {
+    return sql `coalesce((select * from ${expr} as agg for json path, include_null_values), '[]')`;
+}
+/**
+ * An MS SQL Server helper for turning a subquery into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', 1)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", (
+ *   select * from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = @1
+ *   ) as "agg" for json path, include_null_values, without_array_wrapper
+ * ) as "favorite_pet"
+ * from "person"
+ * ```
+ */
+export function jsonObjectFrom(expr) {
+    return sql `(select * from ${expr} as agg for json path, include_null_values, without_array_wrapper)`;
+}
+/**
+ * The MS SQL Server `json_query` function, single argument variant.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new MssqlDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: eb.fn('concat', ['first_name', eb.val(' '), 'last_name'])
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ * ```
+ *
+ * The generated SQL (MS SQL Server):
+ *
+ * ```sql
+ * select "id", json_query(
+ *   '{"first":"'+"first_name"+',"last":"'+"last_name"+',"full":"'+concat("first_name", ' ', "last_name")+'"}'
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export function jsonBuildObject(obj) {
+    return sql `json_query('{${sql.join(Object.keys(obj).map((k) => sql `"${sql.raw(k)}":"'+${obj[k]}+'"`), sql `,`)}}')`;
+}

package/dist/esm/helpers/mysql.d.ts

@@ -1,5 +1,5 @@
 import { Expression } from '../expression/expression.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { Simplify } from '../util/type-utils.js';
 /**
@@ -48,7 +48,7 @@ import { Simplify } from '../util/type-utils.js';
  * from `person`
  * ```
  */
-export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>[]>;
+export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O>[]>;
 /**
  * A MySQL helper for turning a subquery into a JSON object.
  *
@@ -97,7 +97,7 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>):
  * from `person`
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O> | null>;
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O> | null>;
 /**
  * The MySQL `json_object` function.
  *

package/dist/esm/helpers/sqlite.d.ts

@@ -1,5 +1,5 @@
 import { Expression } from '../expression/expression.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { Simplify } from '../util/type-utils.js';
 /**
@@ -55,7 +55,7 @@ import { Simplify } from '../util/type-utils.js';
  * from "person"
  * ```
  */
-export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>[]>;
+export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O>[]>;
 /**
  * A SQLite helper for turning a subquery into a JSON object.
  *
@@ -111,7 +111,7 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>):
  * from "person";
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O> | null>;
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O> | null>;
 /**
  * The SQLite `json_object` function.
  *

package/dist/esm/index.d.ts

@@ -72,6 +72,12 @@ export * from './dialect/postgres/postgres-dialect.js';
 export * from './dialect/sqlite/sqlite-query-compiler.js';
 export * from './dialect/sqlite/sqlite-introspector.js';
 export * from './dialect/sqlite/sqlite-adapter.js';
+export * from './dialect/mssql/mssql-adapter.js';
+export * from './dialect/mssql/mssql-dialect-config.js';
+export * from './dialect/mssql/mssql-dialect.js';
+export * from './dialect/mssql/mssql-driver.js';
+export * from './dialect/mssql/mssql-introspector.js';
+export * from './dialect/mssql/mssql-query-compiler.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migrator.js';
@@ -176,10 +182,10 @@ export * from './util/compilable.js';
 export * from './util/explainable.js';
 export * from './util/streamable.js';
 export * from './util/log.js';
-export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, AnySelectQueryBuilder, Equals, UnknownRow, Simplify, SqlBool, } from './util/type-utils.js';
+export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NotNull, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
-export { SelectExpression, SelectArg, Selection, } from './parser/select-parser.js';
+export { SelectExpression, SelectCallback, SelectArg, Selection, CallbackSelection, } from './parser/select-parser.js';
 export { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
 export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
 export { TableExpression, TableExpressionOrList, } from './parser/table-parser.js';

package/dist/esm/index.js

@@ -73,6 +73,12 @@ export * from './dialect/postgres/postgres-dialect.js';
 export * from './dialect/sqlite/sqlite-query-compiler.js';
 export * from './dialect/sqlite/sqlite-introspector.js';
 export * from './dialect/sqlite/sqlite-adapter.js';
+export * from './dialect/mssql/mssql-adapter.js';
+export * from './dialect/mssql/mssql-dialect-config.js';
+export * from './dialect/mssql/mssql-dialect.js';
+export * from './dialect/mssql/mssql-driver.js';
+export * from './dialect/mssql/mssql-introspector.js';
+export * from './dialect/mssql/mssql-query-compiler.js';
 export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/query-compiler.js';
 export * from './migration/migrator.js';

package/dist/esm/migration/migrator.js

@@ -218,10 +218,7 @@ export class Migrator {
         }
         if (!(await this.#doesSchemaExists())) {
             try {
-                await this.#props.db.schema
-                    .createSchema(this.#migrationTableSchema)
-                    .ifNotExists()
-                    .execute();
+                await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
             }
             catch (error) {
                 // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
@@ -237,20 +234,15 @@ export class Migrator {
         if (!(await this.#doesTableExists(this.#migrationTable))) {
             try {
                 if (this.#migrationTableSchema) {
-                    await this.#props.db.schema
-                        .createSchema(this.#migrationTableSchema)
-                        .ifNotExists()
-                        .execute();
+                    await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
                 }
-                await this.#props.db.schema
+                await this.#createIfNotExists(this.#props.db.schema
                     .withPlugin(this.#schemaPlugin)
                     .createTable(this.#migrationTable)
-                    .ifNotExists()
                     .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
                     // The migration run time as ISO string. This is not a real date type as we
                     // can't know which data type is supported by all future dialects.
-                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull())
-                    .execute();
+                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
             }
             catch (error) {
                 // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
@@ -265,13 +257,11 @@ export class Migrator {
     async #ensureMigrationLockTableExists() {
         if (!(await this.#doesTableExists(this.#migrationLockTable))) {
             try {
-                await this.#props.db.schema
+                await this.#createIfNotExists(this.#props.db.schema
                     .withPlugin(this.#schemaPlugin)
                     .createTable(this.#migrationLockTable)
-                    .ifNotExists()
                     .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
-                    .execute();
+                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
             }
             catch (error) {
                 // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
@@ -479,6 +469,12 @@ export class Migrator {
         }
         return { results };
     }
+    async #createIfNotExists(qb) {
+        if (this.#props.db.getExecutor().adapter.supportsCreateIfNotExists) {
+            qb = qb.ifNotExists();
+        }
+        await qb.execute();
+    }
 }
 class MigrationResultSetError extends Error {
     #resultSet;

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

@@ -0,0 +1,21 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export type AddIndexNodeProps = Omit<AddIndexNode, 'kind' | 'name'>;
+export interface AddIndexNode extends OperationNode {
+    readonly kind: 'AddIndexNode';
+    readonly name: IdentifierNode;
+    readonly columns?: OperationNode[];
+    readonly unique?: boolean;
+    readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const AddIndexNode: Readonly<{
+    is(node: OperationNode): node is AddIndexNode;
+    create(name: string): AddIndexNode;
+    cloneWith(node: AddIndexNode, props: AddIndexNodeProps): AddIndexNode;
+    cloneWithColumns(node: AddIndexNode, columns: OperationNode[]): AddIndexNode;
+}>;

package/dist/esm/operation-node/add-index-node.js

@@ -0,0 +1,29 @@
+/// <reference types="./add-index-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+import { IdentifierNode } from './identifier-node.js';
+/**
+ * @internal
+ */
+export const AddIndexNode = freeze({
+    is(node) {
+        return node.kind === 'AddIndexNode';
+    },
+    create(name) {
+        return freeze({
+            kind: 'AddIndexNode',
+            name: IdentifierNode.create(name)
+        });
+    },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumns(node, columns) {
+        return freeze({
+            ...node,
+            columns: [...(node.columns || []), ...columns],
+        });
+    },
+});

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

@@ -8,7 +8,9 @@ import { AlterColumnNode } from './alter-column-node.js';
 import { AddConstraintNode } from './add-constraint-node.js';
 import { DropConstraintNode } from './drop-constraint-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
-export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint'>;
+import { DropIndexNode } from './drop-index-node.js';
+import { AddIndexNode } from './add-index-node.js';
+export type AlterTableNodeTableProps = Pick<AlterTableNode, 'renameTo' | 'setSchema' | 'addConstraint' | 'dropConstraint' | 'addIndex' | 'dropIndex'>;
 export type AlterTableColumnAlterationNode = RenameColumnNode | AddColumnNode | DropColumnNode | AlterColumnNode | ModifyColumnNode;
 export interface AlterTableNode extends OperationNode {
     readonly kind: 'AlterTableNode';
@@ -18,6 +20,8 @@ export interface AlterTableNode extends OperationNode {
     readonly columnAlterations?: ReadonlyArray<AlterTableColumnAlterationNode>;
     readonly addConstraint?: AddConstraintNode;
     readonly dropConstraint?: DropConstraintNode;
+    readonly addIndex?: AddIndexNode;
+    readonly dropIndex?: DropIndexNode;
 }
 /**
  * @internal

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

@@ -20,6 +20,7 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly unsigned?: boolean;
     readonly frontModifiers?: ReadonlyArray<OperationNode>;
     readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly nullsNotDistinct?: boolean;
 }
 /**
  * @internal

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

@@ -1,8 +1,7 @@
-import { ColumnNode } from './column-node.js';
 import { OperationNode } from './operation-node.js';
 export interface ColumnUpdateNode extends OperationNode {
     readonly kind: 'ColumnUpdateNode';
-    readonly column: ColumnNode;
+    readonly column: OperationNode;
     readonly value: OperationNode;
 }
 /**
@@ -10,5 +9,5 @@ export interface ColumnUpdateNode extends OperationNode {
  */
 export declare const ColumnUpdateNode: Readonly<{
     is(node: OperationNode): node is ColumnUpdateNode;
-    create(column: ColumnNode, value: OperationNode): ColumnUpdateNode;
+    create(column: OperationNode, value: OperationNode): ColumnUpdateNode;
 }>;

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

@@ -14,6 +14,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly using?: RawNode;
     readonly ifNotExists?: boolean;
     readonly where?: WhereNode;
+    readonly nullsNotDistinct?: boolean;
 }
 /**
  * @internal

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

@@ -16,6 +16,7 @@ export interface CreateTableNode extends OperationNode {
     readonly onCommit?: OnCommitAction;
     readonly frontModifiers?: ReadonlyArray<OperationNode>;
     readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly selectQuery?: OperationNode;
 }
 /**
  * @internal

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

@@ -85,6 +85,7 @@ import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
 import { TupleNode } from './tuple-node.js';
+import { AddIndexNode } from './add-index-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -199,6 +200,7 @@ export declare class OperationNodeTransformer {
     protected transformJSONPathLeg(node: JSONPathLegNode): JSONPathLegNode;
     protected transformJSONOperatorChain(node: JSONOperatorChainNode): JSONOperatorChainNode;
     protected transformTuple(node: TupleNode): TupleNode;
+    protected transformAddIndex(node: AddIndexNode): AddIndexNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;