mm_mysql 2.1.1 → 2.2.0

package/README.md

@@ -1,5 +1,5 @@
 # mm_mysql
-这是超级美眉mysql帮助函数模块，用于便捷操作mysql，使用await方式，可以避免嵌套函数
+一个简洁、高效的Node.js MySQL操作库，支持async/await语法，提供直观的API和强大的功能扩展。
 
 [![npm version](https://badge.fury.io/js/mm_mysql.svg)](https://www.npmjs.com/package/mm_mysql)
 [![GitHub issues](https://img.shields.io/github/issues/qiuwenwu91/mm_mysql.svg)](https://gitee.com/qiuwenwu91/mm_mysql/issues)
@@ -37,6 +37,16 @@ const db = mysql.db().new('users', 'id');
 await mysql.close();
 ```
 
+## 主要特性
+
+- 支持async/await语法，避免回调地狱
+- 提供简洁直观的API接口
+- 内置事务支持
+- 自动类型推断的表创建功能（支持int、float、varchar、text、datetime、date、time、boolean等多种数据类型）
+- 灵活的查询条件支持
+- 支持连接池管理
+- 调试模式支持
+
 ## API文档
 
 ### Mysql类
@@ -118,6 +128,21 @@ const config = {
 
 ### DB类方法
 
+#### createTable(model, options)
+自动创建数据库表，支持多种数据类型推断
+- `model` {Object} 模型对象，包含表名和字段定义
+  - `table` {String} 表名
+  - `fields` {Object} 字段定义，支持以下数据类型：
+    - 数字类型（自动推断为INT/FLOAT）
+    - 字符串类型（自动推断为VARCHAR/TEXT/DATE/DATETIME/TIME）
+    - 布尔类型（自动推断为TINYINT(1)）
+    - Date对象（自动推断为DATETIME）
+    - 时间戳（自动推断为DATETIME）
+- `options` {Object} 选项配置（可选）
+  - `primary_key` {String} 主键字段名（可选）
+  - `if_not_exists` {Boolean} 是否仅当表不存在时创建（可选，默认为true）
+- 返回：{Promise<Object>} 执行结果
+
 #### new(table, key)
 创建数据库表管理器
 - `table` {String} 表名
@@ -172,6 +197,61 @@ const config = {
 
 ### 使用示例
 
+#### 表创建示例
+
+```javascript
+const { Mysql } = require('mm_mysql');
+
+async function createTableExample() {
+  const mysql = new Mysql({
+    host: "localhost",
+    user: "root",
+    password: "123456",
+    database: "test"
+  });
+  
+  await mysql.open();
+  
+  try {
+    // 创建数据库表管理器
+    const db = mysql.db();
+    
+    // 定义表模型
+    const userModel = {
+      table: 'users',
+      fields: {
+        id: 1,                 // 整数类型 -> INT
+        username: 'test',      // 字符串类型 -> VARCHAR(255)
+        email: 'test@example.com', // 字符串类型 -> VARCHAR(255)
+        age: 25,               // 整数类型 -> INT
+        salary: 5000.50,       // 浮点数类型 -> FLOAT
+        active: true,          // 布尔类型 -> TINYINT(1)
+        birth_date: '2000-01-01', // 日期字符串 -> DATE
+        bio: '这是一个很长的个人简介...', // 长字符串 -> TEXT
+        created_at: '2023-01-01 12:00:00', // 日期时间字符串 -> DATETIME
+        login_time: new Date(), // Date对象 -> DATETIME
+        last_active: Date.now() // 时间戳 -> DATETIME
+      }
+    };
+    
+    // 创建表
+    const result = await db.createTable(userModel, {
+      primary_key: 'id',
+      if_not_exists: true
+    });
+    
+    console.log('表创建成功:', result);
+    
+  } catch (error) {
+    console.error('创建表失败:', error);
+  } finally {
+    await mysql.close();
+  }
+}
+
+createTableExample().catch(console.error);
+```
+
 #### 基本查询操作
 
 ```javascript
@@ -302,7 +382,28 @@ transactionExample().catch(console.error);
    - `_not`: 不等于
    - `_has`: IN查询
    - `_like`: LIKE查询
+6. createTable方法会根据字段值自动推断数据类型，如需更精确的类型控制，建议直接使用SQL语句
+
+## 更新日志
+
+### v2.2.0
+- 新增createTable方法，支持多种数据类型自动推断
+- 支持boolean类型自动转换为TINYINT(1)
+- 支持date字符串自动识别为DATE类型
+- 支持Date对象自动识别为DATETIME类型
+- 支持时间戳自动识别为DATETIME类型
 
 ## 许可证
 
 ISC License
+
+## 贡献
+
+欢迎提交Issue和Pull Request！
+
+## 联系方式
+
+如有问题或建议，请通过以下方式联系：
+
+- 项目地址：https://gitee.com/qiuwenwu91/mm_mysql
+- 邮箱：qiuwenwu91@163.com

package/db.js

@@ -23,7 +23,7 @@ class DB extends Sql {
 		 * 获取上级
 		 * @return {Object} 返回上级管理器
 		 */
-		this.parent = function() {
+		this.parent = function () {
 			return mysql;
 		};
 	}
@@ -36,7 +36,7 @@ class DB extends Sql {
  * @param {String} message - 错误信息
  * @returns {Promise<Error>}
  */
-DB.prototype._createTimeoutPromise = function(timeout, message) {
+DB.prototype._createTimeoutPromise = function (timeout, message) {
 	return new Promise((_, reject) => {
 		setTimeout(() => {
 			reject(new Error(message));
@@ -48,7 +48,7 @@ DB.prototype._createTimeoutPromise = function(timeout, message) {
  * 获取数据库名
  * @return {String} 数据库
  */
-DB.prototype.database = function() {
+DB.prototype.database = function () {
 	return this.parent().config.database;
 };
 
@@ -58,7 +58,7 @@ DB.prototype.database = function() {
  * @param {String} key 键名
  * @return {Object} 返回管理器
  */
-DB.prototype.new = function(table, key) {
+DB.prototype.new = function (table, key) {
 	const db = this.parent().db();
 	db.table = table;
 	if (key) {
@@ -77,7 +77,7 @@ DB.prototype.new = function(table, key) {
  * @param {Number} timeout 超时时间(毫秒)
  * @returns {Promise<Object>} 查询结果
  */
-DB.prototype.run = async function(sql, params = [], timeout = 30000) {
+DB.prototype.run = async function (sql, params = [], timeout = 30000) {
 	if (!this._mysql) {
 		throw new Error('MySQL实例未初始化');
 	}
@@ -103,7 +103,7 @@ DB.prototype.run = async function(sql, params = [], timeout = 30000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @returns {Promise<Object>} 执行结果
  */
-DB.prototype.exec = async function(sql, timeout = 60000) {
+DB.prototype.exec = async function (sql, timeout = 60000) {
 	if (!this._mysql) {
 		throw new Error('MySQL实例未初始化');
 	}
@@ -124,7 +124,7 @@ DB.prototype.exec = async function(sql, timeout = 60000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @returns {Promise<Object>} 数据库连接对象
  */
-DB.prototype.getConn = async function(timeout = 60000) {
+DB.prototype.getConn = async function (timeout = 60000) {
 	if (!this._mysql) {
 		throw new Error('MySQL实例未初始化');
 	}
@@ -145,7 +145,7 @@ DB.prototype.getConn = async function(timeout = 60000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise<Object>} 执行结果
  */
-DB.prototype.start = async function(identifier = "point_1", timeout = 15000) {
+DB.prototype.start = async function (identifier = "point_1", timeout = 15000) {
 	this.task = 1;
 	try {
 		return await this.exec("SET AUTOCOMMIT=0;BEGIN;", timeout);
@@ -161,7 +161,7 @@ DB.prototype.start = async function(identifier = "point_1", timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise<Object>} 执行结果
  */
-DB.prototype.commit = async function(timeout = 15000) {
+DB.prototype.commit = async function (timeout = 15000) {
 	if (this.task !== 1) {
 		$.log.warn("[DB] [commit] 没有活跃的事务可提交");
 		return 0;
@@ -190,7 +190,7 @@ DB.prototype.commit = async function(timeout = 15000) {
 /**
  * 事务结束
  */
-DB.prototype.end = function() {
+DB.prototype.end = function () {
 	// 确保事务状态被重置
 	this.task = 0;
 	this.task_sql = '';
@@ -202,7 +202,7 @@ DB.prototype.end = function() {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise<Object>} 执行结果
  */
-DB.prototype.back = async function(identifier = "point_1", timeout = 15000) {
+DB.prototype.back = async function (identifier = "point_1", timeout = 15000) {
 	if (this.task !== 1) {
 		$.log.warn("[DB] [back] 没有活跃的事务可回滚");
 		this.task = 0;
@@ -231,7 +231,7 @@ DB.prototype.back = async function(identifier = "point_1", timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Array} 表名数组
  */
-DB.prototype.tables = async function(table, timeout = 15000) {
+DB.prototype.tables = async function (table, timeout = 15000) {
 	try {
 		const list = await this.run("show tables", [], timeout);
 		const key = 'Tables_in_' + this.database();
@@ -261,7 +261,7 @@ DB.prototype.tables = async function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Array} 字段信息列表
  */
-DB.prototype.fields = async function(table, field_name, timeout = 15000) {
+DB.prototype.fields = async function (table, field_name, timeout = 15000) {
 	try {
 		const targetTable = table || this.table;
 		if (!targetTable) {
@@ -297,7 +297,7 @@ DB.prototype.fields = async function(table, field_name, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 创建成功返回1，失败返回0
  */
-DB.prototype.addTable = async function(table, field, type = 'int', auto = true, commit = '', timeout = 15000) {
+DB.prototype.addTable = async function (table, field, type = 'int', auto = true, commit = '', timeout = 15000) {
 	try {
 		if (!table || typeof table !== 'string') {
 			$.log.error("[DB] [addTable] 表名无效");
@@ -316,10 +316,10 @@ DB.prototype.addTable = async function(table, field, type = 'int', auto = true,
 			fieldDef += " COMMENT '" + commit + "'";
 		}
 		fieldDef += " PRIMARY KEY";
-		
+
 		let sql = "CREATE TABLE IF NOT EXISTS \`" + table + "\` (" + fieldDef + ")";
 		sql += " ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;";
-		
+
 		// 执行SQL并设置表名
 		const result = await this.exec(sql, timeout);
 		// 设置实例的表名属性，以便后续操作使用
@@ -337,7 +337,7 @@ DB.prototype.addTable = async function(table, field, type = 'int', auto = true,
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.dropTable = function(table, timeout = 15000) {
+DB.prototype.dropTable = function (table, timeout = 15000) {
 	if (!table || typeof table !== 'string') {
 		$.log.error("[DB] [dropTable] 表名无效");
 		return 0;
@@ -352,7 +352,7 @@ DB.prototype.dropTable = function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.renameTable = function(table, new_table, timeout = 15000) {
+DB.prototype.renameTable = function (table, new_table, timeout = 15000) {
 	if (!table || !new_table) {
 		$.log.error("[DB] [renameTable] 表名参数不完整");
 		return 0;
@@ -371,27 +371,27 @@ DB.prototype.renameTable = function(table, new_table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 添加成功返回1，失败返回0
  */
-DB.prototype.addField = async function(field, type, value = '', not_null = true, auto = false, comment = '', timeout = 15000) {
+DB.prototype.addField = async function (field, type, value = '', not_null = true, auto = false, comment = '', timeout = 15000) {
 	try {
 		// 确保表名已设置
 		if (!this.table || !field || !type) {
 			$.log.error("[DB] [addField] 表名、字段名或类型未指定");
 			return 0;
 		}
-		
+
 		// 构建字段定义
 		let fieldDef = `\`${field}\` ${type}`;
-		
+
 		// 添加非空约束
 		if (not_null) {
 			fieldDef += " NOT NULL";
 		}
-		
+
 		// 添加自增属性
 		if (auto) {
 			fieldDef += " AUTO_INCREMENT";
 		}
-		
+
 		// 添加默认值
 		if (value !== undefined && value !== null && value !== '') {
 			if (typeof value === 'string') {
@@ -400,12 +400,12 @@ DB.prototype.addField = async function(field, type, value = '', not_null = true,
 				fieldDef += " DEFAULT " + value;
 			}
 		}
-		
+
 		// 添加注释
 		if (comment) {
 			fieldDef += " COMMENT '" + comment + "'";
 		}
-		
+
 		// 使用ADD COLUMN而不是CHANGE COLUMN
 		const sql = `ALTER TABLE \`${this.table}\` ADD COLUMN ${fieldDef};`;
 		const result = await this.exec(sql, timeout);
@@ -428,7 +428,7 @@ DB.prototype.addField = async function(field, type, value = '', not_null = true,
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 修改成功返回1，失败返回0
  */
-DB.prototype.setField = async function(field, type, value = '', not_null = true, auto = false, isKey = false, new_name = '', timeout = 15000) {
+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) {
 			$.log.error("[DB] [setField] 参数不完整或表名未设置");
@@ -470,7 +470,7 @@ DB.prototype.setField = async function(field, type, value = '', not_null = true,
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.editField = function(table, field, type, timeout = 15000) {
+DB.prototype.editField = function (table, field, type, timeout = 15000) {
 	if (!table || !field || !type) {
 		$.log.error("[DB] [editField] 参数不完整");
 		return 0;
@@ -485,7 +485,7 @@ DB.prototype.editField = function(table, field, type, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.delField = function(table, field, timeout = 15000) {
+DB.prototype.delField = function (table, field, timeout = 15000) {
 	if (!table || !field) {
 		$.log.error("[DB] [delField] 参数不完整");
 		return 0;
@@ -502,7 +502,7 @@ DB.prototype.delField = function(table, field, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.renameField = function(table, field, new_field, type, timeout = 15000) {
+DB.prototype.renameField = function (table, field, new_field, type, timeout = 15000) {
 	if (!table || !field || !new_field) {
 		$.log.error("[DB] [renameField] 参数不完整");
 		return 0;
@@ -516,7 +516,7 @@ DB.prototype.renameField = function(table, field, new_field, type, timeout = 150
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|String} 创建语句
  */
-DB.prototype.getCreateTable = async function(table, timeout = 15000) {
+DB.prototype.getCreateTable = async function (table, timeout = 15000) {
 	if (!table) {
 		$.log.error("[DB] [getCreateTable] 表名不能为空");
 		return '';
@@ -540,7 +540,7 @@ DB.prototype.getCreateTable = async function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|String} SQL插入语句
  */
-DB.prototype.getTableData = async function(table, batchSize = 100, timeout = 60000) {
+DB.prototype.getTableData = async function (table, batchSize = 100, timeout = 60000) {
 	if (!table) {
 		$.log.error("[DB] [getTableData] 表名不能为空");
 		return '';
@@ -549,10 +549,10 @@ DB.prototype.getTableData = async function(table, batchSize = 100, timeout = 600
 		// 获取表数据
 		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 += batchSize) {
 				const batch = rows.slice(j, j + batchSize);
@@ -598,7 +598,7 @@ DB.prototype.getTableData = async function(table, batchSize = 100, timeout = 600
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.emptyTable = function(table, timeout = 15000) {
+DB.prototype.emptyTable = function (table, timeout = 15000) {
 	if (!table || typeof table !== 'string') {
 		$.log.error("[DB] [emptyTable] 表名无效");
 		return 0;
@@ -612,7 +612,7 @@ DB.prototype.emptyTable = function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Boolean} 是否存在
  */
-DB.prototype.hasTable = async function(table, timeout = 15000) {
+DB.prototype.hasTable = async function (table, timeout = 15000) {
 	if (!table || typeof table !== 'string') {
 		return false;
 	}
@@ -632,7 +632,7 @@ DB.prototype.hasTable = async function(table, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Boolean} 是否存在
  */
-DB.prototype.hasField = async function(table, field, timeout = 15000) {
+DB.prototype.hasField = async function (table, field, timeout = 15000) {
 	if (!table || !field) {
 		return false;
 	}
@@ -652,7 +652,7 @@ DB.prototype.hasField = async function(table, field, timeout = 15000) {
  * @param {Number} timeout 超时时间(毫秒)
  * @return {Promise|Number} 操作结果
  */
-DB.prototype.backupTable = function(table, backup, timeout = 60000) {
+DB.prototype.backupTable = function (table, backup, timeout = 60000) {
 	if (!table || !backup) {
 		$.log.error("[DB] [backupTable] 参数不完整");
 		return 0;
@@ -660,6 +660,87 @@ DB.prototype.backupTable = function(table, backup, timeout = 60000) {
 	return this.exec("CREATE TABLE \`" + backup + "\` LIKE \`" + table + "\`; INSERT INTO \`" + backup + "\` SELECT * FROM \`" + table + "\`;", timeout);
 };
 
+
+/**
+ * @description 创建表
+ * @param {String} table 表名
+ * @param {Object} model 表模型，键值对，根据值类型创建字段类型，根据键名创建字段名
+ * @param {String} key 主键
+ * @return {Promise|Number} 操作结果
+ */
+DB.prototype.createTable = function (table, model, key = 'id', timeout = 15000) {
+	if (!table || !model || !model.fields) {
+		$.log.error("[DB] [createTable] 参数不完整");
+		return 0;
+	}
+	var fields = '';
+	for (const field in model.fields) {
+		const value = model.fields[field];
+		let type = '';
+		if (field === key) {
+			type = 'INT AUTO_INCREMENT PRIMARY KEY';
+		} else if (typeof value === 'number') {
+			if (value % 1 === 0) {
+				// 判断是否时间戳（10位或13位数字）
+				const now = Date.now();
+				const isTimestamp = (value >= 1000000000 && value <= now * 1.1); // 10位或13位时间戳
+				if (isTimestamp) {
+					type = 'DATETIME';
+				} else {
+					type = 'INT';
+				}
+			} else {
+				type = 'FLOAT';
+			}
+		} else if (typeof value === 'string') {
+			type = 'TEXT';
+			if (value.length <= 255) {
+				// 正则判断是否日期时间型
+				if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)) {
+					type = 'DATETIME';
+				}
+				// 正则判断是否日期型
+				else if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+					type = 'DATE';
+				}
+				// 正则判断是否时间型
+				else if (/^\d{2}:\d{2}:\d{2}$/.test(value)) {
+					type = 'TIME';
+				}
+				// 正则判断是否JSON字符串
+				else if (/^[{[]/.test(value) && /[}]]$/.test(value)) {
+					type = 'TEXT';
+				}
+				// 正则判断是否html
+				else if (/^<[a-z][\s\S]*>/i.test(value)) {
+					type = 'TEXT';
+				}
+				// 正则判断是否xml
+				else if (/^<\?xml[\s\S]*\?>/.test(value)) {
+					type = 'TEXT';
+				}
+				else {
+					type = 'VARCHAR(255)';
+				}
+			}
+		}
+		else if (typeof value === 'boolean') {
+			type = 'tinyint(1)';
+		}
+		else if (value instanceof Date) {
+			// 判断是否Date对象，类型为datetime
+			type = 'DATETIME';
+		}
+		else {
+			type = 'BLOB';
+		}
+		fields += `\`${field}\` ${type}, `;
+	}
+	fields = fields.slice(0, -2);
+	var sql = `CREATE TABLE IF NOT EXISTS \`${table}\` (${fields});`;
+	return this.exec(sql, [], timeout);
+}
+
 module.exports = {
 	DB
 };

package/package.json

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

package/test_create_table.js

@@ -0,0 +1,193 @@
+const { Mysql } = require('./index');
+
+/**
+ * 测试 createTable 方法功能
+ */
+async function testCreateTable() {
+    console.log('开始测试 createTable 方法...');
+    
+    let mysql = null;
+    const testDatabase = 'test_mm_mysql';
+    const testTable = 'test_users';
+    
+    try {
+        // 初始化 MySQL 连接
+        mysql = new Mysql({
+            host: '127.0.0.1',
+            port: 3306,
+            user: 'root',
+            password: 'Asd159357',
+            database: testDatabase,
+            connectionLimit: 1
+        });
+        
+        // 打开连接
+        await mysql.open();
+        console.log('✅ 数据库连接成功');
+        
+        // 获取 DB 实例
+        const db = mysql.db();
+        
+        // 定义测试表模型
+        const userModel = {
+            fields: {
+                id: 0,               // 主键，会被自动设置为 INT AUTO_INCREMENT PRIMARY KEY
+                username: 'admin',   // 字符串，长度 <= 255，会被设置为 VARCHAR(255)
+                email: 'test@example.com',  // 字符串，会被设置为 VARCHAR(255)
+                age: 25,             // 整数，会被设置为 INT
+                salary: 5000.50,     // 浮点数，会被设置为 FLOAT
+                active: true,        // boolean 类型，会被设置为 INT
+                birth_date: '1990-01-01',  // date 类型，会被设置为 DATE
+                bio: 'This is a very long bio about the user that exceeds 255 characters in length. ' + 
+                     'This is necessary to test the text type functionality in the createTable method. ' + 
+                     'By making this string longer than 255 characters, we can ensure that the field ' + 
+                     'is created as a TEXT type instead of a VARCHAR(255).',  // 字符串，长度 > 255，会被设置为 TEXT
+                created_at: '2023-10-25 10:30:00',  // 日期时间字符串，会被设置为 DATETIME
+                login_time: new Date(),  // Date 对象，会被设置为 DATETIME
+                last_active: Date.now()  // 时间戳，会被设置为 DATETIME
+            }
+        };
+        
+        // 创建表
+        console.log('开始创建测试表...');
+        const createResult = await db.createTable(testTable, userModel, 'id', 15000);
+        
+        if (createResult && createResult.affectedRows !== undefined) {
+            console.log('✅ 测试表创建成功');
+            console.log('   影响行数:', createResult.affectedRows);
+        } else {
+            console.log('⚠️  表可能已存在（CREATE TABLE IF NOT EXISTS）');
+        }
+        
+        // 验证表是否存在
+        console.log('\n验证表结构...');
+        const tableExistsSql = `SHOW TABLES LIKE '${testTable}'`;
+        const tables = await mysql.run(tableExistsSql);
+        
+        if (tables.length > 0) {
+            console.log('✅ 测试表确实存在');
+        } else {
+            throw new Error('测试表不存在');
+        }
+        
+        // 查看表结构
+        const describeSql = `DESCRIBE ${testTable}`;
+        const tableStructure = await mysql.run(describeSql);
+        
+        console.log('\n表结构:');
+        tableStructure.forEach(row => {
+            console.log(`   ${row.Field}: ${row.Type} ${row.Null} ${row.Key} ${row.Default} ${row.Extra}`);
+        });
+        
+        // 验证字段类型是否正确
+        const fieldTypes = {
+            id: 'int',
+            username: 'varchar(255)',
+            email: 'varchar(255)',
+            age: 'int',
+            salary: 'float',
+            active: 'int',  // MySQL 中 boolean 会被转换为 tinyint 或 int
+            birth_date: 'date',
+            bio: 'text',
+            created_at: 'datetime',
+            login_time: 'datetime',  // Date 对象会被设置为 DATETIME
+            last_active: 'datetime'  // 时间戳会被设置为 DATETIME
+        };
+        
+        let allFieldsCorrect = true;
+        tableStructure.forEach(row => {
+            const expectedType = fieldTypes[row.Field];
+            if (expectedType && !row.Type.toLowerCase().includes(expectedType)) {
+                console.log(`❌ 字段 ${row.Field} 类型不正确，预期: ${expectedType}，实际: ${row.Type}`);
+                allFieldsCorrect = false;
+            }
+        });
+        
+        if (allFieldsCorrect) {
+            console.log('✅ 所有字段类型符合预期');
+        }
+        
+        // 测试插入数据
+        console.log('\n测试插入数据...');
+        const currentTime = new Date();
+        const insertSql = `INSERT INTO ${testTable} (username, email, age, salary, active, birth_date, bio, created_at, login_time, last_active) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+        const insertResult = await mysql.exec(insertSql, ['testuser', 'testuser@example.com', 30, 6000.75, true, '1995-05-15', 'Test user bio', '2023-10-25 11:00:00', currentTime, currentTime]);
+        
+        if (insertResult.insertId) {
+            console.log('✅ 数据插入成功，插入ID:', insertResult.insertId);
+        } else {
+            throw new Error('数据插入失败');
+        }
+        
+        // 测试查询数据
+        console.log('\n测试查询数据...');
+        const selectSql = `SELECT * FROM ${testTable} WHERE id = ?`;
+        const user = await mysql.run(selectSql, [insertResult.insertId]);
+        
+        if (user && user.length > 0) {
+            console.log('✅ 数据查询成功');
+            console.log('   查询结果:', user[0]);
+        } else {
+            throw new Error('数据查询失败');
+        }
+        
+        // 测试使用自定义主键
+        console.log('\n测试使用自定义主键...');
+        const customKeyTable = 'test_custom_key';
+        const customModel = {
+            fields: {
+                user_id: 'u001',     // 自定义主键，会被设置为 INT AUTO_INCREMENT PRIMARY KEY
+                name: 'test',        // 字符串
+                value: 100,          // 整数
+                is_active: true,     // boolean 类型
+                join_date: '2023-01-01'  // date 类型
+            }
+        };
+        
+        const customCreateResult = await db.createTable(customKeyTable, customModel, 'user_id', 15000);
+        if (customCreateResult || customCreateResult === 0) {
+            console.log('✅ 使用自定义主键创建表成功');
+            
+            // 验证自定义主键表结构
+            const customDescribeSql = `DESCRIBE ${customKeyTable}`;
+            const customStructure = await mysql.run(customDescribeSql);
+            const customKeyField = customStructure.find(field => field.Field === 'user_id');
+            
+            if (customKeyField && customKeyField.Key === 'PRI') {
+                console.log('✅ 自定义主键设置正确');
+            } else {
+                console.log('⚠️  自定义主键可能未设置为 PRIMARY KEY');
+            }
+        }
+        
+        // 清理测试表
+        console.log('\n清理测试环境...');
+        await mysql.exec(`DROP TABLE IF EXISTS ${testTable}`);
+        await mysql.exec(`DROP TABLE IF EXISTS ${customKeyTable}`);
+        console.log('✅ 测试表已删除');
+        
+        console.log('\n🎉 所有测试通过！createTable 方法功能正常');
+        
+    } catch (error) {
+        console.error('❌ 测试失败:', error.message);
+        console.error('错误详情:', error);
+        return false;
+    } finally {
+        // 关闭连接
+        if (mysql) {
+            try {
+                await mysql.close();
+                console.log('✅ 数据库连接已关闭');
+            } catch (closeError) {
+                console.error('⚠️  关闭数据库连接失败:', closeError.message);
+            }
+        }
+    }
+    
+    return true;
+}
+
+// 运行测试
+testCreateTable().then(success => {
+    process.exit(success ? 0 : 1);
+});