squirreling 0.4.5 → 0.4.7

package/README.md

@@ -67,3 +67,14 @@ const allUsers: Record<string, SqlPrimitive>[] = await collect(executeSql({
 }))
 console.log(allUsers)
 ```
+
+## Supported SQL Features
+
+- `SELECT` statements with `WHERE`, `ORDER BY`, `LIMIT`, `OFFSET`
+- Subqueries in `SELECT`, `FROM`, and `WHERE` clauses
+- `JOIN` operations: `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL JOIN`
+- `GROUP BY` and `HAVING` clauses
+- Aggregate functions: `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`, `JSON_ARRAYAGG`
+- String functions: `CONCAT`, `SUBSTRING`, `LENGTH`, `UPPER`, `LOWER`
+- Json functions: `JSON_VALUE`, `JSON_QUERY`, `JSON_OBJECT`
+- Basic expressions and arithmetic operations

package/package.json

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

package/src/execute/aggregates.js

@@ -1,15 +1,15 @@
 import { evaluateExpr } from './expression.js'
-import { defaultDerivedAlias } from './utils.js'
+import { defaultDerivedAlias, stringify } from './utils.js'
 
 /**
  * Evaluates an aggregate function over a set of rows
  *
- * @import { AggregateColumn, AsyncDataSource, ExprNode, AsyncRow } from '../types.js'
+ * @import { AggregateColumn, AsyncDataSource, AsyncRow, SqlPrimitive } from '../types.js'
  * @param {Object} options
  * @param {AggregateColumn} options.col - aggregate column definition
  * @param {AsyncRow[]} options.rows - rows to aggregate
  * @param {Record<string, AsyncDataSource>} options.tables
- * @returns {Promise<number | null>} aggregated result
+ * @returns {Promise<SqlPrimitive>} aggregated result
  */
 export async function evaluateAggregate({ col, rows, tables }) {
   const { arg, func } = col
@@ -70,6 +70,31 @@ export async function evaluateAggregate({ col, rows, tables }) {
     if (func === 'MAX') return max
   }
 
+  if (func === 'JSON_ARRAYAGG') {
+    if (arg.kind === 'star') {
+      throw new Error('JSON_ARRAYAGG(*) is not supported, use a column name or expression')
+    }
+    /** @type {SqlPrimitive[]} */
+    const values = []
+    if (arg.quantifier === 'distinct') {
+      const seen = new Set()
+      for (const row of rows) {
+        const v = await evaluateExpr({ node: arg.expr, row, tables })
+        const key = stringify(v)
+        if (!seen.has(key)) {
+          seen.add(key)
+          values.push(v)
+        }
+      }
+    } else {
+      for (const row of rows) {
+        const v = await evaluateExpr({ node: arg.expr, row, tables })
+        values.push(v)
+      }
+    }
+    return values
+  }
+
   throw new Error('Unsupported aggregate function ' + func)
 }
 

package/src/execute/execute.js

@@ -1,14 +1,14 @@
 import { generatorSource, memorySource } from '../backend/dataSource.js'
 import { parseSql } from '../parse/parse.js'
 import { defaultAggregateAlias, evaluateAggregate } from './aggregates.js'
+import { extractColumns } from './columns.js'
 import { evaluateExpr } from './expression.js'
 import { evaluateHavingExpr } from './having.js'
 import { executeJoins } from './join.js'
-import { compareForTerm, defaultDerivedAlias } from './utils.js'
-import { extractColumns } from './columns.js'
+import { compareForTerm, defaultDerivedAlias, stringify } from './utils.js'
 
 /**
- * @import { AsyncDataSource, AsyncRow, ExecuteSqlOptions, ExprNode, OrderByItem, QueryHints, SelectStatement, SqlPrimitive } from '../types.js'
+ * @import { AsyncDataSource, AsyncRow, ExecuteSqlOptions, OrderByItem, QueryHints, SelectStatement, SqlPrimitive } from '../types.js'
  */
 
 /**
@@ -85,7 +85,7 @@ async function stableRowKey(row) {
   const parts = []
   for (const k of keys) {
     const v = await row[k]()
-    parts.push(k + ':' + JSON.stringify(v))
+    parts.push(k + ':' + stringify(v))
   }
   return parts.join('|')
 }
@@ -358,7 +358,7 @@ async function* evaluateBuffered(select, dataSource, tables, hasAggregate, useGr
         const keyParts = []
         for (const expr of select.groupBy) {
           const v = await evaluateExpr({ node: expr, row, tables })
-          keyParts.push(JSON.stringify(v))
+          keyParts.push(stringify(v))
         }
         const key = keyParts.join('|')
         let group = map.get(key)

package/src/execute/expression.js

@@ -1,4 +1,5 @@
 import { executeSelect } from './execute.js'
+import { applyBinaryOp, stringify } from './utils.js'
 
 /**
  * @import { ExprNode, AsyncRow, SqlPrimitive, AsyncDataSource } from '../types.js'
@@ -59,60 +60,30 @@ 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
   if (node.type === 'function') {
     const funcName = node.name.toUpperCase()
+    /** @type {SqlPrimitive[]} */
     const args = await Promise.all(node.args.map(arg => evaluateExpr({ node: arg, row, tables })))
 
     if (funcName === 'UPPER') {
@@ -132,8 +103,9 @@ export async function evaluateExpr({ node, row, tables }) {
     if (funcName === 'CONCAT') {
       if (args.length < 1) throw new Error('CONCAT requires at least 1 argument')
       // SQL CONCAT returns NULL if any argument is NULL
-      for (let i = 0; i < args.length; i += 1) {
-        if (args[i] == null) return null
+      if (args.some(a => a == null)) return null
+      if (args.some(a => typeof a === 'object')) {
+        throw new Error('CONCAT does not support object arguments')
       }
       return args.map(a => String(a)).join('')
     }
@@ -190,6 +162,67 @@ export async function evaluateExpr({ node, row, tables }) {
       return Math.random()
     }
 
+    if (funcName === 'JSON_OBJECT') {
+      if (args.length % 2 !== 0) {
+        throw new Error('JSON_OBJECT requires an even number of arguments (key-value pairs)')
+      }
+      /** @type {Record<string, SqlPrimitive>} */
+      const result = {}
+      for (let i = 0; i < args.length; i += 2) {
+        const key = args[i]
+        const value = args[i + 1]
+        if (key == null) {
+          throw new Error('JSON_OBJECT: key cannot be null')
+        }
+        result[String(key)] = value
+      }
+      return result
+    }
+
+    if (funcName === 'JSON_VALUE' || funcName === 'JSON_QUERY') {
+      if (args.length !== 2) throw new Error(`${funcName} requires exactly 2 arguments`)
+      let jsonArg = args[0]
+      const pathArg = args[1]
+      if (jsonArg == null || pathArg == null) return null
+
+      // Parse JSON if string, otherwise use directly
+      if (typeof jsonArg === 'string') {
+        try {
+          jsonArg = JSON.parse(jsonArg)
+        } catch {
+          throw new Error(`${funcName}: invalid JSON string`)
+        }
+      }
+      if (typeof jsonArg !== 'object') {
+        throw new Error(`${funcName}: first argument must be JSON string or object`)
+      }
+
+      // Parse path ("$.foo.bar[0].baz" or "foo.bar[0]")
+      const path = String(pathArg)
+      const normalizedPath = path.startsWith('$') ? path.slice(1) : path
+
+      // Navigate the path
+      let current = jsonArg
+      const segments = normalizedPath.match(/\.?([^.[]+)|\[(\d+)\]/g) || []
+      for (const segment of segments) {
+        if (current == null) return null
+        if (segment.startsWith('[')) {
+          // Array index access
+          const index = parseInt(segment.slice(1, -1), 10)
+          if (!Array.isArray(current)) return null
+          current = current[index]
+        } else {
+          // Property access
+          const key = segment.startsWith('.') ? segment.slice(1) : segment
+          if (typeof current !== 'object' || Array.isArray(current)) return null
+          current = current[key]
+        }
+      }
+
+      if (current == null) return null
+      return current
+    }
+
     throw new Error('Unsupported function ' + funcName)
   }
 
@@ -197,6 +230,12 @@ export async function evaluateExpr({ node, row, tables }) {
     const val = await evaluateExpr({ node: node.expr, row, tables })
     if (val == null) return null
     const toType = node.toType.toUpperCase()
+    if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
+      if (typeof val === 'object') return stringify(val)
+      return String(val)
+    }
+    // Can only cast primitives to other primitive types
+    if (typeof val === 'object') throw new Error(`Cannot CAST object to type ${node.toType}`)
     if (toType === 'INTEGER' || toType === 'INT') {
       const num = Number(val)
       if (isNaN(num)) return null
@@ -210,9 +249,6 @@ export async function evaluateExpr({ node, row, tables }) {
       if (isNaN(num)) return null
       return num
     }
-    if (toType === 'TEXT' || toType === 'STRING' || toType === 'VARCHAR') {
-      return String(val)
-    }
     if (toType === 'BOOLEAN' || toType === 'BOOL') {
       return Boolean(val)
     }

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 Boolean(applyBinaryOp(expr.op, left, right))
   }
 
   if (expr.type === 'unary') {

package/src/execute/join.js

@@ -1,4 +1,5 @@
 import { evaluateExpr } from './expression.js'
+import { stringify } from './utils.js'
 
 /**
  * @import { AsyncRow, AsyncDataSource, JoinClause, ExprNode } from '../types.js'
@@ -258,8 +259,7 @@ async function* hashJoin({ leftRows, rightRows, join, leftTable, rightTable, tab
     for (const rightRow of rightRows) {
       const keyValue = await evaluateExpr({ node: keys.rightKey, row: rightRow, tables })
       if (keyValue == null) continue // NULL keys never match
-      const keyStr = JSON.stringify(keyValue)
-
+      const keyStr = stringify(keyValue)
       let bucket = hashMap.get(keyStr)
       if (!bucket) {
         bucket = []
@@ -283,7 +283,7 @@ async function* hashJoin({ leftRows, rightRows, join, leftTable, rightTable, tab
       }
 
       const keyValue = await evaluateExpr({ node: keys.leftKey, row: leftRow, tables })
-      const keyStr = JSON.stringify(keyValue)
+      const keyStr = stringify(keyValue)
 
       const matchingRightRows = hashMap.get(keyStr)
 

package/src/execute/utils.js

@@ -1,14 +1,62 @@
 /**
- * @import {AsyncRow, ExprNode, OrderByItem, SqlPrimitive} from '../types.js'
+ * @import {AsyncRow, BinaryOp, ExprNode, OrderByItem, SqlPrimitive} from '../types.js'
  */
 
+/**
+ * Applies a binary operator to two values, handling nulls according to SQL semantics
+ *
+ * @param {BinaryOp} op
+ * @param {SqlPrimitive} a
+ * @param {SqlPrimitive} b
+ * @returns {SqlPrimitive}
+ */
+export function applyBinaryOp(op, a, b) {
+  // Arithmetic operators return null if either operand is null
+  if (op === '+' || op === '-' || op === '*' || op === '/' || op === '%') {
+    if (a == null || b == null) return null
+    const numA = Number(a)
+    const numB = Number(b)
+    if (op === '+') return numA + numB
+    if (op === '-') return numA - numB
+    if (op === '*') return numA * numB
+    if (op === '/') return numB === 0 ? null : numA / numB
+    if (op === '%') return numB === 0 ? null : numA % numB
+  }
+
+  // Comparison and logical operators
+  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)
+  }
+
+  return null
+}
+
 /**
  * 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 +70,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
@@ -88,3 +136,17 @@ export function defaultDerivedAlias(expr) {
   }
   return 'expr'
 }
+
+/**
+ * @param {SqlPrimitive} value
+ * @returns {string}
+ */
+export function stringify(value) {
+  if (value == null) return 'NULL'
+  return JSON.stringify(value, (_, val) => {
+    if (typeof val === 'bigint') {
+      return val <= Number.MAX_SAFE_INTEGER ? Number(val) : val.toString()
+    }
+    return val
+  })
+}

package/src/parse/comparison.js

@@ -1,5 +1,5 @@
 import { isBinaryOp } from '../validation.js'
-import { parseExpression, parsePrimary, parseSubquery } from './expression.js'
+import { parseAdditive, parseExpression, parseSubquery } from './expression.js'
 import { consume, current, expect, match, peekToken } from './state.js'
 
 /**
@@ -11,7 +11,7 @@ import { consume, current, expect, match, peekToken } from './state.js'
  * @returns {ExprNode}
  */
 export function parseComparison(state) {
-  const left = parsePrimary(state)
+  const left = parseAdditive(state)
   const tok = current(state)
 
   // IS [NOT] NULL
@@ -41,7 +41,7 @@ export function parseComparison(state) {
     if (nextTok.type === 'keyword' && nextTok.value === 'LIKE') {
       consume(state) // NOT
       consume(state) // LIKE
-      const right = parsePrimary(state)
+      const right = parseAdditive(state)
       return {
         type: 'unary',
         op: 'NOT',
@@ -57,7 +57,7 @@ export function parseComparison(state) {
 
   if (tok.type === 'keyword' && tok.value === 'LIKE') {
     consume(state)
-    const right = parsePrimary(state)
+    const right = parseAdditive(state)
     return {
       type: 'binary',
       op: 'LIKE',
@@ -72,9 +72,9 @@ export function parseComparison(state) {
     if (nextTok.type === 'keyword' && nextTok.value === 'BETWEEN') {
       consume(state) // NOT
       consume(state) // BETWEEN
-      const lower = parsePrimary(state)
+      const lower = parseAdditive(state)
       expect(state, 'keyword', 'AND')
-      const upper = parsePrimary(state)
+      const upper = parseAdditive(state)
       // NOT BETWEEN -> expr < lower OR expr > upper
       return {
         type: 'binary',
@@ -87,9 +87,9 @@ export function parseComparison(state) {
 
   if (tok.type === 'keyword' && tok.value === 'BETWEEN') {
     consume(state)
-    const lower = parsePrimary(state)
+    const lower = parseAdditive(state)
     expect(state, 'keyword', 'AND')
-    const upper = parsePrimary(state)
+    const upper = parseAdditive(state)
     // BETWEEN -> expr >= lower AND expr <= upper
     return {
       type: 'binary',
@@ -186,7 +186,7 @@ export function parseComparison(state) {
 
   if (tok.type === 'operator' && isBinaryOp(tok.value)) {
     consume(state)
-    const right = parsePrimary(state)
+    const right = parseAdditive(state)
     return {
       type: 'binary',
       op: tok.value,

package/src/parse/expression.js

@@ -272,6 +272,54 @@ function parseNot(state) {
   return parseComparison(state)
 }
 
+/**
+ * @param {ParserState} state
+ * @returns {ExprNode}
+ */
+export function parseAdditive(state) {
+  let node = parseMultiplicative(state)
+  while (true) {
+    const tok = current(state)
+    if (tok.type === 'operator' && (tok.value === '+' || tok.value === '-')) {
+      consume(state)
+      const right = parseMultiplicative(state)
+      node = {
+        type: 'binary',
+        op: tok.value,
+        left: node,
+        right,
+      }
+    } else {
+      break
+    }
+  }
+  return node
+}
+
+/**
+ * @param {ParserState} state
+ * @returns {ExprNode}
+ */
+function parseMultiplicative(state) {
+  let node = parsePrimary(state)
+  while (true) {
+    const tok = current(state)
+    if (tok.type === 'operator' && (tok.value === '*' || tok.value === '/' || tok.value === '%')) {
+      consume(state)
+      const right = parsePrimary(state)
+      node = {
+        type: 'binary',
+        op: tok.value,
+        left: node,
+        right,
+      }
+    } else {
+      break
+    }
+  }
+  return node
+}
+
 /**
  * Creates an ExprCursor adapter for the ParserState.
  *

package/src/types.d.ts

@@ -27,7 +27,7 @@ export interface ExecuteSqlOptions {
   query: string
 }
 
-export type SqlPrimitive = string | number | bigint | boolean | null
+export type SqlPrimitive = string | number | bigint | boolean | SqlPrimitive[] | Record<string, any> | null
 
 export interface SelectStatement {
   distinct: boolean
@@ -54,7 +54,9 @@ export interface FromSubquery {
   alias: string
 }
 
-export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp
+export type ArithmeticOp = '+' | '-' | '*' | '/' | '%'
+
+export type BinaryOp = 'AND' | 'OR' | 'LIKE' | ComparisonOp | ArithmeticOp
 
 export type ComparisonOp = '=' | '!=' | '<>' | '<' | '>' | '<=' | '>='
 
@@ -146,9 +148,20 @@ export interface StarColumn {
   alias?: string
 }
 
-export type AggregateFunc = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX'
-
-export type StringFunc = 'UPPER' | 'LOWER' | 'CONCAT' | 'LENGTH' | 'SUBSTRING' | 'SUBSTR' | 'TRIM' | 'REPLACE'
+export type AggregateFunc = 'COUNT' | 'SUM' | 'AVG' | 'MIN' | 'MAX' | 'JSON_ARRAYAGG'
+
+export type StringFunc =
+  | 'UPPER'
+  | 'LOWER'
+  | 'CONCAT'
+  | 'LENGTH'
+  | 'SUBSTRING'
+  | 'SUBSTR'
+  | 'TRIM'
+  | 'REPLACE'
+  | 'JSON_VALUE'
+  | 'JSON_QUERY'
+  | 'JSON_OBJECT'
 
 export interface AggregateArgStar {
   kind: 'star'

package/src/validation.js

@@ -1,11 +1,11 @@
 
 /**
- * @import {AggregateFunc, BinaryOp, StringFunc} from './types.js'
+ * @import {AggregateFunc, BinaryOp, ComparisonOp, StringFunc} from './types.js'
  * @param {string} name
  * @returns {name is AggregateFunc}
  */
 export function isAggregateFunc(name) {
-  return ['COUNT', 'SUM', 'AVG', 'MIN', 'MAX'].includes(name)
+  return ['COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'JSON_ARRAYAGG'].includes(name)
 }
 
 /**
@@ -13,7 +13,21 @@ export function isAggregateFunc(name) {
  * @returns {name is StringFunc}
  */
 export function isStringFunc(name) {
-  return ['UPPER', 'LOWER', 'CONCAT', 'LENGTH', 'SUBSTRING', 'SUBSTR', 'TRIM', 'REPLACE', 'RANDOM', 'RAND'].includes(name)
+  return [
+    'UPPER',
+    'LOWER',
+    'CONCAT',
+    'LENGTH',
+    'SUBSTRING',
+    'SUBSTR',
+    'TRIM',
+    'REPLACE',
+    'RANDOM',
+    'RAND',
+    'JSON_VALUE',
+    'JSON_QUERY',
+    'JSON_OBJECT',
+  ].includes(name)
 }
 
 /**
@@ -21,7 +35,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