kysely 0.26.2 → 0.27.0

package/dist/cjs/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/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,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/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/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) {
@@ -297,6 +298,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 +317,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 +419,7 @@ class OperationNodeTransformer {
             using: this.transformNode(node.using),
             ifNotExists: node.ifNotExists,
             where: this.transformNode(node.where),
+            nullsNotDistinct: node.nullsNotDistinct,
         });
     }
     transformList(node) {
@@ -445,6 +449,7 @@ class OperationNodeTransformer {
             kind: 'UniqueConstraintNode',
             columns: this.transformNodeList(node.columns),
             name: this.transformNode(node.name),
+            nullsNotDistinct: node.nullsNotDistinct,
         });
     }
     transformForeignKeyConstraint(node) {
@@ -533,6 +538,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) {
@@ -765,6 +772,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/unique-constraint-node.d.ts

@@ -5,11 +5,14 @@ export interface UniqueConstraintNode extends OperationNode {
     readonly kind: 'UniqueConstraintNode';
     readonly columns: ReadonlyArray<ColumnNode>;
     readonly name?: IdentifierNode;
+    readonly nullsNotDistinct?: boolean;
 }
+export type UniqueConstraintNodeProps = Omit<Partial<UniqueConstraintNode>, 'kind'>;
 /**
  * @internal
  */
 export declare const UniqueConstraintNode: Readonly<{
     is(node: OperationNode): node is UniqueConstraintNode;
-    create(columns: string[], constraintName?: string): UniqueConstraintNode;
+    create(columns: string[], constraintName?: string, nullsNotDistinct?: boolean): UniqueConstraintNode;
+    cloneWith(node: UniqueConstraintNode, props: UniqueConstraintNodeProps): UniqueConstraintNode;
 }>;

package/dist/cjs/operation-node/unique-constraint-node.js

@@ -11,11 +11,18 @@ exports.UniqueConstraintNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'UniqueConstraintNode';
     },
-    create(columns, constraintName) {
+    create(columns, constraintName, nullsNotDistinct) {
         return (0, object_utils_js_1.freeze)({
             kind: 'UniqueConstraintNode',
             columns: (0, object_utils_js_1.freeze)(columns.map(column_node_js_1.ColumnNode.create)),
             name: constraintName ? identifier_node_js_1.IdentifierNode.create(constraintName) : undefined,
+            nullsNotDistinct,
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
         });
     },
 });

package/dist/cjs/parser/binary-operation-parser.js

@@ -41,7 +41,7 @@ exports.parseFilterObject = parseFilterObject;
 function parseFilterList(list, combinator) {
     const combine = combinator === 'and' ? and_node_js_1.AndNode.create : or_node_js_1.OrNode.create;
     if (list.length === 0) {
-        return value_node_js_1.ValueNode.createImmediate(combinator === 'and');
+        return binary_operation_node_js_1.BinaryOperationNode.create(value_node_js_1.ValueNode.createImmediate(1), operator_node_js_1.OperatorNode.create('='), value_node_js_1.ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
     }
     let node = toOperationNode(list[0]);
     for (let i = 1; i < list.length; ++i) {

package/dist/cjs/parser/coalesce-parser.d.ts

@@ -1,2 +1,12 @@
-import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
-export type CoalesceReferenceExpressionList<DB, TB extends keyof DB, RE extends unknown[], O = never> = RE extends [] ? O : RE extends [infer L, ...infer R] ? L extends ReferenceExpression<any, any> ? null extends ExtractTypeFromReferenceExpression<DB, TB, L> ? CoalesceReferenceExpressionList<DB, TB, R extends ReferenceExpression<any, any>[] ? R : never, O | ExtractTypeFromReferenceExpression<DB, TB, L>> : Exclude<O, null> | ExtractTypeFromReferenceExpression<DB, TB, L> : never : never;
+import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+export type ExtractTypeFromCoalesce1<DB, TB extends keyof DB, R1> = ExtractTypeFromReferenceExpression<DB, TB, R1>;
+export type ExtractTypeFromCoalesce2<DB, TB extends keyof DB, R1, R2> = ExtractTypeFromCoalesceValues2<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>>;
+type ExtractTypeFromCoalesceValues2<V1, V2> = null extends V1 ? null extends V2 ? V1 | V2 : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce3<DB, TB extends keyof DB, R1, R2, R3> = ExtractTypeFromCoalesceValues3<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>>;
+type ExtractTypeFromCoalesceValues3<V1, V2, V3> = null extends V1 ? null extends V2 ? null extends V3 ? V1 | V2 | V3 : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce4<DB, TB extends keyof DB, R1, R2, R3, R4> = ExtractTypeFromCoalesceValues4<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>>;
+type ExtractTypeFromCoalesceValues4<V1, V2, V3, V4> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? V1 | V2 | V3 | V4 : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = ExtractTypeFromCoalesceValues5<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>, ExtractTypeFromReferenceExpression<DB, TB, R5>>;
+type ExtractTypeFromCoalesceValues5<V1, V2, V3, V4, V5> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? null extends V5 ? V1 | V2 | V3 | V4 | V5 : NotNull<V1 | V2 | V3 | V4 | V5> : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+type NotNull<T> = Exclude<T, null>;
+export {};

package/dist/cjs/parser/expression-parser.d.ts

@@ -2,13 +2,13 @@ import { AliasedExpression, Expression } from '../expression/expression.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OperationNode } from '../operation-node/operation-node.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 /**
  * Like `Expression<V>` but also accepts a select query with an output
  * type extending `Record<string, V>`. This type is useful because SQL
  * treats records with a single column as single values.
  */
-export type OperandExpression<V> = Expression<V> | SelectQueryBuilder<any, any, Record<string, V>>;
+export type OperandExpression<V> = Expression<V> | SelectQueryBuilderExpression<Record<string, V>>;
 export type ExpressionOrFactory<DB, TB extends keyof DB, V> = OperandExpression<V> | OperandExpressionFactory<DB, TB, V>;
 export type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
 export type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;

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

@@ -2,7 +2,7 @@ import { AliasNode } from '../operation-node/alias-node.js';
 import { ColumnNode } from '../operation-node/column-node.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
-import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import { ExpressionOrFactory } from './expression-parser.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { SelectType } from '../util/column-type.js';
@@ -16,7 +16,8 @@ export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyCo
 export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
 export type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
 export type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
-export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? SelectType<ExtractTypeFromStringReference<DB, TB, RE>> : RE extends SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilder<any, any, infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
+export type ExtractRawTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
 export type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
 export type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
 export type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;

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

@@ -1,6 +1,7 @@
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
-import { Selection, AllSelection } from './select-parser.js';
+import { Selection, AllSelection, CallbackSelection } from './select-parser.js';
 export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult ? Selection<DB, TB, SE> : O extends DeleteResult ? Selection<DB, TB, SE> : O extends UpdateResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
+export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult ? CallbackSelection<DB, TB, CB> : O extends DeleteResult ? CallbackSelection<DB, TB, CB> : O extends UpdateResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
 export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult ? AllSelection<DB, TB> : O extends DeleteResult ? AllSelection<DB, TB> : O extends UpdateResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

package/dist/cjs/parser/select-parser.d.ts

@@ -3,23 +3,34 @@ import { SelectionNode } from '../operation-node/selection-node.js';
 import { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, ExtractColumnType } from '../util/type-utils.js';
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
 import { AliasedExpressionOrFactory } from './expression-parser.js';
-import { Selectable, SelectType } from '../util/column-type.js';
+import { SelectType } from '../util/column-type.js';
 import { AliasedExpression } from '../expression/expression.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 export type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
+export type SelectCallback<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SelectExpression<DB, TB>>;
+/**
+ * Turns a SelectExpression or a union of them into a selection object.
+ */
+export type Selection<DB, TB extends keyof DB, SE> = [DB] extends [unknown] ? {
+    [E in FlattenSelectExpression<SE> as ExtractAliasFromSelectExpression<E>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, E>>;
+} : {};
+/**
+ * Turns a SelectCallback into a selection object.
+ */
+export type CallbackSelection<DB, TB extends keyof DB, CB> = CB extends (eb: any) => ReadonlyArray<infer SE> ? Selection<DB, TB, SE> : never;
 export type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
-export type Selection<DB, TB extends keyof DB, SE> = DrainOuterGeneric<{
-    [A in ExtractAliasFromSelectExpression<SE>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, SE, A>>;
-}>;
+type FlattenSelectExpression<SE> = SE extends DynamicReferenceBuilder<infer RA> ? {
+    [R in RA]: DynamicReferenceBuilder<R>;
+}[RA] : SE;
 type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
 type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
-type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE, A extends keyof any> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE, A> : SE extends AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends (qb: any) => AliasedSelectQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O[keyof O] | null : never : SE extends AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends (qb: any) => AliasedExpression<infer O, infer EA> ? EA extends A ? O : never : SE extends DynamicReferenceBuilder<infer RA> ? A extends ExtractAliasFromStringSelectExpression<RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA, A> | undefined : never : never;
-type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string, A extends keyof any> = SE extends `${infer SC}.${infer T}.${infer C} as ${infer RA}` ? RA extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C} as ${infer RA}` ? RA extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends `${infer C} as ${infer RA}` ? RA extends A ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : never : SE extends `${infer SC}.${infer T}.${infer C}` ? C extends A ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : never : SE extends `${infer T}.${infer C}` ? C extends A ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : never : SE extends A ? SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never : never;
-export type AllSelection<DB, TB extends keyof DB> = DrainOuterGeneric<Selectable<{
+type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE> : SE extends AliasedSelectQueryBuilder<infer O, any> ? O[keyof O] | null : SE extends (eb: any) => AliasedSelectQueryBuilder<infer O, any> ? O[keyof O] | null : SE extends AliasedExpression<infer O, any> ? O : SE extends (eb: any) => AliasedExpression<infer O, any> ? O : SE extends DynamicReferenceBuilder<infer RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA> | undefined : never;
+type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string> = SE extends `${infer SC}.${infer T}.${infer C} as ${string}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : SE extends `${infer T}.${infer C} as ${string}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : SE extends `${infer C} as ${string}` ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : SE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : SE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never;
+export type AllSelection<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [C in AnyColumn<DB, TB>]: {
-        [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+        [T in TB]: SelectType<C extends keyof DB[T] ? DB[T][C] : never>;
     }[TB];
-}>>;
+}>;
 export declare function parseSelectArg(selection: SelectArg<any, any, SelectExpression<any, any>>): SelectionNode[];
 export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
 export {};

package/dist/cjs/parser/update-set-parser.d.ts

@@ -2,9 +2,12 @@ import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { ExpressionBuilder } from '../expression/expression-builder.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
+import { ExtractRawTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
 export type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
     [C in UpdateKeys<DB[UT]>]?: ValueExpression<DB, TB, UpdateType<DB[UT][C]>> | undefined;
 };
 export type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
-export type UpdateExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
-export declare function parseUpdateExpression(update: UpdateExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;
+export type UpdateObjectExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
+export type ExtractUpdateTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = UpdateType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
+export declare function parseUpdate(...args: [UpdateObjectExpression<any, any, any>] | [ReferenceExpression<any, any>, ValueExpression<any, any, any>]): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObjectExpression(update: UpdateObjectExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;