mm_sqlite 1.4.0 → 1.4.2

package/db.js

@@ -75,21 +75,15 @@ DB.prototype.new = function (table = '', key = '') {
  * @returns {Promise<object>} 数据库连接对象
  */
 DB.prototype.getConn = async function (timeout = 15000) {
-  try {
-    // 直接使用SQLite实例的getConn方法，避免Promise.race导致的死锁
-    return await this.getParent().getConn(timeout);
-  } catch (error) {
-    this.log('error', '获取连接失败', error);
-    // 重新抛出异常，因为调用方需要连接对象
-    throw error;
-  }
+  // 直接使用SQLite实例的getConn方法，避免Promise.race导致的死锁
+  return await this.getParent().getConn(timeout);
 };
 
 /**
  * 开始事务
  * @returns {Promise<object>}
  */
-DB.prototype.start = async function() {
+DB.prototype.start = async function () {
   this.task = 1;
   try {
     await this.exec('BEGIN;');
@@ -116,17 +110,17 @@ DB.prototype.start = async function() {
  * @returns {Promise<void>}
  * @throws {TypeError} 当transaction参数无效时
  */
-DB.prototype.commit = async function(transaction) {
+DB.prototype.commit = async function (transaction) {
   // 参数校验
   if (!transaction || typeof transaction !== 'object') {
     throw new TypeError('transaction must be object');
   }
-  
+
   if (this.task !== 1) {
     this.log('warn', '没有活跃的事务可提交');
     return;
   }
-  
+
   try {
     await this.exec('COMMIT;', [], 15000);
     this.task = 0;
@@ -158,17 +152,17 @@ DB.prototype.end = function () {
  * @returns {Promise<void>}
  * @throws {TypeError} 当transaction参数无效时
  */
-DB.prototype.back = async function(transaction) {
+DB.prototype.back = async function (transaction) {
   // 参数校验
   if (!transaction || typeof transaction !== 'object') {
     throw new TypeError('transaction must be object');
   }
-  
+
   if (this.task !== 1) {
     this.log('warn', '没有活跃的事务可回滚');
     return;
   }
-  
+
   try {
     await this.exec('ROLLBACK;', [], 15000);
     this.task = 0;
@@ -186,22 +180,22 @@ DB.prototype.back = async function(transaction) {
  * @returns {Promise<*>}
  * @throws {TypeError} 当callback参数无效时
  */
-DB.prototype.transaction = async function(callback) {
+DB.prototype.transaction = async function (callback) {
   // 参数校验
   if (typeof callback !== 'function') {
     throw new TypeError('callback must be function');
   }
-  
+
   try {
     // 开始事务
     await this.start();
-    
+
     // 执行回调函数
     const result = await callback();
-    
+
     // 提交事务
     await this.commit({});
-    
+
     return result;
   } catch (err) {
     // 回滚事务
@@ -219,25 +213,20 @@ DB.prototype.transaction = async function(callback) {
  * @returns {Promise|Array} 表名数组
  */
 DB.prototype.tables = async function (table, timeout = 15000) {
-  try {
-    const list = await this.run("SELECT `name` FROM sqlite_master WHERE type='table';", [], timeout);
-    if (table) {
-      // 简单的过滤实现
-      const filtered = [];
-      for (const item of list) {
-        const value = item.name;
-        if (value && value.includes(table)) {
-          filtered.push(item);
-        }
+  const list = await this.run("SELECT `name` FROM sqlite_master WHERE type='table';", [], timeout);
+  if (table) {
+    // 简单的过滤实现
+    const filtered = [];
+    for (const item of list) {
+      const value = item.name;
+      if (value && value.includes(table)) {
+        filtered.push(item);
       }
-      return filtered.map(item => item.name);
     }
-    // 使用原生方法提取表名
-    return list.map(item => item.name);
-  } catch (err) {
-    this.log('error', '获取表名失败', err);
-    return [];
+    return filtered.map(item => item.name);
   }
+  // 使用原生方法提取表名
+  return list.map(item => item.name);
 };
 
 /**
@@ -247,38 +236,33 @@ DB.prototype.tables = async function (table, timeout = 15000) {
  * @returns {Promise|Array} 字段信息列表
  */
 DB.prototype.fields = async function (table, field_name, timeout = 15000) {
-  try {
-    const targetTable = table || this.table;
-    if (!targetTable) {
-      throw new TypeError('table must be specified');
-    }
-    var sql = 'PRAGMA table_info(`{0}`);'.replace('{0}', targetTable);
-    var list = await this.run(sql, [], timeout);
-    var len = list.length;
-    for (var i = 0; i < len; i++) {
-      list[i].pk = list[i].pk ? true : false;
-      list[i].not_null = list[i].not_null ? true : false;
-    }
-    
-    // 如果指定了字段名，过滤结果
-    if (field_name) {
-      list = list.filter(field => field.name === field_name);
-    }
-    
-    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 [];
+  const targetTable = table || this.table;
+  if (!targetTable) {
+    throw new TypeError('table must be specified');
   }
+  var sql = 'PRAGMA table_info(`{0}`);'.replace('{0}', targetTable);
+  var list = await this.run(sql, [], timeout);
+  var len = list.length;
+  for (var i = 0; i < len; i++) {
+    list[i].pk = list[i].pk ? true : false;
+    list[i].not_null = list[i].not_null ? true : false;
+  }
+
+  // 如果指定了字段名，过滤结果
+  if (field_name) {
+    list = list.filter(field => field.name === field_name);
+  }
+
+  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
+  }));
 };
 
 /**
@@ -424,42 +408,37 @@ DB.prototype.setType = function (field, type, value, not_null, auto) {
  * @returns {Promise | number} 创建成功返回1，失败返回0
  */
 DB.prototype.addTable = async function (table, field, type = 'int', auto = true, commit = '', timeout = 15000) {
-  try {
-    if (!table || typeof table !== 'string') {
-      throw new TypeError('table must be non-empty string');
-    }
-    if (!field) {
-      field = 'id';
-    }
-    // SQLite的自增主键要求字段类型必须是INTEGER（大写且不带长度）
-    let fieldType;
-    if (auto) {
-      // 自增字段使用简单的INTEGER类型，由后面的PRIMARY KEY AUTOINCREMENT决定自增行为
-      fieldType = 'INTEGER';
-    } else {
-      // 非自增字段使用正常的类型设置
-      fieldType = this.setType(field, type, null, true, auto);
-    }
-    // 根据是否自增来构造不同的SQL语句
-    let sqlTemplate;
-    if (auto) {
-      // 自增字段：使用INTEGER PRIMARY KEY AUTOINCREMENT语法
-      sqlTemplate = 'CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY AUTOINCREMENT)';
-    } else {
-      // 非自增字段：使用正常的字段类型和主键定义
-      sqlTemplate = 'CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY)';
-    }
-    var sql = sqlTemplate.replace('{0}', table).replace(
-      '{1}', field).replace('{2}', fieldType) + ';';
-    // SQLite不支持表级COMMENT语法，所以忽略commit参数
-    var bl = await this.exec(sql, [], timeout);
-    // 设置实例的表名属性，以便后续操作使用
-    this.table = table;
-    return bl;
-  } catch (err) {
-    this.log('error', '创建表失败', err);
-    return 0;
-  }
+  if (!table || typeof table !== 'string') {
+    throw new TypeError('table must be non-empty string');
+  }
+  if (!field) {
+    field = 'id';
+  }
+  // SQLite的自增主键要求字段类型必须是INTEGER（大写且不带长度）
+  let fieldType;
+  if (auto) {
+    // 自增字段使用简单的INTEGER类型，由后面的PRIMARY KEY AUTOINCREMENT决定自增行为
+    fieldType = 'INTEGER';
+  } else {
+    // 非自增字段使用正常的类型设置
+    fieldType = this.setType(field, type, null, true, auto);
+  }
+  // 根据是否自增来构造不同的SQL语句
+  let sqlTemplate;
+  if (auto) {
+    // 自增字段：使用INTEGER PRIMARY KEY AUTOINCREMENT语法
+    sqlTemplate = 'CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY AUTOINCREMENT)';
+  } else {
+    // 非自增字段：使用正常的字段类型和主键定义
+    sqlTemplate = 'CREATE TABLE IF NOT EXISTS `{0}` (`{1}` {2} PRIMARY KEY)';
+  }
+  var sql = sqlTemplate.replace('{0}', table).replace(
+    '{1}', field).replace('{2}', fieldType) + ';';
+  // SQLite不支持表级COMMENT语法，所以忽略commit参数
+  var bl = await this.exec(sql, [], timeout);
+  // 设置实例的表名属性，以便后续操作使用
+  this.table = table;
+  return bl;
 };
 
 /**
@@ -488,36 +467,32 @@ DB.prototype.emptyTable = function (table, timeout = 15000) {
  * @returns {Promise | number} 添加成功返回1，失败返回0
  */
 DB.prototype.addField = async function (field, type, value = '', not_null = true, auto = false, comment = '', timeout = 15000) {
-  try {
-    // 确保表名已设置
-    if (!this.table || !field || !type) {
-      throw new TypeError('table, field, and type must be specified');
-    }
 
-    // 在SQLite中，使用PRAGMA table_info检查表中是否已存在字段
-    var sql = 'PRAGMA table_info(`{0}`)';
-    sql = sql.replace('{0}', this.table);
-    var columns = await this.run(sql, [], timeout);
-    var fieldExists = false;
-    for (var i = 0; i < columns.length; i++) {
-      if (columns[i].name === field) {
-        fieldExists = true;
-        break;
-      }
-    }
+  // 确保表名已设置
+  if (!this.table || !field || !type) {
+    throw new TypeError('table, field, and type must be specified');
+  }
 
-    if (!fieldExists) {
-      var fieldType = this.setType(field, type, value, not_null, auto);
-      var sql = 'ALTER Table `{0}` ADD `{1}` {2}';
-      sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', fieldType) + ';';
-      // SQLite不支持字段级COMMENT语法，所以忽略comment参数
-      return await this.exec(sql, [], timeout);
+  // 在SQLite中，使用PRAGMA table_info检查表中是否已存在字段
+  var sql = 'PRAGMA table_info(`{0}`)';
+  sql = sql.replace('{0}', this.table);
+  var columns = await this.run(sql, [], timeout);
+  var fieldExists = false;
+  for (var i = 0; i < columns.length; i++) {
+    if (columns[i].name === field) {
+      fieldExists = true;
+      break;
     }
-    return 0;
-  } catch (err) {
-    this.log('error', '添加字段失败', err);
-    return 0;
   }
+
+  if (!fieldExists) {
+    var fieldType = this.setType(field, type, value, not_null, auto);
+    var sql = 'ALTER Table `{0}` ADD `{1}` {2}';
+    sql = sql.replace('{0}', this.table).replace('{1}', field).replace('{2}', fieldType) + ';';
+    // SQLite不支持字段级COMMENT语法，所以忽略comment参数
+    return await this.exec(sql, [], timeout);
+  }
+  return 0;
 };
 
 /**
@@ -533,53 +508,49 @@ DB.prototype.addField = async function (field, type, value = '', not_null = true
  * @returns {Promise | number} 修改成功返回1，失败返回0
  */
 DB.prototype.setField = async function (field, type, value = '', not_null = true, auto = false, isKey = false, new_name = '', timeout = 15000) {
-  try {
-    if (!field || !type || !this.table) {
-      throw new TypeError('field, type, and table must be specified');
-    }
 
-    var sql =
-			"select count(*) as `count` from sqlite_master where `type` = 'table' and `name` = '{1}' and `sql` like '%{2}%'";
-    sql = sql.replace('{1}', this.table).replace('{2}', field);
-    var arr = await this.run(sql, [], timeout);
-    if (arr && arr.length > 0) {
-      if (arr[0].count == 0) {
-        return 0;
-      }
-    }
+  if (!field || !type || !this.table) {
+    throw new TypeError('field, type, and table must be specified');
+  }
 
-    var field_type = this.setType(field, type, value, not_null, auto);
-    if (field_type.has('text')) {
-      field_type = field_type.replace('NOT NULL', '').replace("DEFAULT ''", '');
+  var sql =
+    "select count(*) as `count` from sqlite_master where `type` = 'table' and `name` = '{1}' and `sql` like '%{2}%'";
+  sql = sql.replace('{1}', this.table).replace('{2}', field);
+  var arr = await this.run(sql, [], timeout);
+  if (arr && arr.length > 0) {
+    if (arr[0].count == 0) {
+      return 0;
     }
+  }
 
-    if (!new_name) {
-      new_name = field;
-    }
+  var field_type = this.setType(field, type, value, not_null, auto);
+  if (field_type.has('text')) {
+    field_type = field_type.replace('NOT NULL', '').replace("DEFAULT ''", '');
+  }
 
-    sql = 'ALTER TABLE `{0}` ADD COLUMN `{2}` {3}';
-    sql = sql.replace('{0}', this.table).replace('{2}', new_name).replace('{3}', field_type);
-    if (isKey) {
-      sql += ', DROP PRIMARY KEY, ADD PRIMARY KEY (' + new_name + ') USING BTREE;';
-    } else {
-      sql += ';';
-    }
-    await this.exec(sql, [], timeout);
+  if (!new_name) {
+    new_name = field;
+  }
 
-    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);
+  sql = 'ALTER TABLE `{0}` ADD COLUMN `{2}` {3}';
+  sql = sql.replace('{0}', this.table).replace('{2}', new_name).replace('{3}', field_type);
+  if (isKey) {
+    sql += ', DROP PRIMARY KEY, ADD PRIMARY KEY (' + new_name + ') USING BTREE;';
+  } else {
+    sql += ';';
+  }
+  await this.exec(sql, [], timeout);
 
-    if (field !== new_name) {
-      // sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
-      // sql = sql.replace('{0}', this.table).replace('{1}', field);
-      // ret = await this.exec(sql);
-    }
-    return ret;
-  } catch (err) {
-    this.log('error', '修改字段失败', err);
-    return 0;
+  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);
+
+  if (field !== new_name) {
+    // sql = "ALTER TABLE `{0}` DROP COLUMN `{1}`;";
+    // sql = sql.replace('{0}', this.table).replace('{1}', field);
+    // ret = await this.exec(sql);
   }
+  return ret;
 };
 
 /**
@@ -590,18 +561,13 @@ DB.prototype.setField = async function (field, type, value = '', not_null = true
  * @returns {Promise | number} 删除成功返回1，失败返回0
  */
 DB.prototype.delField = async function (table, field, timeout = 15000) {
-  try {
-    if (!table || !field) {
-      throw new TypeError('table and field must be specified');
-    }
-
-    var sql = 'ALTER TABLE {0} DROP COLUMN {1};';
-    sql = sql.replace('{0}', table).replace('{1}', field);
-    return await this.exec(sql, [], timeout);
-  } catch (err) {
-    this.log('error', '删除字段失败', err);
-    return 0;
+  if (!table || !field) {
+    throw new TypeError('table and field must be specified');
   }
+
+  var sql = 'ALTER TABLE {0} DROP COLUMN {1};';
+  sql = sql.replace('{0}', table).replace('{1}', field);
+  return await this.exec(sql, [], timeout);
 };
 
 /**
@@ -650,18 +616,13 @@ DB.prototype.sqlField = function (fd) {
  * @returns {Promise | number} 重命名成功返回1，失败返回0
  */
 DB.prototype.renameField = async function (table, field, new_field, type, timeout = 15000) {
-  try {
-    if (!table || !field || !new_field) {
-      throw new TypeError('table, field, and new_field must be specified');
-    }
-
-    var sql = 'ALTER TABLE {0} RENAME COLUMN {1} TO {2};';
-    sql = sql.replace('{0}', table).replace('{1}', field).replace('{2}', new_field);
-    return await this.exec(sql, [], timeout);
-  } catch (err) {
-    this.log('error', '重命名字段失败', err);
-    return 0;
+  if (!table || !field || !new_field) {
+    throw new TypeError('table, field, and new_field must be specified');
   }
+
+  var sql = 'ALTER TABLE {0} RENAME COLUMN {1} TO {2};';
+  sql = sql.replace('{0}', table).replace('{1}', field).replace('{2}', new_field);
+  return await this.exec(sql, [], timeout);
 };
 
 /**
@@ -731,16 +692,11 @@ DB.prototype.emptyTable = function (table, timeout = 15000) {
  * @returns {Promise | boolean} 存在返回true，不存在返回false
  */
 DB.prototype.hasTable = async function (table, timeout = 15000) {
-  try {
-    if (!table) {
-      return false;
-    }
-    var list = await this.run("SELECT name FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
-    return list && list.length > 0;
-  } catch (err) {
-    this.log('error', '检查表是否存在失败', err);
+  if (!table) {
     return false;
   }
+  var list = await this.run("SELECT name FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
+  return list && list.length > 0;
 };
 
 /**
@@ -751,16 +707,11 @@ DB.prototype.hasTable = async function (table, timeout = 15000) {
  * @returns {Promise | boolean} 存在返回true，不存在返回false
  */
 DB.prototype.hasField = async function (table, field, timeout = 15000) {
-  try {
-    if (!table || !field) {
-      return false;
-    }
-    var fields = await this.fields(table, field, timeout);
-    return fields && fields.some(f => f.name === field);
-  } catch (err) {
-    this.log('error', '检查字段是否存在失败', err);
+  if (!table || !field) {
     return false;
   }
+  var fields = await this.fields(table, field, timeout);
+  return fields && fields.some(f => f.name === field);
 };
 
 /**
@@ -788,16 +739,11 @@ DB.prototype.getCreateTable = async function (table, timeout = 15000) {
   if (!table) {
     throw new TypeError('table must be specified');
   }
-  try {
-    const list = await this.run("SELECT sql FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
-    if (list && list.length > 0) {
-      return list[0].sql || '';
-    }
-    return '';
-  } catch (err) {
-    this.log('error', '获取表结构失败', err);
-    return '';
+  const list = await this.run("SELECT sql FROM sqlite_master WHERE type='table' AND name=?;", [table], timeout);
+  if (list && list.length > 0) {
+    return list[0].sql || '';
   }
+  return '';
 };
 
 /**
@@ -811,51 +757,46 @@ DB.prototype.getTableData = async function (table, batch_size = 100, timeout = 6
   if (!table) {
     throw new TypeError('table must be specified');
   }
-  try {
-    // 获取表数据
-    const rows = await this.run(`SELECT * FROM \`${table}\``, [], timeout);
-    let sql = '';
-
-    if (rows && rows.length > 0) {
-      sql += `-- 表数据: ${table}\n`;
-
-      // 批量处理大数据量
-      for (let j = 0; j < rows.length; j += batch_size) {
-        const batch = rows.slice(j, j + batch_size);
-        for (const row of batch) {
-          try {
-            const row_data = Object.values(row)
-              .map(value => {
-                if (value === null) return 'NULL';
-                if (typeof value === 'boolean') return value ? 1 : 0;
-                if (typeof value === 'number') return value;
-                if (value instanceof Date) {
-                  return "'" + value.toISOString().slice(0, 19).replace('T', ' ') + "'";
-                }
-                // 处理字符串，转义特殊字符
-                if (typeof value === 'string') {
-                  return "'" + value
-                    .replace(/[\\']/g, '\\$&')
-                    .replace(/\n/g, '\\n')
-                    .replace(/\r/g, '\\r')
-                    .replace(/\t/g, '\\t')
-                    .replace(/\u0000/g, '\\0') + "'";
-                }
-                return "'" + String(value || '') + "'";
-              }).join(',');
-            sql += `INSERT INTO \`${table}\` VALUES (${row_data});\n`;
-          } catch (rowErr) {
-            this.log('error', '处理行数据失败', rowErr);
-          }
+  // 获取表数据
+  const rows = await this.run(`SELECT * FROM \`${table}\``, [], timeout);
+  let sql = '';
+
+  if (rows && rows.length > 0) {
+    sql += `-- 表数据: ${table}\n`;
+
+    // 批量处理大数据量
+    for (let j = 0; j < rows.length; j += batch_size) {
+      const batch = rows.slice(j, j + batch_size);
+      for (const row of batch) {
+        try {
+          const row_data = Object.values(row)
+            .map(value => {
+              if (value === null) return 'NULL';
+              if (typeof value === 'boolean') return value ? 1 : 0;
+              if (typeof value === 'number') return value;
+              if (value instanceof Date) {
+                return "'" + value.toISOString().slice(0, 19).replace('T', ' ') + "'";
+              }
+              // 处理字符串，转义特殊字符
+              if (typeof value === 'string') {
+                return "'" + value
+                  .replace(/[\\']/g, '\\$&')
+                  .replace(/\n/g, '\\n')
+                  .replace(/\r/g, '\\r')
+                  .replace(/\t/g, '\\t')
+                  .replace(/\u0000/g, '\\0') + "'";
+              }
+              return "'" + String(value || '') + "'";
+            }).join(',');
+          sql += `INSERT INTO \`${table}\` VALUES (${row_data});\n`;
+        } catch (rowErr) {
+          this.log('error', '处理行数据失败', rowErr);
         }
       }
-      sql += '\n';
     }
-    return sql;
-  } catch (err) {
-    this.log('error', '获取表数据失败', err);
-    return '';
+    sql += '\n';
   }
+  return sql;
 };
 
 /**
@@ -866,15 +807,10 @@ DB.prototype.getTableData = async function (table, batch_size = 100, timeout = 6
  * @returns {Promise | number} 操作结果
  */
 DB.prototype.backup = function (table, backup, timeout = 60000) {
-  try {
-    if (!table || !backup) {
-      throw new TypeError('table and backup must be specified');
-    }
-    return this.backupTable(table, backup, timeout);
-  } catch (err) {
-    this.log('error', '备份表失败', err);
-    return 0;
+  if (!table || !backup) {
+    throw new TypeError('table and backup must be specified');
   }
+  return this.backupTable(table, backup, timeout);
 };
 
 /**