fix: LIKE case sensitivity, bigint arithmetic precision, CAST(str AS BIGINT)

Three SQL correctness fixes:

1. decode.ts: compileLikeRegex used "i" flag — LIKE was case-insensitive,
   violating SQL standard and disagreeing with the WASM SIMD path (which
   does byte-level comparison). Removed "i" flag, kept "s" for dotAll.

2. evaluator.ts: arithmetic ops (add/subtract/multiply) went through
   toNumber() which loses precision for bigint values > MAX_SAFE_INTEGER.
   Added numericOp() that preserves bigint arithmetic when both operands
   are bigint or safe integers. Unary minus also preserves bigint.

3. evaluator.ts: CAST(string AS BIGINT) went through toNumber() → float
   before BigInt(), losing precision for large integer strings. Now uses
   BigInt(val) directly for string inputs.

Author: teamchong

src/decode.ts

@@ -584,7 +584,7 @@ export function compileLikeRegex(pattern: string): RegExp {
   if (cached) return cached;
   // Escape regex metacharacters, then replace SQL wildcards
   const escaped = pattern.replace(/[.+?^${}()|[\]\\*]/g, "\\$&");
-  const re = new RegExp("^" + escaped.replace(/%/g, ".*").replace(/_/g, ".") + "$", "i");
+  const re = new RegExp("^" + escaped.replace(/%/g, ".*").replace(/_/g, ".") + "$", "s");
   likeRegexCache.set(pattern, re);
   if (likeRegexCache.size > 1000) likeRegexCache.clear(); // prevent unbounded growth
   return re;

src/sql/evaluator.ts

@@ -118,9 +118,9 @@ function evaluateBinary(op: string, leftExpr: SqlExpr, rightExpr: SqlExpr, row:
     case "le": return compare(left, right) <= 0;
     case "gt": return compare(left, right) > 0;
     case "ge": return compare(left, right) >= 0;
-    case "add": return toNumber(left) + toNumber(right);
-    case "subtract": return toNumber(left) - toNumber(right);
-    case "multiply": return toNumber(left) * toNumber(right);
+    case "add": return numericOp(left, right, (a, b) => a + b, (a, b) => a + b);
+    case "subtract": return numericOp(left, right, (a, b) => a - b, (a, b) => a - b);
+    case "multiply": return numericOp(left, right, (a, b) => a * b, (a, b) => a * b);
     case "divide": {
       const divisor = toNumber(right);
       return divisor === 0 ? null : toNumber(left) / divisor;
@@ -149,7 +149,7 @@ function evaluateUnary(op: string, operandExpr: SqlExpr, row: Row): unknown {
   }
   if (op === "minus") {
     if (val === null) return null;
-    return -toNumber(val);
+    return typeof val === "bigint" ? -val : -toNumber(val);
   }
   return null;
 }
@@ -183,14 +183,32 @@ function toNumber(val: unknown): number {
   return 0;
 }
 
+/** Preserve bigint precision when both operands are bigint or safe integers. */
+function numericOp(
+  left: unknown, right: unknown,
+  numFn: (a: number, b: number) => number,
+  bigFn: (a: bigint, b: bigint) => bigint,
+): number | bigint {
+  const lb = typeof left === "bigint";
+  const rb = typeof right === "bigint";
+  if (lb && rb) return bigFn(left as bigint, right as bigint);
+  if (lb && typeof right === "number" && Number.isInteger(right)) return bigFn(left as bigint, BigInt(right));
+  if (rb && typeof left === "number" && Number.isInteger(left)) return bigFn(BigInt(left), right as bigint);
+  return numFn(toNumber(left), toNumber(right));
+}
+
 function matchLike(value: string, pattern: string): boolean {
   return compileLikeRegex(pattern).test(value);
 }
 
 function castValue(val: unknown, targetType: string): unknown {
   if (val === null) return null;
   const t = targetType.toLowerCase();
-  if (t === "bigint") return typeof val === "bigint" ? val : BigInt(Math.trunc(toNumber(val)));
+  if (t === "bigint") {
+    if (typeof val === "bigint") return val;
+    if (typeof val === "string") { try { return BigInt(val); } catch { return 0n; } }
+    return BigInt(Math.trunc(toNumber(val)));
+  }
   if (t === "int" || t === "integer") return Math.trunc(toNumber(val));
   if (t === "float" || t === "double" || t === "real" || t === "decimal" || t === "numeric") return toNumber(val);
   if (t === "text" || t === "varchar" || t === "string" || t === "char") return String(val);