effect-qb 0.15.0 → 0.17.0

package/src/internal/predicate/runtime.ts

@@ -4,6 +4,7 @@ import type { PredicateAtom } from "./atom.js"
 import type {
   EqColumnAtom,
   EqLiteralAtom,
+  LiteralSetAtom,
   NeqLiteralAtom,
   NonNullAtom,
   NullAtom,
@@ -24,6 +25,7 @@ export interface RuntimeContext {
   readonly nullKeys: ReadonlySet<string>
   readonly eqLiterals: ReadonlyMap<string, string>
   readonly neqLiterals: ReadonlyMap<string, ReadonlySet<string>>
+  readonly literalSets: ReadonlyMap<string, ReadonlySet<string>>
   readonly sourceNames: ReadonlySet<string>
   readonly contradiction: boolean
   readonly unknown: boolean
@@ -34,6 +36,7 @@ type MutableContext = {
   nullKeys: Set<string>
   eqLiterals: Map<string, string>
   neqLiterals: Map<string, Set<string>>
+  literalSets: Map<string, Set<string>>
   sourceNames: Set<string>
   contradiction: boolean
   unknown: boolean
@@ -72,6 +75,7 @@ const emptyContext = (): MutableContext => ({
   nullKeys: new Set(),
   eqLiterals: new Map(),
   neqLiterals: new Map(),
+  literalSets: new Map(),
   sourceNames: new Set(),
   contradiction: false,
   unknown: false
@@ -84,6 +88,9 @@ const cloneContext = (context: MutableContext): MutableContext => ({
   neqLiterals: new Map(
     Array.from(context.neqLiterals.entries(), ([key, values]) => [key, new Set(values)])
   ),
+  literalSets: new Map(
+    Array.from(context.literalSets.entries(), ([key, values]) => [key, new Set(values)])
+  ),
   sourceNames: new Set(context.sourceNames),
   contradiction: context.contradiction,
   unknown: context.unknown
@@ -91,7 +98,26 @@ const cloneContext = (context: MutableContext): MutableContext => ({
 
 const freezeContext = (context: MutableContext): RuntimeContext => context
 
-const sourceNameOfKey = (key: string): string => key.split(".", 1)[0] ?? key
+export const columnPredicateKey = (tableName: string, columnName: string): string =>
+  JSON.stringify([tableName, columnName])
+
+const columnPredicateKeyParts = (key: string): readonly [string, string] | undefined => {
+  const jsonSeparator = key.indexOf("#json:")
+  const columnKey = jsonSeparator === -1 ? key : key.slice(0, jsonSeparator)
+  try {
+    const parsed = JSON.parse(columnKey) as unknown
+    return Array.isArray(parsed) &&
+      parsed.length === 2 &&
+      typeof parsed[0] === "string" &&
+      typeof parsed[1] === "string"
+      ? [parsed[0], parsed[1]]
+      : undefined
+  } catch {
+    return undefined
+  }
+}
+
+const sourceNameOfKey = (key: string): string => columnPredicateKeyParts(key)?.[0] ?? key.split(".", 1)[0] ?? key
 
 const addSourceName = (context: MutableContext, key: string): void => {
   context.sourceNames.add(sourceNameOfKey(key))
@@ -123,7 +149,12 @@ const addEqLiteral = (context: MutableContext, key: string, value: string): void
   if (neqValues?.has(value)) {
     context.contradiction = true
   }
+  const existingSet = context.literalSets.get(key)
+  if (existingSet !== undefined && !existingSet.has(value)) {
+    context.contradiction = true
+  }
   context.eqLiterals.set(key, value)
+  context.literalSets.set(key, new Set([value]))
 }
 
 const addNeqLiteral = (context: MutableContext, key: string, value: string): void => {
@@ -136,6 +167,24 @@ const addNeqLiteral = (context: MutableContext, key: string, value: string): voi
   context.neqLiterals.set(key, values)
 }
 
+const addLiteralSet = (context: MutableContext, key: string, values: ReadonlySet<string>): void => {
+  addNonNull(context, key)
+  const existingEq = context.eqLiterals.get(key)
+  if (existingEq !== undefined && !values.has(existingEq)) {
+    context.contradiction = true
+  }
+  const existing = context.literalSets.get(key)
+  context.literalSets.set(
+    key,
+    existing === undefined
+      ? new Set(values)
+      : new Set(Array.from(existing).filter((value) => values.has(value)))
+  )
+  if (context.literalSets.get(key)?.size === 0) {
+    context.contradiction = true
+  }
+}
+
 const applyEqColumn = (context: MutableContext, left: string, right: string): void => {
   const leftValue = context.eqLiterals.get(left)
   const rightValue = context.eqLiterals.get(right)
@@ -176,6 +225,9 @@ const applyAtom = (context: MutableContext, atom: PredicateAtom): void => {
     case "neq-literal":
       addNeqLiteral(context, atom.key, atom.value)
       return
+    case "literal-set":
+      addLiteralSet(context, atom.key, new Set(atom.values))
+      return
     case "eq-column":
       applyEqColumn(context, atom.left, atom.right)
       return
@@ -199,6 +251,9 @@ const applyNegativeAtom = (context: MutableContext, atom: PredicateAtom): void =
     case "neq-literal":
       addEqLiteral(context, atom.key, atom.value)
       return
+    case "literal-set":
+      addNonNull(context, atom.key)
+      return
     case "eq-column":
       addNonNull(context, atom.left)
       addNonNull(context, atom.right)
@@ -240,6 +295,21 @@ const intersectNeqLiterals = (
   return result
 }
 
+const unionLiteralSets = (
+  left: ReadonlyMap<string, ReadonlySet<string>>,
+  right: ReadonlyMap<string, ReadonlySet<string>>
+): Map<string, Set<string>> => {
+  const result = new Map<string, Set<string>>()
+  for (const [key, leftValues] of left) {
+    const rightValues = right.get(key)
+    if (rightValues === undefined) {
+      continue
+    }
+    result.set(key, new Set([...leftValues, ...rightValues]))
+  }
+  return result
+}
+
 const intersectContexts = (left: MutableContext, right: MutableContext): MutableContext => {
   if (left.contradiction) {
     return cloneContext(right)
@@ -252,6 +322,7 @@ const intersectContexts = (left: MutableContext, right: MutableContext): Mutable
     nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
     eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
     neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
+    literalSets: unionLiteralSets(left.literalSets, right.literalSets),
     sourceNames: new Set(Array.from(left.sourceNames).filter((name) => right.sourceNames.has(name))),
     contradiction: false,
     unknown: left.unknown || right.unknown
@@ -334,7 +405,59 @@ const astOf = (value: Expression.Any): ExpressionAst.Any =>
 
 const columnKeyOfExpression = (value: Expression.Any): string | undefined => {
   const ast = astOf(value)
-  return ast.kind === "column" ? `${ast.tableName}.${ast.columnName}` : undefined
+  return ast.kind === "column" ? columnPredicateKey(ast.tableName, ast.columnName) : undefined
+}
+
+const sameDbType = (left: Expression.DbType.Any, right: Expression.DbType.Any): boolean =>
+  left.dialect === right.dialect && left.kind === right.kind
+
+const escapeJsonPathPredicateKeySegment = (value: string): string =>
+  value.replaceAll("\\", "\\\\").replaceAll(".", "\\.")
+
+const jsonPathPredicateKeyOfExpression = (value: Expression.Any): string | undefined => {
+  const ast = astOf(value)
+  switch (ast.kind) {
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText": {
+      const jsonAst = ast as ExpressionAst.JsonAccessNode
+      const segments = jsonAst.segments
+      if (segments.length === 0 || segments.length > 8) {
+        return undefined
+      }
+      const path: Array<string> = []
+      for (const segment of segments) {
+        if (typeof segment !== "object" || segment === null || segment.kind !== "key") {
+          return undefined
+        }
+        path.push(segment.key)
+      }
+      if (path.length === 0) {
+        return undefined
+      }
+      const baseKey = columnKeyOfExpression(jsonAst.base)
+      return baseKey === undefined
+        ? undefined
+        : `${baseKey}#json:${path.map(escapeJsonPathPredicateKeySegment).join(".")}`
+    }
+    default:
+      return undefined
+  }
+}
+
+const predicateKeyOfExpression = (value: Expression.Any): string | undefined =>
+  columnKeyOfExpression(value) ?? castPredicateKeyOfExpression(value) ?? jsonPathPredicateKeyOfExpression(value)
+
+const castPredicateKeyOfExpression = (value: Expression.Any): string | undefined => {
+  const ast = astOf(value)
+  if (ast.kind !== "cast") {
+    return undefined
+  }
+  const source = ast.value as Expression.Any
+  return sameDbType(source[Expression.TypeId].dbType, ast.target)
+    ? predicateKeyOfExpression(source)
+    : undefined
 }
 
 const valueKeyOfLiteral = (value: unknown): string => {
@@ -357,7 +480,7 @@ const valueKeyOfLiteral = (value: unknown): string => {
 }
 
 const nonNullFactsOfExpression = (value: Expression.Any): PredicateFormula | undefined => {
-  const key = columnKeyOfExpression(value)
+  const key = predicateKeyOfExpression(value)
   return key === undefined ? undefined : atomFormula<NonNullAtom<string>>({ kind: "is-not-null", key })
 }
 
@@ -375,8 +498,8 @@ const combineFacts = (
 }
 
 const formulaOfEq = (left: Expression.Any, right: Expression.Any): PredicateFormula => {
-  const leftKey = columnKeyOfExpression(left)
-  const rightKey = columnKeyOfExpression(right)
+  const leftKey = predicateKeyOfExpression(left)
+  const rightKey = predicateKeyOfExpression(right)
   const leftAst = astOf(left)
   const rightAst = astOf(right)
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined
@@ -428,8 +551,8 @@ const formulaOfEq = (left: Expression.Any, right: Expression.Any): PredicateForm
 }
 
 const formulaOfNeq = (left: Expression.Any, right: Expression.Any): PredicateFormula => {
-  const leftKey = columnKeyOfExpression(left)
-  const rightKey = columnKeyOfExpression(right)
+  const leftKey = predicateKeyOfExpression(left)
+  const rightKey = predicateKeyOfExpression(right)
   const leftAst = astOf(left)
   const rightAst = astOf(right)
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined
@@ -477,8 +600,8 @@ const formulaOfNeq = (left: Expression.Any, right: Expression.Any): PredicateFor
 }
 
 const formulaOfIsNotDistinctFrom = (left: Expression.Any, right: Expression.Any): PredicateFormula => {
-  const leftKey = columnKeyOfExpression(left)
-  const rightKey = columnKeyOfExpression(right)
+  const leftKey = predicateKeyOfExpression(left)
+  const rightKey = predicateKeyOfExpression(right)
   const leftAst = astOf(left)
   const rightAst = astOf(right)
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined
@@ -587,13 +710,13 @@ export const formulaOfExpression = (value: Expression.Any): PredicateFormula =>
       }
       return unknownTag("literal:non-boolean")
     case "isNull": {
-      const key = columnKeyOfExpression(ast.value)
+      const key = predicateKeyOfExpression(ast.value)
       return key === undefined
         ? unknownTag("isNull:unsupported")
         : atomFormula<NullAtom<string>>({ kind: "is-null", key })
     }
     case "isNotNull": {
-      const key = columnKeyOfExpression(ast.value)
+      const key = predicateKeyOfExpression(ast.value)
       return key === undefined
         ? unknownTag("isNotNull:unsupported")
         : atomFormula<NonNullAtom<string>>({ kind: "is-not-null", key })
@@ -614,8 +737,16 @@ export const formulaOfExpression = (value: Expression.Any): PredicateFormula =>
       return anyFormula(ast.values.map((value: Expression.Any) => formulaOfExpression(value)))
     case "in": {
       const [left, ...rest] = ast.values
-      return left === undefined
-        ? falseFormula()
+      if (left === undefined) {
+        return falseFormula()
+      }
+      const key = predicateKeyOfExpression(left)
+      const literalValues = rest.map((entry: Expression.Any) => {
+        const entryAst = astOf(entry)
+        return entryAst.kind === "literal" && entryAst.value !== null ? valueKeyOfLiteral(entryAst.value) : undefined
+      })
+      return key !== undefined && literalValues.every((entry): entry is string => entry !== undefined)
+        ? atomFormula<LiteralSetAtom<string, string>>({ kind: "literal-set", key, values: literalValues })
         : anyFormula(rest.map((value: Expression.Any) => formulaOfEq(left, value)))
     }
     case "notIn": {