mm_sqlite 1.3.4 → 1.3.7

package/db.js

@@ -11,8 +11,6 @@ class DB extends Sql {
    */
   constructor(sqlite) {
     super(sqlite.run, sqlite.exec);
-    // 保存sqlite实例引用
-    this._sqlite = sqlite;
     // 事务中
     this.task = 0;
 
@@ -72,20 +70,14 @@ DB.prototype.new = function (table, key) {
 };
 
 /**
- * 获取数据库连接
+ * 获取数据库连接（修复死锁版）
  * @param {number} timeout 超时时间(毫秒)
  * @returns {Promise<object>} 数据库连接对象
  */
 DB.prototype.getConn = async function (timeout = 15000) {
-  if (!this._sqlite) {
-    throw new Error('SQLite实例未初始化');
-  }
   try {
-    // 使用Promise.race实现超时控制
-    return await Promise.race([
-      this._sqlite.getConn(),
-      this._createTimeoutPromise(timeout, '获取数据库连接超时')
-    ]);
+    // 直接使用SQLite实例的getConn方法，避免Promise.race导致的死锁
+    return await this.parent().getConn(timeout);
   } catch (error) {
     this.log('error', '获取连接失败', error);
     // 重新抛出异常，因为调用方需要连接对象
@@ -100,7 +92,7 @@ DB.prototype.getConn = async function (timeout = 15000) {
 DB.prototype.start = async function() {
   this.task = 1;
   try {
-    await this.exec('BEGIN;', [], 15000);
+    await this.exec('BEGIN;');
     // 返回事务对象
     return {
       commit: async () => {
@@ -265,7 +257,7 @@ DB.prototype.fields = async function (table, field_name, timeout = 15000) {
     var len = list.length;
     for (var i = 0; i < len; i++) {
       list[i].pk = list[i].pk ? true : false;
-      list[i].notnull = list[i].notnull ? true : false;
+      list[i].not_null = list[i].not_null ? true : false;
     }
     
     // 如果指定了字段名，过滤结果
@@ -273,7 +265,16 @@ DB.prototype.fields = async function (table, field_name, timeout = 15000) {
       list = list.filter(field => field.name === field_name);
     }
     
-    return list;
+    return list.map(item => ({
+      name: item.name,
+      cid: item.cid,
+      default_value: item.dflt_value,
+      not_null: item.notnull,
+      type: item.type,
+      pk: item.pk,
+      auto: item.auto,
+      note: item.note
+    }));
   } catch (err) {
     this.log('error', '获取字段信息失败', err);
     return [];
@@ -472,7 +473,7 @@ DB.prototype.emptyTable = function (table, timeout = 15000) {
   if (!table || typeof table !== 'string') {
     throw new TypeError('table must be a valid string');
   }
-  return this.exec('DELETE FROM `' + table + '`;', timeout);
+  return this.exec('DELETE FROM `' + table + '`;', [], timeout);
 };
 
 /**
@@ -563,11 +564,11 @@ DB.prototype.setField = async function (field, type, value = '', not_null = true
     } else {
       sql += ';';
     }
-    await this.exec(sql, timeout);
+    await this.exec(sql, [], timeout);
 
     sql = 'UPDATE TABLE `{0}` SET `{2}` = `{1}`;';
     sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', new_name);
-    var ret = await this.exec(sql, timeout);
+    var ret = await this.exec(sql, [], timeout);
 
     if (field !== new_name) {
       // sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
@@ -611,22 +612,22 @@ DB.prototype.delField = async function (table, field, timeout = 15000) {
 DB.prototype.sqlField = function (fd) {
   var sql = '`{0}`'.replace('{0}', fd.name);
   sql += ' ' + fd.type;
-  if (fd.notnull) {
+  if (fd.not_null) {
     sql += ' NOT NULL';
   }
   if (fd.auto) {
-    if (fd.dflt_value) {
-      if (fd.dflt_value === '0000-00-00 00:00:00') {
-        fd.dflt_value = 'CURRENT_TIMESTAMP';
+    if (fd.default_value) {
+      if (fd.default_value === '0000-00-00 00:00:00') {
+        fd.default_value = 'CURRENT_TIMESTAMP';
       }
-      sql += ' DEFAULT ' + fd.dflt_value;
+      sql += ' DEFAULT ' + fd.default_value;
     }
     sql += ' ' + fd.auto;
-  } else if (fd.dflt_value) {
-    if (fd.dflt_value === '0000-00-00 00:00:00') {
-      fd.dflt_value = '1970-01-01 00:00:00';
+  } else if (fd.default_value) {
+    if (fd.default_value === '0000-00-00 00:00:00') {
+      fd.default_value = '1970-01-01 00:00:00';
     }
-    sql += ' DEFAULT ' + fd.dflt_value;
+    sql += ' DEFAULT ' + fd.default_value;
   }
   if (fd.note) {
     sql += " COMMENT '" + fd.note + "'";
@@ -802,12 +803,11 @@ DB.prototype.getCreateTable = async function (table, timeout = 15000) {
 /**
  * @description 获取表数据的SQL插入语句
  * @param {string} table 表名
- * @param {number} batchSize 批量处理大小
- * @param batch_size
- * @param {number} timeout 超时时间(毫秒)
+ * @param {number} batch_size 批量处理大小
+ * @param {number} timeout - 超时时间(毫秒)
  * @returns {Promise | string} SQL插入语句
  */
-DB.prototype.getTableData = async function (table, batchSize = 100, timeout = 60000) {
+DB.prototype.getTableData = async function (table, batch_size = 100, timeout = 60000) {
   if (!table) {
     throw new TypeError('table must be specified');
   }

package/index.js

@@ -853,15 +853,15 @@ 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();

package/package.json

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

package/sql.js

@@ -932,34 +932,23 @@ Sql.prototype.set = async function (query, body, like) {
 };
 
 /**
- * @description 查询数据
+ * @description 查询数据（优化版）
  * @param {object} query 查询条件
  * @param {string} sort 排序
  * @param {string} view 返回的字段
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {number} timeout 超时时间（毫秒），默认30000ms
+ * @param {number} timeout 超时时间（毫秒），默认5000ms
  * @returns {Promise|Array} 查询结果
  */
-Sql.prototype.get = async function (query, sort, view, like, timeout = 30000) {
+Sql.prototype.get = async function (query, sort, view, like, timeout = 5000) {
   if (!this.table) {
     throw new Error('表名未设置');
   }
 
   try {
-    // 使用Promise.race实现超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('查询操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 生成SQL并执行
-        var sql = this.toGetSql(query, sort, view, like);
-        var list = await this.run(sql);
-        return list;
-      })(),
-      timeout_promise
-    ]);
+    var sql = this.toGetSql(query, sort, view, like);
+    var list = await this.run(sql, [], timeout);
+    return list;
   } catch (err) {
     this.error = err.message;
     this.log('error', '查询数据失败', err);
@@ -1044,24 +1033,13 @@ Sql.prototype.count = async function (query, like, timeout = 30000) {
   }
 
   try {
-    // 添加超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('统计操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 正确生成count SQL
-        const where = typeof query === 'string' ? query : await this.toWhere(query, like);
-        const sql = 'SELECT COUNT(*) as num FROM `' + this.table + '`' + (where ? ' WHERE ' + where : '');
-        this.sql = sql;
-        const list = await this.run(sql);
-        const total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
-
-        return total;
-      })(),
-      timeout_promise
-    ]);
+    const where = typeof query === 'string' ? query : await this.toWhere(query, like);
+    const sql = 'SELECT COUNT(*) as num FROM `' + this.table + '`' + (where ? ' WHERE ' + where : '');
+    this.sql = sql;
+    const list = await this.run(sql);
+    const total = list && list[0] && list[0].num ? parseInt(list[0].num) : 0;
+
+    return total;
   } catch (err) {
     this.error = err.message;
     this.log('error', '统计记录数失败', err);
@@ -1094,48 +1072,31 @@ Sql.prototype.addList = async function (list, batch_size = 100, timeout = 60000)
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('批量添加数据操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batch_size) {
-          // 使用批量插入语法，不使用事务包装
-          this.sql = this.toBatchAddSql(list);
-          return await this.exec(this.sql);
-        }
+    if (list.length <= batch_size) {
+      // 使用批量插入语法，不使用事务包装
+      this.sql = this.toBatchAddSql(list);
+      return await this.exec(this.sql);
+    }
 
-        // 分批处理大数据量
-        const total = Math.ceil(list.length / batch_size);
-        $.log.info(`开始分批添加数据，共${total}批，每批${batch_size}条`);
-
-        // 分批执行，每批一个单独的批量插入语句
-        let final_res = null;
-        for (let i = 0; i < total; i++) {
-          const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-          $.log.debug(`处理第${i + 1}/${total}批数据，${batch.length}条`);
-
-          // 生成批量插入SQL
-          const batch_sql = this.toBatchAddSql(batch);
-          this.sql = batch_sql;
-
-          // 为每批操作添加超时控制
-          final_res = await Promise.race([
-            this.exec(batch_sql),
-            new Promise((unused_resolve, reject) => {
-              setTimeout(() => reject(new Error(`第${i + 1}批数据处理超时`)), timeout / total);
-            })
-          ]);
-        }
+    // 分批处理大数据量
+    const total = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批添加数据，共${total}批，每批${batch_size}条`);
+
+    // 分批执行，每批一个单独的批量插入语句
+    let final_res = null;
+    for (let i = 0; i < total; i++) {
+      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+      this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
+
+      // 生成批量插入SQL
+      const batch_sql = this.toBatchAddSql(batch);
+      this.sql = batch_sql;
+
+      final_res = await this.exec(batch_sql);
+    }
 
-        $.log.success(`批量添加数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeout_promise
-    ]);
+    this.log('success', `批量添加数据完成，共${list.length}条`);
+    return final_res;
   } catch (error) {
     this.log('error', '批量添加数据失败', error);
     // 返回默认操作结果对象，保持返回值类型一致
@@ -1197,71 +1158,53 @@ Sql.prototype.delList = async function (list, like, batch_size = 100, timeout =
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('批量删除数据操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batch_size) {
-          let sql = '';
-          for (const item of list) {
-            sql += this.toDelSql(item.query, like);
-          }
-          this.sql = sql;
-          return await this.exec(sql);
-        }
-
-        // 分批处理大数据量
-        const total = Math.ceil(list.length / batch_size);
-        $.log.info(`开始分批删除数据，共${total}批，每批${batch_size}条`);
-
-        // 使用事务包装整个操作以保证原子性
-        let final_res = null;
-        try {
-          // 开始事务
-          await this.exec('BEGIN;', 15000);
+    if (list.length <= batch_size) {
+      let sql = '';
+      for (const item of list) {
+        sql += this.toDelSql(item.query, like);
+      }
+      this.sql = sql;
+      return await this.exec(sql, [], timeout);
+    }
 
-          // 分批处理
-          for (let i = 0; i < total; i++) {
-            const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-            $.log.debug(`处理第${i + 1}/${total}批数据，${batch.length}条`);
+    // 分批处理大数据量
+    const total = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批删除数据，共${total}批，每批${batch_size}条`);
 
-            let batch_sql = '';
-            for (const item of batch) {
-              batch_sql += this.toDelSql(item.query, like);
-            }
+    // 使用事务包装整个操作以保证原子性
+    let final_res = null;
+    try {
+      // 开始事务
+      await this.exec('BEGIN;');
 
-            // 为每批操作添加超时控制
-            final_res = await Promise.race([
-              this.exec(batch_sql),
-              new Promise((unused_resolve, reject) => {
-                setTimeout(() => reject(new Error(`第${i + 1}批数据删除超时`)), timeout / total);
-              })
-            ]);
-          }
+      // 分批处理
+      for (let i = 0; i < total; i++) {
+        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+        this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-          // 提交事务
-          await this.exec('COMMIT;', 15000);
-        } catch (error) {
-          // 发生错误时回滚事务
-          try {
-            await this.exec('ROLLBACK;', 15000);
-            this.log('error', '批量删除数据失败，事务已回滚', error);
-          } catch (rollback_err) {
-            this.log('error', '批量删除数据失败，事务回滚也失败', rollback_err);
-          }
-          // 记录错误日志
-          this.log('error', 'SQL语句执行失败', error);
+        let batch_sql = '';
+        for (const item of batch) {
+          batch_sql += this.toDelSql(item.query, like);
         }
+        final_res = await this.exec(batch_sql, [], timeout);
+      }
+
+      // 提交事务
+      await this.exec('COMMIT;', [], timeout);
+    } catch (error) {
+      // 发生错误时回滚事务
+      try {
+        await this.exec('ROLLBACK;', [], timeout);
+        this.log('error', '批量删除数据失败，事务已回滚', error);
+      } catch (rollback_err) {
+        this.log('error', '批量删除数据失败，事务回滚也失败', rollback_err);
+      }
+      // 记录错误日志
+      this.log('error', 'SQL语句执行失败', error);
+    }
 
-        $.log.success(`批量删除数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeout_promise
-    ]);
+    this.log('success', `批量删除数据完成，共${list.length}条`);
+    return final_res;
   } catch (err) {
     this.log('error', '批量删除数据失败', err);
     // 返回默认操作结果对象，保持返回值类型一致
@@ -1281,69 +1224,52 @@ Sql.prototype.setList = async function (list, like = false, batch_size = 100, ti
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((unused_resolve, reject) => {
-      setTimeout(() => reject(new Error('批量更新数据操作超时')), timeout);
-    });
-
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batch_size) {
-          let sql = '';
-          for (const item of list) {
-            sql += this.toSetSql(item.query, item.obj, like);
-          }
-          this.sql = sql;
-          return await this.exec(sql);
-        }
+    if (list.length <= batch_size) {
+      let sql = '';
+      for (const item of list) {
+        sql += this.toSetSql(item.query, item.obj, like);
+      }
+      this.sql = sql;
+      return await this.exec(sql, [], timeout);
+    }
 
-        // 分批处理大数据量
-        const total = Math.ceil(list.length / batch_size);
-        $.log.info(`开始分批更新数据，共${total}批，每批${batch_size}条`);
+    // 分批处理大数据量
+    const total = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批更新数据，共${total}批，每批${batch_size}条`);
 
-        // 使用事务包装整个操作以保证原子性
-        let final_res = null;
-        try {
-          // 开始事务
-          await this.exec('BEGIN;', 15000);
+    // 使用事务包装整个操作以保证原子性
+    let final_res = null;
+    try {
+      // 开始事务
+      await this.exec('BEGIN;');
 
-          // 分批处理
-          for (let i = 0; i < total; i++) {
-            const batch = list.slice(i * batch_size, (i + 1) * batch_size);
-            $.log.debug(`处理第${i + 1}/${total}批数据，${batch.length}条`);
+      // 分批处理
+      for (let i = 0; i < total; i++) {
+        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+        this.log('debug', `处理第${i + 1}/${total}批数据，${batch.length}条`);
 
-            let batch_sql = '';
-            for (const item of batch) {
-              batch_sql += this.toSetSql(item.query, item.obj, like);
-            }
+        let batch_sql = '';
+        for (const item of batch) {
+          batch_sql += this.toSetSql(item.query, item.obj, like);
+        }
 
-            // 为每批操作添加超时控制
-            final_res = await Promise.race([
-              this.exec(batch_sql),
-              new Promise((unused_resolve, reject) => {
-                setTimeout(() => reject(new Error(`第${i + 1}批数据更新超时`)), timeout / total);
-              })
-            ]);
-          }
+        final_res = await this.exec(batch_sql, [], timeout);
+      }
 
-          // 提交事务
-          await this.exec('COMMIT;', 15000);
-        } catch (error) {
-          // 发生错误时回滚事务
-          try {
-            await this.exec('ROLLBACK;', 15000);
-            this.log('error', '批量更新数据失败，事务已回滚', error);
-          } catch (rollback_err) {
-            this.log('error', '批量更新数据失败，事务回滚也失败', rollback_err);
-          }
-        }
+      // 提交事务
+      await this.exec('COMMIT;', [], timeout);
+    } catch (error) {
+      // 发生错误时回滚事务
+      try {
+        await this.exec('ROLLBACK;', [], timeout);
+        this.log('error', '批量更新数据失败，事务已回滚', error);
+      } catch (rollback_err) {
+        this.log('error', '批量更新数据失败，事务回滚也失败', rollback_err);
+      }
+    }
 
-        $.log.success(`批量更新数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeout_promise
-    ]);
+    this.log('success', `批量更新数据完成，共${list.length}条`);
+    return final_res;
   } catch (err) {
     this.log('error', '批量更新数据失败', err);
     // 返回默认操作结果对象，保持返回值类型一致