fix: 8 bugs — scientific notation parse, SQL comments, NOT IN NULL, frame bounds

SQL parser/lexer:
- 1e10 parsed via parseInt gave 1 instead of 10000000000 — now uses parseFloat
- SQL line comments (--) and block comments (/* */) now skipped by lexer
- 1e (no digits after exponent) no longer consumed as valid number
- Window frame default end was "current" instead of "current_row" (NaN frame bound)
- Hoisted comparison opMap to module scope (no per-parse allocation)
- Removed dead variable colTok in table.column parsing

SQL evaluator:
- NOT IN with NULL elements now returns NULL per SQL three-valued logic

Operators:
- Cross join push(...batch) → loop to prevent stack overflow

Types/partial-agg:
- rowComparator handles undefined (missing keys after joins)
- GROUP BY key restoration guards against Infinity/NaN strings

Author: teamchong

src/operators.ts

@@ -2166,7 +2166,7 @@ export class HashJoinOperator implements Operator {
       while (true) {
         const batch = await this.right.next();
         if (!batch) break;
-        this.crossRightBuffer.push(...batch);
+        for (const row of batch) this.crossRightBuffer.push(row);
       }
       return;
     }

src/partial-agg.ts

@@ -295,7 +295,7 @@ export function finalizePartialAgg(
       } else {
         // Attempt to restore numeric types
         const num = Number(part);
-        row[groupCols[i]] = part !== "" && !isNaN(num) && String(num) === part ? num : part;
+        row[groupCols[i]] = part !== "" && !isNaN(num) && isFinite(num) && String(num) === part ? num : part;
       }
     }
     for (let i = 0; i < states.length; i++) {

src/sql/evaluator.ts

@@ -30,10 +30,15 @@ export function evaluateExpr(expr: SqlExpr, row: Row): unknown {
       const val = evaluateExpr(expr.expr, row);
       if (val === null) return null;
       let found = false;
+      let hasNull = false;
       for (const v of expr.values) {
-        if (looseEqual(val, evaluateExpr(v, row))) { found = true; break; }
+        const ev = evaluateExpr(v, row);
+        if (ev === null) { hasNull = true; continue; }
+        if (looseEqual(val, ev)) { found = true; break; }
       }
-      return expr.negated ? !found : found;
+      if (found) return !expr.negated;
+      if (hasNull) return null; // SQL three-valued: NOT IN (..., NULL) → NULL when not found
+      return expr.negated;
     }
 
     case "between": {

src/sql/lexer.ts

@@ -126,6 +126,19 @@ export function tokenize(sql: string): Token[] {
     const start = pos;
     const ch = sql[pos];
 
+    // Line comments (--)
+    if (ch === "-" && pos + 1 < len && sql[pos + 1] === "-") {
+      while (pos < len && sql[pos] !== "\n") pos++;
+      continue;
+    }
+    // Block comments (/* */)
+    if (ch === "/" && pos + 1 < len && sql[pos + 1] === "*") {
+      pos += 2;
+      while (pos + 1 < len && !(sql[pos] === "*" && sql[pos + 1] === "/")) pos++;
+      pos += 2;
+      continue;
+    }
+
     // Identifiers and keywords
     if (/[a-zA-Z_]/.test(ch)) {
       while (pos < len && /[a-zA-Z0-9_]/.test(sql[pos])) pos++;
@@ -143,9 +156,14 @@ export function tokenize(sql: string): Token[] {
         while (pos < len && /[0-9]/.test(sql[pos])) pos++;
       }
       if (pos < len && (sql[pos] === "e" || sql[pos] === "E")) {
+        const ePos = pos;
         pos++;
         if (pos < len && (sql[pos] === "+" || sql[pos] === "-")) pos++;
-        while (pos < len && /[0-9]/.test(sql[pos])) pos++;
+        if (pos < len && /[0-9]/.test(sql[pos])) {
+          while (pos < len && /[0-9]/.test(sql[pos])) pos++;
+        } else {
+          pos = ePos; // rollback — 'e' is not part of this number
+        }
       }
       tokens.push({ type: TokenType.NUMBER, lexeme: sql.slice(start, pos), position: start });
       continue;

src/sql/parser.ts

@@ -8,6 +8,12 @@ import type {
   SqlStatement, ShowVersionsStmt, DiffStmt,
 } from "./ast.js";
 
+const COMPARISON_OPS: readonly [TokenType, BinaryOp][] = [
+  [TokenType.EQ, "eq"], [TokenType.NE, "ne"],
+  [TokenType.LT, "lt"], [TokenType.LE, "le"],
+  [TokenType.GT, "gt"], [TokenType.GE, "ge"],
+];
+
 export function parse(sql: string): SelectStmt {
   const tokens = tokenize(sql);
   const parser = new Parser(tokens, sql);
@@ -498,12 +504,7 @@ class Parser {
     }
 
     // Standard comparisons
-    const opMap: [TokenType, BinaryOp][] = [
-      [TokenType.EQ, "eq"], [TokenType.NE, "ne"],
-      [TokenType.LT, "lt"], [TokenType.LE, "le"],
-      [TokenType.GT, "gt"], [TokenType.GE, "ge"],
-    ];
-    for (const [tt, op] of opMap) {
+    for (const [tt, op] of COMPARISON_OPS) {
       if (this.match(tt)) {
         const right = this.parseAddSub();
         return { kind: "binary", op, left, right };
@@ -603,8 +604,9 @@ class Parser {
 
     // Number
     if (this.match(TokenType.NUMBER)) {
-      const num = tok.lexeme.includes(".") ? parseFloat(tok.lexeme) : parseInt(tok.lexeme, 10);
-      const valType = tok.lexeme.includes(".") ? "float" as const : "integer" as const;
+      const isFloat = tok.lexeme.includes(".") || tok.lexeme.includes("e") || tok.lexeme.includes("E");
+      const num = isFloat ? parseFloat(tok.lexeme) : parseInt(tok.lexeme, 10);
+      const valType = isFloat ? "float" as const : "integer" as const;
       return { kind: "value", value: { type: valType, value: num } };
     }
 
@@ -663,7 +665,6 @@ class Parser {
 
       // Check for table.column
       if (this.match(TokenType.DOT)) {
-        const colTok = this.current();
         if (this.match(TokenType.STAR)) {
           // table.* in expression context
           return { kind: "column", table: name, name: "*" };
@@ -734,7 +735,7 @@ class Parser {
       const frameType = this.match(TokenType.ROWS) ? "rows" as const : (this.advance(), "range" as const);
       this.match(TokenType.BETWEEN); // consume optional BETWEEN keyword
       const start = this.parseFrameBound();
-      let end: NonNullable<SqlWindowSpec["frame"]>["end"] = { type: "current" as const };
+      let end: NonNullable<SqlWindowSpec["frame"]>["end"] = { type: "current_row" as const };
       if (this.match(TokenType.AND)) {
         end = this.parseFrameBound();
       }

src/types.ts

@@ -17,9 +17,9 @@ export function rowComparator(col: string, desc: boolean): (a: Row, b: Row) => n
   const dir = desc ? -1 : 1;
   return (a: Row, b: Row): number => {
     const av = a[col], bv = b[col];
-    if (av === null && bv === null) return 0;
-    if (av === null) return 1;
-    if (bv === null) return -1;
+    if ((av === null || av === undefined) && (bv === null || bv === undefined)) return 0;
+    if (av === null || av === undefined) return 1;
+    if (bv === null || bv === undefined) return -1;
     return av < bv ? -dir : av > bv ? dir : 0;
   };
 }