effect-qb 0.14.0 → 0.16.0

package/src/internal/{predicate-normalize.ts → predicate/normalize.ts}

@@ -1,8 +1,8 @@
-import type * as Expression from "./expression.js"
-import type * as ExpressionAst from "./expression-ast.js"
-import type { ColumnKeyOfExpression, ValueKey } from "./predicate-key.js"
-import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./predicate-formula.js"
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, UnknownAtom } from "./predicate-atom.js"
+import type * as Expression from "../scalar.js"
+import type * as ExpressionAst from "../expression-ast.js"
+import type { PredicateKeyOfExpression, ValueKey } from "./key.js"
+import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./formula.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
@@ -16,13 +16,13 @@ type True = TrueFormula
 type False = FalseFormula
 
 type UnknownTag<Tag extends string> = AtomFormula<UnknownAtom<Tag>>
-type AtomOf<Atom extends import("./predicate-atom.js").PredicateAtom> = AtomFormula<Atom>
-type FactOf<Atom extends import("./predicate-atom.js").PredicateAtom> = AtomFormula<Atom>
+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,
@@ -31,7 +31,7 @@ type CombineFacts<
   ? Right
   : [Right] extends [never]
     ? Left
-    : import("./predicate-formula.js").NormalizeBooleanConstants<AllFormula<[Left, Right]>>
+    : import("./formula.js").NormalizeBooleanConstants<AllFormula<[Left, Right]>>
 
 type FactsOfExpressions<Values extends readonly Expression.Any[]> =
   Values extends readonly [
@@ -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("./predicate-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,47 +127,96 @@ 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">
 
 type OrFormulas<
   Items extends readonly PredicateFormula[]
-> = import("./predicate-formula.js").NormalizeBooleanConstants<AnyFormula<Items>>
+> = import("./formula.js").NormalizeBooleanConstants<AnyFormula<Items>>
 
 type AndFormulas<
   Items extends readonly PredicateFormula[]
-> = import("./predicate-formula.js").NormalizeBooleanConstants<AllFormula<Items>>
+> = import("./formula.js").NormalizeBooleanConstants<AllFormula<Items>>
 
 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[]
-> = import("./predicate-formula.js").NormalizeBooleanConstants<AllFormula<FormulaTupleOf<Values>>>
+> = import("./formula.js").NormalizeBooleanConstants<AllFormula<FormulaTupleOf<Values>>>
 
 type AnyFormulaOfValues<
   Values extends readonly Expression.Any[]
-> = import("./predicate-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,12 +281,12 @@ 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[]]
-          ? AndFormulas<FormulaOfNotInValues<Left, Tail>>
-          : True
+  : Kind extends "notIn"
+    ? Values extends readonly [infer Left extends Expression.Any, ...infer Tail extends readonly Expression.Any[]]
+      ? CombineFacts<NonNullFactsOfExpression<Left>, AndFormulas<FormulaOfNotInValues<Left, Tail>>>
+      : True
         : Kind extends "between"
           ? FactsOfExpressions<Values> extends infer Facts extends PredicateFormula
             ? [Facts] extends [never]
@@ -218,15 +299,15 @@ 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("./predicate-formula.js").Not<FormulaOfExpression<Inner>>
+      ? import("./formula.js").Not<FormulaOfExpression<Inner>>
       : UnknownTag<`unary:${Kind}`>
 
 type FormulaOfBinary<
@@ -242,7 +323,7 @@ type FormulaOfBinary<
       : Kind extends "isNotDistinctFrom"
         ? FormulaOfIsNotDistinctFrom<Left, Right>
         : Kind extends "isDistinctFrom"
-          ? import("./predicate-formula.js").Not<FormulaOfIsNotDistinctFrom<Left, Right>>
+          ? import("./formula.js").Not<FormulaOfIsNotDistinctFrom<Left, Right>>
           : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>
 
 type FormulaOfAst<

package/src/internal/predicate/runtime.d.ts

@@ -0,0 +1,31 @@
+import * as Expression from "../scalar.js";
+import type { PredicateAtom } from "./atom.js";
+import type { AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./formula.js";
+export interface RuntimeContext {
+    readonly nonNullKeys: ReadonlySet<string>;
+    readonly nullKeys: ReadonlySet<string>;
+    readonly eqLiterals: ReadonlyMap<string, string>;
+    readonly neqLiterals: ReadonlyMap<string, ReadonlySet<string>>;
+    readonly sourceNames: ReadonlySet<string>;
+    readonly contradiction: boolean;
+    readonly unknown: boolean;
+}
+export declare const trueFormula: () => TrueFormula;
+export declare const falseFormula: () => FalseFormula;
+export declare const atomFormula: <Atom extends PredicateAtom>(atom: Atom) => AtomFormula<Atom>;
+export declare const allFormula: (items: readonly PredicateFormula[]) => PredicateFormula;
+export declare const anyFormula: (items: readonly PredicateFormula[]) => PredicateFormula;
+export declare const notFormula: (item: PredicateFormula) => PredicateFormula;
+export declare const andFormula: (left: PredicateFormula, right: PredicateFormula) => PredicateFormula;
+export declare const orFormula: (left: PredicateFormula, right: PredicateFormula) => PredicateFormula;
+export declare const analyzeFormula: (formula: PredicateFormula) => RuntimeContext;
+export declare const normalizeFormula: (formula: PredicateFormula) => PredicateFormula;
+export declare const formulaOfExpression: (value: Expression.Any) => PredicateFormula;
+export declare const formulaOfPredicate: (value: boolean | Expression.Any) => PredicateFormula;
+export declare const assumeFormulaTrue: (assumptions: PredicateFormula, formula: PredicateFormula) => PredicateFormula;
+export declare const assumeFormulaFalse: (assumptions: PredicateFormula, formula: PredicateFormula) => PredicateFormula;
+export declare const contradictsFormula: (assumptions: PredicateFormula, formula: PredicateFormula) => boolean;
+export declare const impliesFormula: (assumptions: PredicateFormula, formula: PredicateFormula) => boolean;
+export declare const guaranteedNonNullKeys: (assumptions: PredicateFormula) => ReadonlySet<string>;
+export declare const guaranteedNullKeys: (assumptions: PredicateFormula) => ReadonlySet<string>;
+export declare const guaranteedSourceNames: (assumptions: PredicateFormula) => ReadonlySet<string>;

package/src/internal/{predicate-runtime.ts → predicate/runtime.ts}

@@ -1,14 +1,15 @@
-import * as Expression from "./expression.js"
-import * as ExpressionAst from "./expression-ast.js"
-import type { PredicateAtom } from "./predicate-atom.js"
+import * as Expression from "../scalar.js"
+import * as ExpressionAst from "../expression-ast.js"
+import type { PredicateAtom } from "./atom.js"
 import type {
   EqColumnAtom,
   EqLiteralAtom,
+  LiteralSetAtom,
   NeqLiteralAtom,
   NonNullAtom,
   NullAtom,
   UnknownAtom
-} from "./predicate-atom.js"
+} from "./atom.js"
 import type {
   AllFormula,
   AnyFormula,
@@ -17,13 +18,14 @@ import type {
   NotFormula,
   PredicateFormula,
   TrueFormula
-} from "./predicate-formula.js"
+} from "./formula.js"
 
 export interface RuntimeContext {
   readonly nonNullKeys: ReadonlySet<string>
   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,15 +713,26 @@ 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": {
       const [left, ...rest] = ast.values
       return left === undefined
         ? trueFormula()
-        : allFormula(rest.map((value: Expression.Any) => formulaOfNeq(left, value)))
+        : combineFacts(
+            nonNullFactsOfExpression(left),
+            allFormula(rest.map((value: Expression.Any) => formulaOfNeq(left, value)))
+          )
     }
     case "between":
       return combineFacts(

package/src/internal/projection-alias.d.ts

@@ -0,0 +1,13 @@
+/** Symbol used to attach explicit projection-alias metadata to an expression. */
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
+/**
+ * Projection-alias metadata carried by a runtime expression wrapper.
+ *
+ * This is intentionally orthogonal to the scalar expression AST. Aliasing does
+ * not change SQL semantics; it only changes how a selected expression is named
+ * in the rendered `SELECT ... AS ...` list.
+ */
+export interface State<Alias extends string = string> {
+    readonly alias: Alias;
+}

package/src/internal/projections.d.ts

@@ -0,0 +1,31 @@
+import * as Expression from "./scalar.js";
+/**
+ * Flat projection metadata shared by renderers and executors.
+ *
+ * `path` identifies where a value should be decoded in the nested result row,
+ * while `alias` is the flat SQL column alias used by the rendered query.
+ */
+export interface Projection {
+    readonly path: readonly string[];
+    readonly alias: string;
+}
+/** Selection leaf paired with its resolved projection alias. */
+export interface FlattenedProjection {
+    readonly path: readonly string[];
+    readonly expression: Expression.Any;
+    readonly alias: string;
+}
+/**
+ * Flattens a nested selection object into leaf expressions with decode paths
+ * and resolved SQL aliases.
+ */
+export declare const flattenSelection: (selection: Record<string, unknown>, path?: readonly string[]) => readonly FlattenedProjection[];
+/**
+ * Validates the flattened projection set shared by renderer and executor code.
+ *
+ * This rejects:
+ * - duplicate SQL aliases
+ * - duplicate decode paths
+ * - conflicting prefix paths like `profile` and `profile.id`
+ */
+export declare const validateProjections: (projections: readonly Projection[]) => void;

package/src/internal/projections.ts

@@ -1,4 +1,4 @@
-import * as Expression from "./expression.js"
+import * as Expression from "./scalar.js"
 import * as ProjectionAlias from "./projection-alias.js"
 
 /**