kysely 0.26.3 → 0.27.1

package/dist/cjs/helpers/mssql.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonBuildObject = exports.jsonObjectFrom = exports.jsonArrayFrom = void 0;
+const sql_js_1 = require("../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"
+ * ```
+ */
+function jsonArrayFrom(expr) {
+    return (0, sql_js_1.sql) `coalesce((select * from ${expr} as agg for json path, include_null_values), '[]')`;
+}
+exports.jsonArrayFrom = jsonArrayFrom;
+/**
+ * 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"
+ * ```
+ */
+function jsonObjectFrom(expr) {
+    return (0, sql_js_1.sql) `(select * from ${expr} as agg for json path, include_null_values, without_array_wrapper)`;
+}
+exports.jsonObjectFrom = jsonObjectFrom;
+/**
+ * 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"
+ * ```
+ */
+function jsonBuildObject(obj) {
+    return (0, sql_js_1.sql) `json_query('{${sql_js_1.sql.join(Object.keys(obj).map((k) => (0, sql_js_1.sql) `"${sql_js_1.sql.raw(k)}":"'+${obj[k]}+'"`), (0, sql_js_1.sql) `,`)}}')`;
+}
+exports.jsonBuildObject = jsonBuildObject;

package/dist/cjs/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,7 +182,7 @@ 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, 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, SelectCallback, SelectArg, Selection, CallbackSelection, } from './parser/select-parser.js';

package/dist/cjs/index.js

@@ -90,6 +90,12 @@ __exportStar(require("./dialect/postgres/postgres-dialect.js"), exports);
 __exportStar(require("./dialect/sqlite/sqlite-query-compiler.js"), exports);
 __exportStar(require("./dialect/sqlite/sqlite-introspector.js"), exports);
 __exportStar(require("./dialect/sqlite/sqlite-adapter.js"), exports);
+__exportStar(require("./dialect/mssql/mssql-adapter.js"), exports);
+__exportStar(require("./dialect/mssql/mssql-dialect-config.js"), exports);
+__exportStar(require("./dialect/mssql/mssql-dialect.js"), exports);
+__exportStar(require("./dialect/mssql/mssql-driver.js"), exports);
+__exportStar(require("./dialect/mssql/mssql-introspector.js"), exports);
+__exportStar(require("./dialect/mssql/mssql-query-compiler.js"), exports);
 __exportStar(require("./query-compiler/default-query-compiler.js"), exports);
 __exportStar(require("./query-compiler/query-compiler.js"), exports);
 __exportStar(require("./migration/migrator.js"), exports);

package/dist/cjs/migration/migrator.js

@@ -220,10 +220,7 @@ 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`
@@ -239,20 +236,15 @@ 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`
@@ -267,13 +259,11 @@ 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`
@@ -481,6 +471,12 @@ class Migrator {
         }
         return { results };
     }
+    async #createIfNotExists(qb) {
+        if (this.#props.db.getExecutor().adapter.supportsCreateIfNotExists) {
+            qb = qb.ifNotExists();
+        }
+        await qb.execute();
+    }
 }
 exports.Migrator = Migrator;
 class MigrationResultSetError extends Error {

package/dist/cjs/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/cjs/operation-node/add-index-node.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddIndexNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.AddIndexNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'AddIndexNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'AddIndexNode',
+            name: identifier_node_js_1.IdentifierNode.create(name)
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+    cloneWithColumns(node, columns) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            columns: [...(node.columns || []), ...columns],
+        });
+    },
+});

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/operation-node/insert-query-node.d.ts

@@ -19,6 +19,7 @@ export interface InsertQueryNode extends OperationNode {
     readonly ignore?: boolean;
     readonly replace?: boolean;
     readonly explain?: ExplainNode;
+    readonly defaultValues?: boolean;
 }
 /**
  * @internal

package/dist/cjs/operation-node/limit-node.d.ts

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { ValueNode } from './value-node.js';
 export interface LimitNode extends OperationNode {
     readonly kind: 'LimitNode';
-    readonly limit: ValueNode;
+    readonly limit: OperationNode;
 }
 /**
  * @internal
  */
 export declare const LimitNode: Readonly<{
     is(node: OperationNode): node is LimitNode;
-    create(limit: number): LimitNode;
+    create(limit: OperationNode): LimitNode;
 }>;

package/dist/cjs/operation-node/limit-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LimitNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const value_node_js_1 = require("./value-node.js");
 /**
  * @internal
  */
@@ -13,7 +12,7 @@ exports.LimitNode = (0, object_utils_js_1.freeze)({
     create(limit) {
         return (0, object_utils_js_1.freeze)({
             kind: 'LimitNode',
-            limit: value_node_js_1.ValueNode.create(limit),
+            limit,
         });
     },
 });

package/dist/cjs/operation-node/offset-node.d.ts

@@ -1,13 +1,12 @@
 import { OperationNode } from './operation-node.js';
-import { ValueNode } from './value-node.js';
 export interface OffsetNode extends OperationNode {
     readonly kind: 'OffsetNode';
-    readonly offset: ValueNode;
+    readonly offset: OperationNode;
 }
 /**
  * @internal
  */
 export declare const OffsetNode: Readonly<{
     is(node: OperationNode): node is OffsetNode;
-    create(offset: number): OffsetNode;
+    create(offset: OperationNode): OffsetNode;
 }>;

package/dist/cjs/operation-node/offset-node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OffsetNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const value_node_js_1 = require("./value-node.js");
 /**
  * @internal
  */
@@ -13,7 +12,7 @@ exports.OffsetNode = (0, object_utils_js_1.freeze)({
     create(offset) {
         return (0, object_utils_js_1.freeze)({
             kind: 'OffsetNode',
-            offset: value_node_js_1.ValueNode.create(offset),
+            offset,
         });
     },
 });

package/dist/cjs/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;

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -121,6 +121,7 @@ class OperationNodeTransformer {
         JSONPathLegNode: this.transformJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
         TupleNode: this.transformTuple.bind(this),
+        AddIndexNode: this.transformAddIndex.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -258,6 +259,7 @@ class OperationNodeTransformer {
             ignore: node.ignore,
             replace: node.replace,
             explain: this.transformNode(node.explain),
+            defaultValues: node.defaultValues,
         });
     }
     transformValues(node) {
@@ -297,6 +299,7 @@ class OperationNodeTransformer {
             onCommit: node.onCommit,
             frontModifiers: this.transformNodeList(node.frontModifiers),
             endModifiers: this.transformNodeList(node.endModifiers),
+            selectQuery: this.transformNode(node.selectQuery),
         });
     }
     transformColumnDefinition(node) {
@@ -315,6 +318,7 @@ class OperationNodeTransformer {
             generated: this.transformNode(node.generated),
             frontModifiers: this.transformNodeList(node.frontModifiers),
             endModifiers: this.transformNodeList(node.endModifiers),
+            nullsNotDistinct: node.nullsNotDistinct,
         });
     }
     transformAddColumn(node) {
@@ -416,6 +420,7 @@ class OperationNodeTransformer {
             using: this.transformNode(node.using),
             ifNotExists: node.ifNotExists,
             where: this.transformNode(node.where),
+            nullsNotDistinct: node.nullsNotDistinct,
         });
     }
     transformList(node) {
@@ -445,6 +450,7 @@ class OperationNodeTransformer {
             kind: 'UniqueConstraintNode',
             columns: this.transformNodeList(node.columns),
             name: this.transformNode(node.name),
+            nullsNotDistinct: node.nullsNotDistinct,
         });
     }
     transformForeignKeyConstraint(node) {
@@ -533,6 +539,8 @@ class OperationNodeTransformer {
             columnAlterations: this.transformNodeList(node.columnAlterations),
             addConstraint: this.transformNode(node.addConstraint),
             dropConstraint: this.transformNode(node.dropConstraint),
+            addIndex: this.transformNode(node.addIndex),
+            dropIndex: this.transformNode(node.dropIndex),
         });
     }
     transformDropColumn(node) {
@@ -628,6 +636,7 @@ class OperationNodeTransformer {
             kind: 'SelectModifierNode',
             modifier: node.modifier,
             rawModifier: this.transformNode(node.rawModifier),
+            of: this.transformNodeList(node.of),
         });
     }
     transformCreateType(node) {
@@ -765,6 +774,16 @@ class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
         });
     }
+    transformAddIndex(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'AddIndexNode',
+            name: this.transformNode(node.name),
+            columns: this.transformNodeList(node.columns),
+            unique: node.unique,
+            using: this.transformNode(node.using),
+            ifNotExists: node.ifNotExists,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/cjs/operation-node/operation-node-visitor.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';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -176,4 +177,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitJSONPathLeg(node: JSONPathLegNode): void;
     protected abstract visitJSONOperatorChain(node: JSONOperatorChainNode): void;
     protected abstract visitTuple(node: TupleNode): void;
+    protected abstract visitAddIndex(node: AddIndexNode): void;
 }

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

@@ -94,6 +94,7 @@ class OperationNodeVisitor {
         JSONPathLegNode: this.visitJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
         TupleNode: this.visitTuple.bind(this),
+        AddIndexNode: this.visitAddIndex.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | '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' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode';
+export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | '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' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode' | 'AddIndexNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/operator-node.d.ts

@@ -1,11 +1,11 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
 export declare const JSON_OPERATORS: readonly ["->", "->>"];
-export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare const UNARY_OPERATORS: readonly ["not", "-", "exists", "not exists"];
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
 export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
 export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
 export type JSONOperator = (typeof JSON_OPERATORS)[number];

package/dist/cjs/operation-node/operator-node.js

@@ -37,6 +37,8 @@ exports.COMPARISON_OPERATORS = [
     '!!',
     '<->',
     'regexp',
+    'is distinct from',
+    'is not distinct from',
 ];
 exports.ARITHMETIC_OPERATORS = [
     '+',

package/dist/cjs/operation-node/select-modifier-node.d.ts

@@ -4,12 +4,13 @@ export interface SelectModifierNode extends OperationNode {
     readonly kind: 'SelectModifierNode';
     readonly modifier?: SelectModifier;
     readonly rawModifier?: OperationNode;
+    readonly of?: ReadonlyArray<OperationNode>;
 }
 /**
  * @internal
  */
 export declare const SelectModifierNode: Readonly<{
     is(node: OperationNode): node is SelectModifierNode;
-    create(modifier: SelectModifier): SelectModifierNode;
+    create(modifier: SelectModifier, of?: ReadonlyArray<OperationNode>): SelectModifierNode;
     createWithExpression(modifier: OperationNode): SelectModifierNode;
 }>;