jsql-neo 5.4.2 → 6.0.0-beta2

package/nativesrc/jsql-neo-core/src/engine/table.rs

@@ -161,6 +161,32 @@ fn millis_to_string(ms: u64) -> String {
     }
 }
 
+/// 行内时间戳格式化缓存：批量写入的行共享同一个毫秒时间戳，
+/// 命中缓存可避免每行都做一次 chrono/JS Date 格式化与字符串分配。
+#[derive(Default)]
+pub struct TimeCache {
+    last_ms: u64,
+    last_str: String,
+    valid: bool,
+}
+
+impl TimeCache {
+    pub fn new() -> Self {
+        Self { last_ms: 0, last_str: String::new(), valid: false }
+    }
+
+    #[inline]
+    fn write(&mut self, out: &mut String, ms: u64) {
+        if !self.valid || self.last_ms != ms {
+            self.last_str.clear();
+            self.last_str.push_str(&millis_to_string(ms));
+            self.last_ms = ms;
+            self.valid = true;
+        }
+        out.push_str(&self.last_str);
+    }
+}
+
 impl Table {
     pub fn new(name: String, schema: &[(String, FieldSchema)]) -> Self {
         let pk_field = schema.iter()
@@ -215,6 +241,29 @@ impl Table {
         }
     }
 
+    /// 运行期加列（供 `db.addColumn` 使用）：扩展 schema / field_order / field_index，
+    /// 并为已有行按「default → 非空类型默认值 → null」的既有语义回填新列的值。
+    /// 返回 true 表示新增成功；false 表示该列已存在（no-op）。
+    pub fn add_column(&mut self, name: &str, fs: &FieldSchema) -> bool {
+        if self.field_index.contains_key(name) {
+            return false;
+        }
+        let fill = match &fs.default {
+            Some(dv) => FieldValue::from_json(dv.clone()),
+            None => if !fs.nullable { default_value(&fs.field_type) } else { FieldValue::Null },
+        };
+        let pos = self.field_order.len();
+        self.schema.insert(name.to_string(), fs.clone());
+        self.field_order.push(name.to_string());
+        self.field_index.insert(name.to_string(), pos);
+        for i in 0..self.rows.len() {
+            let start = self.rows[i].values_start + self.rows[i].num_values;
+            self.values.insert(start, fill.clone());
+            self.rows[i].num_values += 1;
+        }
+        true
+    }
+
     pub fn add_rows(&mut self, fields_batch: Vec<HashMap<String, serde_json::Value>>) -> Vec<u64> {
         let now = now_millis();
         let batch_len = fields_batch.len();
@@ -409,12 +458,32 @@ impl Table {
     }
 
     pub fn row_matches(&self, r: &RowStore, filter: &HashMap<String, serde_json::Value>) -> bool {
-        let vals = self.get_row_values(r);
-        filter.iter().all(|(k, v)| {
-            self.field_index.get(k)
-                .and_then(|&pos| vals.get(pos))
-                .map_or(false, |fv| fv.eq_json(v))
-        })
+        let conds = self.parse_filter(filter);
+        matches_filter(self.get_row_values(r), &conds)
+    }
+
+    /// 预解析过滤条件：字段名 → 行内下标 + 条件，避免逐行重复做 HashMap 查找。
+    /// 支持字段级操作符（$eq/$ne/$gt/$gte/$lt/$lte/$in/$nin/$between/$exists/$like/$regex），
+    /// 一个字段多个操作符（如 {$gte:18,$lte:65}）会展开成多条，需同时满足。
+    pub(crate) fn parse_filter<'a>(&self, filter: &'a HashMap<String, serde_json::Value>)
+        -> Vec<(usize, Cond<'a>)>
+    {
+        let mut out = Vec::with_capacity(filter.len());
+        for (k, v) in filter {
+            // 未知字段用哨兵下标，按「字段不存在」参与匹配（不再静默放行）
+            let pos = self.field_index.get(k).copied().unwrap_or(ABSENT_FIELD);
+            match v {
+                serde_json::Value::Object(map)
+                    if !map.is_empty() && map.keys().all(|kk| kk.starts_with('$')) =>
+                {
+                    for (op, target) in map {
+                        out.push((pos, parse_op(op, target)));
+                    }
+                }
+                other => out.push((pos, Cond::Eq(other))),
+            }
+        }
+        out
     }
 
     pub fn get_row(&self, id: u64) -> Option<Row> {
@@ -429,6 +498,7 @@ impl Table {
 
     pub fn get_rows_json(&self, ids: &[u64]) -> String {
         let mut out = String::with_capacity(ids.len() * 128);
+        let mut tc = TimeCache::new();
         out.push('[');
         let mut first = true;
         for &id in ids {
@@ -436,7 +506,7 @@ impl Table {
                 if let Some(rs) = self.rows.get(idx) {
                     if !first { out.push(','); }
                     first = false;
-                    out.push_str(&self.to_row_json_string(rs));
+                    self.write_row_json_into(rs, &mut out, &mut tc);
                 }
             }
         }
@@ -458,30 +528,42 @@ impl Table {
     }
 
     fn to_row_json_string(&self, rs: &RowStore) -> String {
-        let vals = self.get_row_values(rs);
         let mut out = String::with_capacity(160);
+        let mut tc = TimeCache::new();
+        self.write_row_json_into(rs, &mut out, &mut tc);
+        out
+    }
+
+    /// 直接把一行写成 JSON 追加到 `out`。
+    /// 相比先构造 `Row`（HashMap<String, Value>）再 serde 序列化，
+    /// 省掉了每个字段一次的字符串分配与一次完整的二次序列化。
+    pub fn write_row_json_into(&self, rs: &RowStore, out: &mut String, tc: &mut TimeCache) {
+        let vals = self.get_row_values(rs);
         out.push_str(r#"{"id":"#);
         out.push_str(itoa::Buffer::new().format(rs.id));
         out.push_str(r#","fields":{"#);
         for (i, name) in self.field_order.iter().enumerate() {
             if i > 0 { out.push(','); }
-            write_json_string(&mut out, name);
+            write_json_string(out, name);
             out.push(':');
-            if let Some(v) = vals.get(i) {
-                v.write_json(&mut out);
-            } else {
-                out.push_str("null");
+            match vals.get(i) {
+                Some(v) => v.write_json(out),
+                None => out.push_str("null"),
             }
         }
-        out.push_str(r#"},"created_at":"#);
-        write_json_string(&mut out, &millis_to_string(rs.created_at));
-        out.push_str(r#","updated_at":"#);
-        write_json_string(&mut out, &millis_to_string(rs.updated_at));
-        out.push_str("}");
-        out
+        out.push_str(r#"},"created_at":""#);
+        tc.write(out, rs.created_at);
+        out.push_str(r#"","updated_at":""#);
+        tc.write(out, rs.updated_at);
+        out.push_str(r#""}"#);
     }
 
     pub fn update_row(&mut self, id: u64, data: HashMap<String, serde_json::Value>) -> bool {
+        self.update_row_ref(id, &data)
+    }
+
+    /// 借用版本：批量按 filter 更新时复用同一份 data，避免每行都克隆整个 HashMap。
+    pub fn update_row_ref(&mut self, id: u64, data: &HashMap<String, serde_json::Value>) -> bool {
         let idx = match self.pk_index.get(&id) {
             Some(i) => *i,
             None => return false,
@@ -492,9 +574,9 @@ impl Table {
             let nv = row.num_values;
             let s = row.values_start;
             for (k, v) in data {
-                if let Some(&pos) = self.field_index.get(&k) {
+                if let Some(&pos) = self.field_index.get(k) {
                     if pos < nv {
-                        self.values[s + pos] = FieldValue::from_json(v);
+                        self.values[s + pos] = FieldValue::from_json(v.clone());
                     }
                 }
             }
@@ -651,38 +733,252 @@ impl Table {
         Ok(())
     }
 
+    /// 与 `find_rows` 语义一致，但直接把结果写成 JSON 字符串。
+    /// - 无排序时流式扫描，凑够 limit 立刻停止，不再先收集全表行指针
+    /// - 命中 limit 后仍多探一行，用于判断是否还有下一页（has_more）
+    /// 返回 (json, has_more)
+    pub fn find_rows_json(&self,
+                          filter: &Option<HashMap<String, serde_json::Value>>,
+                          limit: Option<usize>, offset: Option<usize>,
+                          order_by: &Option<String>, order: &Option<String>) -> (String, bool) {
+        let o = offset.unwrap_or(0);
+        let cap = limit.unwrap_or(usize::MAX);
+        let conds = filter.as_ref().map(|f| self.parse_filter(f)).unwrap_or_default();
+
+        let mut out = String::with_capacity(128);
+        out.push('[');
+        let mut written = 0usize;
+        let mut has_more = false;
+        let mut tc = TimeCache::new();
+
+        let ordered = order_by.as_ref().and_then(|f| {
+            self.field_index.get(f).map(|&p| (p, order.as_deref() == Some("desc")))
+        });
+
+        match ordered {
+            Some((pos, desc)) => {
+                // 排序路径必须先收集全部匹配行
+                let mut matched: Vec<&RowStore> = self.rows.iter()
+                    .filter(|r| matches_filter(self.get_row_values(r), &conds))
+                    .collect();
+                matched.sort_by(|a, b| {
+                    let cmp = cmp_field_values(
+                        self.get_row_values(a).get(pos),
+                        self.get_row_values(b).get(pos),
+                    );
+                    if desc { cmp.reverse() } else { cmp }
+                });
+                has_more = limit.is_some() && matched.len().saturating_sub(o) > cap;
+                for r in matched.into_iter().skip(o).take(cap) {
+                    if written > 0 { out.push(','); }
+                    self.write_row_json_into(r, &mut out, &mut tc);
+                    written += 1;
+                }
+            }
+            None => {
+                let mut skipped = 0usize;
+                for r in &self.rows {
+                    if !matches_filter(self.get_row_values(r), &conds) { continue; }
+                    if skipped < o { skipped += 1; continue; }
+                    if written >= cap { has_more = true; break; }
+                    if written > 0 { out.push(','); }
+                    self.write_row_json_into(r, &mut out, &mut tc);
+                    written += 1;
+                }
+            }
+        }
+
+        out.push(']');
+        (out, has_more)
+    }
+
     pub fn find_rows(&self, filter: &Option<HashMap<String, serde_json::Value>>,
                      limit: Option<usize>, offset: Option<usize>,
                      order_by: &Option<String>, order: &Option<String>) -> Vec<Row> {
-        let mut results: Vec<&RowStore> = self.rows.iter().collect();
+        let o = offset.unwrap_or(0);
+        let l = limit.unwrap_or(usize::MAX);
+        let conds = filter.as_ref().map(|f| self.parse_filter(f)).unwrap_or_default();
 
-        if let Some(ref f) = filter {
-            let filter_indices: Vec<(usize, &serde_json::Value)> = f.iter()
-                .filter_map(|(k, v)| self.field_index.get(k).map(|&pos| (pos, v)))
+        if let Some(field) = order_by.as_ref().filter(|f| self.field_index.contains_key(*f)) {
+            let pos = self.field_index[field];
+            let desc = order.as_deref() == Some("desc");
+            let mut results: Vec<&RowStore> = self.rows.iter()
+                .filter(|r| matches_filter(self.get_row_values(r), &conds))
                 .collect();
-            results.retain(|r| {
-                let vals = self.get_row_values(r);
-                filter_indices.iter().all(|(pos, v)| {
-                    vals.get(*pos).map_or(false, |fv| fv.eq_json(v))
-                })
+            results.sort_by(|a, b| {
+                let cmp = cmp_field_values(
+                    self.get_row_values(a).get(pos),
+                    self.get_row_values(b).get(pos),
+                );
+                if desc { cmp.reverse() } else { cmp }
             });
+            return results.into_iter().skip(o).take(l).map(|r| self.to_row(r)).collect();
         }
 
-        if let Some(ref field) = order_by {
-            let desc = order.as_deref() == Some("desc");
-            if let Some(&pos) = self.field_index.get(field) {
-                results.sort_by(|a, b| {
-                    let vals_a = self.get_row_values(a);
-                    let vals_b = self.get_row_values(b);
-                    let cmp = cmp_field_values(vals_a.get(pos), vals_b.get(pos));
-                    if desc { cmp.reverse() } else { cmp }
-                });
+        // 无排序：流式扫描，凑够 limit 立刻停止，不先收集全表行指针
+        let mut out = Vec::with_capacity(l.min(self.rows.len()));
+        let mut skipped = 0usize;
+        for r in &self.rows {
+            if !matches_filter(self.get_row_values(r), &conds) { continue; }
+            if skipped < o { skipped += 1; continue; }
+            if out.len() >= l { break; }
+            out.push(self.to_row(r));
+        }
+        out
+    }
+}
+
+/// 过滤条件里出现 schema 之外的字段时用它作为哨兵下标：
+/// `vals.get(SENTINEL)` 恒为 None，等价于「该字段不存在」，
+/// 于是 {$exists:false}/{$ne:x} 等语义与 lib/table.js 的 `_matchRow` 一致，
+/// 而 `{noSuchField: 5}` 会正确地匹配 0 行（旧实现会静默放行全部行）。
+const ABSENT_FIELD: usize = usize::MAX;
+
+/// 单字段查询条件（字段名已在解析阶段降为行内下标）
+pub(crate) enum Cond<'a> {
+    Eq(&'a serde_json::Value),
+    Ne(&'a serde_json::Value),
+    Gt(&'a serde_json::Value),
+    Gte(&'a serde_json::Value),
+    Lt(&'a serde_json::Value),
+    Lte(&'a serde_json::Value),
+    In(&'a serde_json::Value),
+    Nin(&'a serde_json::Value),
+    /// 闭区间 [lo, hi]
+    Between(&'a serde_json::Value),
+    Exists(bool),
+    /// `$like`：SQL 风格通配（`%` = 任意多字符，`_` = 单字符），大小写不敏感。
+    /// 模式在解析阶段编译一次，逐行只做匹配。
+    Like(Box<regex_lite::Regex>),
+    /// `$regex`：JavaScript 风格正则，大小写敏感。
+    Regex(Box<regex_lite::Regex>),
+    /// 不认识的写法：永不匹配（与旧的等值语义一致，避免静默放行全部行）
+    Never,
+}
+
+/// 解析单个操作符。语义对齐 lib/table.js 的 `_matchOperator`。
+pub(crate) fn parse_op<'a>(op: &str, target: &'a serde_json::Value) -> Cond<'a> {
+    match op {
+        "$eq" => Cond::Eq(target),
+        "$ne" => Cond::Ne(target),
+        "$gt" => Cond::Gt(target),
+        "$gte" => Cond::Gte(target),
+        "$lt" => Cond::Lt(target),
+        "$lte" => Cond::Lte(target),
+        "$in" => Cond::In(target),
+        "$nin" => Cond::Nin(target),
+        "$between" => Cond::Between(target),
+        "$exists" => Cond::Exists(target.as_bool().unwrap_or(true)),
+        // $like / $regex 目标必须是字符串；非法或编译失败的模式退化为「永不匹配」。
+        // regex-lite 为线性时间引擎，不存在灾难性回溯，无需 JS 侧 isSafeRegex 的长度拦截。
+        "$like" => match target.as_str() {
+            Some(p) => regex_lite::Regex::new(&like_to_regex(p))
+                .map(|re| Cond::Like(Box::new(re)))
+                .unwrap_or(Cond::Never),
+            None => Cond::Never,
+        },
+        "$regex" => match target.as_str() {
+            Some(p) => regex_lite::Regex::new(p)
+                .map(|re| Cond::Regex(Box::new(re)))
+                .unwrap_or(Cond::Never),
+            None => Cond::Never,
+        },
+        _ => Cond::Never,
+    }
+}
+
+/// 把 SQL LIKE 模式转成锚定的、大小写不敏感的正则：
+/// 先转义正则元字符，再把 `%` 视作 `.*`、`_` 视作 `.`，
+/// 与 lib/table.js 的 `$like` 实现逐字符对齐。
+fn like_to_regex(pattern: &str) -> String {
+    let mut out = String::with_capacity(pattern.len() + 8);
+    out.push_str("(?i)^");
+    for ch in pattern.chars() {
+        match ch {
+            '%' => out.push_str(".*"),
+            '_' => out.push('.'),
+            '.' | '*' | '+' | '?' | '^' | '$' | '{' | '}' | '(' | ')' | '|' | '[' | ']' | '\\' => {
+                out.push('\\');
+                out.push(ch);
             }
+            c => out.push(c),
         }
+    }
+    out.push('$');
+    out
+}
 
-        let o = offset.unwrap_or(0);
-        let l = limit.unwrap_or(usize::MAX);
-        results.into_iter().skip(o).take(l).map(|r| self.to_row(r)).collect()
+/// 把存储值转成 JS `String(value)` 的等价字符串（供 `$regex` 语义使用）。
+fn field_value_to_string(v: &FieldValue) -> std::borrow::Cow<'_, str> {
+    use std::borrow::Cow;
+    match v {
+        FieldValue::Null => Cow::Borrowed("null"),
+        FieldValue::Bool(b) => Cow::Owned(b.to_string()),
+        FieldValue::Int(n) => Cow::Owned(n.to_string()),
+        FieldValue::Float(f) => Cow::Owned(f.to_string()),
+        FieldValue::String(s) => Cow::Borrowed(s),
+    }
+}
+
+#[inline]
+pub(crate) fn matches_filter(vals: &[FieldValue], conds: &[(usize, Cond)]) -> bool {
+    // 最常见形态（单字段等值，如按主键点查）走直通，避免逐行做枚举分派
+    if let [(pos, Cond::Eq(t))] = conds {
+        return vals.get(*pos).map_or(false, |fv| fv.eq_json(t));
+    }
+    conds.iter().all(|(pos, c)| match_cond(vals.get(*pos), c))
+}
+
+#[inline]
+fn match_cond(fv: Option<&FieldValue>, cond: &Cond) -> bool {
+    use std::cmp::Ordering;
+    let cmp = |t: &serde_json::Value, want: fn(Ordering) -> bool| {
+        fv.and_then(|v| cmp_to_json(v, t)).map_or(false, want)
+    };
+    match cond {
+        Cond::Never => false,
+        Cond::Exists(want) => fv.is_some() == *want,
+        Cond::Eq(t) => fv.map_or(false, |v| v.eq_json(t)),
+        Cond::Ne(t) => !fv.map_or(false, |v| v.eq_json(t)),
+        Cond::In(t) => match t.as_array() {
+            Some(arr) => fv.map_or(false, |v| arr.iter().any(|e| v.eq_json(e))),
+            None => false,
+        },
+        Cond::Nin(t) => match t.as_array() {
+            Some(arr) => !fv.map_or(false, |v| arr.iter().any(|e| v.eq_json(e))),
+            None => false,
+        },
+        Cond::Gt(t) => cmp(t, |o| o == Ordering::Greater),
+        Cond::Gte(t) => cmp(t, |o| o != Ordering::Less),
+        Cond::Lt(t) => cmp(t, |o| o == Ordering::Less),
+        Cond::Lte(t) => cmp(t, |o| o != Ordering::Greater),
+        Cond::Between(t) => match t.as_array() {
+            Some(arr) if arr.len() == 2 => {
+                cmp(&arr[0], |o| o != Ordering::Less) && cmp(&arr[1], |o| o != Ordering::Greater)
+            }
+            _ => false,
+        },
+        // $like 只对字符串字段生效（对齐 lib/table.js：非字符串直接 false）
+        Cond::Like(re) => matches!(fv, Some(FieldValue::String(s)) if re.is_match(s)),
+        // $regex 先把值字符串化再匹配（对齐 lib/table.js 的 String(value)）
+        Cond::Regex(re) => fv.map_or(false, |v| re.is_match(&field_value_to_string(v))),
+    }
+}
+
+/// 存储值与 JSON 目标值比较；类型不可比或含 null/NaN 时返回 None（视为不匹配，
+/// 对齐 JS 里 `value !== null && value > expected` 的写法）。
+fn cmp_to_json(fv: &FieldValue, jv: &serde_json::Value) -> Option<std::cmp::Ordering> {
+    use serde_json::Value as J;
+    match (fv, jv) {
+        (FieldValue::Null, _) | (_, J::Null) => None,
+        (FieldValue::Int(a), J::Number(n)) => match n.as_i64() {
+            Some(b) => Some(a.cmp(&b)),
+            None => n.as_f64().and_then(|b| (*a as f64).partial_cmp(&b)),
+        },
+        (FieldValue::Float(a), J::Number(n)) => n.as_f64().and_then(|b| a.partial_cmp(&b)),
+        (FieldValue::Bool(a), J::Bool(b)) => Some(a.cmp(b)),
+        (FieldValue::String(a), J::String(b)) => Some(a.as_str().cmp(b.as_str())),
+        _ => None,
     }
 }