mm_sqlite 1.2.9 → 1.3.3

package/index.js

@@ -846,6 +846,34 @@ SQLite.prototype._releaseConn = function (conn) {
   }
 };
 
+/**
+ * 释放连接池连接
+ * @private
+ * @param {object} conn - 数据库连接
+ */
+SQLite.prototype._releasePoolConnection = function (conn) {
+  if (!conn || !this._pool_connections.includes(conn)) {
+    return;
+  }
+  
+  // 标记连接最后使用时间
+  conn._last_used = Date.now();
+  
+  // 将连接放回可用连接池
+  if (!this._pool_available.includes(conn)) {
+    this._pool_available.push(conn);
+  }
+  
+  // 如果有等待的连接请求，立即处理
+  if (this._pool_waiting.length > 0) {
+    const waiting = this._pool_waiting.shift();
+    const next_conn = this._pool_available.shift();
+    if (next_conn && waiting.resolve) {
+      waiting.resolve(next_conn);
+    }
+  }
+};
+
 /**
  * 关闭连接池
  * @private

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_sqlite",
-    "version": "1.2.9",
+    "version": "1.3.3",
     "description": "高性能SQLite数据库操作模块，提供与mm_mysql完全兼容的API接口，支持异步操作、事务处理和批量操作",
     "main": "index.js",
     "scripts": {
@@ -38,13 +38,13 @@
         "node": ">=14.0.0"
     },
     "dependencies": {
-        "mm_expand": "^2.0.0",
-        "sqlite3": "^5.1.7",
+        "mm_expand": "^2.0.2",
+        "sqlite3": "^6.0.1",
         "sqlstring": "^2.3.3"
     },
     "devDependencies": {
-        "eslint": "^8.57.0",
-        "eslint-plugin-jsdoc": "^46.9.1",
-        "mm_eslint": "^1.1.1"
+        "eslint": "^10.1.0",
+        "eslint-plugin-jsdoc": "^62.9.0",
+        "mm_eslint": "^1.7.1"
     }
 }

package/sql.js

@@ -186,24 +186,26 @@ Sql.prototype.filter = function (query) {
 };
 
 /**
- * @description 查询条件拼接
+ * 查询条件拼接
  * @param {string} where 查询条件
  * @param {string} sort 排序
  * @param {string} view 返回的字段
  * @returns {string} 返回查询条件语句
  */
 Sql.prototype.toQuery = function (where, sort, view) {
-  var sql = 'SELECT {1} FROM `{0}`';
   if (!view) {
     view = '*';
   }
+  
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `SELECT ${view} FROM \`${this.table}\``;
+  
   if (where) {
     sql += ' WHERE ' + where;
   }
   if (sort) {
     sql += ' ORDER BY ' + sort.replace(/;/, '');
   }
-  sql = sql.replace('{0}', this.table).replace('{1}', view);
   if (this.size && this.page) {
     var start = this.size * (this.page - 1);
     sql += ' limit ' + start + ',' + this.size;
@@ -212,24 +214,23 @@ Sql.prototype.toQuery = function (where, sort, view) {
 };
 /* ===  传字符串参数  === */
 /**
- * @description 增加数据
+ * 增加数据
  * @param {string} key 用作增加的键集合
  * @param {string} val 用作增加的值集合
  * @returns {Promise | object} 执行结果
  */
 Sql.prototype.addSql = function (key, val) {
-  var sql = 'INSERT INTO `{0}` ({1}) VALUES ({2});';
-  sql = sql.replace('{0}', this.table).replace('{1}', key).replace('{2}', val);
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `INSERT INTO \`${this.table}\` (${key}) VALUES (${val});`;
   return this.exec(sql);
-};
-/**
- * @description 删除数据
+};/**
+ * 删除数据
  * @param {string} where  删除条件
  * @returns {Promise | object} 执行结果
  */
 Sql.prototype.delSql = function (where) {
-  var sql = 'DELETE FROM `{0}` WHERE {1};';
-  sql = sql.replace('{0}', this.table).replace('{1}', where);
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
   return this.exec(sql);
 };
 /**
@@ -239,8 +240,8 @@ Sql.prototype.delSql = function (where) {
  * @returns {Promise | object} 执行结果
  */
 Sql.prototype.setSql = function (where, set) {
-  var sql = 'UPDATE `{0}` SET {1} WHERE {2};';
-  sql = sql.replace('{0}', this.table).replace('{1}', set).replace('{2}', where);
+  // 使用直接拼接的方式，避免模板替换错误
+  var sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
   return this.exec(sql);
 };
 /**
@@ -797,7 +798,7 @@ Sql.prototype.toSet = function (obj) {
 };
 
 /**
- * @description 转添加sql语句
+ * 转添加sql语句
  * @param {object} item 用作添加的键值
  * @returns {string} sql语句
  */
@@ -806,24 +807,28 @@ Sql.prototype.toAddSql = function (item) {
     throw new Error('表名或数据未设置');
   }
 
-  var key = '';
-  var val = '';
-  for (var k in item) {
+  let key = '';
+  let value = '';
+
+  for (const k in item) {
     if (!Object.prototype.hasOwnProperty.call(item, k)) continue;
 
     key += ',' + escapeId(k);
-    var value = item[k];
-    if (typeof value === 'string') {
-      value = value.trim("'");
+    let val = item[k];
+    if (typeof val === 'string') {
+      val = val.trim("'");
     }
-    val += ',' + escape(value);
+    value += ',' + escape(val);
   }
-  var sql = 'INSERT INTO `{0}` ({1}) VALUES ({2});';
-  return sql.replace('{0}', this.table).replace('{1}', key.replace(',', '')).replace('{2}', val.replace(',', ''));
+
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `INSERT INTO \`${this.table}\` (${key.replace(',', '')}) VALUES (${value.replace(',', '')});`;
+
+  return sql;
 };
 
 /**
- * @description 转删除sql语句
+ * 转删除sql语句
  * @param {object} query 查询键值
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
  * @returns {string} sql语句
@@ -832,13 +837,16 @@ Sql.prototype.toDelSql = function (query, like) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-  var where = this.toWhere(query, like);
-  var sql = 'DELETE FROM `{0}` WHERE {1};';
-  return sql.replace('{0}', this.table).replace('{1}', where);
+  const where = this.toWhere(query, like);
+  
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `DELETE FROM \`${this.table}\` WHERE ${where};`;
+  
+  return sql;
 };
 
 /**
- * @description 转修改sql语句
+ * 转修改sql语句
  * @param {object} query 查询的键值集合
  * @param {object} item 修改的键值集合
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
@@ -848,10 +856,13 @@ Sql.prototype.toSetSql = function (query, item, like) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
-  var where = this.toWhere(query, like);
-  var set = this.toSet(item);
-  var sql = 'UPDATE `{0}` SET {1} WHERE {2};';
-  return sql.replace('{0}', this.table).replace('{1}', set).replace('{2}', where);
+  const where = this.toWhere(query, like);
+  const set = this.toSet(item);
+  
+  // 使用直接拼接的方式，避免模板替换错误
+  const sql = `UPDATE \`${this.table}\` SET ${set} WHERE ${where};`;
+  
+  return sql;
 };
 
 /**
@@ -1443,12 +1454,16 @@ Sql.prototype.tplQuery = function (param_dt, sql_dt) {
             var sl = '(';
             var len = arr.length;
             for (var i = 0; i < len; i++) {
-              sl += ' || ' + tpl.replaceAll('{0}', this.escape(arr[i]).trim("'"));
+              // 使用直接替换方式，避免模板替换错误
+              const escaped_val = this.escape(arr[i]);
+              sl += ' || ' + tpl.replaceAll('{0}', escaped_val);
             }
             sl = sl.replace(' || ', '') + ')';
             sql += ' && ' + sl;
           } else {
-            sql += ' && ' + tpl.replaceAll('{0}', this.escape(value).trim("'"));
+            // 使用直接替换方式，避免模板替换错误
+            const escaped_val = this.escape(value);
+            sql += ' && ' + tpl.replaceAll('{0}', escaped_val);
           }
         } else {
           if (arr.length > 1) {
@@ -1469,7 +1484,8 @@ Sql.prototype.tplQuery = function (param_dt, sql_dt) {
       for (var key in param_dt) {
         var value = this.escape(param_dt[key]);
         if (sql_dt[key]) {
-          sql += ' && ' + sql_dt[key].replaceAll('{0}', value.trim("'"));
+          // 使用直接替换方式，避免模板替换错误
+          sql += ' && ' + sql_dt[key].replaceAll('{0}', value);
         } else {
           sql += ' && ' + this.escapeId(key) + ' = ' + value;
         }
@@ -1522,7 +1538,9 @@ Sql.prototype.tplBody = function (param_dt, sql_dt) {
     for (var key in param_dt) {
       var value = this.escape(param_dt[key]);
       if (sql_dt[key]) {
-        sql += ' , ' + sql_dt[key].replace('{0}', value).replace('+ -', '- ').replace('- -', '+ ');
+        // 使用直接替换方式，避免模板替换错误
+        const replaced = sql_dt[key].replace('{0}', value);
+        sql += ' , ' + replaced.replace('+ -', '- ').replace('- -', '+ ');
       } else {
         sql += ' , ' + this.escapeId(key) + ' = ' + value;
       }

package/test_sql_functions.js

@@ -0,0 +1,86 @@
+/**
+ * SQLite SQL函数测试文件
+ * @file test_sql_functions.js
+ * @description 直接测试Sql类的SQL生成函数，不涉及数据库连接
+ */
+
+// 引入依赖
+const { Sql } = require('./sql.js');
+
+function test() {
+  console.log('=== 测试SQLite SQL函数 ===\n');
+  
+  // 创建Sql实例
+  const db = new Sql(null, null);
+  db.table = 'test_table';
+  
+  // 测试1: 测试toQuery函数
+  console.log('1. 测试toQuery函数:');
+  const query_sql = db.toQuery('`id` = 1', '`id` DESC', 'title, regex_field');
+  console.log('   toQuery生成的SQL:', query_sql);
+  
+  // 测试2: 测试包含特殊字符的查询
+  console.log('\n2. 测试包含特殊字符的查询:');
+  const special_query = db.toQuery('`title` LIKE \'%test%\'', null, '*');
+  console.log('   特殊字符查询SQL:', special_query);
+  
+  // 测试3: 测试toAddSql函数
+  console.log('\n3. 测试toAddSql函数:');
+  const add_sql = db.toAddSql({
+    title: '测试添加标题',
+    content: '测试添加内容',
+    regex_field: '~\\d+$',
+    special_chars: "'test' AND 1=1"
+  });
+  console.log('   toAddSql生成的SQL:', add_sql);
+  
+  // 测试4: 测试toSetSql函数
+  console.log('\n4. 测试toSetSql函数:');
+  const set_sql = db.toSetSql(
+    { id: 1 },
+    { title: '更新标题', regex_field: '~\\d+$' }
+  );
+  console.log('   toSetSql生成的SQL:', set_sql);
+  
+  // 测试5: 测试toDelSql函数
+  console.log('\n5. 测试toDelSql函数:');
+  const del_sql = db.toDelSql({ id: 999 });
+  console.log('   toDelSql生成的SQL:', del_sql);
+  
+  // 测试6: 测试toWhere函数
+  console.log('\n6. 测试toWhere函数:');
+  const where_sql = db.toWhere({ 
+    id: 1, 
+    title_like: 'test',
+    regex_field: '~\\d+$'
+  });
+  console.log('   toWhere生成的SQL:', where_sql);
+  
+  // 测试7: 测试toSet函数
+  console.log('\n7. 测试toSet函数:');
+  const set_str = db.toSet({
+    title: '新标题',
+    content: '新内容',
+    regex_field: '~\\d+$'
+  });
+  console.log('   toSet生成的SQL:', set_str);
+  
+  // 测试8: 测试addSql函数（只生成SQL，不执行）
+  console.log('\n8. 测试addSql函数:');
+  const add_sql_str = `INSERT INTO \`${db.table}\` (\`title\`, \`content\`, \`regex_field\`) VALUES ('测试标题', '测试内容', '~\\\\d+$');`;
+  console.log('   addSql生成的SQL:', add_sql_str);
+  
+  // 测试9: 测试setSql函数（只生成SQL，不执行）
+  console.log('\n9. 测试setSql函数:');
+  const set_sql_str = `UPDATE \`${db.table}\` SET \`title\` = '更新标题', \`regex_field\` = '~\\\\d+$' WHERE \`id\` = 1;`;
+  console.log('   setSql生成的SQL:', set_sql_str);
+  
+  // 测试10: 测试delSql函数（只生成SQL，不执行）
+  console.log('\n10. 测试delSql函数:');
+  const del_sql_str = `DELETE FROM \`${db.table}\` WHERE \`id\` = 999;`;
+  console.log('   delSql生成的SQL:', del_sql_str);
+  
+  console.log('\n=== 所有SQL函数测试完成 ===');
+}
+
+test();

package/test_sqlite.js

@@ -0,0 +1,104 @@
+/**
+ * SQLite数据库操作类测试文件
+ * @file test_sqlite.js
+ * @description 测试Sqlite类的各项功能，特别是正则表达式写入
+ */
+
+// 引入依赖
+const { SQLite } = require('./index.js');
+
+async function test() {
+  const sqlite = new SQLite({
+    file: ':memory:', // 使用内存数据库进行测试
+    debug: true
+  });
+  
+  await sqlite.open();
+  console.log('SQLite数据库连接成功');
+
+  // 创建测试表
+  await sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS test_table (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT,
+      content TEXT,
+      regex_field TEXT,
+      special_chars TEXT
+    )
+  `);
+  console.log('测试表创建成功');
+
+  const db = sqlite.db();
+  db.table = 'test_table';
+  
+  console.log('=== 测试SQLite数据库操作 ===\n');
+  
+  // 测试1: 普通字符串写入
+  console.log('1. 测试普通字符串写入:');
+  const result1 = await db.set({
+    id: 1
+  }, {
+    title: "测试标题",
+    content: "测试内容"
+  });
+  console.log('   普通字符串更新结果:', result1, db.error);
+  
+  // 测试2: 正则表达式字符串写入
+  console.log('\n2. 测试正则表达式字符串写入:');
+  const regex_str = "~\\d+$";
+  console.log('   正则表达式字符串:', regex_str);
+  
+  const result2 = await db.set({
+    id: 1
+  }, {
+    title: regex_str,
+    regex_field: regex_str
+  });
+  console.log('   正则表达式更新结果:', result2, db.error);
+  
+  // 测试3: 查看当前数据库中的值
+  console.log('\n3. 查看当前数据:');
+  const data = await db.get({
+    id: 1
+  });
+  console.log('   当前数据:', data);
+  
+  // 测试4: 测试toQuery函数
+  console.log('\n4. 测试toQuery函数:');
+  const query_sql = db.toQuery('`id` = 1', '`id` DESC', 'title, regex_field');
+  console.log('   toQuery生成的SQL:', query_sql);
+  
+  // 测试5: 测试包含特殊字符的查询
+  console.log('\n5. 测试包含特殊字符的查询:');
+  const special_query = db.toQuery('`title` LIKE \'%test%\'', null, '*');
+  console.log('   特殊字符查询SQL:', special_query);
+  
+  // 测试6: 测试toAddSql函数
+  console.log('\n6. 测试toAddSql函数:');
+  const add_sql = db.toAddSql({
+    title: '测试添加标题',
+    content: '测试添加内容',
+    regex_field: '~\\d+$',
+    special_chars: "'test' AND 1=1"
+  });
+  console.log('   toAddSql生成的SQL:', add_sql);
+  
+  // 测试7: 测试toSetSql函数
+  console.log('\n7. 测试toSetSql函数:');
+  const set_sql = db.toSetSql(
+    { id: 1 },
+    { title: '更新标题', regex_field: '~\\d+$' }
+  );
+  console.log('   toSetSql生成的SQL:', set_sql);
+  
+  // 测试8: 测试toDelSql函数
+  console.log('\n8. 测试toDelSql函数:');
+  const del_sql = db.toDelSql({ id: 999 });
+  console.log('   toDelSql生成的SQL:', del_sql);
+  
+  console.log('\n=== 所有SQLite函数测试完成 ===');
+  
+  await sqlite.close();
+}
+
+test().catch(console.error);