effect-qb 0.13.0 → 0.14.0

package/src/internal/datatypes/define.ts

@@ -12,33 +12,3 @@ export type DatatypeModule<
 } & {
   readonly [Alias in keyof Aliases]: () => Expression.DbType.Base<Dialect, Aliases[Alias] & string>
 }
-
-export const makeDatatypeModule = <
-  Dialect extends string,
-  Kinds extends Record<string, DatatypeKindSpec>,
-  Aliases extends Record<string, string> = Record<never, never>
->(
-  dialect: Dialect,
-  kinds: Kinds,
-  aliases?: Aliases
-): DatatypeModule<Dialect, Kinds, Aliases> => {
-  const module: Record<string, (...args: readonly any[]) => Expression.DbType.Base<Dialect, string>> = {
-    custom: (kind: string) => ({
-      dialect,
-      kind
-    })
-  }
-  for (const kind of Object.keys(kinds)) {
-    module[kind] = () => ({
-      dialect,
-      kind
-    })
-  }
-  for (const [alias, kind] of Object.entries(aliases ?? {})) {
-    module[alias] = () => ({
-      dialect,
-      kind
-    })
-  }
-  return module as DatatypeModule<Dialect, Kinds, Aliases>
-}

package/src/internal/executor.ts

@@ -4,6 +4,8 @@ import * as SqlClient from "@effect/sql/SqlClient"
 import * as SqlError from "@effect/sql/SqlError"
 
 import * as Expression from "./expression.js"
+import * as ExpressionAst from "./expression-ast.js"
+import { resolveImplicationScope, type ImplicationScope } from "./implication-runtime.js"
 import { normalizeDbValue } from "./runtime-normalize.js"
 import { expressionRuntimeSchema } from "./runtime-schema.js"
 import { flattenSelection } from "./projections.js"
@@ -16,6 +18,10 @@ import * as Plan from "./plan.js"
 export type FlatRow = Readonly<Record<string, unknown>>
 export type DriverMode = "raw" | "normalized"
 
+type AstBackedExpression = Expression.Any & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+}
+
 export interface RowDecodeError {
   readonly _tag: "RowDecodeError"
   readonly message: string
@@ -67,7 +73,7 @@ export interface Executor<
   Context = never
 > {
   readonly dialect: Dialect
-  execute<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+  execute<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ): Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
 }
@@ -189,24 +195,39 @@ const makeRowDecodeError = (
 
 const hasOptionalSourceDependency = (
   expression: Expression.Any,
-  available: Readonly<Record<string, Plan.Source>>
+  scope: ImplicationScope
 ): boolean => {
   const state = expression[Expression.TypeId]
   if (state.sourceNullability === "resolved") {
     return false
   }
-  return Object.keys(state.dependencies).some((sourceName) => available[sourceName]?.mode === "optional")
+  return Object.keys(state.dependencies).some((sourceName) =>
+    !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional")
 }
 
 const effectiveRuntimeNullability = (
   expression: Expression.Any,
-  available: Readonly<Record<string, Plan.Source>>
+  scope: ImplicationScope
 ): Expression.Nullability => {
   const nullability = expression[Expression.TypeId].nullability
+  const ast = (expression as AstBackedExpression)[ExpressionAst.TypeId]
   if (nullability === "always") {
     return "always"
   }
-  return hasOptionalSourceDependency(expression, available)
+  if (ast.kind === "column") {
+    const key = `${ast.tableName}.${ast.columnName}`
+    if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key)) {
+      return "always"
+    }
+    if (scope.nonNullKeys.has(key)) {
+      return "never"
+    }
+  }
+  if (expression[Expression.TypeId].sourceNullability !== "resolved" &&
+      Object.keys(expression[Expression.TypeId].dependencies).some((sourceName) => scope.absentSourceNames.has(sourceName))) {
+    return "always"
+  }
+  return hasOptionalSourceDependency(expression, scope)
     ? "maybe"
     : nullability
 }
@@ -216,7 +237,7 @@ const decodeProjectionValue = (
   projection: Renderer.RenderedQuery<any, any>["projections"][number],
   expression: Expression.Any,
   raw: unknown,
-  available: Readonly<Record<string, Plan.Source>>,
+  scope: ImplicationScope,
   driverMode: DriverMode
 ): unknown => {
   let normalized = raw
@@ -228,8 +249,9 @@ const decodeProjectionValue = (
     }
   }
 
+  const nullability = effectiveRuntimeNullability(expression, scope)
   if (normalized === null) {
-    if (effectiveRuntimeNullability(expression, available) === "never") {
+    if (nullability === "never") {
       throw makeRowDecodeError(
         rendered,
         projection,
@@ -243,7 +265,19 @@ const decodeProjectionValue = (
     return null
   }
 
-  const schema = expressionRuntimeSchema(expression)
+  if (nullability === "always") {
+    throw makeRowDecodeError(
+      rendered,
+      projection,
+      expression,
+      raw,
+      "schema",
+      new Error("Received non-null for an always-null projection"),
+      normalized
+    )
+  }
+
+  const schema = expressionRuntimeSchema(expression, { assumptions: scope.assumptions })
   if (schema === undefined) {
     return normalized
   }
@@ -274,7 +308,7 @@ export const decodeRows = (
     projections.map((projection) => [projection.alias, projection.expression] as const)
   )
   const driverMode = options.driverMode ?? "raw"
-  const available = plan[Plan.TypeId].available
+  const scope = resolveImplicationScope(plan[Plan.TypeId].available, Query.getQueryState(plan).assumptions)
   return rows.map((row) => {
     const decoded: Record<string, unknown> = {}
     for (const projection of rendered.projections) {
@@ -288,7 +322,7 @@ export const decodeRows = (
       setPath(
         decoded,
         projection.path,
-        decodeProjectionValue(rendered, projection, expression, row[projection.alias], available, driverMode)
+        decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode)
       )
     }
     return decoded
@@ -304,7 +338,7 @@ export const make = <
   Context = never
 >(
   dialect: Dialect,
-  execute: <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+  execute: <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ) => Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
 ): Executor<Dialect, Error, Context> => ({

package/src/internal/expression-ast.ts

@@ -82,6 +82,10 @@ export type BinaryKind =
   | "gte"
   | "like"
   | "ilike"
+  | "regexMatch"
+  | "regexIMatch"
+  | "regexNotMatch"
+  | "regexNotIMatch"
   | "isDistinctFrom"
   | "isNotDistinctFrom"
   | "contains"

package/src/internal/expression.ts

@@ -89,7 +89,7 @@ export declare namespace DbType {
     SchemaName extends string = "json"
   > extends Base<Dialect, SchemaName>
   {
-    readonly variant: "json"
+    readonly variant: SchemaName extends "jsonb" ? "jsonb" : "json"
   }
 
   /** Array database type. */

package/src/internal/implication-runtime.ts

@@ -0,0 +1,171 @@
+import * as Expression from "./expression.js"
+import * as ExpressionAst from "./expression-ast.js"
+import * as Plan from "./plan.js"
+import * as Table from "./table.js"
+import type { PredicateFormula } from "./predicate-formula.js"
+import {
+  assumeFormulaTrue,
+  contradictsFormula,
+  guaranteedNonNullKeys,
+  guaranteedNullKeys,
+  guaranteedSourceNames,
+  trueFormula
+} from "./predicate-runtime.js"
+import type { SourceLike } from "./query.js"
+
+export interface ImplicationScope {
+  readonly assumptions: PredicateFormula
+  readonly nonNullKeys: ReadonlySet<string>
+  readonly nullKeys: ReadonlySet<string>
+  readonly requiredSourceNames: ReadonlySet<string>
+  readonly absentSourceNames: ReadonlySet<string>
+  readonly sourceModes: ReadonlyMap<string, Plan.SourceMode>
+}
+
+type AstBackedExpression = Expression.Any & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+}
+
+export const presentFormulaOfSource = (source: Plan.Source): PredicateFormula =>
+  source._presentFormula ?? trueFormula()
+
+export const presenceWitnessesOfSource = (source: Plan.Source): ReadonlySet<string> =>
+  new Set(source._presenceWitnesses ?? [])
+
+const collectPresenceWitnesses = (
+  selection: unknown,
+  output: Set<string>
+): void => {
+  if (typeof selection !== "object" || selection === null) {
+    return
+  }
+  if (Expression.TypeId in selection && ExpressionAst.TypeId in selection) {
+    const expression = selection as unknown as AstBackedExpression
+    const ast = expression[ExpressionAst.TypeId]
+    if (ast.kind === "column" && expression[Expression.TypeId].nullability === "never") {
+      output.add(`${ast.tableName}.${ast.columnName}`)
+    }
+    return
+  }
+  for (const value of Object.values(selection as Record<string, unknown>)) {
+    collectPresenceWitnesses(value, output)
+  }
+}
+
+export const presenceWitnessesOfSourceLike = (source: SourceLike): readonly string[] => {
+  const output = new Set<string>()
+  if (typeof source !== "object" || source === null) {
+    return []
+  }
+  if (Table.TypeId in source) {
+    collectPresenceWitnesses((source as Plan.Any)[Plan.TypeId].selection, output)
+    return [...output]
+  }
+  if ("columns" in source) {
+    collectPresenceWitnesses((source as { readonly columns: unknown }).columns, output)
+  }
+  return [...output]
+}
+
+const directAbsentSourceNames = (
+  available: Readonly<Record<string, Plan.Source>>,
+  assumptions: PredicateFormula
+): Set<string> => {
+  const nullKeys = guaranteedNullKeys(assumptions)
+  const absent = new Set<string>()
+  for (const [name, source] of Object.entries(available)) {
+    if (source._presenceWitnesses?.some((key) => nullKeys.has(key))) {
+      absent.add(name)
+      continue
+    }
+    if (contradictsFormula(assumptions, presentFormulaOfSource(source))) {
+      absent.add(name)
+    }
+  }
+  return absent
+}
+
+const propagateAbsentSourceNames = (
+  available: Readonly<Record<string, Plan.Source>>,
+  seed: ReadonlySet<string>
+): Set<string> => {
+  const absent = new Set(seed)
+  let changed = true
+  while (changed) {
+    changed = false
+    for (const [name, source] of Object.entries(available)) {
+      if (absent.has(name)) {
+        continue
+      }
+      const required = guaranteedSourceNames(presentFormulaOfSource(source))
+      if (Array.from(required).some((dependency) => absent.has(dependency))) {
+        absent.add(name)
+        changed = true
+      }
+    }
+  }
+  return absent
+}
+
+export const resolveImplicationScope = (
+  available: Readonly<Record<string, Plan.Source>>,
+  initialAssumptions: PredicateFormula
+): ImplicationScope => {
+  let assumptions = initialAssumptions
+  const required = new Set<string>(
+    Object.entries(available)
+      .filter(([, source]) => source.mode === "required")
+      .map(([name]) => name)
+  )
+  const appliedRequired = new Set<string>()
+  let absent = new Set<string>()
+
+  let changed = true
+  while (changed) {
+    changed = false
+
+    for (const name of guaranteedSourceNames(assumptions)) {
+      if (!required.has(name)) {
+        required.add(name)
+        changed = true
+      }
+    }
+
+    for (const name of required) {
+      if (absent.has(name) || appliedRequired.has(name)) {
+        continue
+      }
+      const source = available[name]
+      if (source === undefined) {
+        continue
+      }
+      assumptions = assumeFormulaTrue(assumptions, presentFormulaOfSource(source))
+      appliedRequired.add(name)
+      changed = true
+    }
+
+    const nextAbsent = propagateAbsentSourceNames(available, directAbsentSourceNames(available, assumptions))
+    if (nextAbsent.size !== absent.size || Array.from(nextAbsent).some((name) => !absent.has(name))) {
+      absent = nextAbsent
+      changed = true
+    }
+  }
+
+  for (const name of absent) {
+    required.delete(name)
+  }
+
+  const sourceModes = new Map<string, Plan.SourceMode>()
+  for (const [name, source] of Object.entries(available)) {
+    sourceModes.set(name, required.has(name) ? "required" : source.mode)
+  }
+
+  return {
+    assumptions,
+    nonNullKeys: guaranteedNonNullKeys(assumptions),
+    nullKeys: guaranteedNullKeys(assumptions),
+    requiredSourceNames: required,
+    absentSourceNames: absent,
+    sourceModes
+  }
+}