vectrojs 0.0.1 → 0.1.0

package/src/sqltext.mjs

@@ -0,0 +1,132 @@
+// SQL's text functions as plain JavaScript on one set of values (sql.mjs
+// runs them through Table._textmap: once per distinct value, not per row).
+// Positions count characters (code points) from 1, as in DuckDB; text
+// missing is '' (as everywhere in Vectro), numbers missing are NaN.
+import { parseDateText } from './dates.mjs';
+
+// a value as text: numbers shortest (whole ones without ".0"), dates as
+// 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM:SS[.mmm]'
+export function toText(v, kind) {
+  if (kind === 'text') return v;
+  if (v !== v || v === null || v === undefined) return '';
+  if (kind === 'date') {
+    const iso = new Date(v).toISOString();
+    if (iso.endsWith('T00:00:00.000Z')) return iso.slice(0, 10);
+    return iso.slice(0, iso.endsWith('.000Z') ? 19 : 23).replace('T', ' ');
+  }
+  if (Number.isInteger(v) && Math.abs(v) < 1e21) return v === 0 ? '0' : String(v);
+  return String(Number(v.toPrecision(15)));
+}
+export const isNull = (v, kind) => (kind === 'text' ? v === '' : v !== v);
+export const textToNumber = (s) => (s.trim() === '' ? NaN : Number(s.trim()));
+export const textToDate = (s) => (s.trim() === '' ? NaN : parseDateText(s.trim()));
+
+const chars = (s) => Array.from(s);
+function trimSet(s, set, start, end) {
+  const cs = chars(s), drop = new Set(chars(set));
+  let a = 0, b = cs.length;
+  if (start) while (a < b && drop.has(cs[a])) a++;
+  if (end) while (b > a && drop.has(cs[b - 1])) b--;
+  return cs.slice(a, b).join('');
+}
+// DuckDB's substring: start 1 is the first character, 0 the place before
+// it, negative counts from the end; a negative length takes the characters before
+function substring(s, start, len) {
+  const cs = chars(s), n = cs.length;
+  const at = start > 0 ? start - 1 : start === 0 ? -1 : n + start;
+  let a = at, b = len === undefined ? Infinity : at + len;
+  if (len !== undefined && len < 0) { a = at + len; b = at; }
+  return cs.slice(Math.max(0, a), Math.max(0, Math.min(n, b))).join('');
+}
+const regexes = new Map();
+function regex(pattern, flags = '') {
+  const key = `${flags}/${pattern}`;
+  let re = regexes.get(key);
+  if (!re) {
+    if (regexes.size > 1000) regexes.clear();
+    try { re = new RegExp(pattern, flags.replace(/[^gimsu]/g, '') + 'u'); } catch (err) { throw new SyntaxError(`vectro SQL: bad regular expression /${pattern}/: ${err.message}`); }
+    regexes.set(key, re);
+  }
+  re.lastIndex = 0;
+  return re;
+}
+const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+function strftime(t, fmt) {
+  const d = new Date(t), p2 = (x) => String(x).padStart(2, '0');
+  const Y = d.getUTCFullYear(), M = d.getUTCMonth(), D = d.getUTCDate(), h = d.getUTCHours(), w = d.getUTCDay();
+  const yday = Math.floor((Date.UTC(Y, M, D) - Date.UTC(Y, 0, 1)) / 86_400_000) + 1;
+  return fmt.replace(/%([a-zA-Z%])/g, (m, c) => {
+    switch (c) {
+      case 'Y': return String(Y);
+      case 'y': return p2(Y % 100);
+      case 'm': return p2(M + 1);
+      case 'd': return p2(D);
+      case 'e': return String(D);
+      case 'H': return p2(h);
+      case 'I': return p2(h % 12 || 12);
+      case 'p': return h < 12 ? 'AM' : 'PM';
+      case 'M': return p2(d.getUTCMinutes());
+      case 'S': return p2(d.getUTCSeconds());
+      case 'f': return String(d.getUTCMilliseconds() * 1000).padStart(6, '0');
+      case 'j': return String(yday).padStart(3, '0');
+      case 'a': return DAYS[w].slice(0, 3);
+      case 'A': return DAYS[w];
+      case 'w': return String(w);
+      case 'u': return String(w || 7);
+      case 'b': return MONTHS[M].slice(0, 3);
+      case 'B': return MONTHS[M];
+      case 'F': return `${Y}-${p2(M + 1)}-${p2(D)}`;
+      case 'T': return `${p2(h)}:${p2(d.getUTCMinutes())}:${p2(d.getUTCSeconds())}`;
+      case '%': return '%';
+      default: return m;
+    }
+  });
+}
+
+// name -> { args: types ('s' text, 'n' number, 't' time), min (args
+// needed), rest (type of any further ones), out: 'text' | 'number', skip
+// (missing values are left out instead of making the answer missing), f }
+export const TEXT_FUNCTIONS = {
+  UPPER: { args: 's', out: 'text', f: (s) => s.toUpperCase() },
+  LOWER: { args: 's', out: 'text', f: (s) => s.toLowerCase() },
+  LENGTH: { args: 's', out: 'number', f: (s) => chars(s).length },
+  OCTET_LENGTH: { args: 's', out: 'number', f: (s) => new TextEncoder().encode(s).length },
+  TRIM: { args: 'ss', min: 1, out: 'text', f: (s, set = ' ') => trimSet(s, set, true, true) },
+  LTRIM: { args: 'ss', min: 1, out: 'text', f: (s, set = ' ') => trimSet(s, set, true, false) },
+  RTRIM: { args: 'ss', min: 1, out: 'text', f: (s, set = ' ') => trimSet(s, set, false, true) },
+  SUBSTRING: { args: 'snn', min: 2, out: 'text', f: substring },
+  LEFT: { args: 'sn', out: 'text', f: (s, k) => { const cs = chars(s); return cs.slice(0, k < 0 ? Math.max(0, cs.length + k) : k).join(''); } },
+  RIGHT: { args: 'sn', out: 'text', f: (s, k) => { const cs = chars(s); return k < 0 ? cs.slice(Math.min(cs.length, -k)).join('') : k === 0 ? '' : cs.slice(-k).join(''); } },
+  REPLACE: { args: 'sss', out: 'text', f: (s, a, b) => (a === '' ? s : s.split(a).join(b)) },
+  REVERSE: { args: 's', out: 'text', f: (s) => chars(s).reverse().join('') },
+  REPEAT: { args: 'sn', out: 'text', f: (s, k) => (k > 0 ? s.repeat(Math.floor(k)) : '') },
+  LPAD: { args: 'sns', min: 2, out: 'text', f: (s, k, fill = ' ') => { const cs = chars(s); if (cs.length >= k) return cs.slice(0, Math.max(0, k)).join(''); const f = chars(fill); if (!f.length) return s; const pad = []; while (pad.length < k - cs.length) pad.push(f[pad.length % f.length]); return pad.join('') + s; } },
+  RPAD: { args: 'sns', min: 2, out: 'text', f: (s, k, fill = ' ') => { const cs = chars(s); if (cs.length >= k) return cs.slice(0, Math.max(0, k)).join(''); const f = chars(fill); if (!f.length) return s; const pad = []; while (pad.length < k - cs.length) pad.push(f[pad.length % f.length]); return s + pad.join(''); } },
+  SPLIT_PART: { args: 'ssn', out: 'text', f: (s, d, k) => { const parts = d === '' ? [s] : s.split(d); const i = k > 0 ? k - 1 : k < 0 ? parts.length + k : -1; return i >= 0 && i < parts.length ? parts[i] : ''; } },
+  STRPOS: { args: 'ss', out: 'number', f: (s, sub) => { const i = s.indexOf(sub); return i < 0 ? 0 : chars(s.slice(0, i)).length + 1; } },
+  STARTS_WITH: { args: 'ss', out: 'number', f: (s, p) => (s.startsWith(p) ? 1 : 0) },
+  ENDS_WITH: { args: 'ss', out: 'number', f: (s, p) => (s.endsWith(p) ? 1 : 0) },
+  CONTAINS: { args: 'ss', out: 'number', f: (s, p) => (s.includes(p) ? 1 : 0) },
+  ASCII: { args: 's', out: 'number', f: (s) => s.codePointAt(0) ?? NaN },
+  CHR: { args: 'n', out: 'text', f: (k) => (k >= 0 && k <= 0x10ffff ? String.fromCodePoint(Math.floor(k)) : '') },
+  REGEXP_MATCHES: { args: 'sss', min: 2, out: 'number', f: (s, p, fl) => (regex(p, fl).test(s) ? 1 : 0) },
+  REGEXP_REPLACE: { args: 'ssss', min: 3, out: 'text', f: (s, p, rep, fl = '') => s.replace(regex(p, fl), rep.replace(/\$/g, '$$$$').replace(/\\(\d)/g, '$$$1')) },
+  REGEXP_EXTRACT: { args: 'ssn', min: 2, out: 'text', f: (s, p, g = 0) => regex(p).exec(s)?.[g] ?? '' },
+  STRFTIME: { args: 'ts', out: 'text', f: strftime },
+  CONCAT: { args: '', rest: 's', out: 'text', skip: true, f: (...xs) => xs.filter((x) => x !== null).join('') },
+  CONCAT_WS: { args: 's', rest: 's', out: 'text', skip: true, f: (sep, ...xs) => (sep === null ? '' : xs.filter((x) => x !== null).join(sep)) },
+  '||': { args: '', rest: 's', out: 'text', f: (...xs) => xs.join('') },
+  FORMAT: { args: 's', rest: 's', out: 'text', skip: true, f: (fmt, ...xs) => { // PostgreSQL's format(): %s, %I (a name, quoted when needed), %L (a literal)
+    if (fmt === null) return '';
+    let k = 0;
+    return fmt.replace(/%([%sIL])/g, (m, c) => {
+      if (c === '%') return '%';
+      const x = xs[k++];
+      if (c === 's') return x ?? '';
+      if (c === 'I') return /^[a-z_][a-z0-9_$]*$/.test(x ?? '') ? x : `"${String(x ?? '').replaceAll('"', '""')}"`;
+      return x === null || x === undefined ? 'NULL' : `'${String(x).replaceAll("'", "''")}'`;
+    });
+  } },
+};
+for (const [alias, name] of Object.entries({ UCASE: 'UPPER', LCASE: 'LOWER', LEN: 'LENGTH', CHAR_LENGTH: 'LENGTH', CHARACTER_LENGTH: 'LENGTH', STRLEN: 'OCTET_LENGTH', SUBSTR: 'SUBSTRING', INSTR: 'STRPOS', POSITION: 'STRPOS', PREFIX: 'STARTS_WITH', SUFFIX: 'ENDS_WITH', REGEXP_LIKE: 'REGEXP_MATCHES', STR_SPLIT_PART: 'SPLIT_PART' })) TEXT_FUNCTIONS[alias] = TEXT_FUNCTIONS[name];

package/src/static-kernels.mjs

@@ -0,0 +1,164 @@
+// The engine's fixed WebAssembly module: the built-in kernels plus the
+// building blocks of the vectorized interpreter (elementwise math,
+// comparisons, select, widening sums, group-by scatter, compaction).
+//
+// It never changes, so it can be built ahead of time (scripts/build-wasm.mjs)
+// for places that forbid compiling WebAssembly at runtime, like Cloudflare
+// Workers. With it, nothing else needs code generation.
+
+import { I32, F64, V128, TY, Fn, loops, buildModule, kernelFns, get, set, i32c, simd, vload, vstore, block, loop, end, br, brIf, i32add, i32geu } from './wasm.mjs';
+import { VEC, SCA } from './fuse.mjs';
+
+const V128_AND = 0x4e, BITSELECT = 0x52, F64X2_PROMOTE_LOW = 0x5f, F64X2_ADD = 0xf0, SHUFFLE = 0x0d;
+const SELECT = [0x1b], I32_SUB = [0x6b], I32_SHR_U = [0x76], I32_SHL = [0x74], I32_MUL = [0x6c];
+const F64_LOAD = [0x2b, 3, 0], F64_STORE = [0x39, 3, 0], F64_PROMOTE_F32 = [0xbb];
+const F64_OP = { add: [0xa0], min: [0xa4], max: [0xa5] };
+const TRUNC_SAT_U = { f64: [0xfc, 0x03], f32: [0xfc, 0x01] };
+const HIGH_HALF = [8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7];
+const U = 2;
+
+export const BINARY_OPS = ['add', 'sub', 'mul', 'div', 'min', 'max'];
+export const COMPARE_OPS = ['eq', 'ne', 'lt', 'gt', 'le', 'ge'];
+export const UNARY_OPS = ['neg', 'abs', 'sqrt', 'floor', 'ceil'];
+
+// dst = a OP b; comparisons give 1.0 or 0.0. (dst, a, b, n)
+function vbinary(t, op) {
+  const ty = TY[t], cmp = COMPARE_OPS.includes(op);
+  const f = new Fn(`v${op}_${t}`, [I32, I32, I32, I32], []);
+  const [dst, a, b, n] = [0, 1, 2, 3];
+  const one = f.local(V128);
+  f.emit(ty.cnst(1), ty.vsplat, set(one));
+  loops(f, ty, {
+    ptrs: [a, b, dst], n, U,
+    body: () => {
+      for (let k = 0; k < U; k++) {
+        f.emit(get(dst), get(a), vload(16 * k), get(b), vload(16 * k), simd(VEC[t][op]));
+        if (cmp) f.emit(get(one), simd(V128_AND));
+        f.emit(vstore(16 * k));
+      }
+    },
+    tail: () => {
+      f.emit(get(dst), get(a), ty.load, get(b), ty.load, [SCA[t][op]]);
+      if (cmp) f.emit([SCA[t].fromBool]);
+      f.emit(ty.store);
+    },
+  });
+  return f;
+}
+
+// dst = OP a. (dst, a, n)
+function vunary(t, op) {
+  const ty = TY[t];
+  const f = new Fn(`v${op}_${t}`, [I32, I32, I32], []);
+  const [dst, a, n] = [0, 1, 2];
+  loops(f, ty, {
+    ptrs: [a, dst], n, U,
+    body: () => { for (let k = 0; k < U; k++) f.emit(get(dst), get(a), vload(16 * k), simd(VEC[t][op]), vstore(16 * k)); },
+    tail: () => f.emit(get(dst), get(a), ty.load, [SCA[t][op]], ty.store),
+  });
+  return f;
+}
+
+// dst = m != 0 ? a : b. (dst, m, a, b, n)
+function vselect(t) {
+  const ty = TY[t];
+  const f = new Fn(`vsel_${t}`, [I32, I32, I32, I32, I32], []);
+  const [dst, m, a, b, n] = [0, 1, 2, 3, 4];
+  const zero = f.local(V128);
+  f.emit(ty.cnst(0), ty.vsplat, set(zero));
+  loops(f, ty, {
+    ptrs: [m, a, b, dst], n, U,
+    body: () => {
+      for (let k = 0; k < U; k++) {
+        f.emit(get(dst), get(a), vload(16 * k), get(b), vload(16 * k));
+        f.emit(get(m), vload(16 * k), get(zero), simd(VEC[t].ne), simd(BITSELECT), vstore(16 * k));
+      }
+    },
+    tail: () => f.emit(get(dst), get(a), ty.load, get(b), ty.load, get(m), ty.load, ty.cnst(0), [SCA[t].ne], SELECT, ty.store),
+  });
+  return f;
+}
+
+// Sum of float32 values, added up in float64 so millions of values keep their precision.
+function sumWide() {
+  const ty = TY.f32;
+  const f = new Fn('vsumw_f32', [I32, I32], [F64]);
+  const [p, n] = [0, 1];
+  const accs = Array.from({ length: 2 * U }, () => f.local(V128));
+  const tmp = f.local(V128), s = f.local(F64);
+  for (const a of accs) f.emit(TY.f64.cnst(0), TY.f64.vsplat, set(a));
+  loops(f, ty, {
+    ptrs: [p], n, U,
+    body: () => {
+      for (let k = 0; k < U; k++) {
+        const [lo, hi] = [accs[2 * k], accs[2 * k + 1]];
+        f.emit(get(p), vload(16 * k), set(tmp));
+        f.emit(get(lo), get(tmp), simd(F64X2_PROMOTE_LOW), simd(F64X2_ADD), set(lo));
+        f.emit(get(hi), get(tmp), get(tmp), simd(SHUFFLE, ...HIGH_HALF), simd(F64X2_PROMOTE_LOW), simd(F64X2_ADD), set(hi));
+      }
+    },
+    between: () => {
+      f.emit(get(accs[0]));
+      for (let j = 1; j < accs.length; j++) f.emit(get(accs[j]), simd(F64X2_ADD));
+      f.emit(set(accs[0]), get(accs[0]), simd(0x21, 0), get(accs[0]), simd(0x21, 1), F64_OP.add, set(s));
+    },
+    tail: () => f.emit(get(s), get(p), ty.load, F64_PROMOTE_F32, F64_OP.add, set(s)),
+  });
+  f.emit(get(s));
+  return f;
+}
+
+// acc[key] = acc[key] OP val for each row (rows whose mask is 0 are skipped).
+// (key, val, [mask,] acc, n); acc is float64.
+function groupScatter(t, op, masked) {
+  const ty = TY[t];
+  const params = masked ? [I32, I32, I32, I32, I32] : [I32, I32, I32, I32];
+  const f = new Fn(`g${op}${masked ? 'm' : ''}_${t}`, params, []);
+  const [key, val] = [0, 1];
+  const mask = masked ? 2 : -1, acc = masked ? 3 : 2, n = masked ? 4 : 3;
+  const stop = f.local(I32), addr = f.local(I32);
+  f.emit(get(n), i32c(ty.bytes), I32_MUL, get(key), i32add, set(stop));
+  f.emit(block, loop, get(key), get(stop), i32geu, brIf(1));
+  f.emit(block);
+  if (masked) f.emit(get(mask), ty.load, ty.cnst(0), [SCA[t].eq], brIf(0));
+  f.emit(get(key), ty.load, TRUNC_SAT_U[t], i32c(3), I32_SHL, get(acc), i32add, set(addr));
+  f.emit(get(addr), get(addr), F64_LOAD, get(val), ty.load, t === 'f32' ? F64_PROMOTE_F32 : [], F64_OP[op], F64_STORE);
+  f.emit(end);
+  for (const p of masked ? [key, val, mask] : [key, val]) f.emit(get(p), i32c(ty.bytes), i32add, set(p));
+  f.emit(br(0), end, end);
+  return f;
+}
+
+// Copy src rows whose mask is non-zero to dst; returns how many were copied.
+// (mask, src, dst, n)
+function compact(t) {
+  const ty = TY[t];
+  const f = new Fn(`compact_${t}`, [I32, I32, I32, I32], [I32]);
+  const [mask, src, dst, n] = [0, 1, 2, 3];
+  const stop = f.local(I32), start = f.local(I32);
+  f.emit(get(dst), set(start));
+  f.emit(get(n), i32c(ty.bytes), I32_MUL, get(src), i32add, set(stop));
+  f.emit(block, loop, get(src), get(stop), i32geu, brIf(1));
+  f.emit(block, get(mask), ty.load, ty.cnst(0), [SCA[t].eq], brIf(0));
+  f.emit(get(dst), get(src), ty.load, ty.store, get(dst), i32c(ty.bytes), i32add, set(dst));
+  f.emit(end);
+  for (const p of [mask, src]) f.emit(get(p), i32c(ty.bytes), i32add, set(p));
+  f.emit(br(0), end, end);
+  f.emit(get(dst), get(start), I32_SUB, i32c(Math.log2(ty.bytes)), I32_SHR_U);
+  return f;
+}
+
+export function interpreterFns() {
+  const fns = [sumWide()];
+  for (const t of ['f64', 'f32']) {
+    for (const op of [...BINARY_OPS, ...COMPARE_OPS]) fns.push(vbinary(t, op));
+    for (const op of UNARY_OPS) fns.push(vunary(t, op));
+    fns.push(vselect(t), compact(t));
+    for (const op of ['add', 'min', 'max']) fns.push(groupScatter(t, op, false), groupScatter(t, op, true));
+  }
+  return fns;
+}
+
+export function buildStaticModule(shared) {
+  return buildModule([...kernelFns(), ...interpreterFns()], shared);
+}