make distinct on accept any expression

src/operation-node/operation-node-transformer.ts

@@ -223,7 +223,7 @@ export class OperationNodeTransformer {
       kind: 'SelectQueryNode',
       from: this.transformNode(node.from),
       selections: this.transformNodeList(node.selections),
-      distinctOnSelections: this.transformNodeList(node.distinctOnSelections),
+      distinctOn: this.transformNodeList(node.distinctOn),
       joins: this.transformNodeList(node.joins),
       groupBy: this.transformNode(node.groupBy),
       orderBy: this.transformNode(node.orderBy),

src/operation-node/select-query-node.ts

@@ -15,13 +15,12 @@ import { WithNode } from './with-node.js'
 import { SelectModifierNode } from './select-modifier-node.js'
 import { ExplainNode } from './explain-node.js'
 import { SetOperationNode } from './set-operation-node.js'
-import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js'
 
 export interface SelectQueryNode extends OperationNode {
   readonly kind: 'SelectQueryNode'
   readonly from: FromNode
   readonly selections?: ReadonlyArray<SelectionNode>
-  readonly distinctOnSelections?: ReadonlyArray<SimpleReferenceExpressionNode>
+  readonly distinctOn?: ReadonlyArray<OperationNode>
   readonly joins?: ReadonlyArray<JoinNode>
   readonly groupBy?: GroupByNode
   readonly orderBy?: OrderByNode
@@ -67,15 +66,15 @@ export const SelectQueryNode = freeze({
     })
   },
 
-  cloneWithDistinctOnSelections(
+  cloneWithDistinctOn(
     select: SelectQueryNode,
-    selections: ReadonlyArray<SimpleReferenceExpressionNode>
+    expressions: ReadonlyArray<OperationNode>
   ): SelectQueryNode {
     return freeze({
       ...select,
-      distinctOnSelections: select.distinctOnSelections
-        ? freeze([...select.distinctOnSelections, ...selections])
-        : freeze(selections),
+      distinctOn: select.distinctOn
+        ? freeze([...select.distinctOn, ...expressions])
+        : freeze(expressions),
     })
   },
 

src/parser/expression-parser.ts

@@ -6,7 +6,6 @@ import {
 import { AliasNode } from '../operation-node/alias-node.js'
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js'
 import { OperationNode } from '../operation-node/operation-node.js'
-import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js'
 import { ExpressionBuilder } from '../query-builder/expression-builder.js'
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js'
 import { isFunction } from '../util/object-utils.js'
@@ -30,13 +29,11 @@ export type AliasedExpressionOrFactory<DB, TB extends keyof DB> =
 
 export function parseExpression(
   exp: ExpressionOrFactory<any, any, any>
-): SimpleReferenceExpressionNode {
+): OperationNode {
   if (isOperationNodeSource(exp)) {
-    return exp.toOperationNode() as SimpleReferenceExpressionNode
+    return exp.toOperationNode()
   } else if (isFunction(exp)) {
-    return exp(
-      createExpressionBuilder()
-    ).toOperationNode() as SimpleReferenceExpressionNode
+    return exp(createExpressionBuilder()).toOperationNode()
   }
 
   throw new Error(`invalid expression: ${JSON.stringify(exp)}`)

src/parser/partition-by-parser.ts

@@ -1,8 +1,6 @@
 import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js'
-import { ColumnNode } from '../operation-node/column-node.js'
-import { GroupByItemNode } from '../operation-node/group-by-item-node.js'
 import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js'
-import { ReferenceNode } from '../operation-node/reference-node.js'
+import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js'
 import {
   parseReferenceExpressionOrList,
   StringReference,
@@ -20,9 +18,8 @@ export function parsePartitionBy(
   partitionBy: PartitionByExpressionOrList<any, any>
 ): PartitionByItemNode[] {
   return (
-    parseReferenceExpressionOrList(partitionBy) as (
-      | ColumnNode
-      | ReferenceNode
-    )[]
+    parseReferenceExpressionOrList(
+      partitionBy
+    ) as SimpleReferenceExpressionNode[]
   ).map(PartitionByItemNode.create)
 }

src/parser/reference-parser.ts

@@ -22,6 +22,10 @@ import { OperationNode } from '../operation-node/operation-node.js'
 import { Expression } from '../expression/expression.js'
 import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js'
 
+export type StringReference<DB, TB extends keyof DB> =
+  | AnyColumn<DB, TB>
+  | AnyColumnWithTable<DB, TB>
+
 export type SimpleReferenceExpression<DB, TB extends keyof DB> =
   | StringReference<DB, TB>
   | DynamicReferenceBuilder<any>
@@ -34,10 +38,6 @@ export type ReferenceExpressionOrList<DB, TB extends keyof DB> =
   | ReferenceExpression<DB, TB>
   | ReadonlyArray<ReferenceExpression<DB, TB>>
 
-export type StringReference<DB, TB extends keyof DB> =
-  | AnyColumn<DB, TB>
-  | AnyColumnWithTable<DB, TB>
-
 export type ExtractTypeFromReferenceExpression<
   DB,
   TB extends keyof DB,
@@ -88,7 +88,7 @@ export function parseSimpleReferenceExpression(
 
 export function parseReferenceExpressionOrList(
   arg: ReferenceExpressionOrList<any, any>
-): SimpleReferenceExpressionNode[] {
+): OperationNode[] {
   if (isReadonlyArray(arg)) {
     return arg.map((it) => parseReferenceExpression(it))
   } else {
@@ -98,7 +98,7 @@ export function parseReferenceExpressionOrList(
 
 export function parseReferenceExpression(
   exp: ReferenceExpression<any, any>
-): SimpleReferenceExpressionNode {
+): OperationNode {
   if (isExpressionOrFactory(exp)) {
     return parseExpression(exp)
   }

src/query-builder/select-query-builder.ts

@@ -493,11 +493,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
   }
 
   /**
-   * Adds `distinct on` selections to the select clause.
-   *
-   * Takes the same inputs as the {@link SelectQueryBuilder.select | select} method.
-   * See the {@link SelectQueryBuilder.select | select} method's documentation for
-   * more examples.
+   * Adds `distinct on` expressions to the select clause.
    *
    * ### Examples
    *
@@ -530,7 +526,7 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
   distinctOn(selection: ReferenceExpressionOrList<DB, TB>): any {
     return new SelectQueryBuilder({
       ...this.#props,
-      queryNode: SelectQueryNode.cloneWithDistinctOnSelections(
+      queryNode: SelectQueryNode.cloneWithDistinctOn(
         this.#props.queryNode,
         parseReferenceExpressionOrList(selection)
       ),

src/query-compiler/default-query-compiler.ts

@@ -93,7 +93,6 @@ import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js
 import { SetOperationNode } from '../operation-node/set-operation-node.js'
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js'
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js'
-import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js'
 
 export class DefaultQueryCompiler
   extends OperationNodeVisitor
@@ -146,8 +145,8 @@ export class DefaultQueryCompiler
 
     this.append('select ')
 
-    if (node.distinctOnSelections) {
-      this.compileDistinctOn(node.distinctOnSelections)
+    if (node.distinctOn) {
+      this.compileDistinctOn(node.distinctOn)
       this.append(' ')
     }
 
@@ -226,11 +225,9 @@ export class DefaultQueryCompiler
     this.visitNode(node.column)
   }
 
-  protected compileDistinctOn(
-    selections: ReadonlyArray<SimpleReferenceExpressionNode>
-  ): void {
+  protected compileDistinctOn(expressions: ReadonlyArray<OperationNode>): void {
     this.append('distinct on (')
-    this.compileList(selections)
+    this.compileList(expressions)
     this.append(')')
   }
 

src/schema/alter-column-builder.ts

@@ -3,7 +3,6 @@ import {
   ColumnDataType,
   DataTypeNode,
 } from '../operation-node/data-type-node.js'
-import { OperationNode } from '../operation-node/operation-node.js'
 import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import {
   DefaultValueExpression,

src/schema/alter-table-builder.ts

@@ -31,7 +31,6 @@ import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.j
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js'
 import { ForeignKeyConstraintNode } from '../operation-node/foreign-key-constraint-node.js'
 import { ColumnNode } from '../operation-node/column-node.js'
-import { DefaultValueExpression } from '../parser/default-value-parser.js'
 import { parseTable } from '../parser/table-parser.js'
 import { DropConstraintNode } from '../operation-node/drop-constraint-node.js'
 import { Expression } from '../expression/expression.js'