@cicctencent/json-orm 0.1.1

package/dist/cjs/json-sql-expr.js

@@ -0,0 +1,857 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGG_FUNCS = void 0;
+exports.hasAggregate = hasAggregate;
+exports.truthy = truthy;
+exports.evalExpr = evalExpr;
+exports.toDate = toDate;
+exports.mysqlDatetime = mysqlDatetime;
+exports.jsonPathGet = jsonPathGet;
+exports.jsonUnquote = jsonUnquote;
+exports.parseExpr = parseExpr;
+/**
+ * JSON 回退存储：SQL 表达式引擎（json-fallback-storage 规格）
+ *
+ * 供 json-sql.ts 共用的表达式 AST、递归下降解析与求值：
+ *   - 优先级：OR → AND → NOT → 比较（= != < > <= >= IS [NOT] NULL、
+ *     [NOT] IN、[NOT] LIKE、[NOT] BETWEEN）→ 加减（含 `NOW() ± INTERVAL n UNIT`）
+ *     → 乘除模 → 一元 → 后缀（`col->'$.path'` / `->>`）
+ *   - CASE [operand] WHEN ... THEN ... ELSE ... END、CAST(x AS type)
+ *   - MySQL 函数：COALESCE/NULLIF/IF/IFNULL、JSON_EXTRACT/JSON_UNQUOTE、
+ *     NOW/UNIX_TIMESTAMP/FROM_UNIXTIME/DATE_FORMAT/TIMESTAMPDIFF/DATEDIFF、
+ *     ABS/ROUND/FLOOR/CEIL、CONCAT/LOWER/UPPER/LENGTH/SUBSTRING/TRIM、DATABASE
+ *   - 聚合（SUM/COUNT/AVG/MIN/MAX，含 DISTINCT）在分组上下文中求值
+ *
+ * 未覆盖语法显式抛错（fail-loud）。
+ */
+const json_where_ts_1 = require("./json-where.js");
+exports.AGG_FUNCS = new Set(['SUM', 'COUNT', 'AVG', 'MIN', 'MAX']);
+/** 表达式中是否含聚合函数 */
+function hasAggregate(e) {
+    switch (e.kind) {
+        case 'func':
+            return exports.AGG_FUNCS.has(e.name) || e.args.some(hasAggregate);
+        case 'binary':
+            return hasAggregate(e.left) || hasAggregate(e.right);
+        case 'unary':
+            return hasAggregate(e.operand);
+        case 'case':
+            return ((e.operand ? hasAggregate(e.operand) : false) ||
+                e.whens.some(w => hasAggregate(w.when) || hasAggregate(w.then)) ||
+                (e.else ? hasAggregate(e.else) : false));
+        case 'cast':
+            return hasAggregate(e.operand);
+        case 'jsonPath':
+            return hasAggregate(e.source);
+        case 'interval':
+            return hasAggregate(e.value);
+        default:
+            return false;
+    }
+}
+// ---------------- 解析 ----------------
+function parseExpr(c) {
+    let left = parseAnd(c);
+    while (c.isKeyword('OR')) {
+        c.next();
+        left = { kind: 'binary', op: 'OR', left, right: parseAnd(c) };
+    }
+    return left;
+}
+function parseAnd(c) {
+    let left = parseNot(c);
+    while (c.isKeyword('AND')) {
+        c.next();
+        left = { kind: 'binary', op: 'AND', left, right: parseNot(c) };
+    }
+    return left;
+}
+function parseNot(c) {
+    if (c.isKeyword('NOT')) {
+        c.next();
+        return { kind: 'unary', op: 'NOT', operand: parseNot(c) };
+    }
+    return parseComparison(c);
+}
+const CMP_OPS = ['=', '!=', '<>', '<', '>', '<=', '>='];
+function parseComparison(c) {
+    const left = parseAdditive(c);
+    if (c.isKeyword('IS')) {
+        c.next();
+        let negated = false;
+        if (c.isKeyword('NOT')) {
+            c.next();
+            negated = true;
+        }
+        c.expectKeyword('NULL');
+        return { kind: 'unary', op: negated ? 'IS NOT NULL' : 'IS NULL', operand: left };
+    }
+    let negated = false;
+    if (c.isKeyword('NOT')) {
+        c.next();
+        negated = true;
+    }
+    if (c.isKeyword('IN')) {
+        c.next();
+        c.expect('lparen');
+        const items = [];
+        if (c.peek().type !== 'rparen') {
+            items.push(parseExpr(c));
+            while (c.peek().type === 'comma') {
+                c.next();
+                items.push(parseExpr(c));
+            }
+        }
+        c.expect('rparen');
+        return { kind: 'func', name: negated ? 'NOT IN' : 'IN', args: [left, ...items] };
+    }
+    if (c.isKeyword('LIKE')) {
+        c.next();
+        return { kind: 'binary', op: negated ? 'NOT LIKE' : 'LIKE', left, right: parseAdditive(c) };
+    }
+    // BETWEEN 分支须在 negated 抛错之前，否则 NOT BETWEEN 永不生效
+    if (c.isKeyword('BETWEEN')) {
+        c.next();
+        const low = parseAdditive(c);
+        c.expectKeyword('AND');
+        const high = parseAdditive(c);
+        return { kind: 'func', name: negated ? 'NOT BETWEEN' : 'BETWEEN', args: [left, low, high] };
+    }
+    if (negated) {
+        throw new Error('[json-storage] SQL 解析失败：NOT 后仅支持 IN/LIKE/BETWEEN/IS NULL');
+    }
+    const t = c.peek();
+    if (t.type === 'op' && CMP_OPS.includes(t.value)) {
+        c.next();
+        const right = parseAdditive(c);
+        return { kind: 'binary', op: t.value === '<>' ? '!=' : t.value, left, right };
+    }
+    return left;
+}
+const INTERVAL_UNITS = new Set(['SECOND', 'MINUTE', 'HOUR', 'DAY', 'WEEK', 'MONTH', 'QUARTER', 'YEAR']);
+function parseAdditive(c) {
+    let left = parseMultiplicative(c);
+    while (c.peek().type === 'op' && (c.peek().value === '+' || c.peek().value === '-')) {
+        const op = c.next().value;
+        if (c.isKeyword('INTERVAL')) {
+            c.next();
+            const value = parseUnary(c);
+            const unitTok = c.peek();
+            if (unitTok.type !== 'ident' || !INTERVAL_UNITS.has(unitTok.value.toUpperCase())) {
+                throw new Error(`[json-storage] 不支持的 INTERVAL 单位：${unitTok.value}`);
+            }
+            c.next();
+            left = { kind: 'binary', op, left, right: { kind: 'interval', value, unit: unitTok.value.toUpperCase() } };
+            continue;
+        }
+        left = { kind: 'binary', op, left, right: parseMultiplicative(c) };
+    }
+    return left;
+}
+function parseMultiplicative(c) {
+    let left = parseUnary(c);
+    while (c.peek().type === 'op' && ['*', '/', '%'].includes(c.peek().value)) {
+        const op = c.next().value;
+        left = { kind: 'binary', op, left, right: parseUnary(c) };
+    }
+    return left;
+}
+function parseUnary(c) {
+    const t = c.peek();
+    if (t.type === 'op' && t.value === '-') {
+        c.next();
+        return { kind: 'unary', op: '-', operand: parseUnary(c) };
+    }
+    if (t.type === 'op' && t.value === '+') {
+        c.next();
+        return parseUnary(c);
+    }
+    return parsePostfix(c);
+}
+function parsePostfix(c) {
+    let expr = parsePrimaryExpr(c);
+    while (c.peek().type === 'op' && (c.peek().value === '->' || c.peek().value === '->>')) {
+        const op = c.next().value;
+        const path = c.expect('string');
+        expr = { kind: 'jsonPath', source: expr, path: path.value, unquote: op === '->>' };
+    }
+    return expr;
+}
+function parsePrimaryExpr(c) {
+    const t = c.peek();
+    if (t.type === 'number') {
+        c.next();
+        return { kind: 'literal', value: Number(t.value) };
+    }
+    if (t.type === 'string') {
+        c.next();
+        return { kind: 'literal', value: t.value };
+    }
+    if (t.type === 'param') {
+        c.next();
+        return { kind: 'param', name: t.value };
+    }
+    if (t.type === 'qmark') {
+        c.next();
+        return { kind: 'param', name: '?' };
+    }
+    if (t.type === 'op' && t.value === '*') {
+        c.next();
+        return { kind: 'star' };
+    }
+    if (t.type === 'lparen') {
+        c.next();
+        const inner = parseExpr(c);
+        c.expect('rparen');
+        return inner;
+    }
+    if (t.type === 'ident') {
+        const upper = t.value.toUpperCase();
+        if (upper === 'NULL') {
+            c.next();
+            return { kind: 'literal', value: null };
+        }
+        if (upper === 'TRUE' || upper === 'FALSE') {
+            c.next();
+            return { kind: 'literal', value: upper === 'TRUE' };
+        }
+        if (upper === 'CASE') {
+            return parseCase(c);
+        }
+        if (upper === 'CAST') {
+            return parseCast(c);
+        }
+        c.next();
+        if (c.peek().type === 'lparen') {
+            c.next();
+            const name = upper;
+            if (name === 'VALUES') {
+                const col = c.expect('ident');
+                c.expect('rparen');
+                return { kind: 'valuesCol', column: col.value };
+            }
+            let distinct = false;
+            let star = false;
+            const args = [];
+            if (c.peek().type === 'op' && c.peek().value === '*') {
+                c.next();
+                star = true;
+            }
+            else if (c.peek().type !== 'rparen') {
+                if (c.isKeyword('DISTINCT')) {
+                    c.next();
+                    distinct = true;
+                }
+                args.push(parseExpr(c));
+                while (c.peek().type === 'comma') {
+                    c.next();
+                    args.push(parseExpr(c));
+                }
+            }
+            c.expect('rparen');
+            return { kind: 'func', name, args, distinct, star };
+        }
+        if (c.peek().type === 'dot') {
+            c.next();
+            if (c.peek().type === 'op' && c.peek().value === '*') {
+                c.next();
+                return { kind: 'star', alias: t.value };
+            }
+            const col = c.expect('ident');
+            return { kind: 'column', alias: t.value, name: col.value };
+        }
+        return { kind: 'column', name: t.value };
+    }
+    throw new Error(`[json-storage] SQL 表达式解析失败：不支持的 token（${t.type} "${t.value}"）`);
+}
+function parseCase(c) {
+    c.expectKeyword('CASE');
+    let operand;
+    if (!c.isKeyword('WHEN')) {
+        operand = parseExpr(c);
+    }
+    const whens = [];
+    while (c.isKeyword('WHEN')) {
+        c.next();
+        const when = parseExpr(c);
+        c.expectKeyword('THEN');
+        const then = parseExpr(c);
+        whens.push({ when, then });
+    }
+    if (whens.length === 0) {
+        throw new Error('[json-storage] CASE 表达式缺少 WHEN 分支');
+    }
+    let elseExpr;
+    if (c.isKeyword('ELSE')) {
+        c.next();
+        elseExpr = parseExpr(c);
+    }
+    c.expectKeyword('END');
+    return { kind: 'case', operand, whens, else: elseExpr };
+}
+function parseCast(c) {
+    c.expectKeyword('CAST');
+    c.expect('lparen');
+    const operand = parseExpr(c);
+    c.expectKeyword('AS');
+    const typeTok = c.expect('ident');
+    let type = typeTok.value.toUpperCase();
+    if (c.peek().type === 'lparen') {
+        c.next();
+        while (c.peek().type !== 'rparen')
+            c.next();
+        c.expect('rparen');
+        type = `${type}(...)`;
+    }
+    c.expect('rparen');
+    return { kind: 'cast', operand, type };
+}
+// ---------------- 求值 ----------------
+function truthy(v) {
+    if (v === null || v === undefined)
+        return false;
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return v !== 0;
+    if (typeof v === 'string') {
+        const n = Number(v);
+        return !Number.isNaN(n) && n !== 0;
+    }
+    return true;
+}
+function resolveColumnValue(name, alias, ctx) {
+    if (!alias && ctx.outer && name in ctx.outer)
+        return ctx.outer[name];
+    const candidates = alias ? ctx.aliases.filter(a => a.alias === alias) : ctx.aliases;
+    for (const a of candidates) {
+        const row = ctx.row[a.alias];
+        if (!row)
+            continue;
+        const prop = a.meta?.columnByDbName.get(name) ?? name;
+        if (prop in row)
+            return row[prop];
+        if (name in row)
+            return row[name];
+    }
+    return undefined;
+}
+function evalParam(name, ctx) {
+    if (name === '?') {
+        const v = ctx.positional[ctx.pos.i];
+        ctx.pos.i += 1;
+        return v;
+    }
+    const key = name.replace(/^\.\.\./, '');
+    if (!(key in ctx.named)) {
+        throw new Error(`[json-storage] 缺少 SQL 参数 :${key}`);
+    }
+    return ctx.named[key];
+}
+function evalExpr(e, ctx) {
+    switch (e.kind) {
+        case 'literal':
+            return e.value;
+        case 'param':
+            return evalParam(e.name, ctx);
+        case 'column':
+            return resolveColumnValue(e.name, e.alias, ctx);
+        case 'star':
+            throw new Error('[json-storage] `*` 仅支持出现在 SELECT 投影或 COUNT(*) 中');
+        case 'valuesCol': {
+            if (!ctx.valuesRow) {
+                throw new Error(`[json-storage] VALUES(${e.column}) 仅支持在 ON DUPLICATE KEY UPDATE 中使用`);
+            }
+            return ctx.valuesRow[e.column];
+        }
+        case 'unary': {
+            if (e.op === 'IS NULL' || e.op === 'IS NOT NULL') {
+                const v = evalExpr(e.operand, ctx);
+                const isNull = v === null || v === undefined;
+                return e.op === 'IS NULL' ? isNull : !isNull;
+            }
+            if (e.op === 'NOT')
+                return !truthy(evalExpr(e.operand, ctx));
+            if (e.op === '-') {
+                const v = evalExpr(e.operand, ctx);
+                return v === null || v === undefined ? null : -Number(v);
+            }
+            throw new Error(`[json-storage] 不支持的一元运算符 ${e.op}`);
+        }
+        case 'binary':
+            return evalBinary(e.op, e.left, e.right, ctx);
+        case 'func':
+            return evalFunc(e, ctx);
+        case 'case': {
+            if (e.operand !== undefined) {
+                const base = evalExpr(e.operand, ctx);
+                for (const w of e.whens) {
+                    if ((0, json_where_ts_1.looseEqual)(base, evalExpr(w.when, ctx)))
+                        return evalExpr(w.then, ctx);
+                }
+            }
+            else {
+                for (const w of e.whens) {
+                    if (truthy(evalExpr(w.when, ctx)))
+                        return evalExpr(w.then, ctx);
+                }
+            }
+            return e.else ? evalExpr(e.else, ctx) : null;
+        }
+        case 'cast':
+            return castValue(evalExpr(e.operand, ctx), e.type);
+        case 'jsonPath': {
+            const v = evalExpr(e.source, ctx);
+            const extracted = jsonPathGet(v, e.path);
+            return e.unquote ? jsonUnquote(extracted) : extracted;
+        }
+        case 'interval':
+            throw new Error('[json-storage] INTERVAL 仅支持出现在 +/- 运算中');
+        default:
+            throw new Error(`[json-storage] 未知表达式节点 ${e.kind}`);
+    }
+}
+function evalBinary(op, leftE, rightE, ctx) {
+    if (op === 'AND') {
+        return truthy(evalExpr(leftE, ctx)) && truthy(evalExpr(rightE, ctx));
+    }
+    if (op === 'OR') {
+        return truthy(evalExpr(leftE, ctx)) || truthy(evalExpr(rightE, ctx));
+    }
+    if (op === 'LIKE' || op === 'NOT LIKE') {
+        const l = evalExpr(leftE, ctx);
+        const r = evalExpr(rightE, ctx);
+        const ok = (0, json_where_ts_1.likeMatch)(String(l ?? ''), String(r ?? ''));
+        return op === 'LIKE' ? ok : !ok;
+    }
+    if (['+', '-', '*', '/', '%'].includes(op)) {
+        // INTERVAL 只能作 +/- 右操作数：先判型再求值（interval 节点单独 eval 会抛错）
+        if ((op === '+' || op === '-') && rightE.kind === 'interval') {
+            const date = toDate(evalExpr(leftE, ctx));
+            if (date)
+                return dateAdd(date, op === '-' ? -1 : 1, evalExpr(rightE.value, ctx), rightE.unit);
+        }
+        const l = evalExpr(leftE, ctx);
+        const r = evalExpr(rightE, ctx);
+        if (l === null || l === undefined || r === null || r === undefined)
+            return null;
+        const ln = Number(l);
+        const rn = Number(r);
+        switch (op) {
+            case '+':
+                return ln + rn;
+            case '-':
+                return ln - rn;
+            case '*':
+                return ln * rn;
+            case '/':
+                return rn === 0 ? null : ln / rn;
+            case '%':
+                return rn === 0 ? null : ln % rn;
+            default:
+                throw new Error(`[json-storage] 不支持的运算符 ${op}`);
+        }
+    }
+    if (CMP_OPS.includes(op)) {
+        const l = evalExpr(leftE, ctx);
+        const r = evalExpr(rightE, ctx);
+        if (l === null || l === undefined || r === null || r === undefined)
+            return false;
+        const cmp = (0, json_where_ts_1.compareValues)(l, r);
+        switch (op) {
+            case '=':
+                return cmp === 0;
+            case '!=':
+                return cmp !== 0;
+            case '<':
+                return cmp < 0;
+            case '>':
+                return cmp > 0;
+            case '<=':
+                return cmp <= 0;
+            case '>=':
+                return cmp >= 0;
+            default:
+                throw new Error(`[json-storage] 不支持的比较运算符 ${op}`);
+        }
+    }
+    throw new Error(`[json-storage] 不支持的二元运算符 ${op}`);
+}
+function evalFunc(e, ctx) {
+    const name = e.name;
+    if (exports.AGG_FUNCS.has(name)) {
+        if (!ctx.groupRows) {
+            throw new Error(`[json-storage] 聚合函数 ${name}() 仅支持出现在 SELECT/HAVING/ORDER BY 中`);
+        }
+        const members = ctx.groupRows;
+        if (name === 'COUNT') {
+            if (e.star)
+                return members.length;
+            return aggArgValues(e, ctx).filter(v => v !== null && v !== undefined).length;
+        }
+        const raw = aggArgValues(e, ctx).filter(v => v !== null && v !== undefined);
+        if (name === 'SUM' || name === 'AVG') {
+            // 数值聚合：非数值字符串按 0 计（MySQL 隐式转换语义）。
+            // Number('abc') 为 NaN，须显式归一，否则单个脏值让整个聚合变 NaN
+            const vals = raw.map(v => {
+                const n = Number(v);
+                return Number.isNaN(n) ? 0 : n;
+            });
+            if (vals.length === 0)
+                return null;
+            const sum = vals.reduce((s, n) => s + n, 0);
+            return name === 'SUM' ? sum : sum / vals.length;
+        }
+        // MIN/MAX 保留原值比较：字符串按字典序、日期按时间序（与 MySQL 一致），
+        // 不做 Number() 强转以免非数值字符串（如标题）被折算成 NaN
+        if (name === 'MIN')
+            return raw.length === 0 ? null : raw.reduce((m, v) => ((0, json_where_ts_1.compareValues)(v, m) < 0 ? v : m));
+        return raw.length === 0 ? null : raw.reduce((m, v) => ((0, json_where_ts_1.compareValues)(v, m) > 0 ? v : m));
+    }
+    if (name === 'IN' || name === 'NOT IN') {
+        const l = evalExpr(e.args[0], ctx);
+        let values = [];
+        for (let i = 1; i < e.args.length; i += 1) {
+            const a = e.args[i];
+            const v = evalExpr(a, ctx);
+            if (a.kind === 'param' && a.name.startsWith('...')) {
+                values = values.concat(Array.isArray(v) ? v : [v]);
+            }
+            else {
+                values.push(v);
+            }
+        }
+        const ok = values.some(v => (0, json_where_ts_1.looseEqual)(l, v));
+        return name === 'IN' ? ok : !ok;
+    }
+    if (name === 'BETWEEN' || name === 'NOT BETWEEN') {
+        const v = evalExpr(e.args[0], ctx);
+        if (v === null || v === undefined)
+            return false;
+        const low = evalExpr(e.args[1], ctx);
+        const high = evalExpr(e.args[2], ctx);
+        const inRange = (0, json_where_ts_1.compareValues)(v, low) >= 0 && (0, json_where_ts_1.compareValues)(v, high) <= 0;
+        return name === 'BETWEEN' ? inRange : !inRange;
+    }
+    const args = e.args.map(a => evalExpr(a, ctx));
+    switch (name) {
+        case 'COALESCE': {
+            for (const v of args) {
+                if (v !== null && v !== undefined)
+                    return v;
+            }
+            return null;
+        }
+        case 'NULLIF':
+            return (0, json_where_ts_1.looseEqual)(args[0], args[1]) ? null : args[0];
+        case 'IF':
+            return truthy(args[0]) ? args[1] : args[2];
+        case 'IFNULL':
+            return args[0] === null || args[0] === undefined ? args[1] : args[0];
+        case 'JSON_EXTRACT': {
+            if (e.args.length !== 2)
+                throw new Error('[json-storage] JSON_EXTRACT 需要 2 个参数');
+            // 用已求值的 args[1]：不得二次求值（会多消费一个位置参数，使后续 ? 全部左移）
+            return jsonPathGet(args[0], String(args[1]));
+        }
+        case 'JSON_UNQUOTE':
+            return jsonUnquote(args[0]);
+        case 'NOW':
+        case 'CURRENT_TIMESTAMP':
+        case 'LOCALTIME':
+        case 'LOCALTIMESTAMP':
+            return new Date();
+        case 'UNIX_TIMESTAMP':
+            return args.length === 0 ? Math.floor(Date.now() / 1000) : Math.floor(toTs(args[0]) / 1000);
+        case 'FROM_UNIXTIME':
+            return new Date(Number(args[0]) * 1000);
+        // 已知语义（见设计 Risks）：DATE_FORMAT/FROM_UNIXTIME 输出按「进程本地时区」格式化，
+        // 而落盘用 UTC ISO；仅当服务 TZ 与 MySQL 会话 TZ 一致时与真实库等价，跨 TZ 导入会偏移。
+        case 'DATE_FORMAT':
+            return dateFormat(toDate(args[0]), String(args[1]));
+        case 'TIMESTAMPDIFF': {
+            const unitTok = e.args[0];
+            const unit = unitTok.kind === 'column' ? unitTok.name.toUpperCase() : String(args[0]).toUpperCase();
+            const diffMs = toTs(args[2]) - toTs(args[1]);
+            switch (unit) {
+                case 'SECOND':
+                    return Math.floor(diffMs / 1000);
+                case 'MINUTE':
+                    return Math.floor(diffMs / 60000);
+                case 'HOUR':
+                    return Math.floor(diffMs / 3600000);
+                case 'DAY':
+                    return Math.floor(diffMs / 86400000);
+                case 'WEEK':
+                    return Math.floor(diffMs / 604800000);
+                default:
+                    throw new Error(`[json-storage] 不支持的 TIMESTAMPDIFF 单位：${unit}`);
+            }
+        }
+        case 'DATEDIFF': {
+            const a = toDate(args[0]);
+            const b = toDate(args[1]);
+            if (!a || !b)
+                return null;
+            // MySQL DATEDIFF(expr1, expr2) = expr1 - expr2
+            return Math.floor((startOfDay(a).getTime() - startOfDay(b).getTime()) / 86400000);
+        }
+        case 'ABS':
+            return args[0] === null || args[0] === undefined ? null : Math.abs(Number(args[0]));
+        case 'ROUND':
+            return args[0] === null || args[0] === undefined
+                ? null
+                : Number(Number(args[0]).toFixed(args.length > 1 ? Number(args[1]) : 0));
+        case 'FLOOR':
+            return args[0] === null || args[0] === undefined ? null : Math.floor(Number(args[0]));
+        case 'CEIL':
+        case 'CEILING':
+            return args[0] === null || args[0] === undefined ? null : Math.ceil(Number(args[0]));
+        case 'CONCAT':
+            return args.map(v => (v === null || v === undefined ? '' : String(v))).join('');
+        case 'CONCAT_WS': {
+            const sep = String(args[0]);
+            return args
+                .slice(1)
+                .filter(v => v !== null && v !== undefined)
+                .map(v => String(v))
+                .join(sep);
+        }
+        case 'LOWER':
+        case 'LCASE':
+            return args[0] === null || args[0] === undefined ? null : String(args[0]).toLowerCase();
+        case 'UPPER':
+        case 'UCASE':
+            return args[0] === null || args[0] === undefined ? null : String(args[0]).toUpperCase();
+        case 'LENGTH':
+        case 'CHAR_LENGTH':
+        case 'CHARACTER_LENGTH':
+            return args[0] === null || args[0] === undefined ? null : String(args[0]).length;
+        case 'SUBSTRING':
+        case 'SUBSTR': {
+            const s = String(args[0] ?? '');
+            const from = Number(args[1]) || 1;
+            const startIdx = from > 0 ? from - 1 : Math.max(0, s.length + from);
+            if (e.args.length > 2)
+                return s.substr(startIdx, Number(args[2]));
+            return s.slice(startIdx);
+        }
+        case 'TRIM':
+            return args[0] === null || args[0] === undefined ? null : String(args[0]).trim();
+        case 'DATABASE':
+            return 'json';
+        default:
+            throw new Error(`[json-storage] 不支持的 SQL 函数：${name}()`);
+    }
+}
+function aggArgValues(e, ctx) {
+    const arg = e.args[0];
+    const vals = ctx.groupRows.map(member => 
+    // 逐成员新建 pos：与行级 evalCtxFor 一致，使占位符对组内所有成员绑定同一值
+    // （浅拷贝会共享游标，导致首成员消费参数、后续成员读到 undefined 而结果偏小）
+    evalExpr(arg, { ...ctx, pos: { i: 0 }, row: member, groupRows: undefined, outer: undefined }));
+    if (!e.distinct)
+        return vals;
+    const seen = new Set();
+    const out = [];
+    for (const v of vals) {
+        const key = v instanceof Date ? v.toISOString() : JSON.stringify(v === undefined ? null : v);
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(v);
+        }
+    }
+    return out;
+}
+// ---------------- 值工具 ----------------
+function toDate(v) {
+    if (v instanceof Date)
+        return Number.isNaN(v.getTime()) ? null : v;
+    if (typeof v === 'number')
+        return new Date(v);
+    if (typeof v === 'string' && v.trim() !== '') {
+        const d = new Date(v.replace(' ', 'T'));
+        return Number.isNaN(d.getTime()) ? null : d;
+    }
+    return null;
+}
+function toTs(v) {
+    const d = toDate(v);
+    return d ? d.getTime() : 0;
+}
+function startOfDay(d) {
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
+}
+function dateAdd(date, sign, value, unit) {
+    const n = Number(value) * sign;
+    const d = new Date(date.getTime());
+    switch (unit) {
+        case 'SECOND':
+            d.setSeconds(d.getSeconds() + n);
+            return d;
+        case 'MINUTE':
+            d.setMinutes(d.getMinutes() + n);
+            return d;
+        case 'HOUR':
+            d.setHours(d.getHours() + n);
+            return d;
+        case 'DAY':
+        case 'WEEK':
+            d.setDate(d.getDate() + n * (unit === 'WEEK' ? 7 : 1));
+            return d;
+        case 'MONTH':
+        case 'QUARTER':
+            d.setMonth(d.getMonth() + n * (unit === 'QUARTER' ? 3 : 1));
+            return d;
+        case 'YEAR':
+            d.setFullYear(d.getFullYear() + n);
+            return d;
+        default:
+            throw new Error(`[json-storage] 不支持的 INTERVAL 单位：${unit}`);
+    }
+}
+function castValue(v, type) {
+    if (v === null || v === undefined)
+        return null;
+    if (type.startsWith('UNSIGNED') || type.startsWith('SIGNED') || type.startsWith('DECIMAL') || type.startsWith('INT')) {
+        const n = Number(v);
+        return Number.isNaN(n) ? 0 : n;
+    }
+    if (type.startsWith('CHAR') || type.startsWith('VARCHAR') || type.startsWith('TEXT')) {
+        return v instanceof Date ? mysqlDatetime(v) : String(v);
+    }
+    if (type.startsWith('DATETIME') || type.startsWith('TIMESTAMP')) {
+        return toDate(v);
+    }
+    if (type.startsWith('DATE')) {
+        const d = toDate(v);
+        return d ? startOfDay(d) : null;
+    }
+    if (type.startsWith('JSON')) {
+        if (typeof v === 'string') {
+            try {
+                return JSON.parse(v);
+            }
+            catch {
+                return v;
+            }
+        }
+        return v;
+    }
+    throw new Error(`[json-storage] 不支持的 CAST 类型：${type}`);
+}
+/**
+ * MySQL datetime 文本（本地时区格式化）。
+ * 已知语义：落盘存储为 UTC ISO，此函数按进程本地时区格式化；仅当服务 TZ 与 MySQL 会话 TZ 一致时等价。
+ */
+function mysqlDatetime(d) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+/** JSON 路径取值：`$.a.b[0].c`；`[*]` 通配符收集为数组（MySQL JSON_EXTRACT 语义）；缺失返回 null（SQL NULL） */
+function jsonPathGet(value, path) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string' && value.trim() !== '') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return walkJsonPath(value, parseJsonPathSegments(path));
+}
+function parseJsonPathSegments(path) {
+    return path
+        .replace(/^\$/, '')
+        .split('.')
+        .filter(s => s !== '')
+        .map(seg => {
+        const m = seg.match(/^([^[]*)((?:\[\d+\]|\[\*\])*)$/);
+        const key = m ? m[1] : seg;
+        const indices = [];
+        const idxPart = m ? m[2] : '';
+        for (const idx of idxPart.match(/\[(\d+|\*)\]/g) ?? []) {
+            const inner = idx.slice(1, -1);
+            indices.push(inner === '*' ? '*' : Number(inner));
+        }
+        return { key, indices };
+    });
+}
+function walkJsonPath(cur, segs) {
+    if (segs.length === 0)
+        return cur === undefined ? null : cur;
+    if (cur === null || cur === undefined)
+        return null;
+    const [seg, ...rest] = segs;
+    let next = cur;
+    if (seg.key) {
+        next = cur[seg.key];
+        if (next === undefined)
+            return null;
+    }
+    for (const idx of seg.indices) {
+        if (next === null || next === undefined)
+            return null;
+        if (idx === '*') {
+            if (!Array.isArray(next))
+                return null;
+            // 通配符：对每个元素继续走剩余路径，收集非 null 结果为数组
+            return next
+                .map(el => walkJsonPath(el, rest))
+                .filter(v => v !== null && v !== undefined);
+        }
+        next = next[idx];
+        if (next === undefined)
+            return null;
+    }
+    return walkJsonPath(next, rest);
+}
+function jsonUnquote(v) {
+    if (typeof v !== 'string')
+        return v;
+    return v.length >= 2 && v.startsWith('"') && v.endsWith('"') ? v.slice(1, -1) : v;
+}
+/** MySQL DATE_FORMAT 常用模式 */
+function dateFormat(d, fmt) {
+    if (!d)
+        return null;
+    const p = (n) => String(n).padStart(2, '0');
+    return fmt.replace(/%[YymdHkhisfMp]/g, m => {
+        switch (m) {
+            case '%Y':
+                return String(d.getFullYear());
+            case '%y':
+                return String(d.getFullYear()).slice(-2);
+            case '%m':
+                return p(d.getMonth() + 1);
+            case '%c':
+                return String(d.getMonth() + 1);
+            case '%d':
+                return p(d.getDate());
+            case '%e':
+                return String(d.getDate());
+            case '%H':
+                return p(d.getHours());
+            case '%k':
+                return String(d.getHours());
+            case '%h':
+                return p(d.getHours() % 12 || 12);
+            case '%i':
+                return p(d.getMinutes());
+            case '%s':
+            case '%S':
+                return p(d.getSeconds());
+            case '%f':
+                return String(d.getMilliseconds() * 1000);
+            case '%M':
+                return ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][d.getMonth()];
+            case '%p':
+                return d.getHours() < 12 ? 'AM' : 'PM';
+            default:
+                return m;
+        }
+    });
+}
+//# sourceMappingURL=json-sql-expr.js.map