Interim

src/core/Column.ts

@@ -1,8 +1,8 @@
-import {input, type Input} from './Expr.ts'
-import type {Field, FieldData} from './Field.ts'
 import type {HasColumn, HasSql} from './Internal.ts'
 import {getField, internalColumn} from './Internal.ts'
 import type {Sql} from './Sql.ts'
+import type {Field, FieldData} from './expr/Field.ts'
+import {input, type Input} from './expr/Input.ts'
 
 export class ColumnData {
   type!: Sql

src/core/Constraint.ts

@@ -1,4 +1,3 @@
-import type {Field, FieldData} from './Field.ts'
 import {
   getData,
   getField,
@@ -8,6 +7,7 @@ import {
   type HasData
 } from './Internal.ts'
 import {sql} from './Sql.ts'
+import type {Field, FieldData} from './expr/Field.ts'
 
 export interface UniqueConstraintData {
   fields: Array<FieldData>

src/core/Emitter.ts

@@ -1,5 +1,4 @@
 import type {ColumnData} from './Column.ts'
-import type {FieldData} from './Field.ts'
 import {
   getData,
   getQuery,
@@ -11,6 +10,7 @@ import {
 } from './Internal.ts'
 import {ValueParam, type Param} from './Param.ts'
 import {sql} from './Sql.ts'
+import type {FieldData} from './expr/Field.ts'
 import type {Create} from './query/CreateTable.ts'
 import type {Delete} from './query/Delete.ts'
 import type {Drop} from './query/DropTable.ts'

src/core/Index.ts

@@ -1,11 +1,11 @@
-import type {Field, FieldData} from './Field.ts'
 import {
   getData,
   getField,
   internalData,
   type HasData,
   type HasSql
 } from './Internal.ts'
+import type {Field, FieldData} from './expr/Field.ts'
 
 export interface IndexData {
   fields: Array<FieldData>

src/core/Internal.ts

@@ -1,10 +1,10 @@
 import type {ColumnData} from './Column.ts'
-import type {FieldData} from './Field.ts'
 import type {QueryMeta} from './MetaData.ts'
 import type {Resolver} from './Resolver.ts'
 import type {Selection} from './Selection.ts'
 import type {Sql} from './Sql.ts'
 import type {TableApi, TableDefinition} from './Table.ts'
+import type {FieldData} from './expr/Field.ts'
 
 export const internalData = Symbol()
 export const internalSql = Symbol()

src/core/Selection.ts

@@ -57,7 +57,8 @@ export class Selection implements HasSql {
     const expr = this.#exprOf(input)
     if (expr) {
       const value = values.shift()
-      if (expr.mapFromDriverValue) return expr.mapFromDriverValue(value)
+      if (value !== null && expr.mapFromDriverValue)
+        return expr.mapFromDriverValue(value)
       return value
     }
     const result: Record<string, unknown> = {}

src/core/Sql.ts

@@ -1,6 +1,6 @@
 import type {Emitter} from './Emitter.ts'
-import type {FieldData} from './Field.ts'
 import {getSql, internalSql, type HasSql} from './Internal.ts'
+import type {FieldData} from './expr/Field.ts'
 
 type EmitMethods = {
   [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K]

src/core/Table.ts

@@ -4,8 +4,6 @@ import type {
   PrimaryKeyConstraint,
   UniqueConstraint
 } from './Constraint.ts'
-import {jsonExpr, type Input, type JsonExpr} from './Expr.ts'
-import {Field} from './Field.ts'
 import type {Index} from './Index.ts'
 import {
   getColumn,
@@ -20,6 +18,9 @@ import {
   type HasTarget
 } from './Internal.ts'
 import {sql, type Sql} from './Sql.ts'
+import {jsonExpr, type JsonExpr} from './expr/Conditions.ts'
+import {Field} from './expr/Field.ts'
+import type {Input} from './expr/Input.ts'
 
 const {assign, fromEntries, entries} = Object
 

src/core/Virtual.ts

@@ -1,6 +1,6 @@
-import {Field} from './Field.ts'
 import {getSql, hasSql} from './Internal.ts'
 import type {SelectionInput} from './Selection.ts'
+import {Field} from './expr/Field.ts'
 
 export function virtual<Input extends SelectionInput>(
   alias: string,

src/core/expr/Aggregate.ts

@@ -0,0 +1,36 @@
+import {getSql, type HasSql} from '../Internal.ts'
+import {sql, type Sql} from '../Sql.ts'
+import {distinct} from './Conditions.ts'
+import {Functions} from './Functions.ts'
+
+export function count(input?: HasSql): Sql<number> {
+  return Functions.count(input ?? sql`*`).mapWith(Number)
+}
+
+export function countDistinct(input: HasSql): Sql<number> {
+  return Functions.count(distinct(input)).mapWith(Number)
+}
+
+export function avg(input: HasSql): Sql<string | null> {
+  return Functions.avg(input).mapWith(String)
+}
+
+export function avgDistinct(input: HasSql): Sql<string | null> {
+  return Functions.avg(distinct(input)).mapWith(String)
+}
+
+export function sum(input: HasSql): HasSql<string | null> {
+  return Functions.sum(input).mapWith(String)
+}
+
+export function sumDistinct(input: HasSql): HasSql<string | null> {
+  return Functions.sum(distinct(input)).mapWith(String)
+}
+
+export function max<T>(input: HasSql<T>) {
+  return Functions.max(input).mapWith(getSql(input))
+}
+
+export function min<T>(input: HasSql<T>) {
+  return Functions.min(input).mapWith(getSql(input))
+}

src/core/Expr.ts → src/core/expr/Conditions.ts

@@ -1,14 +1,6 @@
-import {getSql, getTable, hasSql, hasTable, type HasSql} from './Internal.ts'
-import {sql, type Sql} from './Sql.ts'
-
-export type Input<T = unknown> = HasSql<T> | T
-
-export function input<T>(value: Input<T>): HasSql<T> {
-  if (typeof value !== 'object' || value === null) return sql.value(value)
-  if (hasTable(value)) return sql.identifier(getTable(value).name)
-  if (hasSql(value)) return getSql(value) as Sql<T>
-  return sql.value(value)
-}
+import type {HasSql} from '../Internal.ts'
+import {sql, type Sql} from '../Sql.ts'
+import {type Input, input} from './Input.ts'
 
 export function eq<T>(left: Input<T>, right: Input<T>): HasSql<boolean> {
   return sql`${input(left)} = ${input(right)}`
@@ -148,12 +140,16 @@ export function arrayOverlaps<T>(
   return sql`${input(left)} && ${input(right)}`
 }
 
-export function asc<T>(column: HasSql<T>): Sql {
-  return sql`${column} asc`
+export function asc<T>(input: HasSql<T>): Sql {
+  return sql`${input} asc`
+}
+
+export function desc<T>(input: HasSql<T>): Sql {
+  return sql`${input} desc`
 }
 
-export function desc<T>(column: HasSql<T>): Sql {
-  return sql`${column} desc`
+export function distinct<T>(input: HasSql<T>): Sql {
+  return sql`distinct ${input}`
 }
 
 export interface JsonArrayHasSql<Value> extends HasSql<Value> {

src/core/Field.ts → src/core/expr/Field.ts

@@ -1,5 +1,5 @@
-import {internalField, internalSql, type HasSql} from './Internal.ts'
-import {sql, type Sql} from './Sql.ts'
+import {internalField, internalSql, type HasSql} from '../Internal.ts'
+import {sql, type Sql} from '../Sql.ts'
 
 export interface FieldData {
   targetName: string

src/core/expr/Functions.ts

@@ -0,0 +1,14 @@
+import {sql, type Sql} from '../Sql.ts'
+import {input, type Input} from './Input.ts'
+
+function get(target: Record<string, Function>, method: string) {
+  return (target[method] ??= (...args: Array<Input<unknown>>) => {
+    return sql`${sql.identifier(method)}(${sql.join(args.map(input), sql`, `)})`
+  })
+}
+
+export const Functions = <Functions>new Proxy(Object.create(null), {get})
+
+export type Functions = {
+  [key: string]: (...args: Array<Input<any>>) => Sql<any>
+}

src/core/expr/Input.ts

@@ -0,0 +1,11 @@
+import {getSql, getTable, hasSql, hasTable, type HasSql} from '../Internal.ts'
+import {sql, type Sql} from '../Sql.ts'
+
+export type Input<T = unknown> = HasSql<T> | T
+
+export function input<T>(value: Input<T>): HasSql<T> {
+  if (typeof value !== 'object' || value === null) return sql.value(value)
+  if (hasTable(value)) return sql.identifier(getTable(value).name)
+  if (hasSql(value)) return getSql(value) as Sql<T>
+  return sql.value(value)
+}

src/core/query/Insert.ts

@@ -1,4 +1,3 @@
-import {input, type Input} from '../Expr.ts'
 import {
   getColumn,
   getData,
@@ -24,6 +23,7 @@ import type {
   TableRow,
   TableUpdate
 } from '../Table.ts'
+import {input, type Input} from '../expr/Input.ts'
 
 class InsertIntoData<Meta extends QueryMeta> extends QueryData<Meta> {
   into!: HasTable

src/core/query/Select.ts

@@ -1,5 +1,3 @@
-import {input, type Input as UserInput} from '../Expr.ts'
-import type {Field} from '../Field.ts'
 import {
   getData,
   getQuery,
@@ -29,6 +27,8 @@ import {
 import {sql} from '../Sql.ts'
 import type {Table, TableDefinition, TableFields} from '../Table.ts'
 import type {Expand} from '../Types.ts'
+import type {Field} from '../expr/Field.ts'
+import {input, type Input as UserInput} from '../expr/Input.ts'
 import {Union} from './Union.ts'
 
 export type SelectionType = 'selection' | 'allFrom' | 'joinTables'

src/core/query/Update.ts

@@ -1,4 +1,3 @@
-import {input} from '../Expr.ts'
 import {
   getData,
   internalData,
@@ -17,6 +16,7 @@ import {
 } from '../Selection.ts'
 import {sql, type Sql} from '../Sql.ts'
 import type {TableDefinition, TableUpdate} from '../Table.ts'
+import {input} from '../expr/Input.ts'
 
 export class UpdateData<
   Meta extends QueryMeta = QueryMeta

src/index.ts

@@ -2,12 +2,12 @@ export * from './core/Column.ts'
 export * from './core/Constraint.ts'
 export * from './core/Database.ts'
 export * from './core/Driver.ts'
-export * from './core/Expr.ts'
 export * from './core/Index.ts'
 export * from './core/Query.ts'
 export * from './core/Selection.ts'
 export * from './core/Sql.ts'
 export * from './core/Table.ts'
+export * from './core/expr/Conditions.ts'
 export * from './core/query/CreateTable.ts'
 export * from './core/query/Delete.ts'
 export * from './core/query/Insert.ts'