effect-qb 0.15.0 → 0.16.0

package/src/internal/predicate/key.ts

@@ -1,5 +1,6 @@
 import type * as Expression from "../scalar.js"
 import type * as ExpressionAst from "../expression-ast.js"
+import type * as JsonPath from "../json/path.js"
 
 export type ColumnKey<
   TableName extends string,
@@ -7,15 +8,59 @@ export type ColumnKey<
 > = `${TableName}.${ColumnName}`
 
 export type ColumnKeyOfAst<Ast extends ExpressionAst.Any> =
-  Ast extends ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>
+  [Ast] extends [ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>]
     ? ColumnKey<TableName, ColumnName>
     : never
 
+type JsonPathKey<
+  Segments extends ExpressionAst.JsonSegmentTuple,
+  Current extends string = never,
+  Seen extends readonly unknown[] = []
+> = Seen["length"] extends 8
+  ? never
+  : Segments extends readonly [
+    infer Segment,
+    ...infer Tail extends ExpressionAst.JsonSegmentTuple
+  ]
+    ? Segment extends JsonPath.KeySegment<infer Key extends string>
+      ? JsonPathKey<
+          Tail,
+          [Current] extends [never] ? Key : `${Current}.${Key}`,
+          readonly [...Seen, unknown]
+        >
+      : never
+    : Current
+
+export type JsonPathPredicateKey<
+  Base extends Expression.Any,
+  Segments extends ExpressionAst.JsonSegmentTuple
+> = [ColumnKeyOfExpression<Base>] extends [never]
+  ? never
+  : [JsonPathKey<Segments>] extends [never]
+    ? never
+    : `${ColumnKeyOfExpression<Base>}#json:${JsonPathKey<Segments>}`
+
+export type PredicateKeyOfAst<Ast extends ExpressionAst.Any> =
+  [Ast] extends [ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>]
+    ? ColumnKey<TableName, ColumnName>
+    : [Ast] extends [ExpressionAst.CastNode<infer Value extends Expression.Any, infer Target extends Expression.DbType.Any>]
+      ? [Target] extends [Expression.DbTypeOf<Value>]
+        ? [Expression.DbTypeOf<Value>] extends [Target]
+          ? PredicateKeyOfExpression<Value>
+          : never
+        : never
+    : [Ast] extends [ExpressionAst.JsonAccessNode<infer Kind, infer Base extends Expression.Any, infer Segments extends ExpressionAst.JsonSegmentTuple>]
+      ? Kind extends "jsonGetText" | "jsonPathText" | "jsonAccessText" | "jsonTraverseText"
+        ? JsonPathPredicateKey<Base, Segments>
+        : never
+      : never
+
 type AstOf<Value extends Expression.Any> = Value extends {
   readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any
 } ? Ast : never
 
 export type ColumnKeyOfExpression<Value extends Expression.Any> = ColumnKeyOfAst<AstOf<Value>>
+export type PredicateKeyOfExpression<Value extends Expression.Any> = PredicateKeyOfAst<AstOf<Value>>
 
 export type LiteralKey<Value> =
   Value extends string ? `string:${Value}` :

package/src/internal/predicate/normalize.ts

@@ -1,8 +1,8 @@
 import type * as Expression from "../scalar.js"
 import type * as ExpressionAst from "../expression-ast.js"
-import type { ColumnKeyOfExpression, ValueKey } from "./key.js"
+import type { PredicateKeyOfExpression, ValueKey } from "./key.js"
 import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./formula.js"
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, UnknownAtom } from "./atom.js"
+import type { EqColumnAtom, EqLiteralAtom, LiteralSetAtom, NeqLiteralAtom, NonNullAtom, NullAtom, UnknownAtom } from "./atom.js"
 
 type AstOf<Value extends Expression.Any> = Value extends {
   readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any
@@ -20,9 +20,9 @@ type AtomOf<Atom extends import("./atom.js").PredicateAtom> = AtomFormula<Atom>
 type FactOf<Atom extends import("./atom.js").PredicateAtom> = AtomFormula<Atom>
 
 type NonNullFactsOfExpression<Value extends Expression.Any> =
-  [ColumnKeyOfExpression<Value>] extends [never]
+  [PredicateKeyOfExpression<Value>] extends [never]
     ? never
-    : FactOf<NonNullAtom<ColumnKeyOfExpression<Value>>>
+    : FactOf<NonNullAtom<PredicateKeyOfExpression<Value>>>
 
 type CombineFacts<
   Left extends PredicateFormula,
@@ -45,8 +45,8 @@ type FormulaOfEq<
   Left extends Expression.Any,
   Right extends Expression.Any
 > =
-  [ColumnKeyOfExpression<Left>] extends [never]
-    ? [ColumnKeyOfExpression<Right>] extends [never]
+  [PredicateKeyOfExpression<Left>] extends [never]
+    ? [PredicateKeyOfExpression<Right>] extends [never]
       ? LiteralValueOfExpression<Left> extends infer LeftLiteral
         ? LiteralValueOfExpression<Right> extends infer RightLiteral
           ? [LeftLiteral] extends [never]
@@ -67,24 +67,24 @@ type FormulaOfEq<
           ? UnknownTag<"eq:unsupported">
           : LeftLiteral extends null
             ? False
-            : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
+            : AtomOf<EqLiteralAtom<PredicateKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
         : UnknownTag<"eq:unsupported">
-    : [ColumnKeyOfExpression<Right>] extends [never]
+    : [PredicateKeyOfExpression<Right>] extends [never]
       ? LiteralValueOfExpression<Right> extends infer RightLiteral
         ? [RightLiteral] extends [never]
           ? UnknownTag<"eq:unsupported">
           : RightLiteral extends null
             ? False
-            : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>>
+            : AtomOf<EqLiteralAtom<PredicateKeyOfExpression<Left>, ValueKey<RightLiteral>>>
         : UnknownTag<"eq:unsupported">
-      : AtomOf<import("./atom.js").EqColumnAtom<ColumnKeyOfExpression<Left>, ColumnKeyOfExpression<Right>>>
+      : AtomOf<import("./atom.js").EqColumnAtom<PredicateKeyOfExpression<Left>, PredicateKeyOfExpression<Right>>>
 
 type FormulaOfNeq<
   Left extends Expression.Any,
   Right extends Expression.Any
 > =
-  [ColumnKeyOfExpression<Left>] extends [never]
-    ? [ColumnKeyOfExpression<Right>] extends [never]
+  [PredicateKeyOfExpression<Left>] extends [never]
+    ? [PredicateKeyOfExpression<Right>] extends [never]
       ? LiteralValueOfExpression<Left> extends infer LeftLiteral
         ? LiteralValueOfExpression<Right> extends infer RightLiteral
           ? [LeftLiteral] extends [never]
@@ -105,15 +105,15 @@ type FormulaOfNeq<
           ? UnknownTag<"neq:unsupported">
           : LeftLiteral extends null
             ? False
-            : AtomOf<NeqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
+            : AtomOf<NeqLiteralAtom<PredicateKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
         : UnknownTag<"neq:unsupported">
-    : [ColumnKeyOfExpression<Right>] extends [never]
+    : [PredicateKeyOfExpression<Right>] extends [never]
       ? LiteralValueOfExpression<Right> extends infer RightLiteral
         ? [RightLiteral] extends [never]
           ? UnknownTag<"neq:unsupported">
           : RightLiteral extends null
             ? False
-            : AtomOf<NeqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>>
+            : AtomOf<NeqLiteralAtom<PredicateKeyOfExpression<Left>, ValueKey<RightLiteral>>>
         : UnknownTag<"neq:unsupported">
       : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
 
@@ -127,23 +127,23 @@ type FormulaOfIsNotDistinctFrom<
         ? [RightLiteral] extends [never]
           ? UnknownTag<"isNotDistinctFrom:unsupported">
           : RightLiteral extends null
-            ? [ColumnKeyOfExpression<Left>] extends [never]
+            ? [PredicateKeyOfExpression<Left>] extends [never]
               ? UnknownTag<"isNotDistinctFrom:unsupported">
-              : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>>
+              : AtomOf<NullAtom<PredicateKeyOfExpression<Left>>>
             : UnknownTag<"isNotDistinctFrom:unsupported">
         : LeftLiteral extends null
-          ? [ColumnKeyOfExpression<Right>] extends [never]
+          ? [PredicateKeyOfExpression<Right>] extends [never]
             ? UnknownTag<"isNotDistinctFrom:unsupported">
-            : AtomOf<NullAtom<ColumnKeyOfExpression<Right>>>
+            : AtomOf<NullAtom<PredicateKeyOfExpression<Right>>>
           : RightLiteral extends null
-            ? [ColumnKeyOfExpression<Left>] extends [never]
+            ? [PredicateKeyOfExpression<Left>] extends [never]
               ? UnknownTag<"isNotDistinctFrom:unsupported">
-              : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>>
-            : [ColumnKeyOfExpression<Left>] extends [never]
-              ? [ColumnKeyOfExpression<Right>] extends [never]
+              : AtomOf<NullAtom<PredicateKeyOfExpression<Left>>>
+            : [PredicateKeyOfExpression<Left>] extends [never]
+              ? [PredicateKeyOfExpression<Right>] extends [never]
                 ? CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
-                : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
-              : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>>
+                : AtomOf<EqLiteralAtom<PredicateKeyOfExpression<Right>, ValueKey<LeftLiteral>>>
+              : AtomOf<EqLiteralAtom<PredicateKeyOfExpression<Left>, ValueKey<RightLiteral>>>
       : UnknownTag<"isNotDistinctFrom:unsupported">
     : UnknownTag<"isNotDistinctFrom:unsupported">
 
@@ -157,9 +157,12 @@ type AndFormulas<
 
 type FormulaTupleOf<
   Values extends readonly Expression.Any[]
-> = {
-  readonly [K in keyof Values]: Values[K] extends Expression.Any ? FormulaOfExpression<Values[K]> : never
-} & readonly PredicateFormula[]
+> = Values extends readonly [
+  infer Head extends Expression.Any,
+  ...infer Tail extends readonly Expression.Any[]
+]
+  ? readonly [FormulaOfExpression<Head>, ...FormulaTupleOf<Tail>]
+  : readonly []
 
 type AllFormulaOfValues<
   Values extends readonly Expression.Any[]
@@ -167,7 +170,53 @@ type AllFormulaOfValues<
 
 type AnyFormulaOfValues<
   Values extends readonly Expression.Any[]
-> = import("./formula.js").NormalizeBooleanConstants<AnyFormula<FormulaTupleOf<Values>>>
+> = FormulaTupleOf<Values> extends infer Formulas extends readonly PredicateFormula[]
+  ? [CompactOrLiteralSet<Formulas>] extends [infer Compact extends PredicateFormula]
+    ? [Compact] extends [never]
+      ? import("./formula.js").NormalizeBooleanConstants<AnyFormula<Formulas>>
+      : Compact
+    : import("./formula.js").NormalizeBooleanConstants<AnyFormula<Formulas>>
+  : import("./formula.js").NormalizeBooleanConstants<AnyFormula<FormulaTupleOf<Values>>>
+
+type LiteralSetDetails<Formula extends PredicateFormula> =
+  Formula extends AtomFormula<EqLiteralAtom<infer Key extends string, infer Value extends string>>
+    ? readonly [Key, Value]
+    : Formula extends AtomFormula<LiteralSetAtom<infer Key extends string, infer Values extends string>>
+      ? readonly [Key, Values]
+      : never
+
+type IsUnion<Value, Candidate = Value> =
+  [Value] extends [never]
+    ? false
+    : Value extends unknown
+      ? [Candidate] extends [Value] ? false : true
+      : false
+
+type CompactOrLiteralSet<
+  Items extends readonly PredicateFormula[],
+  Key extends string = never,
+  Values extends string = never,
+  Seen extends readonly unknown[] = []
+> = Seen["length"] extends 20
+  ? never
+  : Items extends readonly [
+    infer Head extends PredicateFormula,
+    ...infer Tail extends readonly PredicateFormula[]
+  ]
+    ? LiteralSetDetails<Head> extends readonly [infer HeadKey extends string, infer HeadValues extends string]
+      ? IsUnion<HeadKey> extends true
+        ? never
+        : [Key] extends [never]
+          ? CompactOrLiteralSet<Tail, HeadKey, HeadValues, readonly [...Seen, unknown]>
+          : [HeadKey] extends [Key]
+            ? [Key] extends [HeadKey]
+              ? CompactOrLiteralSet<Tail, Key, Values | HeadValues, readonly [...Seen, unknown]>
+              : never
+            : never
+      : never
+    : [Key] extends [never]
+      ? never
+      : AtomOf<LiteralSetAtom<Key, Values>>
 
 type FormulaOfInValues<
   Left extends Expression.Any,
@@ -180,6 +229,38 @@ type FormulaOfInValues<
   ? FormulaOfInValues<Left, Tail, [...Current, FormulaOfEq<Left, Head>]>
   : Current
 
+type LiteralSetValuesOf<
+  Values extends readonly Expression.Any[],
+  Current extends string = never,
+  Seen extends readonly unknown[] = []
+> = Seen["length"] extends 20
+  ? string
+  : Values extends readonly [
+  infer Head extends Expression.Any,
+  ...infer Tail extends readonly Expression.Any[]
+]
+  ? LiteralValueOfExpression<Head> extends infer Literal
+    ? [Literal] extends [never]
+      ? never
+      : Literal extends null
+        ? never
+        : LiteralSetValuesOf<Tail, Current | ValueKey<Literal>, readonly [...Seen, unknown]>
+    : never
+  : Current
+
+type FormulaOfIn<
+  Left extends Expression.Any,
+  Values extends readonly Expression.Any[]
+> = [PredicateKeyOfExpression<Left>] extends [never]
+  ? OrFormulas<FormulaOfInValues<Left, Values>>
+  : LiteralSetValuesOf<Values> extends infer ValueSet extends string
+    ? [ValueSet] extends [never]
+      ? OrFormulas<FormulaOfInValues<Left, Values>>
+      : string extends ValueSet
+        ? CombineFacts<NonNullFactsOfExpression<Left>, UnknownTag<"in:literal-set-too-large">>
+        : AtomOf<LiteralSetAtom<PredicateKeyOfExpression<Left>, ValueSet>>
+    : OrFormulas<FormulaOfInValues<Left, Values>>
+
 type FormulaOfNotInValues<
   Left extends Expression.Any,
   Values extends readonly Expression.Any[],
@@ -200,7 +281,7 @@ type FormulaOfVariadic<
     ? AnyFormulaOfValues<Values>
     : Kind extends "in"
       ? Values extends readonly [infer Left extends Expression.Any, ...infer Tail extends readonly Expression.Any[]]
-        ? OrFormulas<FormulaOfInValues<Left, Tail>>
+        ? FormulaOfIn<Left, Tail>
         : False
   : Kind extends "notIn"
     ? Values extends readonly [infer Left extends Expression.Any, ...infer Tail extends readonly Expression.Any[]]
@@ -218,13 +299,13 @@ type FormulaOfUnary<
   Kind extends ExpressionAst.UnaryKind,
   Inner extends Expression.Any
 > = Kind extends "isNull"
-  ? [ColumnKeyOfExpression<Inner>] extends [never]
+  ? [PredicateKeyOfExpression<Inner>] extends [never]
     ? UnknownTag<"isNull:unsupported">
-    : AtomOf<NullAtom<ColumnKeyOfExpression<Inner>>>
+    : AtomOf<NullAtom<PredicateKeyOfExpression<Inner>>>
   : Kind extends "isNotNull"
-    ? [ColumnKeyOfExpression<Inner>] extends [never]
+    ? [PredicateKeyOfExpression<Inner>] extends [never]
       ? UnknownTag<"isNotNull:unsupported">
-      : AtomOf<NonNullAtom<ColumnKeyOfExpression<Inner>>>
+      : AtomOf<NonNullAtom<PredicateKeyOfExpression<Inner>>>
     : Kind extends "not"
       ? import("./formula.js").Not<FormulaOfExpression<Inner>>
       : UnknownTag<`unary:${Kind}`>

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
@@ -123,7 +130,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 +148,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 +206,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 +232,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 +276,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 +303,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
@@ -337,6 +389,53 @@ const columnKeyOfExpression = (value: Expression.Any): string | undefined => {
   return ast.kind === "column" ? `${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 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.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 => {
   if (typeof value === "string") {
     return `string:${value}`
@@ -357,7 +456,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 +474,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 +527,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 +576,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 +686,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 +713,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": {