Unify handling of IN and OR

Author: kevin-dp

packages/db/src/query/predicate-utils.ts

@@ -1,4 +1,5 @@
-import type { BasicExpression, Func, OrderBy, PropRef } from "./ir.js"
+import { Func, Value } from "./ir.js"
+import type { BasicExpression, OrderBy, PropRef } from "./ir.js"
 import type { LoadSubsetOptions } from "../types.js"
 
 /**
@@ -42,6 +43,25 @@ export function isWhereSubset(
   return isWhereSubsetInternal(subset!, superset!)
 }
 
+function makeDisjunction(
+  preds: Array<BasicExpression<boolean>>
+): BasicExpression<boolean> {
+  if (preds.length === 0) {
+    return new Value(false)
+  }
+  if (preds.length === 1) {
+    return preds[0]!
+  }
+  return new Func(`or`, preds)
+}
+
+function convertInToOr(inField: InField) {
+  const equalities = inField.values.map(
+    (value) => new Func(`eq`, [inField.ref, new Value(value)])
+  )
+  return makeDisjunction(equalities)
+}
+
 function isWhereSubsetInternal(
   subset: BasicExpression<boolean>,
   superset: BasicExpression<boolean>
@@ -68,6 +88,22 @@ function isWhereSubsetInternal(
     )
   }
 
+  // Turn x IN [A, B, C] into x = A OR x = B OR x = C
+  // for unified handling of IN and OR
+  if (subset.type === `func` && subset.name === `in`) {
+    const inField = extractInField(subset)
+    if (inField) {
+      return isWhereSubsetInternal(convertInToOr(inField), superset)
+    }
+  }
+
+  if (superset.type === `func` && superset.name === `in`) {
+    const inField = extractInField(superset)
+    if (inField) {
+      return isWhereSubsetInternal(subset, convertInToOr(inField))
+    }
+  }
+
   // Handle OR in subset: (A OR B) is subset of C only if both A and B are subsets of C
   if (subset.type === `func` && subset.name === `or`) {
     return subset.args.every((arg) =>
@@ -106,6 +142,7 @@ function isWhereSubsetInternal(
       )
     }
 
+    /*
     // Handle eq vs in
     if (subsetFunc.name === `eq` && supersetFunc.name === `in`) {
       const subsetFieldEq = extractEqualityField(subsetFunc)
@@ -147,6 +184,7 @@ function isWhereSubsetInternal(
         )
       }
     }
+    */
   }
 
   // Conservative: if we can't determine, return false

packages/db/tests/predicate-utils.test.ts

@@ -199,6 +199,54 @@ describe(`isWhereSubset`, () => {
         isWhereSubset(inOp(ref(`age`), [5, 20]), inOp(ref(`age`), [5, 10, 15]))
       ).toBe(false)
     })
+
+    it(`should handle empty IN array: age IN [] is subset of age IN []`, () => {
+      expect(isWhereSubset(inOp(ref(`age`), []), inOp(ref(`age`), []))).toBe(
+        true
+      )
+    })
+
+    it(`should handle empty IN array: age IN [] is subset of age IN [5, 10]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), []), inOp(ref(`age`), [5, 10]))
+      ).toBe(true)
+    })
+
+    it(`should handle empty IN array: age IN [5, 10] is NOT subset of age IN []`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5, 10]), inOp(ref(`age`), []))
+      ).toBe(false)
+    })
+
+    it(`should handle singleton IN array: age = 5 is subset of age IN [5]`, () => {
+      expect(isWhereSubset(eq(ref(`age`), val(5)), inOp(ref(`age`), [5]))).toBe(
+        true
+      )
+    })
+
+    it(`should handle singleton IN array: age = 10 is NOT subset of age IN [5]`, () => {
+      expect(
+        isWhereSubset(eq(ref(`age`), val(10)), inOp(ref(`age`), [5]))
+      ).toBe(false)
+    })
+
+    it(`should handle singleton IN array: age IN [5] is subset of age IN [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5]), inOp(ref(`age`), [5, 10, 15]))
+      ).toBe(true)
+    })
+
+    it(`should handle singleton IN array: age IN [20] is NOT subset of age IN [5, 10, 15]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [20]), inOp(ref(`age`), [5, 10, 15]))
+      ).toBe(false)
+    })
+
+    it(`should handle singleton IN array: age IN [5, 10, 15] is NOT subset of age IN [5]`, () => {
+      expect(
+        isWhereSubset(inOp(ref(`age`), [5, 10, 15]), inOp(ref(`age`), [5]))
+      ).toBe(false)
+    })
   })
 
   describe(`AND combinations`, () => {