effect-qb 0.15.0 → 0.17.0

package/src/internal/predicate/context.ts

@@ -1,4 +1,4 @@
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
+import type { EqColumnAtom, EqLiteralAtom, LiteralSetAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
 import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./formula.js"
 
 type Polarity = "positive" | "negative"
@@ -8,6 +8,8 @@ export interface Context<
   NullKeys extends string = never,
   EqLiterals = {},
   NeqLiterals = {},
+  LiteralSets = {},
+  JsonLiteralSets = {},
   SourceNames extends string = never,
   Contradiction extends boolean = false,
   Unknown extends boolean = false
@@ -16,6 +18,8 @@ export interface Context<
   readonly nullKeys: NullKeys
   readonly eqLiterals: EqLiterals
   readonly neqLiterals: NeqLiterals
+  readonly literalSets: LiteralSets
+  readonly jsonLiteralSets: JsonLiteralSets
   readonly sourceNames: SourceNames
   readonly contradiction: Contradiction
   readonly unknown: Unknown
@@ -27,6 +31,8 @@ type AnyContext = Context<
   string,
   Record<string, string>,
   Record<string, string>,
+  Record<string, string>,
+  Record<string, Record<string, string>>,
   string,
   boolean,
   boolean
@@ -40,7 +46,20 @@ type Frame<
   readonly polarity: Direction
 }
 
-type SourceNameOfKey<Key extends string> = Key extends `${infer SourceName}.${string}` ? SourceName : never
+type SourceNameOfKey<
+  Key extends string,
+  Current extends string = ""
+> = string extends Key
+  ? string
+  : Key extends `\\.${infer Rest}`
+    ? SourceNameOfKey<Rest, `${Current}.`>
+    : Key extends `\\\\${infer Rest}`
+      ? SourceNameOfKey<Rest, `${Current}\\`>
+      : Key extends `.${string}`
+        ? Current
+        : Key extends `${infer Character}${infer Rest}`
+          ? SourceNameOfKey<Rest, `${Current}${Character}`>
+          : never
 
 type EqLiteralValueOf<
   EqLiterals,
@@ -84,15 +103,75 @@ type MergeNeqLiteralMaps<Left, Right> = {
         : never
 }
 
+type MergeLiteralSetMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Extract<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
+type MergeJsonLiteralSetPathMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Extract<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
+type MergeJsonLiteralSetMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? MergeJsonLiteralSetPathMaps<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
 type FilterNeverValues<Map> = {
   readonly [K in keyof Map as Map[K] extends never ? never : K]: Map[K]
 }
 
+type JsonKeyParts<Key extends string> = string extends Key
+  ? never
+  : Key extends `${infer ColumnKey}#json:${infer Path}`
+    ? readonly [ColumnKey, Path]
+    : never
+
+type LiteralSetMapAfterAdd<
+  LiteralSets,
+  Key extends string,
+  Values extends string
+> = [JsonKeyParts<Key>] extends [never]
+  ? FilterNeverValues<MergeLiteralSetMaps<LiteralSets, { readonly [K in Key]: Values }>>
+  : LiteralSets
+
+type JsonLiteralSetMapAfterAdd<
+  JsonLiteralSets,
+  Key extends string,
+  Values extends string
+> = JsonKeyParts<Key> extends readonly [infer ColumnKey extends string, infer Path extends string]
+  ? MergeJsonLiteralSetMaps<
+      JsonLiteralSets,
+      { readonly [C in ColumnKey]: { readonly [P in Path]: Values } }
+    >
+  : JsonLiteralSets
+
 type MarkContradiction<Ctx extends AnyContext> = Context<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"],
   true,
   Ctx["unknown"]
@@ -103,6 +182,8 @@ type MarkUnknown<Ctx extends AnyContext> = Context<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"],
   Ctx["contradiction"],
   true
@@ -116,6 +197,8 @@ type AddNonNull<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
@@ -129,11 +212,35 @@ type AddNull<
   Ctx["nullKeys"] | Key,
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nonNullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
 >
 
+type AddLiteralSet<
+  Ctx extends AnyContext,
+  Key extends string,
+  Values extends string
+> = Context<
+  Ctx["nonNullKeys"] | Key,
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
+  LiteralSetMapAfterAdd<Ctx["literalSets"], Key, Values>,
+  JsonLiteralSetMapAfterAdd<Ctx["jsonLiteralSets"], Key, Values>,
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
+    ? [EqValue] extends [never]
+      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : EqValue extends Values
+        ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+        : true
+    : true,
+  Ctx["unknown"]
+>
+
 type AddEqLiteral<
   Ctx extends AnyContext,
   Key extends string,
@@ -143,6 +250,8 @@ type AddEqLiteral<
   Ctx["nullKeys"],
   FilterNeverValues<MergeEqLiteralMaps<Ctx["eqLiterals"], { readonly [K in Key]: Value }>>,
   Ctx["neqLiterals"],
+  LiteralSetMapAfterAdd<Ctx["literalSets"], Key, Value>,
+  JsonLiteralSetMapAfterAdd<Ctx["jsonLiteralSets"], Key, Value>,
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends never
     ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues
@@ -169,6 +278,8 @@ type AddNeqLiteral<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   FilterNeverValues<MergeNeqLiteralMaps<Ctx["neqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
     ? [EqValue] extends [never]
@@ -219,11 +330,13 @@ type ApplyAtom<
         ? AddEqLiteral<Ctx, Key, Value>
         : Atom extends NeqLiteralAtom<infer Key extends string, infer Value extends string>
           ? AddNeqLiteral<Ctx, Key, Value>
-          : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
-            ? ApplyEqColumn<Ctx, Left, Right>
-            : Atom extends UnknownAtom<any>
-              ? MarkUnknown<Ctx>
-              : Ctx
+          : Atom extends LiteralSetAtom<infer Key extends string, infer Values extends string>
+            ? AddLiteralSet<Ctx, Key, Values>
+            : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
+              ? ApplyEqColumn<Ctx, Left, Right>
+              : Atom extends UnknownAtom<any>
+                ? MarkUnknown<Ctx>
+                : Ctx
 
 type ApplyNegativeAtom<
   Ctx extends AnyContext,
@@ -237,11 +350,13 @@ type ApplyNegativeAtom<
         ? AddNeqLiteral<Ctx, Key, Value>
         : Atom extends NeqLiteralAtom<infer Key extends string, infer Value extends string>
           ? AddEqLiteral<Ctx, Key, Value>
-          : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
-            ? AddNonNull<AddNonNull<Ctx, Left>, Right>
-            : Atom extends UnknownAtom<any>
-              ? MarkUnknown<Ctx>
-              : Ctx
+          : Atom extends LiteralSetAtom<infer Key extends string, any>
+            ? AddNonNull<Ctx, Key>
+            : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
+              ? AddNonNull<AddNonNull<Ctx, Left>, Right>
+              : Atom extends UnknownAtom<any>
+                ? MarkUnknown<Ctx>
+                : Ctx
 
 type FramesFromItems<
   Items extends readonly PredicateFormula[],
@@ -268,6 +383,27 @@ type IntersectNeqLiteralMaps<
     Extract<Left[K], Right[K]> extends never ? never : Extract<Left[K], Right[K]>
 }>
 
+type UnionLiteralSetMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]: Left[K] | Right[K]
+}>
+
+type UnionJsonLiteralSetPathMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]: Left[K] | Right[K]
+}>
+
+type UnionJsonLiteralSetMaps<
+  Left,
+  Right
+> = {
+  readonly [K in Extract<keyof Left, keyof Right>]: UnionJsonLiteralSetPathMaps<Left[K], Right[K]>
+}
+
 type IntersectContexts<
   Left extends AnyContext,
   Right extends AnyContext
@@ -276,6 +412,8 @@ type IntersectContexts<
   Extract<Left["nullKeys"], Right["nullKeys"]>,
   IntersectEqLiteralMaps<Left["eqLiterals"], Right["eqLiterals"]>,
   IntersectNeqLiteralMaps<Left["neqLiterals"], Right["neqLiterals"]>,
+  UnionLiteralSetMaps<Left["literalSets"], Right["literalSets"]>,
+  UnionJsonLiteralSetMaps<Left["jsonLiteralSets"], Right["jsonLiteralSets"]>,
   Extract<Left["sourceNames"], Right["sourceNames"]>,
   Left["contradiction"] extends true
     ? Right["contradiction"]
@@ -289,17 +427,20 @@ type AnalyzeAnyBranches<
   Ctx extends AnyContext,
   Items extends readonly PredicateFormula[],
   Direction extends Polarity,
-  Current extends AnyContext | never = never
-> = Items extends readonly [
+  Current extends AnyContext | never = never,
+  Seen extends readonly unknown[] = []
+> = Seen["length"] extends 20
+  ? MarkUnknown<Ctx>
+  : Items extends readonly [
   infer Head extends PredicateFormula,
   ...infer Tail extends readonly PredicateFormula[]
 ]
   ? AnalyzeBranch<Ctx, Head, Direction> extends infer Branch extends AnyContext
     ? Branch["contradiction"] extends true
-      ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current>
+      ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current, readonly [...Seen, unknown]>
       : [Current] extends [never]
-        ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch>
-        : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>>
+        ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch, readonly [...Seen, unknown]>
+        : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>, readonly [...Seen, unknown]>
     : never
   : [Current] extends [never]
     ? MarkContradiction<Ctx>
@@ -356,3 +497,15 @@ export type AnalyzeStack<
 
 export type AnalyzeFormula<Formula extends PredicateFormula> =
   AnalyzeStack<EmptyContext, readonly [Frame<Formula, "positive">]>
+
+export type PredicateContext = AnyContext
+
+export type AssumeFactsTrue<
+  Ctx extends PredicateContext,
+  Formula extends PredicateFormula
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, "positive">]>
+
+export type AssumeFactsFalse<
+  Ctx extends PredicateContext,
+  Formula extends PredicateFormula
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, "negative">]>

package/src/internal/predicate/key.ts

@@ -1,21 +1,83 @@
 import type * as Expression from "../scalar.js"
 import type * as ExpressionAst from "../expression-ast.js"
+import type * as JsonPath from "../json/path.js"
+
+type EscapePredicateBackslashes<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}\\${infer Tail}`
+    ? `${Head}\\\\${EscapePredicateBackslashes<Tail>}`
+    : Value
+
+type EscapePredicateDots<Value extends string> = string extends Value
+  ? string
+  : Value extends `${infer Head}.${infer Tail}`
+    ? `${Head}\\.${EscapePredicateDots<Tail>}`
+    : Value
+
+type EscapePredicateSegment<Value extends string> =
+  EscapePredicateDots<EscapePredicateBackslashes<Value>>
+
+type EscapeJsonPathSegment<Value extends string> = EscapePredicateSegment<Value>
 
 export type ColumnKey<
   TableName extends string,
   ColumnName extends string
-> = `${TableName}.${ColumnName}`
+> = `${EscapePredicateSegment<TableName>}.${EscapePredicateSegment<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] ? EscapeJsonPathSegment<Key> : `${Current}.${EscapeJsonPathSegment<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}`>