squirreling 0.4.5 → 0.4.6

package/package.json

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

package/src/execute/expression.js

@@ -1,4 +1,5 @@
 import { executeSelect } from './execute.js'
+import { applyBinaryOp } from './utils.js'
 
 /**
  * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource } from '../types.js'
@@ -59,55 +60,24 @@ export async function evaluateExpr({ node, row, tables }) {
     if (node.op === '-') {
       const val = await evaluateExpr({ node: node.argument, row, tables })
       if (val == null) return null
-      return -Number(val)
+      return -val
     }
   }
 
   // Binary operators
   if (node.type === 'binary') {
+    const left = await evaluateExpr({ node: node.left, row, tables })
+
+    // Short-circuit evaluation for AND and OR
     if (node.op === 'AND') {
-      const leftVal = await evaluateExpr({ node: node.left, row, tables })
-      if (!leftVal) return false
-      return Boolean(await evaluateExpr({ node: node.right, row, tables }))
+      if (!left) return false
     }
-
     if (node.op === 'OR') {
-      const leftVal = await evaluateExpr({ node: node.left, row, tables })
-      if (leftVal) return true
-      return Boolean(await evaluateExpr({ node: node.right, row, tables }))
+      if (left) return true
     }
 
-    const left = await evaluateExpr({ node: node.left, row, tables })
     const right = await evaluateExpr({ node: node.right, row, tables })
-
-    // In SQL, NULL comparisons with =, !=, <> always return false (unknown)
-    // You must use IS NULL or IS NOT NULL to check for NULL
-    if (left == null || right == null) {
-      if (node.op === '=' || node.op === '!=' || node.op === '<>') {
-        return false
-      }
-    }
-
-    if (node.op === '=') return left === right
-    if (node.op === '!=' || node.op === '<>') return left !== right
-    if (node.op === '<') return left < right
-    if (node.op === '>') return left > right
-    if (node.op === '<=') return left <= right
-    if (node.op === '>=') return left >= right
-
-    if (node.op === 'LIKE') {
-      const str = String(left)
-      const pattern = String(right)
-      // Convert SQL LIKE pattern to regex
-      // % matches zero or more characters
-      // _ matches exactly one character
-      const regexPattern = pattern
-        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // Escape regex special chars
-        .replace(/%/g, '.*') // Replace % with .*
-        .replace(/_/g, '.') // Replace _ with .
-      const regex = new RegExp('^' + regexPattern + '$', 'i')
-      return regex.test(str)
-    }
+    return applyBinaryOp(node.op, left, right)
   }
 
   // Function calls

package/src/execute/having.js

@@ -1,5 +1,6 @@
 import { isAggregateFunc } from '../validation.js'
 import { evaluateExpr } from './expression.js'
+import { applyBinaryOp } from './utils.js'
 
 /**
  * @import { AggregateFunc, AsyncDataSource, ExprNode, AsyncRow, SqlPrimitive } from '../types.js'
@@ -30,38 +31,17 @@ export async function evaluateHavingExpr(expr, row, group, tables) {
 
   if (expr.type === 'binary') {
     const left = await evaluateHavingValue(expr.left, context, group, tables)
-    const right = await evaluateHavingValue(expr.right, context, group, tables)
 
+    // Short-circuit evaluation for AND and OR
     if (expr.op === 'AND') {
-      return Boolean(left && right)
+      if (!left) return false
     }
     if (expr.op === 'OR') {
-      return Boolean(left || right)
-    }
-
-    // Handle NULL comparisons
-    if (left == null || right == null) {
-      if (expr.op === '=' || expr.op === '!=' || expr.op === '<>') {
-        return false
-      }
+      if (left) return true
     }
 
-    if (expr.op === '=') return left === right
-    if (expr.op === '!=' || expr.op === '<>') return left !== right
-    if (expr.op === '<') return left < right
-    if (expr.op === '>') return left > right
-    if (expr.op === '<=') return left <= right
-    if (expr.op === '>=') return left >= right
-    if (expr.op === 'LIKE') {
-      const str = String(left)
-      const pattern = String(right)
-      const regexPattern = pattern
-        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        .replace(/%/g, '.*')
-        .replace(/_/g, '.')
-      const regex = new RegExp('^' + regexPattern + '$', 'i')
-      return regex.test(str)
-    }
+    const right = await evaluateHavingValue(expr.right, context, group, tables)
+    return applyBinaryOp(expr.op, left, right)
   }
 
   if (expr.type === 'unary') {

package/src/execute/utils.js

@@ -1,14 +1,47 @@
 /**
- * @import {AsyncRow, ExprNode, OrderByItem, SqlPrimitive} from '../types.js'
+ * @import {AsyncRow, BinaryOp, ExprNode, OrderByItem, SqlPrimitive} from '../types.js'
  */
 
+/**
+ * Compares two values with the given operator, handling nulls according to SQL semantics
+ *
+ * @param {BinaryOp} op
+ * @param {SqlPrimitive} a
+ * @param {SqlPrimitive} b
+ * @returns {boolean}
+ */
+export function applyBinaryOp(op, a, b) {
+  if (a == null || b == null) {
+    return false
+  }
+  if (op === 'AND') return Boolean(a) && Boolean(b)
+  if (op === 'OR') return Boolean(a) || Boolean(b)
+  if (op === '!=' || op === '<>') return a != b
+  if (op === '=') return a == b
+  if (op === '<') return a < b
+  if (op === '<=') return a <= b
+  if (op === '>') return a > b
+  if (op === '>=') return a >= b
+
+  if (op === 'LIKE') {
+    const str = String(a)
+    const pattern = String(b)
+    const regexPattern = pattern
+      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      .replace(/%/g, '.*')
+      .replace(/_/g, '.')
+    const regex = new RegExp(`^${regexPattern}$`, 'i')
+    return regex.test(str)
+  }
+}
+
 /**
  * Compares two values for a single ORDER BY term, handling nulls and direction
  *
  * @param {SqlPrimitive} a
  * @param {SqlPrimitive} b
  * @param {OrderByItem} term
- * @returns {number} comparison result
+ * @returns {number}
  */
 export function compareForTerm(a, b, term) {
   const aIsNull = a == null
@@ -22,7 +55,7 @@ export function compareForTerm(a, b, term) {
   }
 
   // Compare non-null values
-  if (a === b) return 0
+  if (a == b) return 0
 
   const primitives = ['number', 'bigint', 'boolean', 'string']
   let cmp

package/src/validation.js

@@ -1,6 +1,6 @@
 
 /**
- * @import {AggregateFunc, BinaryOp, StringFunc} from './types.js'
+ * @import {AggregateFunc, BinaryOp, ComparisonOp, StringFunc} from './types.js'
  * @param {string} name
  * @returns {name is AggregateFunc}
  */
@@ -21,7 +21,7 @@ export function isStringFunc(name) {
  * @returns {op is BinaryOp}
  */
 export function isBinaryOp(op) {
-  return ['=', '!=', '<>', '<', '>', '<=', '>='].includes(op)
+  return ['AND', 'OR', 'LIKE', '=', '!=', '<>', '<', '>', '<=', '>='].includes(op)
 }
 
 // Keywords that cannot be used as implicit aliases after a column