mm_mysql 2.3.4 → 2.3.6

package/db.js

@@ -17,8 +17,6 @@ class DB extends Sql {
       mysql.run,
       mysql.exec
     );
-    // 保存mysql实例引用
-    this._mysql = mysql;
     // 事务中
     this.task = 0;
 
@@ -82,7 +80,7 @@ DB.prototype.new = function (table, key) {
  */
 DB.prototype.getConn = async function() {
   try {
-    return await this._mysql.getConn();
+    return await this.parent().getConn();
   } catch (error) {
     this.log('error', '获取连接失败', error);
     // 返回null作为默认值，保持返回值类型一致
@@ -96,7 +94,7 @@ DB.prototype.getConn = async function() {
  */
 DB.prototype.start = async function() {
   try {
-    return await this._mysql.beginTransaction();
+    return await this.parent().beginTransaction();
   } catch (error) {
     this.log('error', '开始事务失败', error);
     // 返回null作为默认值，保持返回值类型一致
@@ -155,7 +153,7 @@ DB.prototype.transaction = async function(callback) {
   }
     
   try {
-    return await this._mysql.transaction(callback);
+    return await this.parent().transaction(callback);
   } catch (error) {
     this.log('error', '事务执行失败', error);
     // 返回null作为默认值，保持返回值类型一致
@@ -257,7 +255,7 @@ DB.prototype.addTable = async function (table, field, type = 'int', auto = true,
     sql += ' ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;';
 
     // 执行SQL并设置表名
-    const result = await this.exec(sql, timeout);
+    const result = await this.exec(sql, [], timeout);
     // 设置实例的表名属性，以便后续操作使用
     this.table = table;
     return result;
@@ -277,7 +275,7 @@ DB.prototype.dropTable = function (table, timeout = 15000) {
   if (!table || typeof table !== 'string') {
     throw new TypeError('table must be a valid string');
   }
-  return this.exec('DROP TABLE IF EXISTS \`' + table + '\`;', timeout);
+  return this.exec('DROP TABLE IF EXISTS \`' + table + '\`;', [], timeout);
 };
 
 /**
@@ -291,7 +289,7 @@ DB.prototype.renameTable = function (table, new_table, timeout = 15000) {
   if (!table || !new_table) {
     throw new TypeError('table and new_table must be specified');
   }
-  return this.exec('RENAME TABLE \`' + table + '\` TO \`' + new_table + '\`;', timeout);
+  return this.exec('RENAME TABLE \`' + table + '\` TO \`' + new_table + '\`;', [], timeout);
 };
 
 /**
@@ -341,7 +339,7 @@ DB.prototype.addField = async function (field, type, value = '', not_null = true
 
     // 使用ADD COLUMN而不是CHANGE COLUMN
     const sql = `ALTER TABLE \`${this.table}\` ADD COLUMN ${fieldDef};`;
-    const result = await this.exec(sql, timeout);
+    const result = await this.exec(sql, [], timeout);
     return result;
   } catch (err) {
     this.log('error', '添加字段失败', err);
@@ -386,7 +384,7 @@ DB.prototype.setField = async function (field, type, value = '', not_null = true
       sql += ', ADD PRIMARY KEY (\`' + targetName + '\`)';
     }
     sql += ';';
-    const result = await this.exec(sql, timeout);
+    const result = await this.exec(sql, [], timeout);
     return result;
   } catch (err) {
     this.log('error', '修改字段失败', err);
@@ -406,7 +404,7 @@ DB.prototype.editField = function (table, field, type, timeout = 15000) {
   if (!table || !field || !type) {
     throw new TypeError('table, field, and type must be specified');
   }
-  return this.exec('ALTER TABLE \`' + table + '\` MODIFY COLUMN \`' + field + '\` ' + type + ';', timeout);
+  return this.exec('ALTER TABLE \`' + table + '\` MODIFY COLUMN \`' + field + '\` ' + type + ';', [], timeout);
 };
 
 /**
@@ -420,7 +418,7 @@ DB.prototype.delField = function (table, field, timeout = 15000) {
   if (!table || !field) {
     throw new TypeError('table and field must be specified');
   }
-  return this.exec('ALTER TABLE \`' + table + '\` DROP COLUMN \`' + field + '\`;', timeout);
+  return this.exec('ALTER TABLE \`' + table + '\` DROP COLUMN \`' + field + '\`;', [], timeout);
 };
 
 /**
@@ -436,7 +434,7 @@ DB.prototype.renameField = function (table, field, new_field, type, timeout = 15
   if (!table || !field || !new_field) {
     throw new TypeError('table, field, and new_field must be specified');
   }
-  return this.exec('ALTER TABLE \`' + table + '\` CHANGE \`' + field + '\` \`' + new_field + '\` ' + type + ';', timeout);
+  return this.exec('ALTER TABLE \`' + table + '\` CHANGE \`' + field + '\` \`' + new_field + '\` ' + type + ';', [], timeout);
 };
 
 /**
@@ -529,7 +527,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('TRUNCATE TABLE \`' + table + '\`;', timeout);
+  return this.exec('TRUNCATE TABLE \`' + table + '\`;', [], timeout);
 };
 
 /**
@@ -582,7 +580,7 @@ DB.prototype.backupTable = function (table, backup, timeout = 60000) {
   if (!table || !backup) {
     throw new TypeError('table and backup must be specified');
   }
-  return this.exec('CREATE TABLE \`' + backup + '\` LIKE \`' + table + '\`; INSERT INTO \`' + backup + '\` SELECT * FROM \`' + table + '\`;', timeout);
+  return this.exec('CREATE TABLE \`' + backup + '\` LIKE \`' + table + '\`; INSERT INTO \`' + backup + '\` SELECT * FROM \`' + table + '\`;', [], timeout);
 };
 
 
@@ -591,7 +589,7 @@ DB.prototype.backupTable = function (table, backup, timeout = 60000) {
  * @param {string} table 表名
  * @param {object} model 表模型，键值对，根据值类型创建字段类型，根据键名创建字段名
  * @param {string} key 主键
- * @param timeout
+ * @param {number} timeout 超时时间(毫秒)
  * @returns {Promise | number} 操作结果
  */
 DB.prototype.createTable = function (table, model, key = 'id', timeout = 15000) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mm_mysql",
-	"version": "2.3.4",
+	"version": "2.3.6",
 	"description": "这是超级美眉mysql帮助函数模块，用于便捷操作mysql，使用await方式，可以避免嵌套函数",
 	"main": "index.js",
 	"dependencies": {

package/sql.js

@@ -750,19 +750,10 @@ Sql.prototype.get = async function (query, sort, view, like, timeout = 20000) {
   }
 
   try {
-    // 使用Promise.race实现超时控制
-    return await Promise.race([
-      (async () => {
-        // 生成SQL并执行
-        const sql = this.toGetSql(query, sort, view, like);
-        this.sql = sql;
-        const list = await this.run(sql);
-        return list;
-      })(),
-      new Promise((resolve, reject) => {
-        setTimeout(() => reject(new Error('查询操作超时')), timeout);
-      })
-    ]);
+    const sql = this.toGetSql(query, sort, view, like);
+    this.sql = sql;
+    const list = await this.run(sql);
+    return list;
   } catch (err) {
     this.error = err.message;
     this.log('error', '查询数据失败', err);
@@ -825,23 +816,12 @@ Sql.prototype.count = async function (query, like, timeout = 20000) {
   }
 
   try {
-    // 添加超时控制
-    const timeout_promise = new Promise((_, 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);
@@ -865,57 +845,40 @@ Sql.prototype.getCount = async function (query, like, timeout = 30000) {
  * 添加多条数据
  * @param {Array} list 对象数组
  * @param {boolean} lock 是否锁定
- * @param {number} batchSize 每批处理数量，默认100
+ * @param {number} batch_size 每批处理数量，默认100
  * @param {number} timeout 超时时间（毫秒），默认60000
  * @returns {Promise<object>} 执行结果
  */
-Sql.prototype.addList = async function (list, batchSize = 100, timeout = 60000) {
+Sql.prototype.addList = async function (list, batch_size = 100, timeout = 60000) {
   if (!this.table || !Array.isArray(list) || list.length === 0) {
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((resolve, reject) => {
-      setTimeout(() => reject(new Error('批量添加数据操作超时')), timeout);
-    });
+    // 如果数据量较小，
+    if (list.length <= batch_size) {
+      // 使用批量插入语法，不使用事务包装
+      this.sql = this.toBatchAddSql(list);
+      return await this.exec(this.sql, [], timeout);
+    }
 
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batchSize) {
-          // 使用批量插入语法，不使用事务包装
-          this.sql = this.toBatchAddSql(list);
-          return await this.exec(this.sql);
-        }
+    // 分批处理大数据量
+    const batches = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批添加数据，共${batches}批，每批${batch_size}条`);
 
-        // 分批处理大数据量
-        const batches = Math.ceil(list.length / batchSize);
-        this.log('info', `开始分批添加数据，共${batches}批，每批${batchSize}条`);
-
-        // 分批执行，每批一个单独的批量插入语句
-        let final_res = null;
-        for (let i = 0; i < batches; i++) {
-          const batch = list.slice(i * batchSize, (i + 1) * batchSize);
-          this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
-
-          // 生成批量插入SQL
-          const batch_sql = this.toBatchAddSql(batch);
-          this.sql = batch_sql;
-
-          // 为每批操作添加超时控制
-          final_res = await Promise.race([
-            this.exec(batch_sql),
-            new Promise((_, reject) => {
-              setTimeout(() => reject(new Error(`第${i + 1}批数据处理超时`)), timeout / batches);
-            })
-          ]);
-        }
+    // 分批执行，每批一个单独的批量插入语句
+    let final_res = null;
+    for (let i = 0; i < batches; i++) {
+      const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+      this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
 
-        this.log('info', `批量添加数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeout_promise
-    ]);
+      // 生成批量插入SQL
+      const batch_sql = this.toBatchAddSql(batch);
+      this.sql = batch_sql;
+      final_res = await this.exec(batch_sql);
+    }
+
+    this.log('info', `批量添加数据完成，共${list.length}条`);
+    return final_res;
   } catch (error) {
     this.log('error', '批量添加数据失败', error);
   }
@@ -970,78 +933,62 @@ Sql.prototype._buildValueList = function (list, keys) {
  * 删除多条数据
  * @param {Array} list 对象数组
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {number} batchSize 每批处理数量，默认100
+ * @param {number} batch_size 每批处理数量，默认100
  * @param {number} timeout 超时时间（毫秒），默认60000
  * @returns {Promise<object>} 执行结果
  */
-Sql.prototype.delList = async function (list, like, batchSize = 100, timeout = 60000) {
+Sql.prototype.delList = async function (list, like, batch_size = 100, timeout = 60000) {
   if (!this.table || !Array.isArray(list) || list.length === 0) {
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((resolve, reject) => {
-      setTimeout(() => reject(new Error('批量删除数据操作超时')), timeout);
-    });
+    // 如果数据量较小，直接处理
+    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);
+    }
 
-    return await Promise.race([
-      (async () => {
-        // 如果数据量较小，直接处理
-        if (list.length <= batchSize) {
-          let sql = '';
-          for (const item of list) {
-            sql += this.toDelSql(item.query, like);
-          }
-          this.sql = sql;
-          return await this.exec(sql);
-        }
+    // 分批处理大数据量
+    const batches = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批删除数据，共${batches}批，每批${batch_size}条`);
 
-        // 分批处理大数据量
-        const batches = Math.ceil(list.length / batchSize);
-        this.log('info', `开始分批删除数据，共${batches}批，每批${batchSize}条`);
-
-        // 使用事务包装整个操作以保证原子性
-        let final_res = null;
-        try {
-          // 开始事务
-          await this.exec('BEGIN;', 15000);
-
-          // 分批处理
-          for (let i = 0; i < batches; i++) {
-            const batch = list.slice(i * batchSize, (i + 1) * batchSize);
-            this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
-
-            let batch_sql = '';
-            for (const item of batch) {
-              batch_sql += this.toDelSql(item.query, like);
-            }
-
-            // 为每批操作添加超时控制
-            final_res = await Promise.race([
-              this.exec(batch_sql),
-              new Promise((_, reject) => {
-                setTimeout(() => reject(new Error(`第${i + 1}批数据删除超时`)), timeout / batches);
-              })
-            ]);
-          }
+    // 使用事务包装整个操作以保证原子性
+    let final_res = null;
+    try {
+      // 开始事务
+      await this.exec('BEGIN;');
 
-          // 提交事务
-          await this.exec('COMMIT;', 15000);
-        } catch (error) {
-          // 发生错误时回滚事务
-          try {
-            await this.exec('ROLLBACK;', 15000);
-            this.log('error', '批量删除数据失败，事务已回滚', error);
-          } catch (rollbackError) {
-            this.log('error', '批量删除数据失败，事务回滚也失败', rollbackError);
-          }
+      // 分批处理exec删除语句
+      for (let i = 0; i < batches; i++) {
+        const batch = list.slice(i * batch_size, (i + 1) * batch_size);
+        this.log('debug', `处理第${i + 1}/${batches}批数据，${batch.length}条`);
+
+        let batch_sql = '';
+        for (const item of batch) {
+          batch_sql += this.toDelSql(item.query, like);
         }
+        final_res = await this.exec(batch_sql);
+      }
+
+      // 提交事务
+      await this.exec('COMMIT;');
+    } catch (error) {
+      // 发生错误时回滚事务
+      try {
+        await this.exec('ROLLBACK;', [], timeout);
+        this.log('error', '批量删除数据失败，事务已回滚', error);
+      } catch (rollbackError) {
+        this.log('error', '批量删除数据失败，事务回滚也失败', rollbackError);
+      }
+      throw error; // 重新抛出错误
+    }
 
-        this.log('info', `批量删除数据完成，共${list.length}条`);
-        return final_res;
-      })(),
-      timeoutPromise
-    ]);
+    this.log('info', `批量删除数据完成，共${list.length}条`);
+    return final_res;
   } catch (err) {
     this.error = err.message;
     this.log('error', '批量删除数据失败', err);
@@ -1053,50 +1000,52 @@ Sql.prototype.delList = async function (list, like, batchSize = 100, timeout = 6
  * 修改多条数据
  * @param {Array} list 对象数组
  * @param {boolean} like 是否使用like匹配, 为空使用默认方式
- * @param {number} batchSize 每批处理数量，默认100
+ * @param {number} batch_size 每批处理数量，默认100
  * @param {number} timeout 超时时间（毫秒），默认60000
  * @returns {Promise<object>} 执行结果
  */
-Sql.prototype.setList = async function (list, like = false, batchSize = 100, timeout = 60000) {
+Sql.prototype.setList = async function (list, like = false, batch_size = 100, timeout = 60000) {
   if (!this.table || !Array.isArray(list) || list.length === 0) {
     throw new Error('表名或数据列表未设置');
   }
   try {
-    // 添加整体操作超时控制
-    const timeout_promise = new Promise((resolve, reject) => {
-      setTimeout(() => reject(new Error('批量修改数据操作超时')), timeout);
-    });
+    // 分批处理大数据量
+    const batches = Math.ceil(list.length / batch_size);
+    this.log('info', `开始分批修改数据，共${batches}批，每批${batch_size}条`);
 
-    return await Promise.race([
-      (async () => {
-        // 分批处理大数据量
-        const batches = Math.ceil(list.length / batchSize);
-        this.log('info', `开始分批修改数据，共${batches}批，每批${batchSize}条`);
-
-        let final_res = null;
-
-        // 逐条处理记录，保持简单可靠
-        for (let i = 0; i < list.length; i++) {
-          const item = list[i];
-          this.log('debug', `处理第${i + 1}/${list.length}条记录`);
-
-          // 生成单个更新SQL
-          const sql = this.toSetSql(item.query, item.item, like);
-          this.sql = sql;
-
-          // 为每条操作添加超时控制
-          final_res = await Promise.race([
-            this.exec(sql),
-            new Promise((_, reject) => {
-              setTimeout(() => reject(new Error(`第${i + 1}条数据修改超时`)), 5000); // 固定超时时间
-            })
-          ]);
-        }
+    let final_res = null;
+
+    // 使用事务包装整个操作以保证原子性
+    try {
+      // 开始事务
+      await this.exec('BEGIN;');
+
+      // 逐条处理记录，保持简单可靠
+      for (let i = 0; i < list.length; i++) {
+        const item = list[i];
+        this.log('debug', `处理第${i + 1}/${list.length}条记录`);
+
+        // 生成单个更新SQL
+        const sql = this.toSetSql(item.query, item.item, like);
+        this.sql = sql;
+
+        final_res = await this.exec(sql, [], timeout);
+      }
+
+      // 提交事务
+      await this.exec('COMMIT;');
+    } catch (error) {
+      // 发生错误时回滚事务
+      try {
+        await this.exec('ROLLBACK;', [], timeout);
+        this.log('error', '批量修改数据失败，事务已回滚', error);
+      } catch (rollbackError) {
+        this.log('error', '批量修改数据失败，事务回滚也失败', rollbackError);
+      }
+      throw error; // 重新抛出错误
+    }
 
-        return final_res;
-      })(),
-      timeoutPromise
-    ]);
+    return final_res;
   } catch (error) {
     this.error = error.message;
     this.log('error', '批量修改数据失败', error);