effect-qb 0.20.0 → 0.22.0

package/src/mysql/internal/dsl.ts

@@ -4,6 +4,7 @@ import * as Schema from "effect/Schema"
 import { mysqlDatatypes } from "../datatypes/index.js"
 
 import * as Expression from "../../internal/scalar.js"
+import type * as FunctionConstraint from "../../internal/function-constraints.js"
 import * as Plan from "../../internal/row-set.js"
 import * as Table from "../../internal/table.js"
 import type {
@@ -133,6 +134,7 @@ import type { FormulaOfPredicate } from "../../internal/predicate/normalize.js"
 import type { TrueFormula } from "../../internal/predicate/formula.js"
 import { assumeFormulaTrue, formulaOfExpression as formulaOfExpressionRuntime, trueFormula } from "../../internal/predicate/runtime.js"
 import { dedupeGroupedExpressions } from "../../internal/grouping-key.js"
+import { validateWindowFrame } from "../../internal/window-frame.js"
 import { makeDslMutationRuntime } from "../../internal/dsl-mutation-runtime.js"
 import { makeDslPlanRuntime } from "../../internal/dsl-plan-runtime.js"
 import { makeDslQueryRuntime } from "../../internal/dsl-query-runtime.js"
@@ -1440,6 +1442,7 @@ type WindowSpecInput<
 > = {
   readonly partitionBy?: PartitionBy
   readonly orderBy?: OrderBy
+  readonly frame?: ExpressionAst.WindowFrameNode<"rows" | "range">
 }
 
 type OrderedWindowSpecInput<
@@ -1448,6 +1451,7 @@ type OrderedWindowSpecInput<
 > = {
   readonly partitionBy?: PartitionBy
   readonly orderBy: OrderBy
+  readonly frame?: never
 }
 
 type WindowOrderExpressionTuple<
@@ -1520,8 +1524,8 @@ type NumberWindowExpression<
   PartitionBy extends readonly WindowPartitionInput[],
   OrderBy extends NonEmptyWindowOrderTerms
 > = AstBackedExpression<
-  number,
-  Expression.DbType.Any,
+  RuntimeOfDbType<ReturnType<typeof mysqlDatatypes.bigint>>,
+  ReturnType<typeof mysqlDatatypes.bigint>,
   "never",
   NumberWindowDialectOf<PartitionBy, OrderBy>,
   "window",
@@ -1812,6 +1816,7 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     spec: WindowSpecInput<PartitionBy, OrderBy> | OrderedWindowSpecInput<PartitionBy, Extract<OrderBy, NonEmptyWindowOrderTerms>> | undefined
   ) => {
+    validateWindowFrame(spec?.frame)
     const partitionBy = [...(spec?.partitionBy ?? [])] as unknown as PartitionBy
     const orderBy = (spec?.orderBy ?? []).map((term) => {
       const direction = term.direction ?? "asc"
@@ -1826,7 +1831,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     } & readonly { readonly value: WindowOrderInput; readonly direction: OrderDirection }[]
     return {
       partitionBy,
-      orderBy
+      orderBy,
+      frame: spec?.frame
     }
   }
 
@@ -2156,12 +2162,17 @@ type BinaryPredicateExpression<
   }
 
   const upper = <Value extends ExpressionInput>(
-    value: Value
+    value: Value & FunctionConstraint.CaseConversionInput<
+      NoInfer<Value>,
+      DialectDbTypeOfInput<NoInfer<Value>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      Dialect,
+      "upper"
+    >
   ): AstBackedExpression<
     string,
     TextDb,
     NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    DialectOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    Dialect,
     KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     DependenciesOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     ExpressionAst.UnaryNode<"upper", DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
@@ -2171,7 +2182,7 @@ type BinaryPredicateExpression<
       runtime: "" as string,
       dbType: profile.textDb as TextDb,
       nullability: expression[Expression.TypeId].nullability as NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      dialect: expression[Expression.TypeId].dialect,
+      dialect: profile.dialect as Dialect,
       kind: expression[Expression.TypeId].kind as KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
 
       dependencies: expression[Expression.TypeId].dependencies
@@ -2182,12 +2193,17 @@ type BinaryPredicateExpression<
   }
 
   const lower = <Value extends ExpressionInput>(
-    value: Value
+    value: Value & FunctionConstraint.CaseConversionInput<
+      NoInfer<Value>,
+      DialectDbTypeOfInput<NoInfer<Value>, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      Dialect,
+      "lower"
+    >
   ): AstBackedExpression<
     string,
     TextDb,
     NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-    DialectOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    Dialect,
     KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     DependenciesOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     ExpressionAst.UnaryNode<"lower", DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
@@ -2197,7 +2213,7 @@ type BinaryPredicateExpression<
       runtime: "" as string,
       dbType: profile.textDb as TextDb,
       nullability: expression[Expression.TypeId].nullability as NullabilityOfDialectStringInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
-      dialect: expression[Expression.TypeId].dialect,
+      dialect: profile.dialect as Dialect,
       kind: expression[Expression.TypeId].kind as KindOf<DialectAsStringExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
 
       dependencies: expression[Expression.TypeId].dependencies
@@ -3476,8 +3492,8 @@ type BinaryPredicateExpression<
   const count = <Value extends ExpressionInput>(
     value: Value
   ): AstBackedExpression<
-    number,
-    NumericDb,
+    RuntimeOfDbType<ReturnType<typeof mysqlDatatypes.bigint>>,
+    ReturnType<typeof mysqlDatatypes.bigint>,
     "never",
     DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     "aggregate",
@@ -3486,8 +3502,8 @@ type BinaryPredicateExpression<
   > => {
     const expression = toDialectExpression(value)
     return makeExpression({
-      runtime: 0 as number,
-      dbType: profile.numericDb as NumericDb,
+      runtime: undefined as unknown as RuntimeOfDbType<ReturnType<typeof mysqlDatatypes.bigint>>,
+      dbType: mysqlDatatypes.bigint(),
       nullability: "never",
       dialect: expression[Expression.TypeId].dialect,
       kind: "aggregate",
@@ -3699,7 +3715,8 @@ type BinaryPredicateExpression<
       function: "over",
       value,
       partitionBy: normalized.partitionBy,
-      orderBy: normalized.orderBy
+      orderBy: normalized.orderBy,
+      frame: normalized.frame
     })
   }
 
@@ -3714,8 +3731,8 @@ type BinaryPredicateExpression<
     const normalized = normalizeWindowSpec(spec)
     const expressions = mergeWindowExpressions(undefined, normalized.partitionBy, normalized.orderBy)
     return makeExpression({
-      runtime: 0 as number,
-      dbType: profile.numericDb as Expression.DbType.Any,
+      runtime: undefined as unknown as RuntimeOfDbType<ReturnType<typeof mysqlDatatypes.bigint>>,
+      dbType: mysqlDatatypes.bigint(),
       nullability: "never",
       dialect: (expressions.find((expression) => expression[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as NumberWindowDialectOf<PartitionBy, OrderBy>,
       kind: "window",
@@ -3725,7 +3742,8 @@ type BinaryPredicateExpression<
       kind: "window",
       function: kind,
       partitionBy: normalized.partitionBy,
-      orderBy: normalized.orderBy
+      orderBy: normalized.orderBy,
+      frame: normalized.frame
     })
   }
 
@@ -3754,7 +3772,7 @@ type BinaryPredicateExpression<
     buildNumberWindow("denseRank", spec)
 
   const max = <Value extends Expression.Any>(
-    value: Value
+    value: Value & FunctionConstraint.OrderedInput<NoInfer<Value>, Dialect, "max">
   ): AstBackedExpression<
     Expression.RuntimeOf<Value>,
     Expression.DbTypeOf<Value>,
@@ -3778,7 +3796,7 @@ type BinaryPredicateExpression<
     })
 
   const min = <Value extends Expression.Any>(
-    value: Value
+    value: Value & FunctionConstraint.OrderedInput<NoInfer<Value>, Dialect, "min">
   ): AstBackedExpression<
     Expression.RuntimeOf<Value>,
     Expression.DbTypeOf<Value>,
@@ -3813,7 +3831,7 @@ type BinaryPredicateExpression<
   const coalesce = <
     Values extends readonly [ExpressionInput, ExpressionInput, ...ExpressionInput[]]
   >(
-    ...values: Values
+    ...values: Values & FunctionConstraint.CoalesceConstraint<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>, Dialect>
   ): AstBackedExpression<
     CoalesceRuntimeTuple<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>,
     Expression.DbTypeOf<DialectExpressionTuple<Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>[number]>,

package/src/mysql.ts

@@ -4,6 +4,8 @@ export * as Column from "./mysql/column-extension.js"
 export * as Datatypes from "./mysql/datatypes/index.js"
 /** MySQL error catalog and error normalization helpers. */
 export * as Errors from "./mysql/errors/index.js"
+/** MySQL-specific SQL function expressions. */
+export * as Function from "./mysql/function/index.js"
 /** MySQL-specific JSON expression helpers. Portable JSON helpers are exported from the root package. */
 export * as Json from "./mysql/json.js"
 /** MySQL-specialized typed query execution contracts. */

package/src/postgres/executor.ts

@@ -26,6 +26,8 @@ export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"po
 /** Postgres-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"postgres">
 export type ValueMappings = Expression.DriverValueMappingsFor<PostgresDatatypeKind, PostgresDatatypeFamily>
+/** PostgreSQL EXPLAIN options. ANALYZE executes the read query. */
+export type ExplainOptions = CoreExecutor.ExplainOptions
 /** Optional renderer / driver overrides for the standard Postgres executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
   readonly renderer?: Renderer
@@ -39,20 +41,37 @@ export type PostgresExecutorError = PostgresDriverError | RowDecodeError
 export type PostgresQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
   Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? PostgresReadQueryError : PostgresExecutorError
 
+/** Pipeable execution cardinality helpers. */
+export const atMostOne = CoreExecutor.atMostOne
+export const exactlyOne = CoreExecutor.exactlyOne
+export const nonEmpty = CoreExecutor.nonEmpty
+
 /** Runs an effect within the ambient Postgres SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
 
 /** Postgres executor whose error channel narrows based on the query plan. */
-export interface QueryExecutor<Context = never> {
+export interface QueryExecutor<Context = never> extends CoreExecutor.Executor<"postgres", PostgresQueryError<any>, Context> {
   readonly dialect: "postgres"
   execute<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
   ): Effect.Effect<CoreQuery.ResultRows<PlanValue>, PostgresQueryError<PlanValue>, Context>
+  executeResult<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
+  ): Effect.Effect<CoreExecutor.ExecutionResult<CoreQuery.ResultRow<PlanValue>>, PostgresQueryError<PlanValue>, Context>
+  prepare<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
+  ): CoreExecutor.PreparedQuery<CoreQuery.ResultRow<PlanValue>, PostgresQueryError<PlanValue>, Context>
   stream<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read" | "locking"> extends never
       ? CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
       : never
   ): Stream.Stream<CoreQuery.ResultRow<PlanValue>, PostgresQueryError<PlanValue>, Context>
+  explain<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read" | "locking"> extends never
+      ? CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
+      : never,
+    options?: ExplainOptions
+  ): Effect.Effect<ReadonlyArray<FlatRow>, PostgresQueryError<PlanValue>, Context>
 }
 
 type DriverExecute<Error, Context> = <Row>(
@@ -61,6 +80,9 @@ type DriverExecute<Error, Context> = <Row>(
 
 type DriverHandlers<Error, Context> = {
   readonly execute: DriverExecute<Error, Context>
+  readonly executeResult?: <Row>(
+    query: CoreRenderer.RenderedQuery<Row, "postgres">
+  ) => Effect.Effect<CoreExecutor.DriverResult, Error, Context>
   readonly stream: <Row>(
     query: CoreRenderer.RenderedQuery<Row, "postgres">
   ) => Stream.Stream<FlatRow, Error, Context>
@@ -114,57 +136,101 @@ const fromDriver = <
   sqlDriver: Driver<Error, Context>,
   driverMode: CoreExecutor.DriverMode = "raw",
   valueMappings?: Expression.DriverValueMappings
-): QueryExecutor<Context> => ({
-  dialect: "postgres",
-  execute(plan) {
-    const rendered = renderer.render(plan)
-    return Effect.mapError(
-      Effect.flatMap(
-        sqlDriver.execute(rendered),
-        (rows) => Effect.try({
-          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
-          catch: (error) => error as RowDecodeError
-        })
-      ),
-      (error) => {
-        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
-          return error as RowDecodeError
-        }
-        const normalized = normalizePostgresDriverError(error, rendered)
-        return CoreExecutor.hasWriteCapability(plan)
-          ? normalized
-          : narrowPostgresDriverErrorForReadQuery(normalized)
-      }
-    ) as Effect.Effect<any, any, Context>
-  },
-  stream(plan) {
-    const rendered = renderer.render(plan)
-    return Stream.mapError(
-      Stream.mapArrayEffect(
-        sqlDriver.stream(rendered),
-        (rows) => Effect.try({
-          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
-          catch: (error) => error as RowDecodeError
-        })
-      ),
-      (error) => {
-        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
-          return error as RowDecodeError
-        }
-        const normalized = normalizePostgresDriverError(error, rendered)
-        return CoreExecutor.hasWriteCapability(plan)
-          ? normalized
-          : narrowPostgresDriverErrorForReadQuery(normalized)
-      }
-    ) as Stream.Stream<any, any, Context>
+): QueryExecutor<Context> => {
+  const renderedCache = new WeakMap<object, CoreRenderer.RenderedQuery<any, "postgres">>()
+  const render = (plan: CoreQuery.Plan.Any) => {
+    const cached = renderedCache.get(plan)
+    if (cached !== undefined) {
+      return cached
+    }
+    const rendered = renderer.render(plan as any)
+    renderedCache.set(plan, rendered)
+    return rendered
   }
-})
+  const mapExecutionError = (
+    error: unknown,
+    rendered: CoreRenderer.RenderedQuery<any, "postgres">,
+    plan: CoreQuery.Plan.Any
+  ) => {
+    if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
+      return error as RowDecodeError
+    }
+    const normalized = normalizePostgresDriverError(error, rendered)
+    return CoreExecutor.hasWriteCapability(plan)
+      ? normalized
+      : narrowPostgresDriverErrorForReadQuery(normalized)
+  }
+  return CoreExecutor.withResultContracts({
+    dialect: "postgres",
+    execute(plan) {
+      const rendered = render(plan)
+      return Effect.mapError(
+        Effect.flatMap(
+          sqlDriver.execute(rendered),
+          (rows) => Effect.try({
+            try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
+            catch: (error) => error as RowDecodeError
+          })
+        ),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Effect.Effect<any, any, Context>
+    },
+    executeResult(plan) {
+      const rendered = render(plan)
+      const result = sqlDriver.executeResult
+        ? sqlDriver.executeResult(rendered)
+        : Effect.map(sqlDriver.execute(rendered), (rows) => ({ rows }))
+      return Effect.mapError(
+        Effect.flatMap(result, ({ rows, ...metadata }) => Effect.try({
+          try: () => ({
+            ...metadata,
+            rows: CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings })
+          }),
+          catch: (error) => error as RowDecodeError
+        })),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Effect.Effect<any, any, Context>
+    },
+    stream(plan) {
+      const rendered = render(plan)
+      return Stream.mapError(
+        Stream.mapArrayEffect(
+          sqlDriver.stream(rendered),
+          (rows) => Effect.try({
+            try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
+            catch: (error) => error as RowDecodeError
+          })
+        ),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Stream.Stream<any, any, Context>
+    },
+    explain(plan, options) {
+      const rendered = CoreExecutor.explainQuery(render(plan), options)
+      return Effect.mapError(
+        sqlDriver.execute(rendered),
+        (error) => mapExecutionError(error, rendered, plan)
+      ) as Effect.Effect<any, any, Context>
+    }
+  }) as QueryExecutor<Context>
+}
 
 const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
   driver({
     execute: (query: CoreRenderer.RenderedQuery<any, "postgres">) =>
       Effect.flatMap(SqlClient.SqlClient, (sql) =>
         sql.unsafe<FlatRow>(query.sql, [...query.params])),
+    executeResult: (query: CoreRenderer.RenderedQuery<any, "postgres">) =>
+      Effect.flatMap(SqlClient.SqlClient, (sql) =>
+        Effect.map(sql.unsafe<FlatRow>(query.sql, [...query.params]).raw, (raw) => {
+          const result = raw as {
+            readonly rows?: ReadonlyArray<FlatRow>
+            readonly rowCount?: number | null
+          }
+          return {
+            rows: result.rows ?? [],
+            ...(typeof result.rowCount === "number" ? { affectedRows: result.rowCount } : {})
+          }
+        })),
     stream: (query: CoreRenderer.RenderedQuery<any, "postgres">) =>
       CoreExecutor.streamFromSqlClient(query)
   })

package/src/postgres/function/aggregate.ts

@@ -1,2 +1,125 @@
-/** Postgres aggregate functions. */
+import * as Numeric from "../../internal/dialect-numeric.js"
+import * as Expression from "../../internal/scalar.js"
+import { postgresDatatypes } from "../datatypes/index.js"
+
 export { count, max, min } from "../internal/dsl.js"
+
+type PgInt8 = ReturnType<typeof postgresDatatypes.int8>
+type PgNumeric = ReturnType<typeof postgresDatatypes.numeric>
+type PgFloat4 = ReturnType<typeof postgresDatatypes.float4>
+type PgFloat8 = ReturnType<typeof postgresDatatypes.float8>
+
+type IsAny<Value> = 0 extends (1 & Value) ? true : false
+
+type BaseDb<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? BaseDb<Base>
+    : Db
+
+type PgAggregateCategory<Db extends Expression.DbType.Any> =
+  BaseDb<Db> extends infer Base extends Expression.DbType.Any
+    ? Base["dialect"] extends "standard"
+      ? Base["kind"] extends "int" | "integer" ? "int4"
+        : Base["kind"] extends "bigint" ? "int8"
+          : Base["kind"] extends "numeric" | "decimal" ? "numeric"
+            : Base["kind"] extends "real" ? "float4"
+              : never
+      : Base["dialect"] extends "postgres"
+        ? Base["kind"] extends "int2" | "int4" | "int8" | "numeric" | "float4" | "float8"
+          ? Base["kind"]
+          : never
+        : never
+    : never
+
+type AggregateInputError<
+  Operation extends "sum" | "avg",
+  Db extends Expression.DbType.Any
+> = {
+  readonly __effect_qb_error__: "effect-qb: unsupported postgres aggregate input"
+  readonly __effect_qb_operation__: Operation
+  readonly __effect_qb_db_type__: Db
+  readonly __effect_qb_expected__: "smallint, integer, bigint, numeric, real, or double precision"
+  readonly __effect_qb_hint__: "Use Cast.to(...) with a supported Type or Pg.Type witness"
+}
+
+type PgAggregateConstraint<
+  Value extends Numeric.Input,
+  Operation extends "sum" | "avg"
+> = IsAny<Value> extends true ? unknown
+  : Numeric.DialectConstraint<Value, PgFloat8, "postgres"> & (
+    PgAggregateCategory<Numeric.DbTypeOfInput<Value, PgFloat8, "postgres">> extends never
+      ? AggregateInputError<
+          Operation,
+          Numeric.DbTypeOfInput<Value, PgFloat8, "postgres">
+        >
+      : unknown
+  )
+
+type PgSumResultDb<Value extends Numeric.Input> =
+  PgAggregateCategory<Numeric.DbTypeOfInput<Value, PgFloat8, "postgres">> extends "int2" | "int4"
+    ? PgInt8
+    : PgAggregateCategory<Numeric.DbTypeOfInput<Value, PgFloat8, "postgres">> extends "int8" | "numeric"
+      ? PgNumeric
+      : PgAggregateCategory<Numeric.DbTypeOfInput<Value, PgFloat8, "postgres">> extends "float4"
+        ? PgFloat4
+        : PgFloat8
+
+type PgAvgResultDb<Value extends Numeric.Input> =
+  PgAggregateCategory<Numeric.DbTypeOfInput<Value, PgFloat8, "postgres">> extends "float4" | "float8"
+    ? PgFloat8
+    : PgNumeric
+
+const baseDb = (db: Expression.DbType.Any): Expression.DbType.Any =>
+  "base" in db ? baseDb(db.base) : db
+
+const category = (
+  value: Numeric.Input
+): "int2" | "int4" | "int8" | "numeric" | "float4" | "float8" => {
+  if (typeof value === "number") return "float8"
+  const db = baseDb(value[Expression.TypeId].dbType)
+  if (db.dialect === "standard") {
+    if (db.kind === "int" || db.kind === "integer") return "int4"
+    if (db.kind === "bigint") return "int8"
+    if (db.kind === "numeric" || db.kind === "decimal") return "numeric"
+    return "float4"
+  }
+  return db.kind as "int2" | "int4" | "int8" | "numeric" | "float4" | "float8"
+}
+
+const sumResultDb = (value: Numeric.Input) => {
+  const valueCategory = category(value)
+  if (valueCategory === "int2" || valueCategory === "int4") {
+    return postgresDatatypes.int8()
+  }
+  if (valueCategory === "int8" || valueCategory === "numeric") {
+    return postgresDatatypes.numeric()
+  }
+  return valueCategory === "float4"
+    ? postgresDatatypes.float4()
+    : postgresDatatypes.float8()
+}
+
+const avgResultDb = (value: Numeric.Input) => {
+  const valueCategory = category(value)
+  return valueCategory === "float4" || valueCategory === "float8"
+    ? postgresDatatypes.float8()
+    : postgresDatatypes.numeric()
+}
+
+export const sum = <Value extends Numeric.Input>(
+  value: Value & PgAggregateConstraint<NoInfer<Value>, "sum">
+): Numeric.AggregateResult<"sum", Value, PgFloat8, PgSumResultDb<Value>, "postgres"> =>
+  (Numeric.aggregate as any)("sum", value, {
+    dialect: "postgres",
+    literalDb: postgresDatatypes.float8(),
+    resultDb: sumResultDb(value)
+  })
+
+export const avg = <Value extends Numeric.Input>(
+  value: Value & PgAggregateConstraint<NoInfer<Value>, "avg">
+): Numeric.AggregateResult<"avg", Value, PgFloat8, PgAvgResultDb<Value>, "postgres"> =>
+  (Numeric.aggregate as any)("avg", value, {
+    dialect: "postgres",
+    literalDb: postgresDatatypes.float8(),
+    resultDb: avgResultDb(value)
+  })

package/src/postgres/function/core.ts

@@ -1,5 +1,6 @@
 import type { ExpressionInput } from "../query.js"
 import {
+  call,
   cast,
   literal,
   nextVal as nextValInternal,
@@ -9,7 +10,7 @@ import {
 import { isSequenceDefinition, type SequenceDefinition } from "../schema-management.js"
 
 /** Postgres scalar core functions. */
-export { uuidGenerateV4 }
+export { call, uuidGenerateV4 }
 
 const safeUnquotedIdentifier = /^[a-z_][a-z0-9_$]*$/
 

package/src/postgres/function/index.ts

@@ -1,3 +1,21 @@
 export * as core from "./core.js"
+export * as string from "./string.js"
+export * as aggregate from "./aggregate.js"
+export * as numeric from "./numeric.js"
+export * as window from "./window.js"
+export * as temporal from "./temporal.js"
 
-export { uuidGenerateV4, nextVal } from "./core.js"
+export { call, uuidGenerateV4, nextVal } from "./core.js"
+export { lower, upper, concat } from "./string.js"
+export { avg, count, max, min, sum } from "./aggregate.js"
+export { modulo, round } from "./numeric.js"
+export { denseRank, firstValue, lastValue, over, rank, rowNumber } from "./window.js"
+export type { WindowSpec } from "./window.js"
+export {
+  currentDate,
+  currentTime,
+  currentTimestamp,
+  localTime,
+  localTimestamp,
+  now
+} from "./temporal.js"