effect-qb 0.20.0 → 0.22.0

package/src/sqlite/function/aggregate.ts

@@ -1,2 +1,91 @@
-/** SQLite aggregate functions. */
+import * as Numeric from "../../internal/dialect-numeric.js"
+import * as Expression from "../../internal/scalar.js"
+import { sqliteDatatypes } from "../datatypes/index.js"
+
 export { count, max, min } from "../internal/dsl.js"
+
+type SqInteger = ReturnType<typeof sqliteDatatypes.integer>
+type SqBigInt = ReturnType<typeof sqliteDatatypes.bigint>
+type SqDouble = ReturnType<typeof sqliteDatatypes.double>
+
+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 SqAggregateCategory<Db extends Expression.DbType.Any> =
+  BaseDb<Db> extends infer Base extends Expression.DbType.Any
+    ? Base["dialect"] extends "standard" | "sqlite"
+      ? Base["kind"] extends "int" | "integer" ? "integer"
+        : Base["kind"] extends "bigint" ? "bigint"
+          : Base["kind"] extends "numeric" | "decimal" | "real" | "double"
+            ? "approximate"
+            : never
+      : never
+    : never
+
+type AggregateInputError<
+  Operation extends "sum" | "avg",
+  Db extends Expression.DbType.Any
+> = {
+  readonly __effect_qb_error__: "effect-qb: unsupported sqlite aggregate input"
+  readonly __effect_qb_operation__: Operation
+  readonly __effect_qb_db_type__: Db
+  readonly __effect_qb_expected__: "an integer, numeric, decimal, real, or double database type"
+  readonly __effect_qb_hint__: "Use Cast.to(...) with a supported Type or Sq.Type witness"
+}
+
+type SqAggregateConstraint<
+  Value extends Numeric.Input,
+  Operation extends "sum" | "avg"
+> = IsAny<Value> extends true ? unknown
+  : Numeric.DialectConstraint<Value, SqDouble, "sqlite"> & (
+    SqAggregateCategory<Numeric.DbTypeOfInput<Value, SqDouble, "sqlite">> extends never
+      ? AggregateInputError<
+          Operation,
+          Numeric.DbTypeOfInput<Value, SqDouble, "sqlite">
+        >
+      : unknown
+  )
+
+type SqSumResultDb<Value extends Numeric.Input> =
+  SqAggregateCategory<Numeric.DbTypeOfInput<Value, SqDouble, "sqlite">> extends "integer"
+    ? SqInteger
+    : SqAggregateCategory<Numeric.DbTypeOfInput<Value, SqDouble, "sqlite">> extends "bigint"
+      ? SqBigInt
+      : SqDouble
+
+const baseDb = (db: Expression.DbType.Any): Expression.DbType.Any =>
+  "base" in db ? baseDb(db.base) : db
+
+const sumResultDb = (value: Numeric.Input): SqInteger | SqBigInt | SqDouble => {
+  if (typeof value === "number") return sqliteDatatypes.double()
+  const db = baseDb(value[Expression.TypeId].dbType)
+  if (db.kind === "int" || db.kind === "integer") {
+    return sqliteDatatypes.integer()
+  }
+  if (db.kind === "bigint") {
+    return sqliteDatatypes.bigint()
+  }
+  return sqliteDatatypes.double()
+}
+
+export const sum = <Value extends Numeric.Input>(
+  value: Value & SqAggregateConstraint<NoInfer<Value>, "sum">
+): Numeric.AggregateResult<"sum", Value, SqDouble, SqSumResultDb<Value>, "sqlite"> =>
+  (Numeric.aggregate as any)("sum", value, {
+    dialect: "sqlite",
+    literalDb: sqliteDatatypes.double(),
+    resultDb: sumResultDb(value)
+  })
+
+export const avg = <Value extends Numeric.Input>(
+  value: Value & SqAggregateConstraint<NoInfer<Value>, "avg">
+): Numeric.AggregateResult<"avg", Value, SqDouble, SqDouble, "sqlite"> =>
+  (Numeric.aggregate as any)("avg", value, {
+    dialect: "sqlite",
+    literalDb: sqliteDatatypes.double(),
+    resultDb: sqliteDatatypes.double()
+  })

package/src/sqlite/function/index.ts

@@ -1,14 +1,17 @@
 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 { coalesce } from "./core.js"
 export { call } from "./core.js"
 export { lower, upper, concat } from "./string.js"
-export { count, max, min } from "./aggregate.js"
-export { over, rowNumber, rank, denseRank } from "./window.js"
+export { avg, count, max, min, sum } from "./aggregate.js"
+export { modulo, round } from "./numeric.js"
+export { firstValue, lastValue, over, rowNumber, rank, denseRank } from "./window.js"
+export type { WindowSpec } from "./window.js"
 export {
   currentDate,
   currentTime,

package/src/sqlite/function/numeric.ts

@@ -0,0 +1,139 @@
+import * as Numeric from "../../internal/dialect-numeric.js"
+import * as Expression from "../../internal/scalar.js"
+import { sqliteDatatypes } from "../datatypes/index.js"
+
+type SqInteger = ReturnType<typeof sqliteDatatypes.integer>
+type SqBigInt = ReturnType<typeof sqliteDatatypes.bigint>
+type SqDouble = ReturnType<typeof sqliteDatatypes.double>
+
+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 SqNumericCategory<Db extends Expression.DbType.Any> =
+  BaseDb<Db> extends infer Base extends Expression.DbType.Any
+    ? Base["dialect"] extends "standard" | "sqlite"
+      ? Base["kind"] extends "int" | "integer" ? "integer"
+        : Base["kind"] extends "bigint" ? "bigint"
+          : Base["kind"] extends "numeric" | "decimal" ? "exact"
+            : Base["kind"] extends "real" | "double" ? "approximate"
+              : never
+      : never
+    : never
+
+type NumericInputError<
+  Operation extends "modulo" | "round",
+  Db extends Expression.DbType.Any
+> = {
+  readonly __effect_qb_error__: "effect-qb: unsupported sqlite numeric input"
+  readonly __effect_qb_operation__: Operation
+  readonly __effect_qb_db_type__: Db
+  readonly __effect_qb_expected__: "an integer, numeric, decimal, real, or double database type"
+  readonly __effect_qb_hint__: "Use Cast.to(...) with a supported Type or Sq.Type witness"
+}
+
+type SqNumericConstraint<
+  Value extends Numeric.Input,
+  Operation extends "modulo" | "round"
+> =
+  IsAny<Value> extends true ? unknown
+    : Numeric.DialectConstraint<Value, SqDouble, "sqlite"> & (
+      SqNumericCategory<Numeric.DbTypeOfInput<Value, SqDouble, "sqlite">> extends never
+        ? NumericInputError<Operation, Numeric.DbTypeOfInput<Value, SqDouble, "sqlite">>
+        : unknown
+    )
+
+type SqModuloResultDb<
+  Left extends Numeric.Input,
+  Right extends Numeric.Input
+> =
+  SqNumericCategory<Numeric.DbTypeOfInput<Left, SqDouble, "sqlite">> extends infer LeftCategory
+    ? SqNumericCategory<Numeric.DbTypeOfInput<Right, SqDouble, "sqlite">> extends infer RightCategory
+      ? Exclude<LeftCategory | RightCategory, "integer" | "bigint"> extends never
+        ? "bigint" extends LeftCategory | RightCategory ? SqBigInt : SqInteger
+        : SqDouble
+      : never
+    : never
+
+type SqModuloResult<
+  Left extends Numeric.Input,
+  Right extends Numeric.Input
+> = Numeric.BinaryResult<
+  Left,
+  Right,
+  SqDouble,
+  SqModuloResultDb<Left, Right>,
+  Numeric.ZeroDivisorNullability<Left, Right, SqDouble, "sqlite">,
+  "sqlite"
+>
+
+type SqRoundResult<
+  Value extends Numeric.Input,
+  WithScale extends boolean
+> = Numeric.RoundResult<
+  Value,
+  SqDouble,
+  SqDouble,
+  Value extends Expression.Any ? Expression.NullabilityOf<Value> : "never",
+  "sqlite",
+  WithScale
+>
+
+const baseDb = (db: Expression.DbType.Any): Expression.DbType.Any =>
+  "base" in db ? baseDb(db.base) : db
+
+const category = (value: Numeric.Input): "integer" | "bigint" | "exact" | "approximate" => {
+  if (typeof value === "number") return "approximate"
+  const db = baseDb(value[Expression.TypeId].dbType)
+  if (db.kind === "int" || db.kind === "integer") return "integer"
+  if (db.kind === "bigint") return "bigint"
+  if (db.kind === "numeric" || db.kind === "decimal") return "exact"
+  return "approximate"
+}
+
+const moduloResultDb = (left: Numeric.Input, right: Numeric.Input) => {
+  const categories = [category(left), category(right)]
+  if (categories.every((value) => value === "integer" || value === "bigint")) {
+    return categories.includes("bigint")
+      ? sqliteDatatypes.bigint()
+      : sqliteDatatypes.integer()
+  }
+  return sqliteDatatypes.double()
+}
+
+export const modulo = <
+  Left extends Numeric.Input,
+  Right extends Numeric.Input
+>(
+  left: Left & SqNumericConstraint<NoInfer<Left>, "modulo">,
+  right: Right & SqNumericConstraint<NoInfer<Right>, "modulo">
+): SqModuloResult<Left, Right> =>
+  (Numeric.modulo as any)(left, right, {
+    dialect: "sqlite",
+    literalDb: sqliteDatatypes.double(),
+    resultDb: moduloResultDb(left, right) as SqModuloResultDb<Left, Right>,
+    nullability: Numeric.nullableForZeroDivisor(left, right) as Numeric.ZeroDivisorNullability<Left, Right, SqDouble, "sqlite">
+  }) as SqModuloResult<Left, Right>
+
+export function round<Value extends Numeric.Input>(
+  value: Value & SqNumericConstraint<NoInfer<Value>, "round">
+): SqRoundResult<Value, false>
+export function round<Value extends Numeric.Input>(
+  value: Value & SqNumericConstraint<NoInfer<Value>, "round">,
+  scale: number
+): SqRoundResult<Value, true>
+export function round(
+  value: Numeric.Input,
+  scale?: number
+): SqRoundResult<Numeric.Input, boolean> {
+  return Numeric.round(value, scale, {
+    dialect: "sqlite",
+    literalDb: sqliteDatatypes.double(),
+    scaleDb: sqliteDatatypes.integer(),
+    resultDb: sqliteDatatypes.double(),
+    nullability: typeof value === "number" ? "never" : value[Expression.TypeId].nullability
+  }) as SqRoundResult<Numeric.Input, boolean>
+}

package/src/sqlite/function/window.ts

@@ -1,2 +1,14 @@
+import {
+  makeDialectFirstValue,
+  makeDialectLastValue
+} from "../../internal/analytics.js"
+export type { WindowSpec } from "../../internal/analytics.js"
+
 /** SQLite window functions. */
 export { over, rowNumber, rank, denseRank } from "../internal/dsl.js"
+
+/** First value in a SQLite window frame. */
+export const firstValue = makeDialectFirstValue("sqlite")
+
+/** Last value in a SQLite window frame. */
+export const lastValue = makeDialectLastValue("sqlite")

package/src/sqlite/internal/dsl.ts

@@ -4,6 +4,7 @@ import * as Schema from "effect/Schema"
 import { sqliteDatatypes } 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"
@@ -1457,6 +1459,7 @@ type WindowSpecInput<
 > = {
   readonly partitionBy?: PartitionBy
   readonly orderBy?: OrderBy
+  readonly frame?: ExpressionAst.WindowFrameNode
 }
 
 type OrderedWindowSpecInput<
@@ -1465,6 +1468,7 @@ type OrderedWindowSpecInput<
 > = {
   readonly partitionBy?: PartitionBy
   readonly orderBy: OrderBy
+  readonly frame?: never
 }
 
 type WindowOrderExpressionTuple<
@@ -1537,8 +1541,8 @@ type NumberWindowExpression<
   PartitionBy extends readonly WindowPartitionInput[],
   OrderBy extends NonEmptyWindowOrderTerms
 > = AstBackedExpression<
-  number,
-  Expression.DbType.Any,
+  RuntimeOfDbType<ReturnType<typeof sqliteDatatypes.bigint>>,
+  ReturnType<typeof sqliteDatatypes.bigint>,
   "never",
   NumberWindowDialectOf<PartitionBy, OrderBy>,
   "window",
@@ -1829,6 +1833,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"
@@ -1843,7 +1848,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     } & readonly { readonly value: WindowOrderInput; readonly direction: OrderDirection }[]
     return {
       partitionBy,
-      orderBy
+      orderBy,
+      frame: spec?.frame
     }
   }
 
@@ -2173,12 +2179,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>>
@@ -2188,7 +2199,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
@@ -2199,12 +2210,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>>
@@ -2214,7 +2230,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
@@ -3493,8 +3509,8 @@ type BinaryPredicateExpression<
   const count = <Value extends ExpressionInput>(
     value: Value
   ): AstBackedExpression<
-    number,
-    NumericDb,
+    RuntimeOfDbType<ReturnType<typeof sqliteDatatypes.bigint>>,
+    ReturnType<typeof sqliteDatatypes.bigint>,
     "never",
     DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     "aggregate",
@@ -3503,8 +3519,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 sqliteDatatypes.bigint>>,
+      dbType: sqliteDatatypes.bigint(),
       nullability: "never",
       dialect: expression[Expression.TypeId].dialect,
       kind: "aggregate",
@@ -3716,7 +3732,8 @@ type BinaryPredicateExpression<
       function: "over",
       value,
       partitionBy: normalized.partitionBy,
-      orderBy: normalized.orderBy
+      orderBy: normalized.orderBy,
+      frame: normalized.frame
     })
   }
 
@@ -3731,8 +3748,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 sqliteDatatypes.bigint>>,
+      dbType: sqliteDatatypes.bigint(),
       nullability: "never",
       dialect: (expressions.find((expression) => expression[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as NumberWindowDialectOf<PartitionBy, OrderBy>,
       kind: "window",
@@ -3742,7 +3759,8 @@ type BinaryPredicateExpression<
       kind: "window",
       function: kind,
       partitionBy: normalized.partitionBy,
-      orderBy: normalized.orderBy
+      orderBy: normalized.orderBy,
+      frame: normalized.frame
     })
   }
 
@@ -3771,7 +3789,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>,
@@ -3795,7 +3813,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>,
@@ -3830,7 +3848,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/sqlite.ts

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

package/src/standard/function/core.ts

@@ -1,2 +1,9 @@
 /** Standard scalar core functions. */
-export { coalesce, call } from "../query.js"
+export {
+  abs,
+  add,
+  coalesce,
+  multiply,
+  negate,
+  subtract,
+} from "../query.js"

package/src/standard/function/index.ts

@@ -2,17 +2,24 @@ export * as core from "./core.js"
 export * as string from "./string.js"
 export * as aggregate from "./aggregate.js"
 export * as window from "./window.js"
-export * as temporal from "./temporal.js"
 
-export { coalesce, call } from "./core.js"
-export { lower, upper, concat } from "./string.js"
+export {
+  abs,
+  add,
+  coalesce,
+  multiply,
+  negate,
+  subtract,
+} from "./core.js"
+export { concat } from "./string.js"
 export { count, max, min } from "./aggregate.js"
-export { over, rowNumber, rank, denseRank } from "./window.js"
 export {
-  currentDate,
-  currentTime,
-  currentTimestamp,
-  localTime,
-  localTimestamp,
-  now
-} from "./temporal.js"
+  denseRank,
+  firstValue,
+  lag,
+  lastValue,
+  lead,
+  over,
+  rank,
+  rowNumber
+} from "./window.js"

package/src/standard/function/string.ts

@@ -1,2 +1,2 @@
 /** Standard string functions. */
-export { lower, upper, concat } from "../query.js"
+export { concat } from "../query.js"

package/src/standard/function/window.ts

@@ -1,2 +1,11 @@
 /** Standard window functions. */
-export { over, rowNumber, rank, denseRank } from "../query.js"
+export {
+  denseRank,
+  firstValue,
+  lag,
+  lastValue,
+  lead,
+  over,
+  rank,
+  rowNumber
+} from "../query.js"

package/src/standard/query.ts

@@ -1,6 +1,3 @@
-import {
-  type as standardType
-} from "../internal/standard-dsl.js"
 import type * as Expression from "../internal/scalar.js"
 
 export {
@@ -88,11 +85,8 @@ export {
   lock,
   orderBy,
   groupBy,
-  lower,
-  upper,
   concat,
   coalesce,
-  call,
   count,
   max,
   min,
@@ -102,7 +96,25 @@ export {
   denseRank
 } from "../internal/standard-dsl.js"
 
-export { standardType as type }
+export {
+  abs,
+  add,
+  multiply,
+  negate,
+  subtract
+} from "../internal/numeric.js"
+
+export { andAll, includeIf, orAll, when } from "../internal/dynamic.js"
+export {
+  firstValue,
+  lag,
+  lastValue,
+  lead,
+  type OffsetOptions,
+  type WindowOrderSpec,
+  type WindowOrderTerm
+} from "../internal/analytics.js"
+
 export { union_query_capabilities } from "../internal/query.js"
 
 export type MutationInputOf<Shape> = {

package/src/standard/type.ts

@@ -0,0 +1,16 @@
+import type * as Expression from "../internal/scalar.js"
+import { standardDatatypes } from "./datatypes/index.js"
+
+const driverValueMapping = <Db extends Expression.DbType.Any>(
+  dbType: Db,
+  mapping: Expression.DriverValueMapping
+): Db => ({
+  ...dbType,
+  driverValueMapping: mapping
+})
+
+/** Portable database-type constructors for casts and typed references. */
+export const type = {
+  ...standardDatatypes,
+  driverValueMapping
+}

package/src/standard.ts

@@ -4,8 +4,12 @@ export * as Column from "./standard/column.js"
 export * as Cast from "./standard/cast.js"
 /** Standard SQL datatype witnesses and coercion families. */
 export * as Datatypes from "./standard/datatypes/index.js"
+/** Portable database-type constructors for casts and typed references. */
+export { type as Type } from "./standard/type.js"
 /** Shared scalar SQL interfaces and DB-type descriptors. */
 export * as Scalar from "./internal/scalar.js"
+/** Typed custom SQL expressions and safely quoted identifiers. */
+export * as Fragment from "./internal/fragment.js"
 /** Standard SQL function expressions. */
 export * as Function from "./standard/function/index.js"
 /** Standard SQL JSON expression helpers and path segments. */