effect-qb 0.20.0 → 0.22.0

package/src/internal/dialect-renderers/mysql.ts

@@ -7,6 +7,8 @@ import * as QueryAst from "../query-ast.js"
 import { renderDbTypeName, type RenderState, type RenderValueContext, type SqlDialect } from "../dialect.js"
 import { renderPortableDatatypeCastType, renderPortableDatatypeDdlType } from "../datatypes/matrix.js"
 import * as ExpressionAst from "../expression-ast.js"
+import { renderCustomSql } from "../custom-sql-renderer.js"
+import { renderWindowFrame } from "../window-renderer.js"
 import * as JsonPath from "../json/path.js"
 import { renderMysqlMutationLockMode, renderSelectLockMode } from "../dsl-plan-runtime.js"
 import { expectConflictClause } from "../dsl-mutation-runtime.js"
@@ -1867,6 +1869,8 @@ export const renderExpression = (
       return `cast(${renderExpression(expectValueExpression("cast", ast.value), state, dialect)} as ${renderCastType(dialect, ast.target)})`
     case "function":
       return renderFunctionCall(ast.name, ast.args, state, dialect)
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression)
     case "eq":
       return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect)
     case "neq":
@@ -1879,6 +1883,16 @@ export const renderExpression = (
       return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect)
     case "gte":
       return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect)
+    case "add":
+      return renderBinaryExpression("add", "+", ast.left, ast.right, state, dialect)
+    case "subtract":
+      return renderBinaryExpression("subtract", "-", ast.left, ast.right, state, dialect)
+    case "multiply":
+      return renderBinaryExpression("multiply", "*", ast.left, ast.right, state, dialect)
+    case "divide":
+      return renderBinaryExpression("divide", "/", ast.left, ast.right, state, dialect)
+    case "modulo":
+      return renderBinaryExpression("modulo", "%", ast.left, ast.right, state, dialect)
     case "like":
       return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect)
     case "ilike": {
@@ -1983,6 +1997,16 @@ export const renderExpression = (
       return `lower(${renderExpression(expectValueExpression("lower", ast.value), state, dialect)})`
     case "count":
       return `count(${renderExpression(expectValueExpression("count", ast.value), state, dialect)})`
+    case "sum":
+      return `sum(${renderExpression(expectValueExpression("sum", ast.value), state, dialect)})`
+    case "avg":
+      return `avg(${renderExpression(expectValueExpression("avg", ast.value), state, dialect)})`
+    case "abs":
+      return `abs(${renderExpression(expectValueExpression("abs", ast.value), state, dialect)})`
+    case "round":
+      return `round(${renderExpression(expectValueExpression("round", ast.value), state, dialect)})`
+    case "negate":
+      return `(-${renderExpression(expectValueExpression("negate", ast.value), state, dialect)})`
     case "max":
       return `max(${renderExpression(expectValueExpression("max", ast.value), state, dialect)})`
     case "min":
@@ -2021,25 +2045,56 @@ export const renderExpression = (
         readonly value: Expression.Any
         readonly direction: string
       }[]
-      const clauses: string[] = []
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`)
-      }
-      if (orderBy.length > 0) {
-        clauses.push(`order by ${orderBy.map((entry) =>
-          `${renderExpression(entry.value, state, dialect)} ${entry.direction}`
-        ).join(", ")}`)
+      const renderSpecification = (): string => {
+        const clauses: string[] = []
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`)
+        }
+        if (orderBy.length > 0) {
+          clauses.push(`order by ${orderBy.map((entry) =>
+            `${renderExpression(entry.value, state, dialect)} ${entry.direction}`
+          ).join(", ")}`)
+        }
+        if (ast.frame !== undefined) {
+          clauses.push(renderWindowFrame(ast.frame))
+        }
+        return clauses.join(" ")
       }
-      const specification = clauses.join(" ")
       switch (ast.function) {
         case "rowNumber":
-          return `row_number() over (${specification})`
+          return `row_number() over (${renderSpecification()})`
         case "rank":
-          return `rank() over (${specification})`
+          return `rank() over (${renderSpecification()})`
         case "denseRank":
-          return `dense_rank() over (${specification})`
+          return `dense_rank() over (${renderSpecification()})`
         case "over":
-          return `${renderExpression(ast.value as Expression.Any, state, dialect)} over (${specification})`
+          return `${renderExpression(ast.value as Expression.Any, state, dialect)} over (${renderSpecification()})`
+        case "lag":
+        case "lead": {
+          const args = [renderExpression(ast.value as Expression.Any, state, dialect)]
+          if (ast.offset !== undefined) {
+            const offsetAst = (ast.offset as Expression.Any & {
+              readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+            })[ExpressionAst.TypeId]
+            if (
+              offsetAst.kind !== "literal" ||
+              typeof offsetAst.value !== "number" ||
+              !Number.isSafeInteger(offsetAst.value) ||
+              offsetAst.value < 0
+            ) {
+              throw new Error(`${ast.function} offset must be a non-negative integer literal in MySQL`)
+            }
+            args.push(String(offsetAst.value))
+          }
+          if (ast.defaultValue !== undefined) {
+            args.push(renderExpression(ast.defaultValue, state, dialect))
+          }
+          return `${ast.function}(${args.join(", ")}) over (${renderSpecification()})`
+        }
+        case "firstValue":
+          return `first_value(${renderExpression(ast.value as Expression.Any, state, dialect)}) over (${renderSpecification()})`
+        case "lastValue":
+          return `last_value(${renderExpression(ast.value as Expression.Any, state, dialect)}) over (${renderSpecification()})`
       }
       break
     }

package/src/internal/dialect-renderers/postgres.ts

@@ -7,6 +7,8 @@ import * as QueryAst from "../query-ast.js"
 import { renderDbTypeName, type RenderState, type RenderValueContext, type SqlDialect } from "../dialect.js"
 import { renderPortableDatatypeCastType, renderPortableDatatypeDdlType } from "../datatypes/matrix.js"
 import * as ExpressionAst from "../expression-ast.js"
+import { renderCustomSql } from "../custom-sql-renderer.js"
+import { renderWindowFrame } from "../window-renderer.js"
 import * as JsonPath from "../json/path.js"
 import { renderSelectLockMode } from "../dsl-plan-runtime.js"
 import { expectConflictClause } from "../dsl-mutation-runtime.js"
@@ -458,6 +460,32 @@ const renderBinaryExpression = (
   return `(${renderExpression(leftExpression, state, dialect)} ${operator} ${renderExpression(rightExpression, state, dialect)})`
 }
 
+const renderNumericExpression = (
+  expression: Expression.Any,
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  const rendered = renderExpression(expression, state, dialect)
+  const ast = (expression as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  return dialect.name === "postgres" && ast.kind === "literal"
+    ? `cast(${rendered} as ${renderCastType(dialect, expression[Expression.TypeId].dbType)})`
+    : rendered
+}
+
+const renderNumericBinaryExpression = (
+  functionName: string,
+  operator: string,
+  left: unknown,
+  right: unknown,
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right)
+  return `(${renderNumericExpression(leftExpression, state, dialect)} ${operator} ${renderNumericExpression(rightExpression, state, dialect)})`
+}
+
 const postgresRangeSubtypeByKind: Readonly<Record<string, string>> = {
   int4range: "int4",
   int8range: "int8",
@@ -1873,6 +1901,8 @@ export const renderExpression = (
       return `(${renderExpression(expectValueExpression("collate", ast.value), state, dialect)} collate ${renderCollation(ast.collation)})`
     case "function":
       return renderFunctionCall(ast.name, ast.args, state, dialect)
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression)
     case "eq":
       return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect)
     case "neq":
@@ -1885,6 +1915,16 @@ export const renderExpression = (
       return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect)
     case "gte":
       return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect)
+    case "add":
+      return renderNumericBinaryExpression("add", "+", ast.left, ast.right, state, dialect)
+    case "subtract":
+      return renderNumericBinaryExpression("subtract", "-", ast.left, ast.right, state, dialect)
+    case "multiply":
+      return renderNumericBinaryExpression("multiply", "*", ast.left, ast.right, state, dialect)
+    case "divide":
+      return renderNumericBinaryExpression("divide", "/", ast.left, ast.right, state, dialect)
+    case "modulo":
+      return renderNumericBinaryExpression("modulo", "%", ast.left, ast.right, state, dialect)
     case "like":
       return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect)
     case "ilike": {
@@ -2004,6 +2044,16 @@ export const renderExpression = (
       return `lower(${renderExpression(expectValueExpression("lower", ast.value), state, dialect)})`
     case "count":
       return `count(${renderExpression(expectValueExpression("count", ast.value), state, dialect)})`
+    case "sum":
+      return `sum(${renderNumericExpression(expectValueExpression("sum", ast.value), state, dialect)})`
+    case "avg":
+      return `avg(${renderNumericExpression(expectValueExpression("avg", ast.value), state, dialect)})`
+    case "abs":
+      return `abs(${renderNumericExpression(expectValueExpression("abs", ast.value), state, dialect)})`
+    case "round":
+      return `round(${renderNumericExpression(expectValueExpression("round", ast.value), state, dialect)})`
+    case "negate":
+      return `(-${renderNumericExpression(expectValueExpression("negate", ast.value), state, dialect)})`
     case "max":
       return `max(${renderExpression(expectValueExpression("max", ast.value), state, dialect)})`
     case "min":
@@ -2054,25 +2104,45 @@ export const renderExpression = (
         readonly value: Expression.Any
         readonly direction: string
       }[]
-      const clauses: string[] = []
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`)
-      }
-      if (orderBy.length > 0) {
-        clauses.push(`order by ${orderBy.map((entry) =>
-          `${renderExpression(entry.value, state, dialect)} ${entry.direction}`
-        ).join(", ")}`)
+      const renderSpecification = (): string => {
+        const clauses: string[] = []
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`)
+        }
+        if (orderBy.length > 0) {
+          clauses.push(`order by ${orderBy.map((entry) =>
+            `${renderExpression(entry.value, state, dialect)} ${entry.direction}`
+          ).join(", ")}`)
+        }
+        if (ast.frame !== undefined) {
+          clauses.push(renderWindowFrame(ast.frame))
+        }
+        return clauses.join(" ")
       }
-      const specification = clauses.join(" ")
       switch (ast.function) {
         case "rowNumber":
-          return `row_number() over (${specification})`
+          return `row_number() over (${renderSpecification()})`
         case "rank":
-          return `rank() over (${specification})`
+          return `rank() over (${renderSpecification()})`
         case "denseRank":
-          return `dense_rank() over (${specification})`
+          return `dense_rank() over (${renderSpecification()})`
         case "over":
-          return `${renderExpression(ast.value as Expression.Any, state, dialect)} over (${specification})`
+          return `${renderExpression(ast.value as Expression.Any, state, dialect)} over (${renderSpecification()})`
+        case "lag":
+        case "lead": {
+          const args = [renderExpression(ast.value as Expression.Any, state, dialect)]
+          if (ast.offset !== undefined) {
+            args.push(renderExpression(ast.offset, state, dialect))
+          }
+          if (ast.defaultValue !== undefined) {
+            args.push(renderExpression(ast.defaultValue, state, dialect))
+          }
+          return `${ast.function}(${args.join(", ")}) over (${renderSpecification()})`
+        }
+        case "firstValue":
+          return `first_value(${renderExpression(ast.value as Expression.Any, state, dialect)}) over (${renderSpecification()})`
+        case "lastValue":
+          return `last_value(${renderExpression(ast.value as Expression.Any, state, dialect)}) over (${renderSpecification()})`
       }
       break
     }

package/src/internal/dialect-renderers/sqlite.ts

@@ -7,6 +7,8 @@ import * as QueryAst from "../query-ast.js"
 import { renderDbTypeName, type RenderState, type RenderValueContext, type SqlDialect } from "../dialect.js"
 import { renderPortableDatatypeCastType, renderPortableDatatypeDdlType } from "../datatypes/matrix.js"
 import * as ExpressionAst from "../expression-ast.js"
+import { renderCustomSql } from "../custom-sql-renderer.js"
+import { renderWindowFrame } from "../window-renderer.js"
 import * as JsonPath from "../json/path.js"
 import { expectConflictClause } from "../dsl-mutation-runtime.js"
 import { expectDdlClauseKind, normalizeStatementFlag, normalizeStatementIdentifier } from "../dsl-transaction-ddl-runtime.js"
@@ -1795,6 +1797,8 @@ export const renderExpression = (
       return `cast(${renderExpression(expectValueExpression("cast", ast.value), state, dialect)} as ${renderCastType(dialect, ast.target)})`
     case "function":
       return renderFunctionCall(ast.name, ast.args, state, dialect)
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression)
     case "eq":
       return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect)
     case "neq":
@@ -1807,6 +1811,16 @@ export const renderExpression = (
       return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect)
     case "gte":
       return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect)
+    case "add":
+      return renderBinaryExpression("add", "+", ast.left, ast.right, state, dialect)
+    case "subtract":
+      return renderBinaryExpression("subtract", "-", ast.left, ast.right, state, dialect)
+    case "multiply":
+      return renderBinaryExpression("multiply", "*", ast.left, ast.right, state, dialect)
+    case "divide":
+      return renderBinaryExpression("divide", "/", ast.left, ast.right, state, dialect)
+    case "modulo":
+      return renderBinaryExpression("modulo", "%", ast.left, ast.right, state, dialect)
     case "like":
       return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect)
     case "ilike": {
@@ -1902,6 +1916,16 @@ export const renderExpression = (
       return `lower(${renderExpression(expectValueExpression("lower", ast.value), state, dialect)})`
     case "count":
       return `count(${renderExpression(expectValueExpression("count", ast.value), state, dialect)})`
+    case "sum":
+      return `sum(${renderExpression(expectValueExpression("sum", ast.value), state, dialect)})`
+    case "avg":
+      return `avg(${renderExpression(expectValueExpression("avg", ast.value), state, dialect)})`
+    case "abs":
+      return `abs(${renderExpression(expectValueExpression("abs", ast.value), state, dialect)})`
+    case "round":
+      return `round(${renderExpression(expectValueExpression("round", ast.value), state, dialect)})`
+    case "negate":
+      return `(-${renderExpression(expectValueExpression("negate", ast.value), state, dialect)})`
     case "max":
       return `max(${renderExpression(expectValueExpression("max", ast.value), state, dialect)})`
     case "min":
@@ -1952,25 +1976,45 @@ export const renderExpression = (
         readonly value: Expression.Any
         readonly direction: string
       }[]
-      const clauses: string[] = []
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`)
-      }
-      if (orderBy.length > 0) {
-        clauses.push(`order by ${orderBy.map((entry) =>
-          `${renderExpression(entry.value, state, dialect)} ${entry.direction}`
-        ).join(", ")}`)
+      const renderSpecification = (): string => {
+        const clauses: string[] = []
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`)
+        }
+        if (orderBy.length > 0) {
+          clauses.push(`order by ${orderBy.map((entry) =>
+            `${renderExpression(entry.value, state, dialect)} ${entry.direction}`
+          ).join(", ")}`)
+        }
+        if (ast.frame !== undefined) {
+          clauses.push(renderWindowFrame(ast.frame))
+        }
+        return clauses.join(" ")
       }
-      const specification = clauses.join(" ")
       switch (ast.function) {
         case "rowNumber":
-          return `row_number() over (${specification})`
+          return `row_number() over (${renderSpecification()})`
         case "rank":
-          return `rank() over (${specification})`
+          return `rank() over (${renderSpecification()})`
         case "denseRank":
-          return `dense_rank() over (${specification})`
+          return `dense_rank() over (${renderSpecification()})`
         case "over":
-          return `${renderExpression(ast.value as Expression.Any, state, dialect)} over (${specification})`
+          return `${renderExpression(ast.value as Expression.Any, state, dialect)} over (${renderSpecification()})`
+        case "lag":
+        case "lead": {
+          const args = [renderExpression(ast.value as Expression.Any, state, dialect)]
+          if (ast.offset !== undefined) {
+            args.push(renderExpression(ast.offset, state, dialect))
+          }
+          if (ast.defaultValue !== undefined) {
+            args.push(renderExpression(ast.defaultValue, state, dialect))
+          }
+          return `${ast.function}(${args.join(", ")}) over (${renderSpecification()})`
+        }
+        case "firstValue":
+          return `first_value(${renderExpression(ast.value as Expression.Any, state, dialect)}) over (${renderSpecification()})`
+        case "lastValue":
+          return `last_value(${renderExpression(ast.value as Expression.Any, state, dialect)}) over (${renderSpecification()})`
       }
       break
     }

package/src/internal/dynamic.ts

@@ -0,0 +1,131 @@
+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,
+  mergeManyDependencies,
+  mergeNullabilityManyRuntime,
+  type MergeNullabilityTuple,
+  type PredicateInput,
+  type TupleDependencies,
+  type TupleDialect
+} from "./query.js"
+
+type BooleanLiteral<Value extends boolean> = Expression.Scalar<
+  Value,
+  ReturnType<typeof standardDatatypes.boolean>,
+  "never",
+  "standard",
+  "scalar",
+  never
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.LiteralNode<Value>
+}
+
+type AsPredicate<Value extends PredicateInput> =
+  Value extends Expression.Any ? Value : BooleanLiteral<Extract<Value, boolean>>
+
+type PredicateTuple<Values extends readonly PredicateInput[]> = {
+  readonly [Key in keyof Values]: AsPredicate<Values[Key]>
+}
+
+type CombinedPredicate<
+  Kind extends "and" | "or",
+  Values extends readonly PredicateInput[]
+> = Values extends readonly [] ? BooleanLiteral<Kind extends "and" ? true : false> : Expression.Scalar<
+  boolean,
+  ReturnType<typeof standardDatatypes.boolean>,
+  MergeNullabilityTuple<PredicateTuple<Values>>,
+  TupleDialect<PredicateTuple<Values>>,
+  "scalar",
+  TupleDependencies<PredicateTuple<Values>>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.VariadicNode<Kind, PredicateTuple<Values>>
+}
+
+const booleanLiteral = <const Value extends boolean>(
+  value: Value
+): BooleanLiteral<Value> => makeExpression({
+  runtime: value,
+  dbType: standardDatatypes.boolean(),
+  runtimeSchema: Schema.Boolean,
+  nullability: "never",
+  dialect: "standard",
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "literal",
+  value
+})
+
+const combine = <
+  Kind extends "and" | "or",
+  const Values extends readonly PredicateInput[]
+>(
+  kind: Kind,
+  values: Values,
+  identity: boolean
+): CombinedPredicate<Kind, Values> => {
+  if (values.length === 0) {
+    return booleanLiteral(identity) as unknown as CombinedPredicate<Kind, Values>
+  }
+  const expressions = values.map((value) =>
+    typeof value === "boolean" ? booleanLiteral(value) : value) as PredicateTuple<Values>
+  return makeExpression({
+    runtime: identity,
+    dbType: standardDatatypes.boolean(),
+    runtimeSchema: Schema.Boolean,
+    nullability: mergeNullabilityManyRuntime(expressions),
+    dialect: expressions.find((value) => value[Expression.TypeId].dialect !== "standard")?.[Expression.TypeId].dialect ??
+      expressions[0]![Expression.TypeId].dialect,
+    kind: "scalar",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind,
+    values: expressions
+  }) as CombinedPredicate<Kind, Values>
+}
+
+/** Combines a runtime list of predicates; an empty list is SQL true. */
+export const andAll = <
+  const Values extends readonly PredicateInput[]
+>(values: Values): CombinedPredicate<"and", Values> =>
+  combine("and", values, true)
+
+/** Combines a runtime list of predicates; an empty list is SQL false. */
+export const orAll = <
+  const Values extends readonly PredicateInput[]
+>(values: Values): CombinedPredicate<"or", Values> =>
+  combine("or", values, false)
+
+/** Applies a query modifier only when the condition is true. */
+export const when = <
+  const Condition extends boolean,
+  Modifier extends (value: any) => any
+>(
+  condition: Condition,
+  modifier: Modifier
+) => <Value>(
+  value: Value
+): Condition extends true ? ReturnType<Modifier> : Condition extends false ? Value : Value | ReturnType<Modifier> =>
+  (condition ? modifier(value) : value) as never
+
+/**
+ * Returns a selection fragment suitable for object spread.
+ *
+ * Dynamic conditions correctly make the selected fields optional.
+ */
+export const includeIf = <
+  const Condition extends boolean,
+  const Selection extends Readonly<Record<string, unknown>>
+>(
+  condition: Condition,
+  selection: Selection
+): Condition extends true
+  ? Selection
+  : Condition extends false
+    ? {}
+    : Partial<Selection> =>
+  (condition ? selection : {}) as never