effect-qb 0.20.0 → 0.22.0

package/src/internal/numeric.ts

@@ -0,0 +1,204 @@
+import * as Schema from "effect/Schema"
+
+import { standardDatatypes } from "../standard/datatypes/index.js"
+import * as ExpressionAst from "./expression-ast.js"
+import * as Expression from "./scalar.js"
+import {
+  makeExpression,
+  mergeAggregationManyRuntime,
+  mergeManyDependencies,
+  mergeNullabilityManyRuntime,
+  type MergeAggregation,
+  type MergeNullabilityTuple,
+  type NumericExpressionInput,
+  type TupleDependencies,
+  type TupleDialect
+} from "./query.js"
+
+type NumberLiteral<Value extends number> = Expression.Scalar<
+  Value,
+  ReturnType<typeof standardDatatypes.real>,
+  "never",
+  "standard",
+  "scalar",
+  never
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.LiteralNode<Value>
+}
+
+type AsExpression<Value extends NumericExpressionInput> =
+  Value extends Expression.Any ? Value : NumberLiteral<Extract<Value, number>>
+
+type BinaryResult<
+  Kind extends Extract<ExpressionAst.BinaryKind, "add" | "subtract" | "multiply" | "divide">,
+  Left extends NumericExpressionInput,
+  Right extends NumericExpressionInput
+> = Expression.Scalar<
+  number,
+  Expression.DbTypeOf<AsExpression<Left>>,
+  MergeNullabilityTuple<readonly [AsExpression<Left>, AsExpression<Right>]>,
+  TupleDialect<readonly [AsExpression<Left>, AsExpression<Right>]>,
+  MergeAggregation<Expression.KindOf<AsExpression<Left>>, Expression.KindOf<AsExpression<Right>>>,
+  TupleDependencies<readonly [AsExpression<Left>, AsExpression<Right>]>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.BinaryNode<Kind, AsExpression<Left>, AsExpression<Right>>
+}
+
+const numberLiteral = <const Value extends number>(value: Value): NumberLiteral<Value> =>
+  makeExpression({
+    runtime: value,
+    dbType: standardDatatypes.real(),
+    runtimeSchema: Schema.Number,
+    nullability: "never",
+    dialect: "standard",
+    kind: "scalar",
+    dependencies: {}
+  }, {
+    kind: "literal",
+    value
+  })
+
+const toExpression = <Value extends NumericExpressionInput>(
+  value: Value
+): AsExpression<Value> =>
+  (typeof value === "number" ? numberLiteral(value) : value) as AsExpression<Value>
+
+const retargetLiteral = (
+  value: Expression.Any,
+  target: Expression.Any
+): Expression.Any => {
+  const ast = (value as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  if (ast.kind !== "literal") {
+    return value
+  }
+  const state = target[Expression.TypeId]
+  return makeExpression({
+    runtime: value[Expression.TypeId].runtime,
+    dbType: state.dbType,
+    runtimeSchema: state.runtimeSchema,
+    driverValueMapping: state.driverValueMapping,
+    nullability: value[Expression.TypeId].nullability,
+    dialect: state.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, ast)
+}
+
+const binary = <
+  Kind extends Extract<ExpressionAst.BinaryKind, "add" | "subtract" | "multiply" | "divide">,
+  Left extends NumericExpressionInput,
+  Right extends NumericExpressionInput
+>(
+  kind: Kind,
+  left: Left,
+  right: Right
+): BinaryResult<Kind, Left, Right> => {
+  let leftExpression = toExpression(left)
+  let rightExpression = toExpression(right)
+  const leftAst = (leftExpression as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  const rightAst = (rightExpression as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  if (leftAst.kind === "literal" && rightAst.kind !== "literal") {
+    leftExpression = retargetLiteral(leftExpression, rightExpression) as AsExpression<Left>
+  } else if (rightAst.kind === "literal" && leftAst.kind !== "literal") {
+    rightExpression = retargetLiteral(rightExpression, leftExpression) as AsExpression<Right>
+  }
+  const values = [leftExpression, rightExpression] as const
+  return makeExpression({
+    runtime: 0,
+    dbType: leftExpression[Expression.TypeId].dbType,
+    runtimeSchema: Schema.Number,
+    driverValueMapping: leftExpression[Expression.TypeId].driverValueMapping,
+    nullability: mergeNullabilityManyRuntime(values),
+    dialect: values.find((value) => value[Expression.TypeId].dialect !== "standard")?.[Expression.TypeId].dialect ??
+      leftExpression[Expression.TypeId].dialect,
+    kind: mergeAggregationManyRuntime(values),
+    dependencies: mergeManyDependencies(values)
+  }, {
+    kind,
+    left: leftExpression,
+    right: rightExpression
+  }) as BinaryResult<Kind, Left, Right>
+}
+
+export const add = <Left extends NumericExpressionInput, Right extends NumericExpressionInput>(
+  left: Left,
+  right: Right
+): BinaryResult<"add", Left, Right> => binary("add", left, right)
+
+export const subtract = <Left extends NumericExpressionInput, Right extends NumericExpressionInput>(
+  left: Left,
+  right: Right
+): BinaryResult<"subtract", Left, Right> => binary("subtract", left, right)
+
+export const multiply = <Left extends NumericExpressionInput, Right extends NumericExpressionInput>(
+  left: Left,
+  right: Right
+): BinaryResult<"multiply", Left, Right> => binary("multiply", left, right)
+
+export const divide = <Left extends NumericExpressionInput, Right extends NumericExpressionInput>(
+  left: Left,
+  right: Right
+): BinaryResult<"divide", Left, Right> => binary("divide", left, right)
+
+type UnaryResult<
+  Kind extends Extract<ExpressionAst.UnaryKind, "abs" | "negate">,
+  Value extends NumericExpressionInput,
+  Nullable extends Expression.Nullability,
+  ResultKind extends Expression.ScalarKind
+> = Expression.Scalar<
+  number,
+  Expression.DbTypeOf<AsExpression<Value>>,
+  Nullable,
+  AsExpression<Value>[typeof Expression.TypeId]["dialect"],
+  ResultKind,
+  Expression.DependenciesOf<AsExpression<Value>>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.UnaryNode<Kind, AsExpression<Value>>
+}
+
+const unary = <
+  Kind extends Extract<ExpressionAst.UnaryKind, "abs" | "negate">,
+  Value extends NumericExpressionInput,
+  Nullable extends Expression.Nullability,
+  ResultKind extends Expression.ScalarKind
+>(
+  kind: Kind,
+  value: Value,
+  nullability: Nullable,
+  resultKind: ResultKind
+): UnaryResult<Kind, Value, Nullable, ResultKind> => {
+  const expression = toExpression(value)
+  return makeExpression({
+    runtime: 0,
+    dbType: expression[Expression.TypeId].dbType,
+    runtimeSchema: Schema.Number,
+    driverValueMapping: expression[Expression.TypeId].driverValueMapping,
+    nullability,
+    dialect: expression[Expression.TypeId].dialect,
+    kind: resultKind,
+    dependencies: expression[Expression.TypeId].dependencies
+  }, {
+    kind,
+    value: expression
+  }) as UnaryResult<Kind, Value, Nullable, ResultKind>
+}
+
+export const abs = <Value extends NumericExpressionInput>(
+  value: Value
+): UnaryResult<"abs", Value, Expression.NullabilityOf<AsExpression<Value>>, Expression.KindOf<AsExpression<Value>>> => {
+  const expression = toExpression(value)
+  return unary("abs", value, expression[Expression.TypeId].nullability, expression[Expression.TypeId].kind) as never
+}
+
+export const negate = <Value extends NumericExpressionInput>(
+  value: Value
+): UnaryResult<"negate", Value, Expression.NullabilityOf<AsExpression<Value>>, Expression.KindOf<AsExpression<Value>>> => {
+  const expression = toExpression(value)
+  return unary("negate", value, expression[Expression.TypeId].nullability, expression[Expression.TypeId].kind) as never
+}

package/src/internal/query.ts

@@ -203,10 +203,20 @@ type LiteralExpression<Value extends LiteralValue> = Expression.Scalar<
  */
 export type ExpressionInput = Expression.Any | LiteralValue
 
+type NumericBaseDbType = Expression.DbType.Base<string, string> & {
+  readonly family: "numeric" | "integer" | "real"
+}
+
+type NumericDbType =
+  | NumericBaseDbType
+  | (Expression.DbType.Domain<string, any, string> & {
+      readonly base: NumericDbType
+    })
+
 /** Input accepted by numeric clauses such as `limit(...)` and `offset(...)`. */
 export type NumericExpressionInput = Expression.Scalar<
   number,
-  Expression.DbType.Any,
+  NumericDbType,
   Expression.Nullability,
   string,
   "scalar",
@@ -429,6 +439,8 @@ type GroupingKeyOfAst<Ast extends ExpressionAst.Any> =
       ? `function(${EscapeGroupingText<Name>},${JoinGroupingKeys<{
           readonly [K in keyof Args]: Args[K] extends Expression.Any ? GroupingKeyOfExpression<Args[K]> : never
         } & readonly string[]>})`
+    : Ast extends ExpressionAst.CustomSqlNode
+      ? string
     : Ast extends ExpressionAst.UnaryNode<infer Kind extends ExpressionAst.UnaryKind, infer Value extends Expression.Any>
       ? `${Kind}(${GroupingKeyOfExpression<Value>})`
     : Ast extends ExpressionAst.BinaryNode<infer Kind extends ExpressionAst.BinaryKind, infer Left extends Expression.Any, infer Right extends Expression.Any>

package/src/internal/runtime/normalize.ts

@@ -164,8 +164,11 @@ const normalizeOffsetTime = (value: unknown): string => {
     return `${formatLocalTime(validDate(value))}Z`
   }
   const raw = expectString(value, "offset time").trim()
-  if (isValidOffsetTimeString(raw)) {
-    return raw
+  const canonical = raw
+    .replace(/([+-]\d{2})$/, "$1:00")
+    .replace(/([+-]\d{2})(\d{2})$/, "$1:$2")
+  if (isValidOffsetTimeString(canonical)) {
+    return canonical
   }
   throw new Error("Expected an offset-time value")
 }

package/src/internal/runtime/schema.ts

@@ -379,6 +379,7 @@ const deriveRuntimeSchema = (
     case "jsonTypeOf":
       return Schema.String
     case "count":
+      return runtimeSchemaForDbType(state.dbType)
     case "jsonLength":
       return FiniteNumberSchema
     case "max":
@@ -396,7 +397,7 @@ const deriveRuntimeSchema = (
     case "window":
       return ast.function === "over" && ast.value !== undefined
         ? expressionRuntimeSchema(ast.value, context)
-        : FiniteNumberSchema
+        : runtimeSchemaForDbType(state.dbType)
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":

package/src/internal/standard-dsl.ts

@@ -4,6 +4,7 @@ import * as Schema from "effect/Schema"
 import { standardDatatypes } from "../standard/datatypes/index.js"
 
 import * as Expression from "./scalar.js"
+import type * as FunctionConstraint from "./function-constraints.js"
 import * as Plan from "./row-set.js"
 import * as Table from "./table.js"
 import type {
@@ -135,6 +136,7 @@ import type { FormulaOfPredicate } from "./predicate/normalize.js"
 import type { TrueFormula } from "./predicate/formula.js"
 import { assumeFormulaTrue, formulaOfExpression as formulaOfExpressionRuntime, trueFormula } from "./predicate/runtime.js"
 import { dedupeGroupedExpressions } from "./grouping-key.js"
+import { validateWindowFrame } from "./window-frame.js"
 import { makeDslMutationRuntime } from "./dsl-mutation-runtime.js"
 import { makeDslPlanRuntime } from "./dsl-plan-runtime.js"
 import { makeDslQueryRuntime } from "./dsl-query-runtime.js"
@@ -1426,6 +1428,7 @@ type WindowSpecInput<
 > = {
   readonly partitionBy?: PartitionBy
   readonly orderBy?: OrderBy
+  readonly frame?: never
 }
 
 type OrderedWindowSpecInput<
@@ -1434,6 +1437,7 @@ type OrderedWindowSpecInput<
 > = {
   readonly partitionBy?: PartitionBy
   readonly orderBy: OrderBy
+  readonly frame?: never
 }
 
 type WindowOrderExpressionTuple<
@@ -1506,8 +1510,8 @@ type NumberWindowExpression<
   PartitionBy extends readonly WindowPartitionInput[],
   OrderBy extends NonEmptyWindowOrderTerms
 > = AstBackedExpression<
-  number,
-  Expression.DbType.Any,
+  RuntimeOfDbType<ReturnType<typeof standardDatatypes.bigint>>,
+  ReturnType<typeof standardDatatypes.bigint>,
   "never",
   NumberWindowDialectOf<PartitionBy, OrderBy>,
   "window",
@@ -1798,6 +1802,12 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
   >(
     spec: WindowSpecInput<PartitionBy, OrderBy> | OrderedWindowSpecInput<PartitionBy, Extract<OrderBy, NonEmptyWindowOrderTerms>> | undefined
   ) => {
+    if ((spec as { readonly frame?: ExpressionAst.WindowFrameNode } | undefined)?.frame !== undefined) {
+      throw new Error(
+        "over does not accept an explicit frame on the portable Function API; use a dialect Function.over helper"
+      )
+    }
+    validateWindowFrame(spec?.frame)
     const partitionBy = [...(spec?.partitionBy ?? [])] as unknown as PartitionBy
     const orderBy = (spec?.orderBy ?? []).map((term) => {
       const direction = term.direction ?? "asc"
@@ -1812,7 +1822,8 @@ const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, Timestamp
     } & readonly { readonly value: WindowOrderInput; readonly direction: OrderDirection }[]
     return {
       partitionBy,
-      orderBy
+      orderBy,
+      frame: spec?.frame
     }
   }
 
@@ -2142,12 +2153,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>>
@@ -2157,7 +2173,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
@@ -2168,12 +2184,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>>
@@ -2183,7 +2204,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
@@ -3494,8 +3515,8 @@ type BinaryPredicateExpression<
   const count = <Value extends ExpressionInput>(
     value: Value
   ): AstBackedExpression<
-    number,
-    NumericDb,
+    RuntimeOfDbType<ReturnType<typeof standardDatatypes.bigint>>,
+    ReturnType<typeof standardDatatypes.bigint>,
     "never",
     DialectOfDialectInput<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
     "aggregate",
@@ -3504,8 +3525,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 standardDatatypes.bigint>>,
+      dbType: standardDatatypes.bigint(),
       nullability: "never",
       dialect: expression[Expression.TypeId].dialect,
       kind: "aggregate",
@@ -3717,7 +3738,8 @@ type BinaryPredicateExpression<
       function: "over",
       value,
       partitionBy: normalized.partitionBy,
-      orderBy: normalized.orderBy
+      orderBy: normalized.orderBy,
+      frame: normalized.frame
     })
   }
 
@@ -3732,8 +3754,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 standardDatatypes.bigint>>,
+      dbType: standardDatatypes.bigint(),
       nullability: "never",
       dialect: (expressions.find((expression) => expression[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as NumberWindowDialectOf<PartitionBy, OrderBy>,
       kind: "window",
@@ -3743,7 +3765,8 @@ type BinaryPredicateExpression<
       kind: "window",
       function: kind,
       partitionBy: normalized.partitionBy,
-      orderBy: normalized.orderBy
+      orderBy: normalized.orderBy,
+      frame: normalized.frame
     })
   }
 
@@ -3772,7 +3795,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>,
@@ -3796,7 +3819,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>,
@@ -3831,7 +3854,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/internal/window-frame.ts

@@ -0,0 +1,30 @@
+import type * as ExpressionAst from "./expression-ast.js"
+
+const validateBoundary = (
+  boundary: ExpressionAst.WindowFrameBoundary
+): void => {
+  if (typeof boundary === "object") {
+    const value = "preceding" in boundary ? boundary.preceding : boundary.following
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new Error("window frame offsets must be non-negative safe integers")
+    }
+  }
+}
+
+export const validateWindowFrame = (
+  frame: ExpressionAst.WindowFrameNode | undefined
+): void => {
+  if (frame === undefined) {
+    return
+  }
+  validateBoundary(frame.start)
+  if (frame.end !== undefined) {
+    validateBoundary(frame.end)
+  }
+  if (frame.start === "unboundedFollowing") {
+    throw new Error("window frame cannot start with unbounded following")
+  }
+  if (frame.end === "unboundedPreceding") {
+    throw new Error("window frame cannot end with unbounded preceding")
+  }
+}

package/src/internal/window-renderer.ts

@@ -0,0 +1,25 @@
+import type * as ExpressionAst from "./expression-ast.js"
+
+const renderBoundary = (
+  boundary: ExpressionAst.WindowFrameBoundary
+): string => {
+  if (boundary === "unboundedPreceding") {
+    return "unbounded preceding"
+  }
+  if (boundary === "currentRow") {
+    return "current row"
+  }
+  if (boundary === "unboundedFollowing") {
+    return "unbounded following"
+  }
+  if ("preceding" in boundary) {
+    return `${boundary.preceding} preceding`
+  }
+  return `${boundary.following} following`
+}
+
+export const renderWindowFrame = (
+  frame: ExpressionAst.WindowFrameNode
+): string => frame.end === undefined
+  ? `${frame.unit} ${renderBoundary(frame.start)}`
+  : `${frame.unit} between ${renderBoundary(frame.start)} and ${renderBoundary(frame.end)}`