effect-qb 0.20.0 → 0.22.0

package/src/internal/executor.ts

@@ -24,6 +24,39 @@ import { isJsonValue } from "./runtime/normalize.js"
 export type FlatRow = Readonly<Record<string, unknown>>
 export type DriverMode = "raw" | "normalized"
 
+/** Driver-level result metadata retained alongside returned rows. */
+export interface DriverResult {
+  readonly rows: ReadonlyArray<FlatRow>
+  readonly affectedRows?: number
+  readonly insertId?: string | number | bigint
+}
+
+/** Decoded execution result plus portable mutation metadata when available. */
+export interface ExecutionResult<Row> {
+  readonly rows: ReadonlyArray<Row>
+  readonly affectedRows?: number
+  readonly insertId?: string | number | bigint
+}
+
+/** Failure raised when an execution result violates a requested cardinality. */
+export interface ResultCardinalityError {
+  readonly _tag: "ResultCardinalityError"
+  readonly expected: "zeroOrOne" | "exactlyOne" | "nonEmpty"
+  readonly actual: number
+}
+
+/** Reusable execution handle for one immutable query plan. */
+export interface PreparedQuery<Row, Error = never, Context = never> {
+  readonly execute: Effect.Effect<ReadonlyArray<Row>, Error, Context>
+  readonly executeResult: Effect.Effect<ExecutionResult<Row>, Error, Context>
+  readonly stream: Stream.Stream<Row, Error, Context>
+}
+
+export interface ExplainOptions {
+  readonly analyze?: boolean
+  readonly format?: "text" | "json"
+}
+
 type AstBackedExpression = Expression.Any & {
   readonly [ExpressionAst.TypeId]: ExpressionAst.Any
 }
@@ -68,6 +101,9 @@ export interface Driver<
   execute<Row>(
     query: Renderer.RenderedQuery<Row, Dialect>
   ): Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+  executeResult?<Row>(
+    query: Renderer.RenderedQuery<Row, Dialect>
+  ): Effect.Effect<DriverResult, Error, Context>
   stream<Row>(
     query: Renderer.RenderedQuery<Row, Dialect>
   ): Stream.Stream<FlatRow, Error, Context>
@@ -89,11 +125,91 @@ export interface Executor<
   execute<PlanValue extends Query.Plan.Any>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ): Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
+  executeResult<PlanValue extends Query.Plan.Any>(
+    plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+  ): Effect.Effect<ExecutionResult<Query.ResultRow<PlanValue>>, Error, Context>
+  prepare<PlanValue extends Query.Plan.Any>(
+    plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+  ): PreparedQuery<Query.ResultRow<PlanValue>, Error, Context>
   stream<PlanValue extends Query.Plan.Any>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ): Stream.Stream<Query.ResultRow<PlanValue>, Error, Context>
 }
 
+type ExecutorBase<
+  Dialect extends string,
+  Error,
+  Context
+> = Pick<Executor<Dialect, Error, Context>, "dialect" | "execute" | "stream"> & {
+  readonly executeResult?: Executor<Dialect, Error, Context>["executeResult"]
+  readonly explain?: (
+    plan: Query.Plan.Any,
+    options?: ExplainOptions
+  ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+}
+
+/** Requires an execution effect to contain at most one row. */
+export const atMostOne = <Row, Error, Context>(
+  self: Effect.Effect<ReadonlyArray<Row>, Error, Context>
+): Effect.Effect<Option.Option<Row>, Error | ResultCardinalityError, Context> =>
+  Effect.flatMap(self, (rows) =>
+    rows.length <= 1
+      ? Effect.succeed(rows.length === 0 ? Option.none() : Option.some(rows[0]!))
+      : Effect.fail({
+          _tag: "ResultCardinalityError",
+          expected: "zeroOrOne",
+          actual: rows.length
+        } satisfies ResultCardinalityError))
+
+/** Requires an execution effect to contain exactly one row. */
+export const exactlyOne = <Row, Error, Context>(
+  self: Effect.Effect<ReadonlyArray<Row>, Error, Context>
+): Effect.Effect<Row, Error | ResultCardinalityError, Context> =>
+  Effect.flatMap(self, (rows) =>
+    rows.length === 1
+      ? Effect.succeed(rows[0]!)
+      : Effect.fail({
+          _tag: "ResultCardinalityError",
+          expected: "exactlyOne",
+          actual: rows.length
+        } satisfies ResultCardinalityError))
+
+/** Requires an execution effect to contain at least one row. */
+export const nonEmpty = <Row, Error, Context>(
+  self: Effect.Effect<ReadonlyArray<Row>, Error, Context>
+): Effect.Effect<readonly [Row, ...Row[]], Error | ResultCardinalityError, Context> =>
+  Effect.flatMap(self, (rows) =>
+    rows.length > 0
+      ? Effect.succeed(rows as readonly [Row, ...Row[]])
+      : Effect.fail({
+          _tag: "ResultCardinalityError",
+          expected: "nonEmpty",
+          actual: 0
+        } satisfies ResultCardinalityError))
+
+/** Adds the standard result/cardinality contract to an executor implementation. */
+export const withResultContracts = <
+  Dialect extends string,
+  Error,
+  Context
+>(
+  base: ExecutorBase<Dialect, Error, Context>
+): Executor<Dialect, Error, Context> => {
+  const executeResult = base.executeResult ?? ((plan) =>
+    Effect.map(base.execute(plan), (rows) => ({ rows })))
+  return {
+    ...base,
+    executeResult,
+    prepare(plan) {
+      return {
+        execute: base.execute(plan),
+        executeResult: executeResult(plan),
+        stream: base.stream(plan)
+      }
+    }
+  } as Executor<Dialect, Error, Context>
+}
+
 const setPath = (
   target: Record<string, unknown>,
   path: readonly string[],
@@ -437,7 +553,7 @@ export const make = <
   execute: <PlanValue extends Query.Plan.Any>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ) => Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
-): Executor<Dialect, Error, Context> => ({
+): Executor<Dialect, Error, Context> => withResultContracts({
   dialect,
   execute(plan) {
     return (execute as any)(plan)
@@ -445,7 +561,7 @@ export const make = <
   stream(plan) {
     return Stream.unwrap(Effect.map((execute as any)(plan), (rows: ReadonlyArray<any>) => Stream.fromIterable(rows)))
   }
-}) as Executor<Dialect, Error, Context>
+})
 
 /**
  * Constructs a driver from a dialect and execution callback.
@@ -473,6 +589,9 @@ export function driver<
     readonly stream: <Row>(
       query: Renderer.RenderedQuery<Row, Dialect>
     ) => Stream.Stream<FlatRow, Error, Context>
+    readonly executeResult?: <Row>(
+      query: Renderer.RenderedQuery<Row, Dialect>
+    ) => Effect.Effect<DriverResult, Error, Context>
   }
 ): Driver<Dialect, Error, Context>
 export function driver<
@@ -492,6 +611,9 @@ export function driver<
       readonly stream: <Row>(
         query: Renderer.RenderedQuery<Row, Dialect>
       ) => Stream.Stream<FlatRow, Error, Context>
+      readonly executeResult?: <Row>(
+        query: Renderer.RenderedQuery<Row, Dialect>
+      ) => Effect.Effect<DriverResult, Error, Context>
     }
 ): Driver<Dialect, Error, Context> {
   return {
@@ -508,7 +630,10 @@ export function driver<
       )
     }
     return executeOrHandlers.stream(query)
-  }
+  },
+  ...(typeof executeOrHandlers === "function" || executeOrHandlers.executeResult === undefined
+    ? {}
+    : { executeResult: executeOrHandlers.executeResult })
   }
 }
 
@@ -528,30 +653,96 @@ export const fromDriver = <
   renderer: Renderer.Renderer<Dialect>,
   sqlDriver: Driver<Dialect, Error, Context>
 ): Executor<Dialect, Error, Context> => {
-  const executor: Executor<Dialect, Error, Context> = {
+  const renderedCache = new WeakMap<object, Renderer.RenderedQuery<any, Dialect>>()
+  const render = (plan: Query.Plan.Any): Renderer.RenderedQuery<any, Dialect> => {
+    const cached = renderedCache.get(plan)
+    if (cached !== undefined) {
+      return cached
+    }
+    const rendered = renderer.render(plan as any) as Renderer.RenderedQuery<any, Dialect>
+    renderedCache.set(plan, rendered)
+    return rendered
+  }
+  const executor = withResultContracts<Dialect, Error, Context>({
     dialect: renderer.dialect,
     execute<PlanValue extends Query.Plan.Any>(
       plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
     ) {
-      const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
+      const rendered = render(plan as Query.Plan.Any)
       return Effect.map(
         sqlDriver.execute(rendered),
         (rows) => remapRows<any>(rendered, rows)
       ) as Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
     },
+    executeResult<PlanValue extends Query.Plan.Any>(
+      plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+    ) {
+      const rendered = render(plan as Query.Plan.Any)
+      const result = sqlDriver.executeResult
+        ? sqlDriver.executeResult(rendered)
+        : Effect.map(sqlDriver.execute(rendered), (rows) => ({ rows }))
+      return Effect.map(result, ({ rows, ...metadata }) => ({
+        ...metadata,
+        rows: remapRows<any>(rendered, rows)
+      })) as Effect.Effect<ExecutionResult<Query.ResultRow<PlanValue>>, Error, Context>
+    },
     stream<PlanValue extends Query.Plan.Any>(
       plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
     ) {
-      const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
+      const rendered = render(plan as Query.Plan.Any)
       return Stream.mapArray(
         sqlDriver.stream(rendered),
         (rows) => remapRows<any>(rendered, rows) as never
       ) as Stream.Stream<Query.ResultRow<PlanValue>, Error, Context>
     }
-  }
+  })
   return executor
 }
 
+/** Builds a dialect-specific EXPLAIN statement around an already rendered query. */
+export const explainQuery = <Dialect extends string>(
+  query: Renderer.RenderedQuery<any, Dialect>,
+  options: ExplainOptions = {}
+): Renderer.RenderedQuery<FlatRow, Dialect> => {
+  const analyze = options.analyze ?? false
+  const format = options.format ?? "text"
+  let prefix: string
+  switch (query.dialect) {
+    case "postgres":
+      prefix = `explain (${[
+        ...(analyze ? ["analyze true"] : []),
+        `format ${format}`
+      ].join(", ")}) `
+      break
+    case "mysql":
+      if (analyze && format === "json") {
+        throw new Error("MySQL EXPLAIN ANALYZE cannot be combined with JSON format")
+      }
+      prefix = analyze ? "explain analyze " : format === "json" ? "explain format=json " : "explain "
+      break
+    case "sqlite":
+      if (analyze || format === "json") {
+        throw new Error("SQLite EXPLAIN QUERY PLAN does not support analyze or JSON format")
+      }
+      prefix = "explain query plan "
+      break
+    default:
+      if (analyze || format === "json") {
+        throw new Error("Portable EXPLAIN only supports text plans without analyze")
+      }
+      prefix = "explain "
+  }
+  return {
+    ...query,
+    sql: prefix + query.sql,
+    projections: [],
+    [Renderer.TypeId]: {
+      row: undefined as unknown as FlatRow,
+      dialect: query.dialect
+    }
+  }
+}
+
 export const streamFromSqlClient = <Dialect extends string>(
   query: Renderer.RenderedQuery<any, Dialect>
 ): Stream.Stream<FlatRow, SqlError.SqlError, SqlClient.SqlClient> =>

package/src/internal/expression-ast.ts

@@ -54,6 +54,24 @@ export interface FunctionCallNode<
   readonly args: Args
 }
 
+/** Safely quoted identifier interpolation inside a custom SQL expression. */
+export interface SqlIdentifierNode<
+  Parts extends readonly [string, ...string[]] = readonly [string, ...string[]]
+> {
+  readonly kind: "sqlIdentifier"
+  readonly parts: Parts
+}
+
+/** Typed custom SQL expression assembled from static text and safe values. */
+export interface CustomSqlNode<
+  Values extends readonly (Expression.Any | SqlIdentifierNode)[] =
+    readonly (Expression.Any | SqlIdentifierNode)[]
+> {
+  readonly kind: "customSql"
+  readonly strings: readonly string[]
+  readonly values: Values
+}
+
 /** `excluded.column` reference used inside insert conflict handlers. */
 export interface ExcludedNode<
   ColumnName extends string = string
@@ -70,6 +88,11 @@ export type UnaryKind =
   | "upper"
   | "lower"
   | "count"
+  | "sum"
+  | "avg"
+  | "abs"
+  | "round"
+  | "negate"
   | "max"
   | "min"
 
@@ -101,6 +124,11 @@ export type BinaryKind =
   | "contains"
   | "containedBy"
   | "overlaps"
+  | "add"
+  | "subtract"
+  | "multiply"
+  | "divide"
+  | "modulo"
 
 /** Binary expression node. */
 export interface BinaryNode<
@@ -192,7 +220,36 @@ export interface WindowOrderByNode<
 }
 
 /** Window function kinds supported by the query layer. */
-export type WindowKind = "rowNumber" | "rank" | "denseRank" | "over"
+export type WindowKind =
+  | "rowNumber"
+  | "rank"
+  | "denseRank"
+  | "over"
+  | "lag"
+  | "lead"
+  | "firstValue"
+  | "lastValue"
+
+export type WindowFrameBoundary =
+  | "unboundedPreceding"
+  | "currentRow"
+  | "unboundedFollowing"
+  | {
+      readonly preceding: number
+    }
+  | {
+      readonly following: number
+    }
+
+export type WindowFrameUnit = "rows" | "range" | "groups"
+
+export interface WindowFrameNode<
+  Unit extends WindowFrameUnit = WindowFrameUnit
+> {
+  readonly unit: Unit
+  readonly start: WindowFrameBoundary
+  readonly end?: WindowFrameBoundary
+}
 
 /** Window function expression node. */
 export interface WindowNode<
@@ -204,8 +261,11 @@ export interface WindowNode<
   readonly kind: "window"
   readonly function: Kind
   readonly value?: Value
+  readonly offset?: Expression.Any
+  readonly defaultValue?: Expression.Any
   readonly partitionBy: PartitionBy
   readonly orderBy: OrderBy
+  readonly frame?: WindowFrameNode
 }
 
 export type JsonSegmentTuple = readonly any[]
@@ -351,6 +411,7 @@ export type Any =
   | CastNode
   | CollateNode
   | FunctionCallNode
+  | CustomSqlNode
   | ExcludedNode
   | UnaryNode
   | BinaryNode

package/src/internal/fragment.ts

@@ -0,0 +1,120 @@
+import type * as Schema from "effect/Schema"
+
+import * as ExpressionAst from "./expression-ast.js"
+import * as Expression from "./scalar.js"
+import {
+  makeExpression,
+  mergeAggregationManyRuntime,
+  mergeManyDependencies,
+  type MergeAggregation,
+  type NormalizeDialect,
+  type TupleDependencies,
+  type TupleDialect
+} from "./query.js"
+
+/** A structured SQL identifier. Every path segment is quoted by the renderer. */
+export type Identifier<
+  Parts extends readonly [string, ...string[]] = readonly [string, ...string[]]
+> = ExpressionAst.SqlIdentifierNode<Parts>
+
+/** Creates a safely quoted identifier interpolation for {@link expression}. */
+export const identifier = <
+  const Parts extends readonly [string, ...string[]]
+>(...parts: Parts): Identifier<Parts> => ({
+  kind: "sqlIdentifier",
+  parts
+})
+
+type Interpolation = Expression.Any | Identifier
+
+type ExpressionsOf<
+  Values extends readonly Interpolation[]
+> = Extract<Values[number], Expression.Any>
+
+type DialectOfValues<
+  Values extends readonly Interpolation[],
+  Db extends Expression.DbType.Any
+> = [ExpressionsOf<Values>] extends [never]
+  ? Db["dialect"]
+  : TupleDialect<readonly ExpressionsOf<Values>[]>
+
+type DependenciesOfValues<
+  Values extends readonly Interpolation[]
+> = TupleDependencies<readonly ExpressionsOf<Values>[]>
+
+type KindOfValues<
+  Values extends readonly Interpolation[],
+  Current extends Expression.ScalarKind = "scalar"
+> = Values extends readonly [infer Head, ...infer Tail extends readonly Interpolation[]]
+  ? KindOfValues<
+      Tail,
+      Head extends Expression.Any
+        ? MergeAggregation<Current, Expression.KindOf<Head>>
+        : Current
+    >
+  : Current
+
+export interface Options<
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Nullable extends Expression.Nullability,
+  Kind extends Expression.ScalarKind = "scalar"
+> {
+  readonly dbType: Db
+  readonly schema: Schema.Schema<Runtime>
+  readonly nullability: Nullable
+  readonly kind?: Kind
+}
+
+/**
+ * Creates a typed SQL expression from a static template.
+ *
+ * Interpolations must be existing typed expressions or values returned by
+ * {@link identifier}; runtime values should first be lifted with
+ * `Query.literal(...)` so they remain bound parameters.
+ */
+export const expression = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Nullable extends Expression.Nullability,
+  Kind extends Expression.ScalarKind = "scalar"
+>(
+  options: Options<Runtime, Db, Nullable, Kind>
+) => <
+  const Values extends readonly Interpolation[]
+>(
+  strings: TemplateStringsArray,
+  ...values: Values
+): Expression.Scalar<
+  Runtime,
+  Db,
+  Nullable,
+  NormalizeDialect<DialectOfValues<Values, Db>>,
+  Kind extends "scalar" ? KindOfValues<Values> : Kind,
+  DependenciesOfValues<Values>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.CustomSqlNode<Values>
+} => {
+  const expressions = values.filter((value): value is Expression.Any =>
+    Expression.TypeId in value)
+  return makeExpression({
+    runtime: undefined as unknown as Runtime,
+    dbType: options.dbType,
+    runtimeSchema: options.schema,
+    driverValueMapping: options.dbType.driverValueMapping,
+    nullability: options.nullability,
+    dialect: (
+      expressions.find((value) => value[Expression.TypeId].dialect !== "standard")?.[Expression.TypeId].dialect ??
+      expressions[0]?.[Expression.TypeId].dialect ??
+      options.dbType.dialect
+    ) as NormalizeDialect<DialectOfValues<Values, Db>>,
+    kind: (options.kind ?? mergeAggregationManyRuntime(expressions)) as Kind extends "scalar"
+      ? KindOfValues<Values>
+      : Kind,
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "customSql",
+    strings: [...strings],
+    values
+  }) as never
+}

package/src/internal/function-constraints.ts

@@ -0,0 +1,105 @@
+import type { OperandCompatibilityError } from "./coercion/errors.js"
+import type * as Expression from "./scalar.js"
+
+type BaseDbType<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? BaseDbType<Base>
+    : Db
+
+type ShallowBaseDbType<Db extends Expression.DbType.Any> =
+  Db extends Expression.DbType.Domain<any, infer Base extends Expression.DbType.Any, any>
+    ? Base
+    : Db
+
+export type OrderedInput<
+  Value extends Expression.Any,
+  Dialect extends string,
+  Operator extends string
+> = BaseDbType<Expression.DbTypeOf<Value>> extends infer Db extends Expression.DbType.Any
+  ? Db extends { readonly traits: { readonly ordered: true } }
+    ? Value
+    : OperandCompatibilityError<Operator, Db, Db, Dialect, "an ordered db type">
+  : never
+
+export type CaseConversionInput<
+  Value,
+  Db extends Expression.DbType.Any,
+  Dialect extends string,
+  Operator extends string
+> = BaseDbType<Db> extends infer Base extends Expression.DbType.Any
+  ? Base extends { readonly family: "text" }
+    ? Value
+    : Dialect extends "mysql" | "sqlite"
+      ? Base extends { readonly family: "uuid" }
+        ? Value
+        : OperandCompatibilityError<Operator, Base, Base, Dialect, "a character string db type">
+      : OperandCompatibilityError<Operator, Base, Base, Dialect, "a character string db type">
+  : never
+
+type IsNullExpression<Value extends Expression.Any> =
+  ShallowBaseDbType<Expression.DbTypeOf<Value>> extends { readonly family: "null" }
+    ? true
+    : false
+
+type CompareGroup<Value extends Expression.Any> =
+  ShallowBaseDbType<Expression.DbTypeOf<Value>> extends {
+    readonly compareGroup: infer Group extends string
+  }
+    ? Group
+    : never
+
+type CoalescePairGuard<
+  Left extends Expression.Any,
+  Right extends Expression.Any,
+  Dialect extends string
+> = [CompareGroup<Left>] extends [CompareGroup<Right>]
+  ? [CompareGroup<Right>] extends [CompareGroup<Left>]
+    ? true
+    : OperandCompatibilityError<
+        "coalesce",
+        Expression.DbTypeOf<Left>,
+        Expression.DbTypeOf<Right>,
+        Dialect,
+        "the same db type family"
+      >
+  : OperandCompatibilityError<
+      "coalesce",
+      Expression.DbTypeOf<Left>,
+      Expression.DbTypeOf<Right>,
+      Dialect,
+      "the same db type family"
+    >
+
+type CoalesceTailGuard<
+  Head extends Expression.Any,
+  Tail extends readonly Expression.Any[],
+  Dialect extends string
+> = Tail extends readonly [
+  infer Next extends Expression.Any,
+  ...infer Rest extends readonly Expression.Any[]
+]
+  ? IsNullExpression<Next> extends true
+    ? CoalesceTailGuard<Head, Rest, Dialect>
+    : CoalescePairGuard<Head, Next, Dialect> extends true
+      ? CoalesceTailGuard<Head, Rest, Dialect>
+      : CoalescePairGuard<Head, Next, Dialect>
+  : true
+
+type CoalesceTupleGuard<
+  Values extends readonly Expression.Any[],
+  Dialect extends string
+> = Values extends readonly [
+  infer Head extends Expression.Any,
+  ...infer Tail extends readonly Expression.Any[]
+]
+  ? IsNullExpression<Head> extends true
+    ? CoalesceTupleGuard<Tail, Dialect>
+    : CoalesceTailGuard<Head, Tail, Dialect>
+  : true
+
+export type CoalesceConstraint<
+  Values extends readonly Expression.Any[],
+  Dialect extends string
+> = CoalesceTupleGuard<Values, Dialect> extends true
+  ? unknown
+  : readonly [CoalesceTupleGuard<Values, Dialect>]

package/src/internal/grouping-key.ts

@@ -81,6 +81,20 @@ const escapeGroupingText = (value: string): string =>
 const functionCallNameGroupingKey = (name: unknown): string =>
   escapeGroupingText(name as string)
 
+const customSqlGroupingKey = (
+  strings: readonly string[],
+  values: readonly (Expression.Any | ExpressionAst.SqlIdentifierNode)[]
+): string => strings.map((part, index) => {
+  const value = values[index]
+  if (value === undefined) {
+    return escapeGroupingText(part)
+  }
+  const rendered = isExpression(value)
+    ? groupingKeyOfExpression(value)
+    : `identifier:${value.parts.map(escapeGroupingText).join(".")}`
+  return `${escapeGroupingText(part)}${rendered}`
+}).join("|")
+
 const quantifiedComparisonGroupingName = (
   kind: "comparisonAny" | "comparisonAll"
 ): "compareAny" | "compareAll" =>
@@ -184,12 +198,19 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
       return `collate(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`
     case "function":
       return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`
+    case "customSql":
+      return `customSql(${customSqlGroupingKey(ast.strings, ast.values)})`
     case "isNull":
     case "isNotNull":
     case "not":
     case "upper":
     case "lower":
     case "count":
+    case "sum":
+    case "avg":
+    case "abs":
+    case "round":
+    case "negate":
     case "max":
     case "min":
       return `${ast.kind}(${requiredExpressionGroupingKey(ast.kind, ast.value)})`
@@ -210,6 +231,11 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "contains":
     case "containedBy":
     case "overlaps":
+    case "add":
+    case "subtract":
+    case "multiply":
+    case "divide":
+    case "modulo":
       return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`
     case "and":
     case "or":