effect-qb 0.13.0 → 0.15.0

package/src/internal/dsl-plan-runtime.ts

@@ -0,0 +1,387 @@
+import * as Expression from "./scalar.js"
+import * as Plan from "./row-set.js"
+import * as Table from "./table.js"
+
+type DslPlanRuntimeContext = {
+  readonly profile: {
+    readonly dialect: string
+  }
+  readonly makePlan: (...args: readonly any[]) => any
+  readonly getAst: (plan: any) => any
+  readonly getQueryState: (plan: any) => any
+  readonly currentRequiredList: (required: any) => readonly string[]
+  readonly toDialectExpression: (value: any) => Expression.Any
+  readonly toDialectNumericExpression: (value: any) => Expression.Any
+  readonly extractRequiredFromDialectInputRuntime: (value: any) => readonly string[]
+  readonly extractRequiredFromDialectNumericInputRuntime: (value: any) => readonly string[]
+  readonly formulaOfExpressionRuntime: (value: Expression.Any) => any
+  readonly assumeFormulaTrue: (assumptions: any, formula: any) => any
+  readonly trueFormula: () => any
+  readonly sourceDetails: (source: any) => { readonly sourceName: string; readonly sourceBaseName: string }
+  readonly presenceWitnessesOfSourceLike: (source: any) => readonly string[]
+  readonly attachInsertSource: (plan: any, source: any) => any
+}
+
+export const makeDslPlanRuntime = (ctx: DslPlanRuntimeContext) => {
+  const buildSetOperation = (kind: string, all: boolean, left: any, right: any) => {
+    const leftState = left[Plan.TypeId]
+    const leftAst = ctx.getAst(left)
+    const basePlan = leftAst.kind === "set"
+      ? leftAst.setBase ?? left
+      : left
+    const leftOperations = leftAst.kind === "set"
+      ? [...(leftAst.setOperations ?? [])]
+      : []
+    return ctx.makePlan({
+      selection: leftState.selection,
+      required: undefined,
+      available: {},
+      dialect: leftState.dialect ?? right[Plan.TypeId].dialect
+    }, {
+      kind: "set",
+      select: leftState.selection,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: [],
+      setBase: basePlan,
+      setOperations: [
+        ...leftOperations,
+        {
+          kind,
+          all,
+          query: right
+        }
+      ]
+    }, undefined, undefined, "set")
+  }
+
+  const where = (predicate: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const predicateExpression = ctx.toDialectExpression(predicate)
+      const predicateRequired = ctx.extractRequiredFromDialectInputRuntime(predicate)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...predicateRequired].filter((name, index, values) =>
+          !(name in current.available) && values.indexOf(name) === index),
+        available: current.available,
+        dialect: current.dialect ?? predicateExpression[Expression.TypeId].dialect
+      }, {
+        ...currentAst,
+        where: [...currentAst.where, {
+          kind: "where",
+          predicate: predicateExpression
+        }]
+      }, ctx.assumeFormulaTrue(
+        currentQuery.assumptions,
+        ctx.formulaOfExpressionRuntime(predicateExpression)
+      ), currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const from = (source: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+
+      if (currentQuery.statement === "insert") {
+        return ctx.attachInsertSource(plan, source)
+      }
+
+      if (
+        typeof source !== "object" ||
+        source === null ||
+        ("kind" in source && source.kind === "values" && !("name" in source)) ||
+        (!(Table.TypeId in source) && !("name" in source && "baseName" in source))
+      ) {
+        throw new Error("from(...) requires an aliased source in select/update statements")
+      }
+
+      const sourceLike = source
+      const { sourceName, sourceBaseName } = ctx.sourceDetails(sourceLike)
+      const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(sourceLike)
+
+      if (currentQuery.statement === "select") {
+        return ctx.makePlan({
+          selection: current.selection,
+          required: ctx.currentRequiredList(current.required).filter((name) => name !== sourceName),
+          available: {
+            [sourceName]: {
+              name: sourceName,
+              mode: "required",
+              baseName: sourceBaseName,
+              _presentFormula: ctx.trueFormula(),
+              _presenceWitnesses: presenceWitnesses
+            }
+          },
+          dialect: current.dialect
+        }, {
+          ...currentAst,
+          from: {
+            kind: "from",
+            tableName: sourceName,
+            baseTableName: sourceBaseName,
+            source: sourceLike
+          }
+        }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+      }
+
+      if (currentQuery.statement === "update") {
+        const nextAvailable = {
+          ...current.available,
+          [sourceName]: {
+            name: sourceName,
+            mode: "required",
+            baseName: sourceBaseName,
+            _presentFormula: ctx.trueFormula(),
+            _presenceWitnesses: presenceWitnesses
+          }
+        }
+        return ctx.makePlan({
+          selection: current.selection,
+          required: ctx.currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+          available: nextAvailable,
+          dialect: current.dialect
+        }, {
+          ...currentAst,
+          fromSources: [
+            ...(currentAst.fromSources ?? []),
+            {
+              kind: "from",
+              tableName: sourceName,
+              baseTableName: sourceBaseName,
+              source: sourceLike
+            }
+          ]
+        }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+      }
+
+      throw new Error(`from(...) is not supported for ${currentQuery.statement} statements`)
+    }
+
+  const having = (predicate: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const predicateExpression = ctx.toDialectExpression(predicate)
+      const predicateRequired = ctx.extractRequiredFromDialectInputRuntime(predicate)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...predicateRequired].filter((name, index, values) =>
+          !(name in current.available) && values.indexOf(name) === index),
+        available: current.available,
+        dialect: current.dialect ?? predicateExpression[Expression.TypeId].dialect
+      }, {
+        ...currentAst,
+        having: [...currentAst.having, {
+          kind: "having",
+          predicate: predicateExpression
+        }]
+      }, ctx.assumeFormulaTrue(
+        currentQuery.assumptions,
+        ctx.formulaOfExpressionRuntime(predicateExpression)
+      ), currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const crossJoin = (table: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const { sourceName, sourceBaseName } = ctx.sourceDetails(table)
+      const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table)
+      const nextAvailable = {
+        ...current.available,
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName,
+          _presentFormula: ctx.trueFormula(),
+          _presenceWitnesses: presenceWitnesses
+        }
+      }
+      return ctx.makePlan({
+        selection: current.selection,
+        required: ctx.currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+        available: nextAvailable,
+        dialect: current.dialect ?? table[Plan.TypeId]?.dialect ?? table.dialect
+      }, {
+        ...currentAst,
+        joins: [...currentAst.joins, {
+          kind: "cross",
+          tableName: sourceName,
+          baseTableName: sourceBaseName,
+          source: table
+        }]
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const join = (kind: string, table: any, on: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const onExpression = ctx.toDialectExpression(on)
+      const onFormula = ctx.formulaOfExpressionRuntime(onExpression)
+      const { sourceName, sourceBaseName } = ctx.sourceDetails(table)
+      const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table)
+      const baseAvailable = (kind === "right" || kind === "full"
+        ? Object.fromEntries(
+          Object.entries(current.available as Record<string, any>).map(([name, source]) => [name, {
+            name: source.name,
+            mode: "optional",
+            baseName: source.baseName,
+            _presentFormula: source._presentFormula,
+            _presenceWitnesses: source._presenceWitnesses
+          }])
+        )
+        : current.available) as Record<string, any>
+      const nextAvailable = {
+        ...baseAvailable,
+        [sourceName]: {
+          name: sourceName,
+          mode: (kind === "left" || kind === "full") ? "optional" : "required",
+          baseName: sourceBaseName,
+          _presentFormula: (kind === "inner" || kind === "left") ? onFormula : ctx.trueFormula(),
+          _presenceWitnesses: presenceWitnesses
+        }
+      }
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...ctx.extractRequiredFromDialectInputRuntime(on)].filter((name, index, values) =>
+          !(name in nextAvailable) && values.indexOf(name) === index),
+        available: nextAvailable,
+        dialect: current.dialect ?? table.dialect ?? onExpression[Expression.TypeId].dialect
+      }, {
+        ...currentAst,
+        joins: [...currentAst.joins, {
+          kind,
+          tableName: sourceName,
+          baseTableName: sourceBaseName,
+          source: table,
+          on: onExpression
+        }]
+      }, (
+        kind === "inner"
+          ? ctx.assumeFormulaTrue(currentQuery.assumptions, onFormula)
+          : currentQuery.assumptions
+      ), currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const orderBy = (value: any, direction: "asc" | "desc" = "asc") =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const expression = ctx.toDialectExpression(value)
+      const required = ctx.extractRequiredFromDialectInputRuntime(value)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index, values) =>
+          !(name in current.available) && values.indexOf(name) === index),
+        available: current.available,
+        dialect: current.dialect ?? expression[Expression.TypeId].dialect
+      }, {
+        ...currentAst,
+        orderBy: [...currentAst.orderBy, {
+          kind: "orderBy",
+          value: expression,
+          direction
+        }]
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const lock = (mode: string, options: { readonly nowait?: boolean; readonly skipLocked?: boolean } = {}) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: current.required,
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        lock: {
+          kind: "lock",
+          mode,
+          nowait: options.nowait ?? false,
+          skipLocked: options.skipLocked ?? false
+        }
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const distinct = () =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: current.required,
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        distinct: true
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const limit = (value: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const expression = ctx.toDialectNumericExpression(value)
+      const required = ctx.extractRequiredFromDialectNumericInputRuntime(value)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index, values) =>
+          !(name in current.available) && values.indexOf(name) === index),
+        available: current.available,
+        dialect: current.dialect ?? expression[Expression.TypeId].dialect
+      }, {
+        ...currentAst,
+        limit: expression
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const offset = (value: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const expression = ctx.toDialectNumericExpression(value)
+      const required = ctx.extractRequiredFromDialectNumericInputRuntime(value)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index, values) =>
+          !(name in current.available) && values.indexOf(name) === index),
+        available: current.available,
+        dialect: current.dialect ?? expression[Expression.TypeId].dialect
+      }, {
+        ...currentAst,
+        offset: expression
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+    }
+
+  return {
+    buildSetOperation,
+    where,
+    from,
+    having,
+    crossJoin,
+    join,
+    orderBy,
+    lock,
+    distinct,
+    limit,
+    offset
+  }
+}

package/src/internal/dsl-query-runtime.ts

@@ -0,0 +1,160 @@
+import * as Expression from "./scalar.js"
+import * as Plan from "./row-set.js"
+
+type DslQueryRuntimeContext = {
+  readonly profile: {
+    readonly dialect: string
+  }
+  readonly ValuesInputProto: object
+  readonly normalizeValuesRow: (row: any) => Record<string, Expression.Any>
+  readonly normalizeUnnestColumns: (columns: any) => Record<string, readonly Expression.Any[]>
+  readonly makeColumnReferenceSelection: (alias: string, selection: Record<string, Expression.Any>) => any
+  readonly toDialectNumericExpression: (value: any) => Expression.Any
+  readonly extractRequiredRuntime: (selection: any) => readonly string[]
+  readonly makePlan: (...args: readonly any[]) => any
+  readonly getAst: (plan: any) => any
+  readonly getQueryState: (plan: any) => any
+  readonly currentRequiredList: (required: any) => readonly string[]
+  readonly dedupeGroupedExpressions: (values: readonly any[]) => any
+}
+
+export const makeDslQueryRuntime = (ctx: DslQueryRuntimeContext) => {
+  const values = (rows: readonly [Record<string, any>, ...Record<string, any>[]]) => {
+    if (rows.length === 0) {
+      throw new Error("values(...) requires at least one row")
+    }
+    const normalizedRows = rows.map((row) => ctx.normalizeValuesRow(row)) as unknown as readonly [
+      Record<string, Expression.Any>,
+      ...Record<string, Expression.Any>[]
+    ]
+    const columnNames = Object.keys(normalizedRows[0]!)
+    for (const row of normalizedRows) {
+      const rowKeys = Object.keys(row)
+      if (rowKeys.length !== columnNames.length || !rowKeys.every((key, index) => key === columnNames[index])) {
+        throw new Error("values(...) rows must project the same columns in the same order")
+      }
+    }
+    return Object.assign(Object.create(ctx.ValuesInputProto), {
+      kind: "values",
+      dialect: ctx.profile.dialect,
+      rows: normalizedRows,
+      selection: normalizedRows[0]!
+    })
+  }
+
+  const unnest = (columns: Record<string, readonly any[]>, alias: string) => {
+    const normalizedColumns = ctx.normalizeUnnestColumns(columns)
+    const columnNames = Object.keys(normalizedColumns)
+    if (columnNames.length === 0) {
+      throw new Error("unnest(...) requires at least one column array")
+    }
+    const firstColumn = normalizedColumns[columnNames[0] as keyof typeof normalizedColumns]
+    const rowCount = firstColumn?.length ?? 0
+    if (rowCount === 0) {
+      throw new Error("unnest(...) requires at least one row")
+    }
+    for (const columnName of columnNames) {
+      const values = normalizedColumns[columnName]!
+      if (values.length !== rowCount) {
+        throw new Error("unnest(...) column arrays must have the same length")
+      }
+    }
+    const firstRow = Object.fromEntries(
+      columnNames.map((columnName) => [columnName, normalizedColumns[columnName]![0]!])
+    ) as Record<string, Expression.Any>
+    const columnsSelection = ctx.makeColumnReferenceSelection(alias, firstRow)
+    const source = {
+      kind: "unnest",
+      name: alias,
+      baseName: alias,
+      dialect: ctx.profile.dialect,
+      values: columns,
+      arrays: normalizedColumns,
+      columns: columnsSelection
+    }
+    return Object.assign(source, columnsSelection)
+  }
+
+  const generateSeries = (start: any, stop: any, step?: any, alias = "series") => {
+    const startExpression = ctx.toDialectNumericExpression(start)
+    const stopExpression = ctx.toDialectNumericExpression(stop)
+    const stepExpression = step === undefined ? undefined : ctx.toDialectNumericExpression(step)
+    const valueSelection = {
+      value: startExpression
+    } as Record<string, Expression.Any>
+    const columns = ctx.makeColumnReferenceSelection(alias, valueSelection)
+    const source = {
+      kind: "tableFunction",
+      name: alias,
+      baseName: alias,
+      dialect: ctx.profile.dialect,
+      functionName: "generate_series",
+      args: stepExpression === undefined
+        ? [startExpression, stopExpression] as readonly Expression.Any[]
+        : [startExpression, stopExpression, stepExpression] as readonly Expression.Any[],
+      columns
+    }
+    return Object.assign(source, columns)
+  }
+
+  const select = (selection: any) =>
+    ctx.makePlan({
+      selection,
+      required: ctx.extractRequiredRuntime(selection),
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "select",
+      select: selection,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "read", "select")
+
+  const groupBy = (...values: readonly Expression.Any[]) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      const required = [...values.flatMap((value) => Object.keys(value[Expression.TypeId].dependencies))].filter((name, index, list) =>
+        !(name in current.available) && list.indexOf(name) === index)
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index, list) =>
+          !(name in current.available) && list.indexOf(name) === index),
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        groupBy: ctx.dedupeGroupedExpressions([...currentAst.groupBy, ...values])
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement)
+    }
+
+  const returning = (selection: any) =>
+    (plan: any) => {
+      const current = plan[Plan.TypeId]
+      const currentAst = ctx.getAst(plan)
+      const currentQuery = ctx.getQueryState(plan)
+      return ctx.makePlan({
+        selection,
+        required: [...ctx.currentRequiredList(current.required), ...ctx.extractRequiredRuntime(selection)].filter((name, index, list) =>
+          !(name in current.available) && list.indexOf(name) === index),
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        select: selection
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, currentQuery.insertSource)
+    }
+
+  return {
+    values,
+    unnest,
+    generateSeries,
+    select,
+    groupBy,
+    returning
+  }
+}