squirreling 0.16.1 → 0.16.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squirreling",
-  "version": "0.16.1",
+  "version": "0.16.2",
   "description": "Squirreling Async SQL Engine",
   "author": "Hyperparam",
   "homepage": "https://hyperparam.app",

package/src/expression/batch.js

@@ -4,6 +4,7 @@ import { yieldToEventLoop } from '../execute/yield.js'
 import { isStringFunc } from '../validation/functions.js'
 import { ColumnNotFoundError } from '../validation/tables.js'
 import { applyBinaryOp } from './binary.js'
+import { evaluateRegexpLike } from './regexp.js'
 import { applyCast, evaluateJsonExtract } from './scalar.js'
 import { evaluateStringFunc } from './strings.js'
 
@@ -260,6 +261,15 @@ function compileFunctionKernel(node, state) {
       return evaluateJsonExtract({ funcName, node, args, rowIndex: streamRowIndex + 1 })
     }
   }
+  if (funcName === 'REGEXP_LIKE') {
+    const cache = node.args[1]?.type === 'literal' ? {} : undefined
+    return function regexpLikeValue(vectors, rowIndex, streamRowIndex) {
+      const args = arguments_.map(function argumentValue(argument) {
+        return argument(vectors, rowIndex, streamRowIndex)
+      })
+      return evaluateRegexpLike({ node, args, rowIndex: streamRowIndex + 1, cache })
+    }
+  }
   if (!isStringFunc(funcName)) return undefined
   return function stringFunctionValue(vectors, rowIndex, streamRowIndex) {
     const args = arguments_.map(function argumentValue(argument) {
@@ -292,7 +302,9 @@ function compileFunctionEvaluator(node, columns) {
     }
   }
   if (funcName !== 'NULLIF' && funcName !== 'JSON_VALUE' && funcName !== 'JSON_QUERY' &&
-    funcName !== 'JSON_EXTRACT' && funcName !== 'JSON_EXTRACT_STRING' && !isStringFunc(funcName)) return undefined
+    funcName !== 'JSON_EXTRACT' && funcName !== 'JSON_EXTRACT_STRING' && funcName !== 'REGEXP_LIKE' &&
+    !isStringFunc(funcName)) return undefined
+  const regexpCache = funcName === 'REGEXP_LIKE' && node.args[1]?.type === 'literal' ? {} : undefined
   return {
     async evaluate(context) {
       const vectors = await Promise.all(arguments_.map(function evaluateArgument(argument) {
@@ -304,6 +316,9 @@ function compileFunctionEvaluator(node, columns) {
         if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY' || funcName === 'JSON_EXTRACT' || funcName === 'JSON_EXTRACT_STRING') {
           return evaluateJsonExtract({ funcName, node, args, rowIndex: streamRowIndex + 1 })
         }
+        if (funcName === 'REGEXP_LIKE') {
+          return evaluateRegexpLike({ node, args, rowIndex: streamRowIndex + 1, cache: regexpCache })
+        }
         return evaluateStringFunc({ funcName, node, args, rowIndex: streamRowIndex + 1 })
       })
     },

package/src/expression/binary.js

@@ -1,3 +1,5 @@
+import { stringify } from '../execute/utils.js'
+
 /**
  * @import { BinaryOp, SqlPrimitive } from '../types.js'
  */
@@ -68,7 +70,11 @@ export function applyBinaryOp(op, a, b) {
   if (op === '>=') return a >= b
 
   if (op === 'LIKE') {
-    const str = String(a)
+    // Objects, arrays, and Dates stringify as JSON, the same coercion as
+    // CAST(x AS VARCHAR), so `x LIKE p` and `CAST(x AS VARCHAR) LIKE p` agree.
+    // String() would collapse every object to '[object Object]', making LIKE
+    // a silent never-match on JSON-typed columns.
+    const str = typeof a === 'object' ? stringify(a) : String(a)
     const pattern = String(b)
     const regexPattern = pattern
       .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')

package/src/expression/regexp.js

@@ -79,24 +79,7 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
   }
 
   if (funcName === 'REGEXP_MATCHES' || funcName === 'REGEXP_LIKE') {
-    const str = args[0]
-    const pattern = args[1]
-    if (str == null || pattern == null) return null
-    const strVal = String(str)
-    const patternStr = String(pattern)
-
-    let regex
-    try {
-      regex = new RegExp(patternStr)
-    } catch (/** @type {any} */ error) {
-      throw new ArgValueError({
-        ...node,
-        message: `invalid regex pattern: ${error.message}`,
-        rowIndex,
-      })
-    }
-
-    return regex.test(strVal)
+    return evaluateRegexpLike({ node, args, rowIndex })
   }
 
   if (funcName === 'REGEXP_REPLACE') {
@@ -168,3 +151,41 @@ export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
 
   throw new Error(`Unsupported regexp function: ${funcName}`)
 }
+
+/**
+ * Evaluates REGEXP_LIKE/REGEXP_MATCHES with an optional single-pattern cache.
+ * Batch kernels use the cache for literal patterns so the RegExp is compiled
+ * once, while scalar and dynamic-pattern evaluation retain row-local behavior.
+ * Compilation stays lazy so a null string still returns null without validating
+ * an otherwise invalid pattern, matching the scalar evaluator.
+ *
+ * @param {Object} options
+ * @param {FunctionNode} options.node
+ * @param {SqlPrimitive[]} options.args
+ * @param {number} [options.rowIndex]
+ * @param {{ pattern?: string, regex?: RegExp }} [options.cache]
+ * @returns {SqlPrimitive}
+ */
+export function evaluateRegexpLike({ node, args, rowIndex, cache }) {
+  const string = args[0]
+  const pattern = args[1]
+  if (string == null || pattern == null) return null
+  const patternString = String(pattern)
+  let regex = cache?.pattern === patternString ? cache.regex : undefined
+  if (!regex) {
+    try {
+      regex = new RegExp(patternString)
+    } catch (/** @type {any} */ error) {
+      throw new ArgValueError({
+        ...node,
+        message: `invalid regex pattern: ${error.message}`,
+        rowIndex,
+      })
+    }
+    if (cache) {
+      cache.pattern = patternString
+      cache.regex = regex
+    }
+  }
+  return regex.test(String(string))
+}