fix tests for query collection

Author: samwillis

packages/query-db-collection/e2e/query-filter.ts

@@ -162,7 +162,62 @@ export function applyPredicates<T>(
 ): Array<T> {
   if (!options) return data
 
-  const { filters, sorts, limit } = parseLoadSubsetOptions(options)
+  // Parse options: try simple comparisons first (faster path), fall back to expression evaluation if needed
+  // extractSimpleComparisons (called by parseLoadSubsetOptions) intentionally throws for unsupported operators
+  // like 'like', 'ilike', 'or', etc. When that happens, we use buildExpressionPredicate instead.
+  let filters: Array<SimpleComparison> = []
+  let sorts: Array<ParsedOrderBy> = []
+  let limit: number | undefined = undefined
+
+  // Check if where clause is simple before trying to parse
+  const hasComplexWhere = options.where && !isSimpleExpression(options.where)
+
+  if (!hasComplexWhere) {
+    // Simple expression - parse everything at once
+    try {
+      const parsed = parseLoadSubsetOptions(options)
+      filters = parsed.filters
+      sorts = parsed.sorts
+      limit = parsed.limit
+    } catch (error) {
+      // This shouldn't happen for simple expressions, but handle it gracefully
+      if (DEBUG_SUMMARY) {
+        console.log(
+          `[query-filter] parseLoadSubsetOptions failed unexpectedly`,
+          error
+        )
+      }
+      limit = options.limit
+    }
+  } else {
+    // Complex expression (like/ilike/or/etc.) - cannot use simple comparisons
+    // We'll filter using buildExpressionPredicate which evaluates the full expression tree
+    // filters stays empty - this signals buildFilterPredicate to use buildExpressionPredicate instead of buildSimplePredicate
+    // Note: Filtering still happens! Just via a different path (expression evaluation vs simple comparisons)
+
+    limit = options.limit
+
+    if (options.orderBy) {
+      try {
+        const orderByParsed = parseLoadSubsetOptions({
+          orderBy: options.orderBy,
+        })
+        sorts = orderByParsed.sorts
+      } catch {
+        // OrderBy parsing failed, will skip sorting
+        if (DEBUG_SUMMARY) {
+          console.log(`[query-filter] orderBy parsing failed, skipping sort`)
+        }
+      }
+    }
+
+    if (DEBUG_SUMMARY) {
+      console.log(
+        `[query-filter] complex where clause detected, will filter using buildExpressionPredicate`
+      )
+    }
+  }
+
   if (DEBUG_SUMMARY) {
     const { limit: rawLimit, where, orderBy } = options
     const analysis = analyzeExpression(where)
@@ -220,6 +275,10 @@ export function applyPredicates<T>(
 
 /**
  * Build a predicate function from expression tree
+ *
+ * Two paths:
+ * 1. Simple expressions (eq, gt, etc.) with parsed filters -> buildSimplePredicate (faster)
+ * 2. Complex expressions (like, ilike, or, etc.) or empty filters -> buildExpressionPredicate (full expression evaluation)
  */
 function buildFilterPredicate<T>(
   where: IR.BasicExpression<boolean> | undefined,
@@ -229,10 +288,13 @@ function buildFilterPredicate<T>(
     return undefined
   }
 
+  // Use simple predicate if we have parsed filters (fast path for eq, gt, etc.)
   if (filters.length > 0 && isSimpleExpression(where)) {
     return buildSimplePredicate<T>(filters)
   }
 
+  // Otherwise, use expression predicate (handles like, ilike, or, etc.)
+  // This still filters! It just evaluates the expression tree directly instead of using parsed comparisons
   try {
     return buildExpressionPredicate<T>(where)
   } catch (error) {
@@ -433,11 +495,58 @@ function evaluateFunction(name: string, args: Array<any>): any {
       return args[0] === undefined
     case `isNotUndefined`:
       return args[0] !== undefined
+    case `like`:
+      return evaluateLike(args[0], args[1], false)
+    case `ilike`:
+      return evaluateLike(args[0], args[1], true)
+    case `lower`:
+      return typeof args[0] === `string` ? args[0].toLowerCase() : args[0]
+    case `upper`:
+      return typeof args[0] === `string` ? args[0].toUpperCase() : args[0]
     default:
       throw new Error(`Unsupported predicate operator: ${name}`)
   }
 }
 
+/**
+ * Evaluates LIKE/ILIKE patterns
+ * Converts SQL LIKE pattern to regex for JavaScript matching
+ * Returns null for 3-valued logic (UNKNOWN) when value or pattern is null/undefined
+ */
+function evaluateLike(
+  value: any,
+  pattern: any,
+  caseInsensitive: boolean
+): boolean | null {
+  // In 3-valued logic, if value or pattern is null/undefined, return UNKNOWN (null)
+  if (
+    value === null ||
+    value === undefined ||
+    pattern === null ||
+    pattern === undefined
+  ) {
+    return null
+  }
+
+  if (typeof value !== `string` || typeof pattern !== `string`) {
+    return false
+  }
+
+  const searchValue = caseInsensitive ? value.toLowerCase() : value
+  const searchPattern = caseInsensitive ? pattern.toLowerCase() : pattern
+
+  // Convert SQL LIKE pattern to regex
+  // First escape all regex special chars except % and _
+  let regexPattern = searchPattern.replace(/[.*+?^${}()|[\]\\]/g, `\\$&`)
+
+  // Then convert SQL wildcards to regex
+  regexPattern = regexPattern.replace(/%/g, `.*`) // % matches any sequence
+  regexPattern = regexPattern.replace(/_/g, `.`) // _ matches any single char
+
+  const regex = new RegExp(`^${regexPattern}$`)
+  return regex.test(searchValue)
+}
+
 function compareBySorts<T>(a: T, b: T, sorts: Array<ParsedOrderBy>): number {
   for (const sort of sorts) {
     const aVal = getFieldValue(a, sort.field)