Function computedSelectExpr

packages/infra/src/Store/Cosmos/query.ts:340–422

(key: string, computed: ComputedProjectionIrExpression)

  }

  const computedSelectExpr = (key: string, computed: ComputedProjectionIrExpression) => {
    const relationPath = computed.path
    const relationAlias = relationPath
    const relationSource = dottedToAccess(`f.${relationPath}`)
    const compileExpr = (expression: ComputedProjectionMathIrExpression): string => {
      switch (expression._tag) {
        case "field":
          return dottedToAccess(`${relationAlias}.${expression.field}`)
        case "mul":
          return `(${compileExpr(expression.left)} * ${compileExpr(expression.right)})`
        default:
          return assertUnreachable(expression)
      }
    }
    const factorExpr = (unitExpr: string, toBase: string, factors: Readonly<Record<string, number>>) => {
      const entries = Object.entries(factors).filter(([, factor]) => Number.isFinite(factor))
      return entries.reduceRight<string>(
        (acc, [unit, factor]) => `IIF(${unitExpr} = ${JSON.stringify(unit)}, ${factor}, ${acc})`,
        `IIF(${unitExpr} = ${JSON.stringify(toBase)}, 1, 0)`
      )
    }
    const filter = "filter" in computed ? computed.filter : []
    // Print filter once — `print` mutates the outer `i` parameter counter, so
    // re-walking the same filter would double-bump it and desync @v indices.
    const filterSql = filter.length > 0 ? print(filter, relationPath, false) : ""
    const where = filterSql ? ` WHERE ${filterSql}` : ""
    switch (computed._tag) {
      case "relation-count":
        return `(SELECT VALUE COUNT(1) FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
      case "relation-any":
        return `EXISTS(SELECT VALUE ${relationAlias} FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
      case "relation-every": {
        // ∀x.P(x) ≡ ¬∃x.¬P(x). Cosmos has no NOT(...) on EXISTS subqueries directly,
        // but we can flip via NOT EXISTS(... WHERE NOT (filter)).
        if (filter.length === 0) return `true AS ${key}`
        return `NOT EXISTS(SELECT VALUE ${relationAlias} FROM ${relationAlias} IN ${relationSource} WHERE NOT (${filterSql})) AS ${key}`
      }
      case "relation-distinct-count": {
        const fieldRef = dottedToAccess(`${relationAlias}.${computed.field}`)
        return `(SELECT VALUE COUNT(1) FROM (SELECT DISTINCT VALUE ${fieldRef} FROM ${relationAlias} IN ${relationSource}${where})) AS ${key}`
      }
      case "relation-sum": {
        const fieldRef = dottedToAccess(`${relationAlias}.${computed.field}`)
        return `(SELECT VALUE SUM(${fieldRef}) FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
      }
      case "relation-sum-expr": {
        const expression = compileExpr(computed.expression)
        return `(SELECT VALUE SUM(${expression}) FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
      }
      case "relation-sum-expr-by": {
        const unitRef = dottedToAccess(`${relationAlias}.${computed.unit}`)
        const expression = compileExpr(computed.expression)
        return `ARRAY(SELECT VALUE { "unit": ${unitRef}, "total": SUM(${expression}) } FROM ${relationAlias} IN ${relationSource}${where} GROUP BY ${unitRef}) AS ${key}`
      }
      case "relation-sum-expr-normalized": {
        const unitRef = dottedToAccess(`${relationAlias}.${computed.unit}`)
        const expression = compileExpr(computed.expression)
        const factor = factorExpr(unitRef, computed.toBase, computed.factors)