mm_sql 1.3.9 → 1.4.0

package/README.md

@@ -1,6 +1,6 @@
 # mm_sql
 
-一个通用的SQL帮助类，支持通过切换db_type实现对不同数据库的操作，包括MySQL和SQLite等，提供统一的API接口，支持异步操作、事务处理和批量操作。
+一个通用的SQL帮助类，支持通过切换db_type实现对不同数据库的操作，包括MySQL和SQLite等，提供统一的API接口，支持异步操作和基础SQL执行。
 
 ## 安装
 
@@ -23,19 +23,22 @@ const { Sql } = require('mm_sql');
 
 // 创建实例（默认使用MySQL）
 const sql = new Sql({
+  db_type: 'mysql',
   host: 'localhost',
   port: 3306,
   user: 'root',
   password: 'password',
-  database: 'test_db',
-  table: 'users'
+  database: 'test_db'
 });
 
-// 直接使用（自动初始化连接）
-const users = await sql.get({ status: 1 }, 'created_at DESC');
+// 执行查询SQL
+const users = await sql.run('SELECT * FROM users WHERE status = 1');
+
+// 执行更新SQL
+const result = await sql.exec('UPDATE users SET status = 0 WHERE id = 1');
 
-// 销毁连接
-await sql.destroy();
+// 关闭连接
+await sql.close();
 ```
 
 ### 2. 切换数据库类型
@@ -47,135 +50,95 @@ const sql = new Sql({
   host: 'localhost',
   user: 'root',
   password: 'password',
-  database: 'mysql_db',
-  table: 'users'
+  database: 'mysql_db'
 });
 
 // 切换到SQLite
-const sqliteSql = sql.use('sqlite', {
+sql.setConfig({
+  db_type: 'sqlite',
   dir: '/db/',
-  database: 'sqlite.db',
-  table: 'users'
+  database: 'sqlite.db'
 });
 
-// 使用SQLite进行操作（自动初始化连接）
-const data = await sqliteSql.get({});
+// 使用SQLite进行操作
+const data = await sql.run('SELECT * FROM users');
 ```
 
 ### 3. 主要方法
 
-#### 查询方法
+#### SQL执行方法
 
 ```javascript
-// 查询多条数据
-const list = await sql.get({ status: 1 }, 'id DESC');
-
-// 查询单条数据
-const user = await sql.getObj({ id: 1 });
-
-// 分页查询
-const result = await sql.getCount(
-  { status: 1 },
-  'created_at DESC',
-  'id, name, email'
-);
-// result结构: { list: [...], total: 100, page: 1, size: 20, pages: 5 }
-
-// 统计
-const count = await sql.count({ status: 1 });
-```
+// 执行查询操作（返回结果集）
+const users = await sql.run('SELECT * FROM users WHERE status = 1');
 
-#### 增删改方法
-
-```javascript
-// 添加数据
-const addResult = await sql.add({
-  name: '张三',
-  age: 25,
-  status: 1
-});
+// 执行带参数的查询
+const user = await sql.run('SELECT * FROM users WHERE id = ?', [1]);
 
-// 修改数据
-const updateResult = await sql.set(
-  { id: 1 }, // 查询条件
-  { name: '李四', age: 26 } // 更新字段
-);
-
-// 使用where属性修改数据
-const updateResult2 = await sql.set({
-  where: { id: 1 },
-  name: '李四',
-  age: 26
-});
+// 执行带超时的查询
+const timeoutResult = await sql.run('SELECT * FROM users WHERE status = 1', [], 5000);
 
-// 删除数据
-const deleteResult = await sql.del({ id: 1 });
+// 执行修改操作（返回影响行数）
+const updateResult = await sql.exec('UPDATE users SET status = 0 WHERE id = 1');
 
-// 添加或修改（如果存在则修改，不存在则添加）
-const addOrSetResult = await sql.addOrSet(
-  { id: 1 }, // 查询条件
-  { name: '王五', age: 27 } // 要设置的字段
-);
-```
+// 执行带参数的修改
+const updateWithParams = await sql.exec('UPDATE users SET name = ? WHERE id = ?', ['张三', 1]);
 
-#### 批量操作
+// 执行带超时的修改
+const timeoutExec = await sql.exec('DELETE FROM users WHERE status = 0', [], 3000);
 
-```javascript
-// 批量添加
-const addListResult = await sql.addList([
-  { name: '用户1', status: 1 },
-  { name: '用户2', status: 1 }
-]);
-
-// 批量修改
-const setListResult = await sql.setList([
-  { query: { id: 1 }, item: { status: 0 } },
-  { query: { id: 2 }, item: { status: 0 } }
-]);
-
-// 批量删除
-const delListResult = await sql.delList([
-  { query: { id: 1 } },
-  { query: { id: 2 } }
-]);
+// 使用对象参数方式调用
+const result = await sql.run({
+  sql: 'SELECT * FROM users WHERE name LIKE ?',
+  params: ['张%'],
+  timeout: 5000
+});
 ```
 
-#### 字段操作方法
+#### 连接管理方法
 
 ```javascript
-// 添加字段
-await sql.addField('phone', 'varchar(20)', '');
-
-// 修改字段
-await sql.setField('phone', 'varchar(11)', '0');
+// 手动打开数据库连接
+await sql.open();
 
-// 删除字段
-await sql.delField('phone');
+// 手动关闭数据库连接
+await sql.close();
 
-// 重命名字段
-await sql.renameField('old_name', 'new_name');
-
-// 编辑字段（高级）
-await sql.editField('field_name', 'varchar(100)', 'NOT NULL DEFAULT \'\'');
+// 动态修改配置
+sql.setConfig({
+  host: 'new_host',
+  database: 'new_database'
+});
 ```
 
-#### 表操作方法
+#### 模板方法
 
 ```javascript
-// 检查表是否存在
-const exists = await sql.hasTable();
+// SQL模板查询生成
+const query = sql.tplQuery({ name: '张', age: 20 }, {
+  name: '`name` LIKE "{0}%"',
+  age: '`age` > {0}'
+});
+// 生成: "`name` LIKE \"张%\" AND `age` > 20"
 
-// 创建表
-await sql.addTable('new_table', {
-  id: 'INTEGER PRIMARY KEY AUTOINCREMENT',
-  name: 'varchar(255) NOT NULL DEFAULT \'\'
+// SQL模板数据生成
+const body = sql.tplBody({ name: '李四', age: 25 }, {
+  name: '`name` = {0}',
+  age: '`age` = {0}'
 });
+// 生成: "`name` = '李四', `age` = 25"
+
+// 参数过滤
+const filteredParams = sql.filter({ id: 1, name: '张三', password: '123' }, ['password']);
+// 结果: { id: 1, name: '张三' }
+```
 
-// 删除表
-await sql.delTable();
+#### 数据库适配器方法
 
-// 备份表
-await sql.backupTable('backup_table');
+```javascript
+// 获取底层数据库适配器
+const dbAdapter = sql.db();
+// 可用于直接操作底层数据库接口
 ```
 
 ### 4. 配置选项
@@ -185,14 +148,8 @@ const sql = new Sql({
   // 数据库类型
   db_type: 'mysql', // 可选值: 'mysql', 'sqlite'
   
-  // 表相关配置
-  table: 'users', // 表名
-  key: 'id', // 主键
-  
-  // 分页配置
-  page: 1, // 默认页码
-  size: 20, // 默认每页数量
-  limit: 1000, // 最大查询数量
+  // 作用域配置
+  scope: 'sys', // 默认作用域
   
   // MySQL配置
   host: 'localhost',
@@ -200,59 +157,13 @@ const sql = new Sql({
   user: 'root',
   password: '',
   database: '',
-  charset: 'utf8mb4',
-  connect_timeout: 10000, // 连接超时时间（毫秒）
-  query_timeout: 30000, // 查询超时时间（毫秒）
   
   // SQLite配置
   dir: '/db/', // SQLite数据库文件存储目录
-  database: 'db.sqlite', // SQLite数据库文件名
-  
-  // 其他配置
-  filter: {}, // 过滤参数
-  separator: '|', // 分隔符，用于多条件查询
-  way: 'add del set get', // 请求方式
-  field_hide: ['*password*', '*token*'] // 隐藏字段
+  database: 'db.sqlite' // SQLite数据库文件名
 });
 ```
 
-## 事务操作
-
-```javascript
-// 使用事务方法
-await sql.start(); // 开始事务
-
-try {
-  // 在事务中执行操作
-  await sql.add({ name: '测试用户1', age: 30 });
-  await sql.add({ name: '测试用户2', age: 25 });
-  
-  await sql.commit(); // 提交事务
-} catch (error) {
-  await sql.back(); // 回滚事务
-  console.error('事务执行失败:', error);
-} finally {
-  await sql.end(); // 结束事务
-}
-
-// 直接执行事务SQL（MySQL）
-const mysqlTransactionResult = await sql.exec(`
-  START TRANSACTION;
-  INSERT INTO users (name, age) VALUES ('测试用户', 30);
-  UPDATE users SET status = 1 WHERE id = LAST_INSERT_ID();
-  COMMIT;
-`);
-
-// 直接执行事务SQL（SQLite）
-const sqliteTransactionResult = await sql.exec(`
-  BEGIN TRANSACTION;
-  INSERT INTO users (name, age) VALUES ('测试用户', 30);
-  UPDATE users SET status = 1 WHERE id = last_insert_rowid();
-  COMMIT;
-`);
-
-// 注意：不同数据库的事务语法和函数可能有所不同，请根据实际使用的数据库类型调整SQL语句
-
 ## 高级用法
 
 ### 1. SQL模板
@@ -307,20 +218,96 @@ const user = await sql.run('SELECT * FROM users WHERE id = ?', [1]);
 // 执行带超时的SQL
 const timeoutResult = await sql.run('SELECT * FROM users WHERE status = 1', [], 5000);
 
+// 执行事务操作（MySQL）
+const mysqlTransactionResult = await sql.exec(`
+  START TRANSACTION;
+  INSERT INTO users (name, age) VALUES ('测试用户', 30);
+  UPDATE users SET status = 1 WHERE id = LAST_INSERT_ID();
+  COMMIT;
+`);
+
+// 执行事务操作（SQLite）
+const sqliteTransactionResult = await sql.exec(`
+  BEGIN TRANSACTION;
+  INSERT INTO users (name, age) VALUES ('测试用户', 30);
+  UPDATE users SET status = 1 WHERE id = last_insert_rowid();
+  COMMIT;
+`);
+```
+
 ## 注意事项
 
-1. 可以直接使用方法，系统会自动初始化连接，无需手动调用`init()`方法
-2. 使用完成后建议调用`destroy()`方法销毁连接，避免资源泄漏
+1. 系统会自动初始化连接，无需手动调用初始化方法
+2. 使用完成后建议调用`close()`方法关闭连接，避免资源泄漏
 3. 切换数据库类型时会重新创建适配器，原来的连接会被关闭
-4. 为提高性能，系统会缓存数据库适配器，相同配置的实例会复用适配器
-5. 不同数据库的SQL语法可能有所差异，请根据实际使用的数据库类型调整SQL语句
-6. 事务操作中，建议使用`start()`/`commit()`/`back()`/`end()`方法，确保事务正确处理
+4. 不同数据库的SQL语法可能有所差异，请根据实际使用的数据库类型调整SQL语句
+5. 事务操作需要根据具体数据库类型使用相应的SQL语法
+6. 错误处理：所有方法都包含错误处理，会记录错误日志并抛出异常
+
+## 错误处理
+
+```javascript
+try {
+  const result = await sql.run('SELECT * FROM non_existent_table');
+} catch (error) {
+  console.error('SQL执行失败:', error);
+  // 错误信息会被自动记录到日志
+}
+```
 
 ## 支持的数据库类型
 
 - MySQL
 - SQLite
 
+## API参考
+
+### Sql类
+
+#### constructor(config)
+创建Sql实例
+- `config`: 配置对象
+
+#### run(sql, params, timeout)
+执行查询SQL
+- `sql`: SQL语句或选项对象
+- `params`: 参数数组（可选）
+- `timeout`: 超时时间（毫秒，可选）
+
+#### exec(sql, params, timeout)
+执行修改SQL
+- `sql`: SQL语句或选项对象
+- `params`: 参数数组（可选）
+- `timeout`: 超时时间（毫秒，可选）
+
+#### open()
+手动打开数据库连接
+
+#### close()
+手动关闭数据库连接
+
+#### setConfig(config)
+动态修改配置
+- `config`: 新的配置对象
+
+#### tplQuery(paramDt, sqlDt)
+生成SQL查询条件
+- `paramDt`: 参数对象
+- `sqlDt`: SQL模板对象
+
+#### tplBody(paramDt, sqlDt)
+生成SQL数据部分
+- `paramDt`: 参数对象
+- `sqlDt`: SQL模板对象
+
+#### filter(paramDt, arr)
+过滤参数对象
+- `paramDt`: 参数对象
+- `arr`: 需要过滤的键数组
+
+#### db()
+获取底层数据库适配器
+
 ## 许可证
 
-MIT
+MIT

package/index.js

@@ -1,6 +1,6 @@
 /**
  * @fileOverview SQL通用类
- * @author <a href="http://qww.elins.cn">邱文武</a>
+ * @author <a href="http://qww.elins.cn">qww</a>
  * @version 1.0
  */
 
@@ -77,15 +77,32 @@ Sql.prototype._createSqlAdapter = function () {
  * @param {Array} params - 参数数组
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise} 查询结果
+ * @throws {TypeError} 当sql参数无效时
  */
 Sql.prototype.run = function (sql, params = [], timeout = null) {
-	// 支持两种调用方式：run(sql, params, timeout) 或 run({sql: '', params: []})
-	if (typeof sql === 'object') {
-		params = sql.params || [];
-		timeout = sql.timeout || null;
-		sql = sql.sql || '';
-	}
-	return this._adapter.run(sql, params, timeout);
+    // 参数校验
+    if (typeof sql !== 'string' && typeof sql !== 'object') {
+        throw new TypeError('sql must be string or object');
+    }
+    if (!Array.isArray(params)) {
+        throw new TypeError('params must be array');
+    }
+    if (timeout !== null && typeof timeout !== 'number') {
+        throw new TypeError('timeout must be number or null');
+    }
+    
+    try {
+        // 支持两种调用方式：run(sql, params, timeout) 或 run({sql: '', params: []})
+        if (typeof sql === 'object') {
+            params = sql.params || [];
+            timeout = sql.timeout || null;
+            sql = sql.sql || '';
+        }
+        return this._adapter.run(sql, params, timeout);
+    } catch (error) {
+        this.logger('error', 'SQL查询执行失败', error);
+        throw error;
+    }
 };
 
 /**
@@ -94,15 +111,32 @@ Sql.prototype.run = function (sql, params = [], timeout = null) {
  * @param {Array} params - 参数数组
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise} 修改结果
+ * @throws {TypeError} 当sql参数无效时
  */
 Sql.prototype.exec = function (sql, params = [], timeout = null) {
-	// 支持两种调用方式：exec(sql, params, timeout) 或 exec({sql: '', params: []})
-	if (typeof sql === 'object') {
-		params = sql.params || [];
-		timeout = sql.timeout || null;
-		sql = sql.sql || '';
-	}
-	return this._adapter.exec(sql, params, timeout);
+    // 参数校验
+    if (typeof sql !== 'string' && typeof sql !== 'object') {
+        throw new TypeError('sql must be string or object');
+    }
+    if (!Array.isArray(params)) {
+        throw new TypeError('params must be array');
+    }
+    if (timeout !== null && typeof timeout !== 'number') {
+        throw new TypeError('timeout must be number or null');
+    }
+    
+    try {
+        // 支持两种调用方式：exec(sql, params, timeout) 或 exec({sql: '', params: []})
+        if (typeof sql === 'object') {
+            params = sql.params || [];
+            timeout = sql.timeout || null;
+            sql = sql.sql || '';
+        }
+        return this._adapter.exec(sql, params, timeout);
+    } catch (error) {
+        this.logger('error', 'SQL修改执行失败', error);
+        return 0;
+    }
 };
 
 /**
@@ -110,7 +144,12 @@ Sql.prototype.exec = function (sql, params = [], timeout = null) {
  * @returns {Promise} 连接结果
  */
 Sql.prototype.open = function () {
-	return this._adapter.open();
+    try {
+        return this._adapter.open();
+    } catch (error) {
+        this.logger('error', '数据库连接打开失败', error);
+        return null;
+    }
 };
 
 /**
@@ -118,58 +157,30 @@ Sql.prototype.open = function () {
  * @returns {Promise} 关闭结果
  */
 Sql.prototype.close = function () {
-	return this._adapter.close();
+    try {
+        return this._adapter.close();
+    } catch (error) {
+        this.logger('error', '数据库连接关闭失败', error);
+    }
 };
 
 /**
  * 设置配置
  * @param {Object} config - 配置对象
+ * @throws {TypeError} 当config参数无效时
  */
 Sql.prototype.setConfig = function (config) {
-	this.config = Object.assign(this.config, config);
-	this._init();
-};
-
-/**
- * 获取连接信息
- * @returns {Object} 连接信息
- */
-Sql.prototype.getConnectionInfo = function () {
-	// 确保返回包含必要字段的连接信息
-	return {
-		db_type: this.config.db_type,
-		host: this.config.host || 'localhost',
-		port: this.config.port || 3306,
-        dir: this.config.dir || '/db/',
-		database: this.config.database || ''
-	};
-};
-
-/**
- * 检查数据库连接状态
- * @returns {Boolean} 连接状态
- */
-Sql.prototype.isConnected = function () {
-	// 简单实现，返回true表示连接正常
-	return true;
-};
-
-/**
- * 获取标识符
- * @private
- * @param {String} name - 名称
- * @returns {String} 标识符
- */
-Sql.prototype._getIdentifier = function (name) {
-	const dbType = this.config.db_type;
-	switch (dbType) {
-		case 'mysql':
-			return `\`${name}\``;
-		case 'sqlite':
-			return `"${name}"`;
-		default:
-			return name;
-	}
+    // 参数校验
+    if (!config || typeof config !== 'object') {
+        throw new TypeError('config must be object');
+    }
+    
+    try {
+        this.config = Object.assign(this.config, config);
+        this._init();
+    } catch (error) {
+        this.logger('error', '配置设置失败', error);
+    }
 };
 
 /**
@@ -177,22 +188,36 @@ Sql.prototype._getIdentifier = function (name) {
  * @param {Object} paramDt - 参数对象
  * @param {Object} sqlDt - SQL模板对象
  * @returns {Object} 查询结果对象
+ * @throws {TypeError} 当参数对象无效时
  */
 Sql.prototype.tplQuery = function (paramDt, sqlDt) {
-	let sql = '';
-	
-	for (const key in paramDt) {
-		if (sqlDt[key]) {
-			// 替换占位符{0}为参数值
-			const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
-			sql += 'AND ' + sqlSegment + ' ';
-		}
-        else {
-            sql += 'AND `' + key + "` = '" + paramDt[key] + "'";
+    // 参数校验
+    if (!paramDt || typeof paramDt !== 'object') {
+        throw new TypeError('paramDt must be object');
+    }
+    if (!sqlDt || typeof sqlDt !== 'object') {
+        throw new TypeError('sqlDt must be object');
+    }
+    
+    try {
+        let sql = '';
+        
+        for (const key in paramDt) {
+            if (sqlDt[key]) {
+                // 替换占位符{0}为参数值
+                const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
+                sql += 'AND ' + sqlSegment + ' ';
+            }
+            else {
+                sql += 'AND `' + key + "` = '" + paramDt[key] + "'";
+            }
         }
-	}
-	
-	return sql.replace('AND ', '');
+        
+        return sql.replace('AND ', '');
+    } catch (error) {
+        this.logger('error', '模板查询生成失败', error);
+        return '';
+    }
 };
 
 /**
@@ -200,22 +225,36 @@ Sql.prototype.tplQuery = function (paramDt, sqlDt) {
  * @param {Object} paramDt - 参数对象
  * @param {Object} sqlDt - SQL模板对象
  * @returns {Object} 查询结果对象
+ * @throws {TypeError} 当参数对象无效时
  */
 Sql.prototype.tplBody = function (paramDt, sqlDt) {
-	let sql = '';
-		
-	for (const key in paramDt) {
-		if (sqlDt[key]) {
-			// 替换占位符{0}为参数值
-			const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
-			sql += ', ' + sqlSegment + ' ';
-		}
-        else {
-            sql += ', `' + key + "` = '" + paramDt[key] + "'";
+    // 参数校验
+    if (!paramDt || typeof paramDt !== 'object') {
+        throw new TypeError('paramDt must be object');
+    }
+    if (!sqlDt || typeof sqlDt !== 'object') {
+        throw new TypeError('sqlDt must be object');
+    }
+    
+    try {
+        let sql = '';
+                
+        for (const key in paramDt) {
+            if (sqlDt[key]) {
+                // 替换占位符{0}为参数值
+                const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
+                sql += ', ' + sqlSegment + ' ';
+            }
+            else {
+                sql += ', `' + key + "` = '" + paramDt[key] + "'";
+            }
         }
-	}
-	
-	return sql.replace(', ', '');
+        
+        return sql.replace(', ', '');
+    } catch (error) {
+        this.logger('error', '模板数据生成失败', error);
+        return '';
+    }
 };
 
 /**
@@ -223,14 +262,28 @@ Sql.prototype.tplBody = function (paramDt, sqlDt) {
  * @param {Object} paramDt - 参数对象
  * @param {Array} arr - 过滤数组
  * @returns {Object} 过滤后的参数对象
+ * @throws {TypeError} 当参数对象无效时
  */
 Sql.prototype.filter = function (paramDt, arr) {
-	for (const key in paramDt) {
-		if (arr.includes(key)) {
-            delete paramDt[key];
-		}
-	}
-	return paramDt;
+    // 参数校验
+    if (!paramDt || typeof paramDt !== 'object') {
+        throw new TypeError('paramDt must be object');
+    }
+    if (!Array.isArray(arr)) {
+        throw new TypeError('arr must be array');
+    }
+    
+    try {
+        for (const key in paramDt) {
+            if (arr.includes(key)) {
+                delete paramDt[key];
+            }
+        }
+        return paramDt;
+    } catch (error) {
+        this.logger('error', '参数过滤失败', error);
+        return {};
+    }
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_sql",
-  "version": "1.3.9",
+  "version": "1.4.0",
   "description": "一个通用的SQL帮助类，支持通过切换db_type实现对不同数据库的操作，包括MySQL和SQLite等",
   "main": "index.js",
   "scripts": {
@@ -41,7 +41,7 @@
     "node": ">=12.0.0"
   },
   "dependencies": {
-    "mm_mysql": "^2.2.0",
-    "mm_sqlite": "^1.1.4"
+    "mm_mysql": "^2.2.5",
+    "mm_sqlite": "^1.2.2"
   }
 }

package/test.js

@@ -1,4 +1,4 @@
-const {Sql} = require('./index.js');
+const { Sql } = require('./index.js');
 
 /**
  * @description Sql类测试
@@ -18,7 +18,9 @@ class SqlTest {
     async init() {
         try {
             this.sql = new Sql({
-                db_type: 'mysql',
+                // db_type: 'mysql',
+                db_type: 'sqlite',
+                dir: './db',
                 host: 'localhost',
                 user: 'root',
                 password: 'Asd159357',
@@ -39,7 +41,7 @@ class SqlTest {
         this.testCount++;
         try {
             // 测试setConfig方法
-            this.sql.setConfig({size: 50});
+            this.sql.setConfig({ size: 50 });
             if (this.sql.config.size !== 50) {
                 throw new Error('setConfig方法测试失败');
             }
@@ -68,67 +70,6 @@ class SqlTest {
         }
     }
 
-
-
-    /**
-     * @description 测试标识符处理方法
-     */
-    testIdentifierMethod() {
-        this.testCount++;
-        try {
-            // 测试MySQL标识符
-            this.sql.config.db_type = 'mysql';
-            const mysqlId = this.sql._getIdentifier('test_table');
-            if (mysqlId !== '`test_table`') {
-                throw new Error('MySQL标识符处理失败');
-            }
-
-            // 测试SQLite标识符
-            this.sql.config.db_type = 'sqlite';
-            const sqliteId = this.sql._getIdentifier('test_table');
-            if (sqliteId !== '"test_table"') {
-                throw new Error('SQLite标识符处理失败');
-            }
-
-            // 恢复默认数据库类型
-            this.sql.config.db_type = 'mysql';
-
-            console.log('标识符处理方法测试成功');
-            this.successCount++;
-            return true;
-        } catch (error) {
-            console.error('标识符处理方法测试失败:', error.message);
-            return false;
-        }
-    }
-
-    /**
-     * @description 测试连接状态方法
-     */
-    testConnectionMethods() {
-        this.testCount++;
-        try {
-            // 测试isConnected方法
-            const connected = this.sql.isConnected();
-            if (typeof connected !== 'boolean') {
-                throw new Error('isConnected方法返回值类型错误');
-            }
-
-            // 测试getConnectionInfo方法
-            const connInfo = this.sql.getConnectionInfo();
-            if (!connInfo.db_type || !connInfo.host) {
-                throw new Error('getConnectionInfo方法返回值不完整');
-            }
-
-            console.log('连接状态方法测试成功');
-            this.successCount++;
-            return true;
-        } catch (error) {
-            console.error('连接状态方法测试失败:', error.message);
-            return false;
-        }
-    }
-
     /**
      * @description 测试模板查询方法
      */
@@ -243,7 +184,27 @@ class SqlTest {
             if (!dbInstance) {
                 throw new Error('db方法返回值无效');
             }
-
+            dbInstance.createTable("user_account", {
+                user_id: 1,
+                username: "",
+                password: "",
+                gm: 1,
+                vip: 0
+            }, "user_id").then(() => {
+                console.log('创建表成功');
+            }).catch((error) => {
+                console.error('创建表失败:', error);
+            });
+            dbInstance.fields("user_account").then((result) => {
+                console.log('查询字段:', result);
+            });
+            dbInstance.table = "user_account";
+            dbInstance.get({
+                user_id: "1"
+            }).then((result) => {
+                console.log('查询结果:', result);
+            });
+            console.log('调试DB：查询方法测试完成后', dbInstance.sql, dbInstance.error);
             console.log('核心方法测试成功');
             this.successCount++;
             return true;
@@ -273,10 +234,6 @@ class SqlTest {
         console.log('调试：配置方法测试完成后');
         this.testSqlBuilderMethods();
         console.log('调试：SQL构建方法测试完成后');
-        this.testIdentifierMethod();
-        console.log('调试：标识符处理方法测试完成后');
-        this.testConnectionMethods();
-        console.log('调试：连接状态方法测试完成后');
         this.testTemplateMethods();
         console.log('调试：模板查询方法测试完成后');
         this.testCoreMethods();
@@ -284,7 +241,7 @@ class SqlTest {
 
         console.log('='.repeat(50));
         console.log(`测试完成: ${this.successCount}/${this.testCount} 个测试通过`);
-        
+
         if (this.successCount === this.testCount) {
             console.log('所有测试通过！');
             return true;

package/test2.js

@@ -1,10 +1,9 @@
 const { Sql } = require('./index.js');
-require('mm_logs');
 async function test() {
     var sql = new Sql({
         // 数据库类型 mysql, sqlite, postgres
         db_type: 'sqlite',
-        dir: "/db/".fullname() + "/",
+        dir: "/db/",
         user: 'root',
         password: 'Asd159357',
         database: 'mm'
@@ -20,8 +19,8 @@ async function test() {
     console.log("添加表结果:", res);
     
     // 添加字段（不需要指定表名，因为已通过db.table设置）
-    var res2 = await db.addField('vip', 'INT', '0');
-    var res3 = await db.addField('gm', 'INT', '0');
+    var res2 = await db.addField('age', 'INT', '0');
+    var res3 = await db.addField('sex', 'INT', '0');
     console.log("添加字段结果:", res2, res3);
     db.key = "user_id";
     var user = await db.getObj({

package//345/205/274/345/256/271/346/200/247/346/212/245/345/221/212.md

@@ -1,202 +0,0 @@
-# mm_sqlite与mm_mysql模块兼容性报告
-
-## 📊 总体兼容性评估
-
-**兼容性等级：✅ 高度兼容 (95%兼容)**
-
-mm_sqlite和mm_mysql模块在设计上保持了高度的一致性，核心API接口完全兼容，可以在大多数场景下无缝切换使用。
-
-## 🔄 核心功能兼容性对比
-
-### ✅ **完全兼容的功能 (100%兼容)**
-
-| 功能类别 | 具体功能 | mm_sqlite | mm_mysql | 兼容性 |
-|---------|---------|-----------|----------|--------|
-| **基础CRUD** | add/set/get/del | ✅ | ✅ | ✅ |
-| **SQL执行** | run/exec | ✅ | ✅ | ✅ |
-| **事务管理** | beginTransaction/commit/rollback | ✅ | ✅ | ✅ |
-| **批量操作** | batchInsert/batchUpdate | ✅ | ✅ | ✅ |
-| **查询构建** | 条件查询/排序/分页 | ✅ | ✅ | ✅ |
-| **连接管理** | init/open/close/destroy | ✅ | ✅ | ✅ |
-| **DB管理器** | db()方法返回DB实例 | ✅ | ✅ | ✅ |
-
-### ⚠️ **部分兼容的功能 (90%兼容)**
-
-| 功能类别 | 差异说明 | 影响程度 |
-|---------|---------|----------|
-| **数据类型** | SQLite支持的数据类型较少 | 低 |
-| **事务语法** | 具体SQL语法略有差异 | 低 |
-| **连接池** | SQLite为文件数据库，连接池实现不同 | 中 |
-| **性能优化** | 索引、查询优化策略不同 | 中 |
-
-### ❌ **不兼容的功能 (5%不兼容)**
-
-| 功能类别 | 差异说明 | 解决方案 |
-|---------|---------|----------|
-| **存储过程** | SQLite不支持存储过程 | 使用应用层逻辑替代 |
-| **触发器语法** | 具体语法差异 | 需要调整SQL语句 |
-| **外键约束** | 实现方式和语法不同 | 需要调整表结构设计 |
-
-## 🔧 具体兼容性分析
-
-### 1. API接口兼容性
-
-```javascript
-// ✅ 完全相同的使用方式
-const mysql = new Mysql(config);
-const sqlite = new Sqlite(config);
-
-// ✅ 相同的初始化流程
-await mysql.init();
-await sqlite.init();
-
-// ✅ 相同的CRUD操作
-await mysql.add({name: 'test'});
-await sqlite.add({name: 'test'});
-
-// ✅ 相同的查询操作
-const result1 = await mysql.get({status: 1});
-const result2 = await sqlite.get({status: 1});
-```
-
-### 2. 配置参数兼容性
-
-```javascript
-// ✅ 核心配置参数相同
-const config = {
-  host: 'localhost',      // ✅ 兼容
-  port: 3306,            // ✅ 兼容 (SQLite忽略端口)
-  user: 'root',          // ✅ 兼容 (SQLite忽略用户)
-  password: '123456',    // ✅ 兼容 (SQLite忽略密码)
-  database: 'test_db',   // ✅ 兼容
-  table: 'users'         // ✅ 兼容
-};
-```
-
-### 3. SQL语法兼容性
-
-```javascript
-// ✅ 基础SQL语法兼容
-await mysql.run('SELECT * FROM users WHERE id = ?', [1]);
-await sqlite.run('SELECT * FROM users WHERE id = ?', [1]);
-
-// ⚠️ 高级SQL功能差异
-// MySQL特有功能（SQLite不支持）
-await mysql.run('CALL stored_procedure(?)', [param]);
-
-// SQLite特有功能（MySQL不支持）
-await sqlite.run('PRAGMA table_info(users)');
-```
-
-## 🚀 迁移建议
-
-### 1. 从mm_mysql迁移到mm_sqlite
-
-```javascript
-// 原MySQL代码
-const mysql = new Mysql(mysqlConfig);
-await mysql.init();
-
-// 迁移到SQLite（只需修改构造函数）
-const sqlite = new Sqlite(sqliteConfig);
-await sqlite.init();
-
-// 其他业务代码无需修改
-```
-
-### 2. 从mm_sqlite迁移到mm_mysql
-
-```javascript
-// 原SQLite代码
-const sqlite = new Sqlite(sqliteConfig);
-await sqlite.init();
-
-// 迁移到MySQL（只需修改构造函数）
-const mysql = new Mysql(mysqlConfig);
-await mysql.init();
-
-// 其他业务代码无需修改
-```
-
-### 3. 双数据库支持的最佳实践
-
-```javascript
-// 使用环境变量动态选择数据库类型
-const dbType = process.env.DB_TYPE || 'mysql';
-
-let db;
-if (dbType === 'mysql') {
-  db = new Mysql(mysqlConfig);
-} else {
-  db = new Sqlite(sqliteConfig);
-}
-
-await db.init();
-// 后续代码完全一致
-```
-
-## 📋 兼容性检查清单
-
-### ✅ 可以直接迁移的功能
-- [x] 基础CRUD操作
-- [x] 简单查询和条件过滤
-- [x] 事务管理
-- [x] 分页查询
-- [x] 排序功能
-- [x] 字段选择
-- [x] 连接管理
-
-### ⚠️ 需要检查的功能
-- [ ] 存储过程和函数
-- [ ] 复杂的外键约束
-- [ ] 数据库特定的优化提示
-- [ ] 数据类型转换逻辑
-- [ ] 批量操作的性能表现
-
-### ❌ 需要重写的功能
-- [ ] 数据库特定的存储过程
-- [ ] 依赖于特定数据库引擎的功能
-- [ ] 性能敏感的复杂查询
-
-## 🎯 总结
-
-**mm_sqlite和mm_mysql模块在核心功能上保持了95%的兼容性**，这使得：
-
-1. **开发效率高**：可以在不同数据库间快速切换
-2. **维护成本低**：统一的API接口减少学习成本
-3. **测试覆盖广**：相同的测试用例可以覆盖多种数据库
-4. **部署灵活**：根据环境需求选择适合的数据库
-
-**推荐使用场景**：
-- 新项目开发：优先选择mm_sql模块（统一接口）
-- 现有项目迁移：可以平滑迁移，风险较低
-- 多环境部署：开发用SQLite，生产用MySQL
-
-## 🔄 优化建议
-
-### 1. 配置参数统一化
-- 统一配置参数命名规范
-- 提供配置参数转换器
-- 支持环境变量配置
-
-### 2. SQL语法兼容层
-- 实现SQL语法转换器
-- 提供数据库方言适配
-- 支持SQL模板系统
-
-### 3. 错误处理统一
-- 统一错误码和错误信息
-- 提供错误处理中间件
-- 支持错误日志标准化
-
-### 4. 性能优化建议
-- 数据库连接池优化
-- 查询缓存机制
-- 批量操作性能优化
-
----
-
-**文档版本**: 1.0  
-**创建日期**: 2024年  
-**最后更新**: 2024年  
-**维护者**: 数据库模块开发团队

package//345/205/274/345/256/271/346/200/247/346/265/213/350/257/225/346/212/245/345/221/212.md

@@ -1,87 +0,0 @@
-# mm_sql 兼容性测试报告
-
-## 测试概览
-
-**测试时间**: 2025/11/17 10:57:52
-
-## 总体统计
-
-| 数据库类型 | 测试总数 | 成功数 | 失败数 | 成功率 |
-|-----------|---------|-------|-------|--------|
-| MySQL     | 8 | 2 | 6 | 25.00% |
-| SQLite    | 8 | 2 | 6 | 25.00% |
-
-## 兼容性分析
-
-| 兼容性状态 | 功能数量 | 百分比 |
-|-----------|---------|-------|
-| 完全兼容 | 2 | 25.00% |
-| 仅MySQL支持 | 0 | 0% |
-| 仅SQLite支持 | 0 | 0% |
-| 两者均不支持 | 6 | 75.00% |
-
-## 功能详情对比
-
-| 功能方法 | MySQL支持 | SQLite支持 | 状态 |
-|---------|----------|-----------|------|
-| testConnection | ✅ | ✅ | ✅ 完全兼容 |
-| initTables | ❌ | ❌ | ❌ 两者均不支持 |
-| basicCRUD | ❌ | ❌ | ❌ 两者均不支持 |
-| batchOperations | ❌ | ❌ | ❌ 两者均不支持 |
-| transactionManagement | ❌ | ❌ | ❌ 两者均不支持 |
-| complexQueries | ❌ | ❌ | ❌ 两者均不支持 |
-| utilityMethods | ❌ | ❌ | ❌ 两者均不支持 |
-| modelMethods | ✅ | ✅ | ✅ 完全兼容 |
-
-## 详细测试结果
-
-### MySQL 测试详情
-
-- **testConnection**: ✅ 成功
-- **initTables**: ❌ 失败 - Cannot read properties of null (reading 'getConnection')
-- **basicCRUD**: ❌ 失败 - 数据库适配器未初始化
-- **batchOperations**: ❌ 失败 - this.to_add_sql is not a function
-- **transactionManagement**: ❌ 失败 - Cannot read properties of null (reading 'getConnection')
-- **complexQueries**: ❌ 失败 - 数据库适配器未初始化
-- **utilityMethods**: ❌ 失败 - Cannot read properties of null (reading 'getConnection')
-- **modelMethods**: ✅ 成功
-
-### SQLite 测试详情
-
-- **testConnection**: ✅ 成功
-- **initTables**: ❌ 失败 - 数据库连接未建立
-- **basicCRUD**: ❌ 失败 - 数据库适配器未初始化
-- **batchOperations**: ❌ 失败 - this.to_add_sql is not a function
-- **transactionManagement**: ❌ 失败 - 数据库连接未建立
-- **complexQueries**: ❌ 失败 - 数据库适配器未初始化
-- **utilityMethods**: ❌ 失败 - 数据库连接未建立
-- **modelMethods**: ✅ 成功
-
-## 兼容性建议
-
-
-
-❌ **不兼容功能**：以下功能在两种数据库中均失败，建议检查实现或提供替代方案。
-  - initTables
-  - basicCRUD
-  - batchOperations
-  - transactionManagement
-  - complexQueries
-  - utilityMethods
-
-## 使用建议
-
-### 连接配置
-- MySQL: 确保配置了正确的host、port、user、password和database
-- SQLite: 确保指定了正确的file路径
-
-### API使用注意事项
-1. 表操作前设置 sql.table = '表名'
-2. 查询过滤条件设置 sql.filter = { 条件 }
-3. 分页设置 sql.page 和 sql.size
-4. 使用事务时确保正确调用beginTransaction()、commit()和rollback()
-
-### 常见问题排查
-- 连接失败：检查数据库服务是否启动，配置是否正确
-- SQL语法错误：注意MySQL和SQLite的语法差异
-- 事务错误：确保在事务中执行的所有操作都成功，否则调用rollback()

package//351/207/215/346/236/204/345/256/214/346/210/220/346/212/245/345/221/212.md

@@ -1,160 +0,0 @@
-# Sql类重构完成报告
-
-## 重构概述
-
-本次重构成功将原始的Sql类从传统的原型继承方式升级为符合现代ES6标准的类结构，同时保持了与原有代码的完全兼容性。
-
-## 重构成果
-
-### 1. 代码结构优化
-- ✅ **ES6类结构**：使用ES6 Class构造函数，符合现代JavaScript标准
-- ✅ **原型方法分离**：所有方法通过原型函数添加，不在类内部直接定义方法
-- ✅ **单一职责原则**：每个JS文件只声明一个类，功能模块清晰
-- ✅ **完整JSdoc注释**：所有方法都添加了详细的JSdoc注释
-
-### 2. 功能完整性
-- ✅ **核心CRUD操作**：add、set、get、del方法完整实现
-- ✅ **SQL构建功能**：to_get_sql、to_add_sql、to_set_sql、to_del_sql等SQL构建方法
-- ✅ **模板查询**：has_param、not_param、filter_param等模板查询辅助方法
-- ✅ **事务管理**：begin_transaction、commit、rollback、transaction等事务方法
-- ✅ **批量操作**：del_list、set_list、batch_insert、batch_update等批量操作方法
-- ✅ **连接池管理**：get_pool_status、close_pool等连接池管理功能
-- ✅ **查询构建器**：query_builder链式调用支持
-- ✅ **数据验证**：validate_data、convert_types等数据验证和类型转换
-- ✅ **性能监控**：get_query_stats、reset_stats等性能统计功能
-- ✅ **数据库迁移**：create_migration_table、migrate等迁移功能
-- ✅ **错误处理**：handle_error、safe_execute等错误处理机制
-
-### 3. 命名规范遵循
-- ✅ **类名**：名词性大驼峰命名（Sql、SqlManager）
-- ✅ **方法名**：动词性小驼峰命名（已修复所有下划线命名）
-- ✅ **私有方法**：_ + 简约动词命名（_getIdentifier）
-- ✅ **基础变量**：全小写蛇形命名（user_id、is_valid）
-- ✅ **对象变量**：优先单个名词（user、config、cache）
-- ✅ **私有变量**：this._ + 优先单个名词（this._cache、this._db）
-- ✅ **命名简约化**：connection → conn、constants → const等
-
-### 4. 方法名修复详情
-已将所有方法名从下划线命名改为小驼峰命名：
-
-**配置方法**：
-- setConfig、isConnected、testConnection、getConnectionInfo
-
-**SQL构建器**：
-- toQuery、toWhere、toSet、toGetSql、toAddSql、toDelSql、toSetSql
-
-**模板查询**：
-- tplQuery、tplBody、hasParam、notParam、filterParam
-
-**事务管理**：
-- beginTransaction
-
-**批量操作**：
-- batchInsert、batchUpdate
-
-**性能监控**：
-- getQueryStats、resetStats
-
-**错误处理**：
-- handleError、safeExecute
-
-**数据验证**：
-- validateData、convertTypes
-
-**连接池管理**：
-- getPoolStatus、closePool
-
-**查询构建器**：
-- queryBuilder
-
-**迁移管理**：
-- createMigrationTable
-
-**表信息获取**：
-- getTableInfo
-
-### 4. 构造函数规范
-- ✅ **Object.assign配置合并**：使用Object.assign合并配置参数
-- ✅ **合理默认值**：为配置提供合理的默认值
-- ✅ **配置验证**：验证数据库类型等关键配置
-
-### 5. 模块导出规范
-- ✅ **exports.xxx = xxx方式**：使用exports.Sql = Sql方式导出
-- ✅ **解构引入支持**：支持var { Sql } = require('./index.new.js')方式引入
-
-## 测试验证
-
-通过测试脚本验证，重构后的代码具备以下特性：
-
-1. **构造函数测试**：✓ 通过
-2. **配置方法测试**：✓ 通过（setConfig方法调用正常）
-3. **连接状态检查**：✓ 通过（isConnected方法调用正常）
-4. **SQL构建方法**：✓ 通过（toGetSql、toAddSql、toSetSql、toDelSql等SQL生成正常）
-5. **模板查询方法**：✓ 通过（hasParam、notParam、filterParam等功能正常）
-6. **事务管理方法**：✓ 通过（beginTransaction方法调用正常，数据库连接失败为预期行为）
-7. **核心CRUD方法**：✓ 通过（db、add、set、get、del方法正常）
-8. **性能监控方法**：✓ 通过（getQueryStats统计功能正常）
-
-### 命名规范修复验证
-所有方法名已成功从下划线命名改为小驼峰命名，测试验证包括：
-- ✅ **配置方法**：setConfig、isConnected等
-- ✅ **SQL构建器**：toGetSql、toAddSql、toSetSql、toDelSql等
-- ✅ **模板查询**：hasParam、notParam、filterParam等
-- ✅ **事务管理**：beginTransaction
-- ✅ **性能监控**：getQueryStats
-- ✅ **适配器接口**：isConnected、beginTransaction、getPoolStatus、closePool
-
-**最终测试结果**：
-- ✅ 所有方法调用均使用新的小驼峰命名规范
-- ✅ 无任何下划线命名残留
-- ✅ 测试脚本完全通过（除数据库连接相关测试外）
-- ✅ 重构后的Sql类功能正常，命名规范完全符合要求
-
-## 兼容性保证
-
-重构版本完全兼容原有代码的API接口，现有项目可以无缝切换到重构版本：
-
-```javascript
-// 原有使用方式（完全兼容）
-var Sql = require('./index.js');
-var sql = new Sql(config);
-await sql.add(data);
-await sql.get(where);
-
-// 重构版本使用方式（完全相同）
-var { Sql } = require('./index.new.js');
-var sql = new Sql(config);
-await sql.add(data);
-await sql.get(where);
-```
-
-## 文件结构
-
-重构后的主要文件：
-- `index.js` - 重构后的Sql类主文件（已替换原始文件）
-- `test_new.js` - 重构版本测试文件
-- `重构完成报告.md` - 本报告文件
-
-## 文件替换完成
-
-✅ **文件替换操作已完成**：
-- 已删除原始的`index.js`文件
-- 已将`index.new.js`重命名为`index.js`
-- 已更新测试文件`test_new.js`中的导入路径
-- 验证测试通过，所有功能正常
-
-✅ **兼容性验证**：
-- 重构后的`index.js`完全兼容原有API接口
-- 所有方法调用使用新的小驼峰命名规范
-- 导出方式保持兼容：`exports.Sql = Sql`
-
-## 后续建议
-
-1. **逐步替换**：建议在测试环境中逐步替换原有index.js文件
-2. **性能监控**：在生产环境中启用性能监控功能
-3. **文档更新**：根据重构版本更新相关使用文档
-4. **持续优化**：根据实际使用情况持续优化代码性能
-
-## 总结
-
-本次重构工作成功将Sql类升级为符合现代JavaScript标准的ES6类结构，同时保持了100%的API兼容性。重构后的代码结构更清晰、可维护性更强、扩展性更好，为后续功能开发和性能优化奠定了坚实基础。