jsql-neo 6.1.0 → 6.3.0

package/README.md

@@ -835,7 +835,7 @@ CREATE TABLE IF NOT EXISTS orders (
 
 **SELECT grammar**
 
-```sql
+```text
 WITH [RECURSIVE] cte_name [(col, ...)] AS (SELECT ...)[, ...]   -- CTE，见下节
 SELECT [DISTINCT] select_list
 FROM table_reference
@@ -1056,10 +1056,15 @@ Coercion rules: numeric strings compare as numbers (`'5' = 5`), `NULL = NULL`
 `DAYOFWEEK`, `DAYNAME`, `MONTHNAME`, `UNIX_TIMESTAMP`, `FROM_UNIXTIME`.
 
 ```sql
-SELECT DATE_ADD('2026-08-12', INTERVAL 1 DAY);      -- '2026-08-13 00:00:00'
+SELECT DATE_ADD('2026-08-12', INTERVAL 1 DAY);         -- '2026-08-13'（纯日期进 → 纯日期出）
+SELECT DATE_ADD('2026-08-12 10:00:00', INTERVAL 1 DAY); -- '2026-08-13 10:00:00'
 SELECT DATE_FORMAT(NOW(), '%Y-%m-%d %H:%i');        -- '2026-08-12 10:30'
 SELECT EXTRACT(YEAR FROM '2026-08-12');             -- 2026
 SELECT AGE('2026-08-12', '2020-01-01');             -- '6 years 7 mons 11 days'
+SELECT DATEDIFF('2026-08-12', '2026-08-01');        -- 11
+SELECT TIMESTAMPDIFF(MONTH, '2026-01-01', '2026-08-01'); -- 7（end - start）
+SELECT TO_DATE('2026-08-12', 'YYYY-MM-DD');         -- '2026-08-12'（PG 格式串）
+SELECT DATE_TRUNC('month', '2026-08-12 10:30:00');  -- '2026-08-01 00:00:00'
 ```
 
 **Conditional / null** — `IF(cond, a, b)`, `IIF`, `IFNULL(a, b)`, `COALESCE(...)`, `NULLIF`,
@@ -1102,14 +1107,14 @@ ORDER BY avg_sal DESC;
 
 **Bitwise** — `& | ^ ~ << >>`（`^` 是按位异或，`~` 是按位取反）。
 
-> **运算符方言说明。** `^` 与 `~` 在 MySQL（位运算）和 PostgreSQL（`^` 为幂、
-> `~` 为正则匹配）中含义冲突，本实现统一采用 **MySQL 语义**：`^` = 按位异或、
-> `~` = 按位取反。需要幂运算请用 `POWER(x, n)`，需要正则请用 `REGEXP`。
-> 因此 PG 风格的 `^`（幂）与 `~ ~* !~ !~*`（正则）**暂不支持**。
+> **运算符方言说明。** `^` 与 `~` 在 MySQL 与 PostgreSQL 中含义冲突，本实现按上下文区分：
+> - `^` 统一为**按位异或**（MySQL 语义）；幂运算请用 `POWER(x, n)`。
+> - `~` 在**单目**位置是按位取反（MySQL），在**双目**位置是正则匹配（PG），
+>   另有 `~*`（不敏感）、`!~`、`!~*`。
+> - 需要正则时也可用 `REGEXP` / `RLIKE`；PG 的 `^`（幂）**暂不支持**。
 
-**JSON (PG style)** — `->`（返回 JSON）、`->>`（返回文本），可链式
-（`meta->'addr'->>'city'`）。`#>` `#>>`（路径）、`@>` `<@`（包含）、
-`?` `?|` `?&`（键存在）**暂不支持**。
+**JSON (PG style)** — `->` / `->>`（取字段）、`#>` / `#>>`（路径取值）、`@>` / `<@`（包含）、
+`?` / `?|` / `?&`（键存在），可链式（`meta->'addr'->>'city'`）。
 
 ### LIKE / ILIKE / regex
 
@@ -1162,7 +1167,7 @@ INSERT INTO users (id, meta) VALUES
   (1, '{"name":"Alice","tags":["admin","ops"],"addr":{"city":"SH"}}');
 
 SELECT meta->>'name' AS name, meta->'addr'->>'city' AS city
-FROM users;
+FROM users WHERE meta @> '{"tags":["admin"]}';
 ```
 
 JSON columns are fully interoperable with Mongo document views.
@@ -3138,7 +3143,7 @@ DELETE FROM orders WHERE status = 'cancelled' LIMIT 100;
 
 #### 查询语法 SELECT
 
-```sql
+```text
 SELECT [DISTINCT] select_list
 FROM table_reference
 [JOIN table_reference ON condition]
@@ -3445,11 +3450,16 @@ INTERVAL 单位：`DAY` `HOUR` `MINUTE` `SECOND` `WEEK` `MONTH` `YEAR` 及其组
 |---|---|---|
 | `->` | 取 JSON 字段（返回 JSON） | `meta->'name'` |
 | `->>` | 取 JSON 字段（返回文本） | `meta->>'name'` |
+| `#>` | 路径取值（返回 JSON） | `meta#>'{addr,city}'` |
+| `#>>` | 路径取值（返回文本） | `meta#>>'{addr,city}'` |
+| `@>` | 包含 | `meta @> '{"plan":"pro"}'` |
+| `<@` | 被包含 | `'{"a":1}' <@ meta` |
+| `?` | 含指定键 | `meta ? 'plan'` |
+| `?\|` | 含任一键 | `meta ?\| '{a,b}'` |
+| `?&` | 含全部键 | `meta ?& '{a,b}'` |
 
 可链式取值：`meta->'addr'->>'city'`。
 
-> `#>` `#>>`（路径访问）、`@>` `<@`（包含）、`?` `?|` `?&`（键存在）**暂不支持** —— 使用时会抛出明确错误，不会静默退化成别的运算。
-
 ### LIKE / ILIKE / 正则
 
 **LIKE 通配符**
@@ -3466,8 +3476,8 @@ INTERVAL 单位：`DAY` `HOUR` `MINUTE` `SECOND` `WEEK` `MONTH` `YEAR` 及其组
 
 - 基于 JS RegExp 引擎
 - 支持 flags：`i`（忽略大小写）、`m`（多行）、`s`（点匹配换行）
-- PG 风格的 `~` / `~*` / `!~` / `!~*` 运算符**暂不支持**（`~` 已被用作按位取反）。
-  正则匹配请用 `REGEXP` / `RLIKE`。
+- PG 风格的 `~`（大小写敏感）/ `~*`（不敏感）/ `!~` / `!~*` 双目运算符也支持；
+  单目位置的 `~` 仍是按位取反。
 
 ```sql
 SELECT * FROM users
@@ -3570,7 +3580,7 @@ INSERT INTO users (id, meta) VALUES
 -- 查询路径
 SELECT meta->>'name' AS name,
        meta->'addr'->>'city' AS city
-FROM users;
+FROM users WHERE meta @> '{"tags":["admin"]}';
 ```
 
 JSON 函数见 [系统与杂项函数](#系统与杂项函数)。Mongo 客户端视角下，JSON 列与 BSON 文档完全互通。
@@ -5798,6 +5808,8 @@ expr := literal
       | expr [NOT] LIKE pattern [ESCAPE char]
       | expr [NOT] ILIKE pattern
       | expr [NOT] RLIKE pattern | expr [NOT] REGEXP pattern
+      | expr ~ pattern | expr ~* pattern | expr !~ pattern | expr !~* pattern
+      | expr ? key | expr ?| keys | expr ?& keys
       | expr IS [NOT] NULL | expr IS [NOT] TRUE | expr IS [NOT] FALSE
       | expr [NOT] IN ( ... )
       | expr [NOT] ANY '(' select_statement ')'
@@ -5843,12 +5855,12 @@ function_call := func_name '(' [DISTINCT] args ')'      -- 普通/聚合
 ### 运算符优先级（从高到低）
 
 ```
-1.  ()  .  []  ->  ->>  ::
+1.  ()  .  []  ->  ->>  #>  #>>  ::
 2.  CAST 一元 + - ~
 3.  ^  *  /  %  DIV  MOD
 4.  +  -
 5.  <<  >>  &  |  ^（位）
-6.  =  <>  !=  <  <=  >  >=  <=>  BETWEEN  IN  LIKE  ILIKE  RLIKE  REGEXP
+6.  =  <>  !=  <  <=  >  >=  <=>  @>  <@  ?  ?|  ?&  BETWEEN  IN  LIKE  ILIKE  RLIKE  REGEXP  ~  ~*  !~  !~*
 7.  NOT
 8.  AND  &&
 9.  XOR
@@ -7445,12 +7457,12 @@ jsql import ./data app.sql
 | 冲突处理 | `ON DUPLICATE KEY UPDATE` | `ON CONFLICT ... DO ...` | 两者都支持 |
 | 占位符 | `?` | `$1, $2` | 两者（分协议） |
 | 模糊匹配 | `LIKE`（大小写敏感） | `LIKE` + `ILIKE` | 两者 |
-| 正则 | `REGEXP` | `REGEXP` | 两者 + `RLIKE` |
+| 正则 | `REGEXP` | `~` `~*` | 两者 + `RLIKE` |
 | 标识符引用 | 反引号 `` ` `` | 双引号 `"` | 两者 |
 | 字符串字面量 | 单引号 | 单引号 | 单引号（双引号按标识符，PG 语义） |
 | 布尔 | `TRUE/FALSE`（1/0） | `t/f`（三值逻辑） | 兼容两者 |
 | 分页 | `LIMIT off, n` | `LIMIT n OFFSET off` | 两者 |
-| JSON 访问 | `JSON_EXTRACT` | `->` `->>` | 两者 |
+| JSON 访问 | `JSON_EXTRACT` | `->` `->>` `#>>` | 两者 |
 | 类型转换 | `CAST`/`CONVERT` | `::` | 三者 |
 | 条件分支 | `IF()` | `CASE` | `IF` + `CASE` + `IIF` |
 | 空值回退 | `IFNULL()` | `COALESCE` | 两者 |

package/lib/date-types.js

@@ -33,17 +33,37 @@ function validateDateType(value, type, fieldName) {
 // DATE: YYYY-MM-DD
 // ============================================================
 
+function pad2(n) { return String(n).padStart(2, '0'); }
+
+/**
+ * 本地时区的 'YYYY-MM-DD'。
+ * 不能用 toISOString().slice(0,10) —— 那是 UTC：东八区 2023-01-01 00:00 本地
+ * 会是 2022-12-31T16:00Z，切出来整整差一天（2024-02-29 → 2024-02-28）。
+ */
+function toLocalDateString(d) {
+    return d.getFullYear() + '-' + pad2(d.getMonth() + 1) + '-' + pad2(d.getDate());
+}
+
+/** 本地时区的 'YYYY-MM-DD HH:MM:SS'（同理不能用 toISOString） */
+function toLocalDateTimeString(d) {
+    return toLocalDateString(d) + ' ' +
+        pad2(d.getHours()) + ':' + pad2(d.getMinutes()) + ':' + pad2(d.getSeconds());
+}
+
 function validateDate(value, fieldName) {
     if (value instanceof Date) {
-        return value.toISOString().slice(0, 10);
+        return toLocalDateString(value);
     }
     if (typeof value === 'number') {
         // Unix timestamp → date
-        return new Date(value * 1000).toISOString().slice(0, 10);
+        return toLocalDateString(new Date(value * 1000));
     }
     if (typeof value === 'string') {
-        const d = parseDateString(value);
-        if (d) return d.toISOString().slice(0, 10);
+        const s = value.trim();
+        // 已是 YYYY-MM-DD：直接返回，避免本地→UTC 往返导致差一天
+        if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return s;
+        const d = parseDateString(s);
+        if (d) return toLocalDateString(d);
     }
     throw createError('ER_INVALID_DATE', fieldName, String(value));
 }
@@ -79,26 +99,23 @@ function parseDateString(str) {
 
 function validateDateTime(value, fieldName) {
     if (value instanceof Date) {
-        return value.toISOString().replace('T', ' ').slice(0, 19);
+        return toLocalDateTimeString(value);
     }
     if (typeof value === 'number') {
-        return new Date(value * 1000).toISOString().replace('T', ' ').slice(0, 19);
+        return toLocalDateTimeString(new Date(value * 1000));
     }
     if (typeof value === 'string') {
-        // ISO format: 2024-01-15T10:30:00.000Z
+        // ISO format: 2024-01-15T10:30:00.000Z（带时区标记，按字面取日期+时间）
         const isoMatch = value.match(/^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})/);
         if (isoMatch) {
             return isoMatch[1] + ' ' + isoMatch[2];
         }
-        // MySQL format: YYYY-MM-DD HH:MM:SS
+        // MySQL format: YYYY-MM-DD HH:MM:SS —— 已是目标格式，原样返回
         const myMatch = value.match(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})$/);
-        if (myMatch) {
-            const d = new Date(value.replace(' ', 'T') + 'Z');
-            if (!isNaN(d.getTime())) return value;
-        }
+        if (myMatch) return value;
         const d = new Date(value);
         if (!isNaN(d.getTime())) {
-            return d.toISOString().replace('T', ' ').slice(0, 19);
+            return toLocalDateTimeString(d);
         }
     }
     throw createError('ER_INVALID_DATE', fieldName, String(value));

package/lib/migrate.js

@@ -12,6 +12,15 @@ const path = require('path');
 const { splitStatements, executeSQL } = require('./sql');
 const { parseFieldShorthand } = require('./database');
 
+// 体积护栏（CWE-770）：与 lib/sql.js 的 DEFAULT_MAX_SQL_LENGTH 同风格。
+// 可用 opts.maxInputSize / opts.maxRows 覆盖；传 Infinity 关闭；chunkSize 控制每批 insert 行数。
+const DEFAULT_MAX_CSV_LENGTH = 64 * 1024 * 1024;  // 64 MiB
+const DEFAULT_MAX_JSON_LENGTH = 64 * 1024 * 1024;
+const DEFAULT_MAX_SQL_LENGTH = 64 * 1024 * 1024;  // 与 lib/sql.js 保持一致
+const DEFAULT_MAX_ROWS = 2_000_000;             // 200 万行
+const DEFAULT_MAX_STATEMENTS = 200_000;          // dump 文件最多允许 20 万条语句
+const DEFAULT_CHUNK_SIZE = 1000;
+
 function normalizeSchema(schema) {
   const out = {};
   for (const [name, def] of Object.entries(schema || {})) {
@@ -52,10 +61,31 @@ function parseValue(str, type) {
   return str;
 }
 
-function parseCSV(text) {
+function parseCSV(text, opts = {}) {
+  if (typeof text !== 'string') {
+    throw new Error('parseCSV: csv must be a string');
+  }
+  const maxLen = opts.maxInputSize == null ? DEFAULT_MAX_CSV_LENGTH : opts.maxInputSize;
+  if (typeof maxLen === 'number' && Number.isFinite(maxLen) && text.length > maxLen) {
+    throw new Error(
+      `CSV text too large: ${text.length} chars exceeds limit of ${maxLen} ` +
+      `(raise opts.maxInputSize to allow larger input)`
+    );
+  }
+  const maxRows = opts.maxRows == null ? DEFAULT_MAX_ROWS : opts.maxRows;
+  const isFiniteMaxRows = typeof maxRows === 'number' && Number.isFinite(maxRows);
+
   const rows = [];
+  // 把 `field += c` 改为数组收集中间 join —— 与 splitStatements 同修 O(n²)
+  let fieldBuf = [];
+  const flushField = () => { const s = fieldBuf.join(''); fieldBuf.length = 0; return s; };
   let row = [];
-  let field = '';
+  const flushRow = () => {
+    const r = row;
+    row = [];
+    rows.push(r);
+    return r;
+  };
   let inQuotes = false;
   let i = 0;
   const n = text.length;
@@ -63,32 +93,48 @@ function parseCSV(text) {
     const c = text[i];
     if (inQuotes) {
       if (c === '"') {
-        if (text[i + 1] === '"') { field += '"'; i += 2; continue; }
+        if (text[i + 1] === '"') { fieldBuf.push('"'); i += 2; continue; }
         inQuotes = false;
         i++;
         continue;
       }
-      field += c;
+      fieldBuf.push(c);
       i++;
       continue;
     }
-    if (c === '"' && field === '') { inQuotes = true; i++; continue; }
-    if (c === ',') { row.push(field); field = ''; i++; continue; }
+    if (c === '"' && fieldBuf.length === 0) { inQuotes = true; i++; continue; }
+    if (c === ',') { row.push(flushField()); i++; continue; }
     if (c === '\n' || c === '\r') {
       if (c === '\r' && text[i + 1] === '\n') i++;
-      row.push(field);
-      field = '';
-      if (row.length > 1 || row[0] !== '') rows.push(row);
-      row = [];
+      row.push(flushField());
+      if (row.length > 1 || row[0] !== '') {
+        if (isFiniteMaxRows && rows.length + 1 > maxRows) {
+          throw new Error(
+            `CSV too many rows: ${rows.length + 1} exceeds limit of ${maxRows} ` +
+            `(raise opts.maxRows or split the file)`
+          );
+        }
+        flushRow();
+      } else {
+        row = [];
+      }
       i++;
       continue;
     }
-    field += c;
+    fieldBuf.push(c);
     i++;
   }
-  if (field !== '' || row.length > 0) {
-    row.push(field);
-    if (row.length > 1 || row[0] !== '') rows.push(row);
+  if (fieldBuf.length > 0 || row.length > 0) {
+    row.push(flushField());
+    if (row.length > 1 || row[0] !== '') {
+      if (isFiniteMaxRows && rows.length + 1 > maxRows) {
+        throw new Error(
+          `CSV too many rows: ${rows.length + 1} exceeds limit of ${maxRows} ` +
+          `(raise opts.maxRows or split the file)`
+        );
+      }
+      flushRow();
+    }
   }
   return rows;
 }
@@ -123,7 +169,23 @@ async function exportAllToJSON(engine, tables) {
 
 async function importFromJSON(engine, data, opts = {}) {
   const overwrite = !!(opts && opts.overwrite);
-  let tables = typeof data === 'string' ? JSON.parse(data) : data;
+  let tables;
+  if (typeof data === 'string') {
+    // JSON.parse 吞超长输入也会打爆堆 —— 先加体积护栏，错误带位置
+    const maxLen = opts.maxInputSize == null ? DEFAULT_MAX_JSON_LENGTH : opts.maxInputSize;
+    if (typeof maxLen === 'number' && Number.isFinite(maxLen) && data.length > maxLen) {
+      throw new Error(
+        `JSON text too large: ${data.length} chars exceeds limit of ${maxLen} ` +
+        `(raise opts.maxInputSize to allow larger input)`
+      );
+    }
+    try { tables = JSON.parse(data); }
+    catch (e) {
+      throw new Error(`importFromJSON: invalid JSON: ${e.message}`);
+    }
+  } else {
+    tables = data;
+  }
   // 兼容单表形状：exportTableToJSON 返回 { table, schema, rows }
   if (tables && !Array.isArray(tables) && typeof tables === 'object'
       && tables.table && tables.schema && !tables[tables.table]) {
@@ -142,8 +204,13 @@ async function importFromJSON(engine, data, opts = {}) {
     await engine.createTable(name, normalizeSchema(t.schema));
     created.push(name);
     if (Array.isArray(t.rows) && t.rows.length > 0) {
-      const ids = await engine.insert(name, t.rows.map(r => ({ ...r })));
-      inserted += Array.isArray(ids) ? ids.length : t.rows.length;
+      // 分块 insert —— 避免全量 rows.map 先攒再 insert
+      const chunkSize = opts.chunkSize != null ? opts.chunkSize : DEFAULT_CHUNK_SIZE;
+      for (let i = 0; i < t.rows.length; i += chunkSize) {
+        const chunk = t.rows.slice(i, i + chunkSize).map(r => ({ ...r }));
+        const ids = await engine.insert(name, chunk);
+        inserted += Array.isArray(ids) ? ids.length : chunk.length;
+      }
     }
   }
   return { created, inserted };
@@ -161,7 +228,8 @@ async function exportTableToCSV(engine, table) {
 
 async function importFromCSV(engine, table, csv, opts = {}) {
   const schema = opts.schema || await engine.getTableSchema(table);
-  const rows = parseCSV(csv);
+  // parseCSV 内已有体积/行数护栏，这里传 opts.maxInputSize / opts.maxRows
+  const rows = parseCSV(csv, opts);
   if (rows.length === 0) return { inserted: 0 };
   let columns;
   let start = 0;
@@ -179,24 +247,43 @@ async function importFromCSV(engine, table, csv, opts = {}) {
     }
     await engine.createTable(table, normalizeSchema(schema));
   }
-  const dataRows = [];
-  for (let i = start; i < rows.length; i++) {
-    const row = {};
-    for (let j = 0; j < columns.length; j++) {
-      const type = schema && schema[columns[j]] ? schema[columns[j]].type : 'string';
-      row[columns[j]] = parseValue(rows[i][j], type);
-    }
-    if (row.id === null || row.id === undefined || row.id === '') delete row.id;
-    dataRows.push(row);
+  const chunkSize = opts.chunkSize != null ? opts.chunkSize : DEFAULT_CHUNK_SIZE;
+  let inserted = 0;
+  // 不攒 dataRows 全量，边解析边分块写入 —— 避免 2M 行全在内存里
+  for (let i = start; i < rows.length; i += chunkSize) {
+    const chunk = rows.slice(i, i + chunkSize);
+    const dataRows = chunk.map(raw => {
+      const row = {};
+      for (let j = 0; j < columns.length; j++) {
+        const type = schema && schema[columns[j]] ? schema[columns[j]].type : 'string';
+        row[columns[j]] = parseValue(raw[j], type);
+      }
+      if (row.id === null || row.id === undefined || row.id === '') delete row.id;
+      return row;
+    });
+    const ids = await engine.insert(table, dataRows);
+    inserted += Array.isArray(ids) ? ids.length : dataRows.length;
   }
-  const ids = dataRows.length > 0 ? await engine.insert(table, dataRows) : [];
-  return { inserted: dataRows.length, ids };
+  return { inserted };
 }
 
 /* ---------- mysqldump ---------- */
 
 async function importDump(engine, sqlText, opts = {}) {
-  const statements = splitStatements(sqlText);
+  // splitStatements 自身有体积护栏，但这里要让用户能通过 opts.maxInputSize 覆盖，
+  // 还要额外加「语句数量」护栏 —— 64 MiB 里可能塞几百万条小 INSERT，每条都合法但合起来打爆堆。
+  const maxLen = opts.maxInputSize == null ? DEFAULT_MAX_SQL_LENGTH : opts.maxInputSize;
+  const splitOpts = { maxLength: maxLen };
+  const statements = splitStatements(sqlText, splitOpts);
+
+  const maxStmts = opts.maxStatements == null ? DEFAULT_MAX_STATEMENTS : opts.maxStatements;
+  if (typeof maxStmts === 'number' && Number.isFinite(maxStmts) && statements.length > maxStmts) {
+    throw new Error(
+      `SQL dump too many statements: ${statements.length} exceeds limit of ${maxStmts} ` +
+      `(raise opts.maxStatements or split the dump file)`
+    );
+  }
+
   const created = [];
   let inserted = 0;
   const errors = [];
@@ -221,6 +308,15 @@ async function importDump(engine, sqlText, opts = {}) {
 }
 
 async function importDumpFile(engine, filePath, opts = {}) {
+  // 先看文件大小再决定是否读 —— 避免 fs.readFileSync 把超大 dump 一次性吃进堆
+  const maxLen = opts.maxInputSize == null ? DEFAULT_MAX_SQL_LENGTH : opts.maxInputSize;
+  const stat = fs.statSync(filePath);
+  if (typeof maxLen === 'number' && Number.isFinite(maxLen) && stat.size > maxLen) {
+    throw new Error(
+      `Dump file too large: ${stat.size} bytes exceeds limit of ${maxLen} ` +
+      `(raise opts.maxInputSize or split the file)`
+    );
+  }
   const text = fs.readFileSync(filePath, 'utf8');
   return importDump(engine, text, opts);
 }