25 changed files with 572 additions and 3855 deletions
--- a/.cursor/debug.log
+++ b/.cursor/debug.log
--- a/.cursor/plans/多数据库方言与前缀支持_d7ceee79.plan.md
+++ b/.cursor/plans/多数据库方言与前缀支持_d7ceee79.plan.md
@ -169,7 +169,7 @@ onCondition := that.GetProcessor().ProcessConditionString(v.(string))
 query += " LEFT JOIN " + table + " ON " + onCondition + " "
 ```

-**Insert/Inserts/Update/Delete** 同样修改表名和字段名处理。
+**Insert/BatchInsert/Update/Delete** 同样修改表名和字段名处理。

 ### 第5步：修改 WHERE 条件处理（[db/where.go](db/where.go)）

--- a/.cursor/plans/缓存数据库表重构_73959142.plan.md
+++ b/.cursor/plans/缓存数据库表重构_73959142.plan.md
@ -1,144 +0,0 @@
---
-name: 缓存数据库表重构
-overview: 重构数据库缓存模块，将 cached 表替换为符合设计规范的 hotime_cache 表，支持 MySQL/SQLite/PostgreSQL，修复并发问题，支持可配置的历史记录功能和自动迁移。
-todos:
-  - id: update-cache-db
-    content: 重构 cache_db.go：新表、UPSERT、历史记录、自动迁移、问题修复
-    status: completed
-  - id: update-cache-go
-    content: 修改 cache.go：添加 HistorySet 配置传递
-    status: completed
-  - id: update-makecode
-    content: 修改 makecode.go：跳过新表名
-    status: completed
---
-
-# 缓存数据库表重构计划
-
-## 设计概要
-
-将原 `cached` 表替换为 `hotime_cache` 表，遵循数据库设计规范，支持：
-
- 多数据库：MySQL、SQLite、PostgreSQL
- 可配置的历史记录功能（仅日志，无读取接口）
- 自动迁移旧 cached 表数据
-
-## 文件改动清单
-
-| 文件 | 改动 | 状态 |
-
-|------|------|------|
-
-| [cache/cache_db.go](cache/cache_db.go) | 完全重构：新表、UPSERT、历史记录、自动迁移 | 待完成 |
-
-| [cache/cache.go](cache/cache.go) | 添加 `HistorySet: db.GetBool("history")` 配置传递 | 待完成 |
-
-| [code/makecode.go](code/makecode.go) | 跳过 hotime_cache 和 hotime_cache_history | 已完成 |
-
-## 表结构设计
-
-### 主表 `hotime_cache`
-
-```sql
-- MySQL
-CREATE TABLE `hotime_cache` (
-  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
-  `key` varchar(64) NOT NULL COMMENT '缓存键',
-  `value` text DEFAULT NULL COMMENT '缓存值',
-  `end_time` datetime DEFAULT NULL COMMENT '过期时间',
-  `state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏',
-  `create_time` datetime DEFAULT NULL COMMENT '创建日期',
-  `modify_time` datetime DEFAULT NULL COMMENT '变更时间',
-  PRIMARY KEY (`id`),
-  UNIQUE KEY `uk_key` (`key`),
-  KEY `idx_end_time` (`end_time`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='缓存管理';
-
-- SQLite
-CREATE TABLE "hotime_cache" (
-  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-  "key" TEXT NOT NULL UNIQUE,
-  "value" TEXT,
-  "end_time" TEXT,
-  "state" INTEGER DEFAULT 0,
-  "create_time" TEXT,
-  "modify_time" TEXT
-);
-
-- PostgreSQL
-CREATE TABLE "hotime_cache" (
-  "id" SERIAL PRIMARY KEY,
-  "key" VARCHAR(64) NOT NULL UNIQUE,
-  "value" TEXT,
-  "end_time" TIMESTAMP,
-  "state" INTEGER DEFAULT 0,
-  "create_time" TIMESTAMP,
-  "modify_time" TIMESTAMP
-);
-CREATE INDEX "idx_hotime_cache_end_time" ON "hotime_cache" ("end_time");
-```
-
-### 历史表 `hotime_cache_history`（配置开启时创建，创建后永不自动删除）
-
-与主表结构相同，但 `id` 改为 `hotime_cache_id` 作为外键关联。
-
-## 问题修复清单
-
-| 问题 | 原状态 | 修复方案 |
-
-|------|--------|----------|
-
-| key 无索引 | 全表扫描 | 唯一索引 uk_key |
-
-| 并发竞态 | Update+Insert 可能重复 | 使用 UPSERT 语法 |
-
-| 时间字段混乱 | time(纳秒) + endtime(秒) | 统一 datetime 格式 |
-
-| value 长度限制 | varchar(2000) | TEXT 类型 |
-
-| TimeOut=0 立即过期 | 无默认值 | 默认 24 小时 |
-
-| get 时删除过期数据 | 每次写操作 | 惰性删除，只返回 nil |
-
-| 旧表 key 重复 | 无约束 | 迁移时取最后一条 |
-
-| value 包装冗余 | `{"data": value}` | 直接存储 |
-
-## 主要代码改动点
-
-### cache_db.go 改动
-
-1. 新增常量：表名、默认过期时间 24 小时
-2. 结构体添加 `HistorySet bool`
-3. 使用 common 包 `Time2Str(time.Now())` 格式化时间
-4. `initDbTable()`: 支持三种数据库、自动迁移、创建历史表
-5. `migrateFromCached()`: 去重迁移（取最后一条）、删除旧表
-6. `writeHistory()`: 查询数据写入历史表（仅日志）
-7. `set()`: 使用 UPSERT、调用 writeHistory
-8. `get()`: 惰性删除
-9. `Cache()`: TimeOut=0 时用默认值
-
-### cache.go 改动
-
-第 268 行添加：`HistorySet: db.GetBool("history")`
-
-## 配置示例
-
-```json
-{
-  "cache": {
-    "db": {
-      "db": true,
-      "session": true,
-      "timeout": 72000,
-      "history": false
-    }
-  }
-}
-```
-
-## 历史记录逻辑
-
- 新增/修改后：查询完整数据，id 改为 hotime_cache_id，插入历史表
- 删除：不记录历史
- 历史表仅日志记录，无读取接口，人工在数据库操作
--- a/.cursor/plans/规范文档创建_6d183386.plan.md
+++ b/.cursor/plans/规范文档创建_6d183386.plan.md
@ -1,103 +0,0 @@
---
-name: 规范文档创建
-overview: 创建两个规范文档：一个数据库设计规范文档，一个管理后台配置规范文档（包含admin.json和rule.json的配置说明），并在README.md中添加链接。
-todos:
-  - id: create-db-doc
-    content: 创建 docs/DatabaseDesign_数据库设计规范.md
-    status: pending
-  - id: create-admin-doc
-    content: 创建 docs/AdminConfig_管理后台配置规范.md
-    status: pending
-  - id: update-readme
-    content: 在 README.md 文档表格中添加两个新文档链接
-    status: pending
-    dependencies:
-      - create-db-doc
-      - create-admin-doc
---
-
-# 创建规范文档
-
-## 任务概述
-
-在 `D:\work\hotimev1.5\docs` 目录下创建两个规范文档，并更新 README.md 添加链接。
-
---
-
-## 文档一：数据库设计规范
-
-**文件**: [docs/DatabaseDesign_数据库设计规范.md](docs/DatabaseDesign_数据库设计规范.md)
-
-### 内容结构
-
-| 章节 | 内容 |
-
-|------|------|
-
-| 表命名规则 | 不加前缀、可用简称、关联表命名（主表_关联表） |
-
-| 字段命名规则 | 主键id、外键表名_id、全局唯一性要求、层级字段（parent_id/parent_ids/level） |
-
-| 注释规则 | select类型格式（`状态:0-正常,1-异常`）、时间用datetime |
-
-| 必有字段 | state、create_time、modify_time |
-
-| 示例 | 完整建表SQL示例 |
-
---
-
-## 文档二：管理后台配置规范
-
-**文件**: [docs/AdminConfig_管理后台配置规范.md](docs/AdminConfig_管理后台配置规范.md)
-
-### 内容结构
-
-| 章节 | 内容 |
-
-|------|------|
-
-| admin.json 配置 | |
-
-| - flow配置 | 数据流控制，定义表间权限关系（sql条件、stop标志） |
-
-| - labelConfig | 操作按钮标签（show/add/delete/edit/info/download） |
-
-| - label | 菜单/表的显示名称 |
-
-| - menus配置 | 菜单结构（嵌套menus、icon、table、name、auth） |
-
-| - auth配置 | 权限数组（show/add/delete/edit/info/download） |
-
-| - icon配置 | 菜单图标（如Setting） |
-
-| - table/name配置 | table指定数据表，name用于分组标识 |
-
-| - stop配置 | 不允许用户修改自身关联数据的表 |
-
-| rule.json 配置 | |
-
-| - 字段默认权限 | add/edit/info/list/must/strict/type 各字段含义 |
-
-| - 内置字段规则 | id、parent_id、create_time、modify_time、password等 |
-
-| - type类型说明 | select/time/image/file/password/textArea/auth/form等 |
-
---
-
-## 更新 README.md
-
-在文档表格中添加两个新链接：
-
-```markdown
-| [数据库设计规范](docs/DatabaseDesign_数据库设计规范.md) | 表命名、字段命名、注释规则、必有字段 |
-| [管理后台配置规范](docs/AdminConfig_管理后台配置规范.md) | admin.json、rule.json 配置说明 |
-```
-
---
-
-## 关键参考文件
-
- [`code/config.go`](code/config.go): RuleConfig 默认规则定义
- [`code/makecode.go`](code/makecode.go): 外键自动关联逻辑
- [`example/config/admin.json`](example/config/admin.json): 完整配置示例
- [`example/config/rule.json`](example/config/rule.json): 字段规则示例
--- a/.gitignore
+++ b/.gitignore
@ -2,5 +2,4 @@
 .idea
 /example/tpt/demo/
 *.exe
-/example/config
-/.cursor/*.log
+/example/config
--- a/README.md
+++ b/README.md
@ -2,45 +2,75 @@

 **高性能 Go Web 服务框架**

-一个"小而全"的 Go Web 框架，内置 ORM、三级缓存、Session 管理，让你专注于业务逻辑。
-
-## 核心特性
+## 特性

 - **高性能** - 单机 10万+ QPS，支持百万级并发用户
- **内置 ORM** - 类 Medoo 语法，链式查询，支持 MySQL/SQLite/PostgreSQL
- **三级缓存** - Memory > Redis > DB，自动穿透与回填
- **Session 管理** - 内置会话管理，支持多种存储后端
- **代码生成** - 根据数据库表自动生成 CRUD 接口
- **开箱即用** - 微信支付/公众号/小程序、阿里云、腾讯云等 SDK 内置
+- **多数据库支持** - MySQL、SQLite3，支持主从分离
+- **三级缓存系统** - Memory > Redis > DB，自动穿透与回填
+- **Session管理** - 内置会话管理，支持多种存储后端
+- **自动代码生成** - 根据数据库表自动生成 CRUD 接口
+- **丰富工具类** - 上下文管理、类型转换、加密解密等

-## 文档
+## 快速开始

-| 文档 | 说明 |
-|------|------|
-| [快速上手指南](docs/QUICKSTART.md) | 5 分钟入门，安装配置、路由、中间件、基础数据库操作 |
-| [HoTimeDB 使用说明](docs/HoTimeDB_使用说明.md) | 完整数据库 ORM 教程 |
-| [HoTimeDB API 参考](docs/HoTimeDB_API参考.md) | 数据库 API 速查手册 |
-| [Common 工具类](docs/Common_工具类使用说明.md) | Map/Slice/Obj 类型、类型转换、工具函数 |
-| [代码生成器](docs/CodeGen_使用说明.md) | 自动 CRUD 代码生成、配置规则 |
-| [数据库设计规范](docs/DatabaseDesign_数据库设计规范.md) | 表命名、字段命名、时间类型、必有字段规范 |
-| [代码生成配置规范](docs/CodeConfig_代码生成配置规范.md) | codeConfig、菜单权限、字段规则配置说明 |
-| [改进规划](docs/ROADMAP_改进规划.md) | 待改进项、设计思考、版本迭代规划 |
-
-## 安装
+### 安装

 ```bash
 go get code.hoteas.com/golang/hotime
 ```

-## 性能
+### 最小示例

-| 并发数 | QPS | 成功率 | 平均延迟 |
-|--------|-----|--------|----------|
-| 500 | 99,960 | 100% | 5.0ms |
-| **1000** | **102,489** | **100%** | **9.7ms** |
-| 2000 | 75,801 | 99.99% | 26.2ms |
+```go
+package main

-> 测试环境：24 核 CPU，Windows 10，Go 1.19.3
+import (
+    . "code.hoteas.com/golang/hotime"
+    . "code.hoteas.com/golang/hotime/common"
+)
+
+func main() {
+    appIns := Init("config/config.json")
+    
+    appIns.Run(Router{
+        "app": {
+            "test": {
+                "hello": func(that *Context) {
+                    that.Display(0, Map{"message": "Hello World"})
+                },
+            },
+        },
+    })
+}
+```
+
+访问: http://localhost:8081/app/test/hello
+
+## 性能测试报告
+
+### 测试环境
+
+| 项目 | 配置 |
+|------|------|
+| CPU | 24 核心 |
+| 系统 | Windows 10 |
+| Go 版本 | 1.19.3 |
+
+### 测试结果
+
+| 并发数 | QPS | 成功率 | 平均延迟 | P99延迟 |
+|--------|-----|--------|----------|---------|
+| 500 | 99,960 | 100% | 5.0ms | 25.2ms |
+| **1000** | **102,489** | **100%** | **9.7ms** | **56.8ms** |
+| 2000 | 75,801 | 99.99% | 26.2ms | 127.7ms |
+| 5000 | 12,611 | 99.95% | 391.4ms | 781.4ms |
+
+### 性能总结
+
+```
+最高 QPS:      102,489 请求/秒
+最佳并发数:    1,000
+```

 ### 并发用户估算

@ -49,9 +79,24 @@ go get code.hoteas.com/golang/hotime
 | 高频交互 | 1次/秒 | ~10万 |
 | 活跃用户 | 1次/5秒 | ~50万 |
 | 普通浏览 | 1次/10秒 | ~100万 |
+| 低频访问 | 1次/30秒 | ~300万 |
+
+**生产环境建议**: 保留 30-50% 性能余量，安全并发用户数约 **50万 - 70万**
+
+### 与主流框架性能对比
+
+| 框架 | 典型QPS | 基础实现 | 性能评级 |
+|------|---------|----------|----------|
+| **HoTime** | **~100K** | net/http | 第一梯队 |
+| Fiber | ~100K+ | fasthttp | 第一梯队 |
+| Gin | ~60-80K | net/http | 第二梯队 |
+| Echo | ~60-80K | net/http | 第二梯队 |
+| Chi | ~50-60K | net/http | 第二梯队 |

 ## 框架对比

+### 功能特性对比
+
 | 特性 | HoTime | Gin | Echo | Fiber |
 |------|--------|-----|------|-------|
 | 性能 | 100K QPS | 70K QPS | 70K QPS | 100K QPS |
@ -60,25 +105,117 @@ go get code.hoteas.com/golang/hotime
 | Session | ✅ 内置 | ❌ 需插件 | ❌ 需插件 | ❌ 需插件 |
 | 代码生成 | ✅ | ❌ | ❌ | ❌ |
 | 微信/支付集成 | ✅ 内置 | ❌ | ❌ | ❌ |
+| 路由灵活性 | 中等 | 优秀 | 优秀 | 优秀 |
+| 社区生态 | 较小 | 庞大 | 较大 | 较大 |

-## 适用场景
+### HoTime 优势
+
+1. **开箱即用** - 内置 ORM + 缓存 + Session，无需额外集成
+2. **三级缓存** - Memory > Redis > DB，自动穿透与回填
+3. **开发效率高** - 链式查询语法简洁，内置微信/云服务SDK
+4. **性能优异** - 100K QPS，媲美最快的 Fiber 框架
+
+### 适用场景

 | 场景 | 推荐度 | 说明 |
 |------|--------|------|
 | 中小型后台系统 | ⭐⭐⭐⭐⭐ | 完美适配，开发效率最高 |
-| 微信小程序后端 | ⭐⭐⭐⭐⭐ | 内置微信 SDK |
+| 微信小程序后端 | ⭐⭐⭐⭐⭐ | 内置微信SDK |
 | 快速原型开发 | ⭐⭐⭐⭐⭐ | 代码生成 + 全功能集成 |
-| 高并发 API 服务 | ⭐⭐⭐⭐ | 性能足够 |
-| 大型微服务 | ⭐⭐⭐ | 建议用 Gin/Echo |
+| 高并发API服务 | ⭐⭐⭐⭐ | 性能足够 |
+| 大型微服务 | ⭐⭐⭐ | 建议用Gin/Echo |
+
+### 总体评价
+
+| 维度 | 评分 | 说明 |
+|------|------|------|
+| 性能 | 95分 | 第一梯队，媲美Fiber |
+| 功能集成 | 90分 | 远超主流框架 |
+| 开发效率 | 85分 | 适合快速开发 |
+| 生态/社区 | 50分 | 持续建设中 |
+
+> **总结**: HoTime 是"小而全"的高性能框架，性能不输主流，集成度远超主流，适合独立开发者或小团队快速构建中小型项目。
+
+---
+
+## 数据库操作
+
+### 基础 CRUD
+
+```go
+// 查询单条
+user := that.Db.Get("user", "*", Map{"id": 1})
+
+// 查询列表
+users := that.Db.Select("user", "*", Map{"status": 1, "ORDER": "id DESC"})
+
+// 插入数据
+id := that.Db.Insert("user", Map{"name": "test", "age": 18})
+
+// 更新数据
+rows := that.Db.Update("user", Map{"name": "new"}, Map{"id": 1})
+
+// 删除数据
+rows := that.Db.Delete("user", Map{"id": 1})
+```
+
+### 链式查询
+
+```go
+users := that.Db.Table("user").
+    LeftJoin("order", "user.id=order.user_id").
+    And("status", 1).
+    Order("id DESC").
+    Page(1, 10).
+    Select("*")
+```
+
+### 条件语法
+
+| 语法 | 说明 | 示例 |
+|------|------|------|
+| key | 等于 | "id": 1 |
+| key[>] | 大于 | "age[>]": 18 |
+| key[<] | 小于 | "age[<]": 60 |
+| key[!] | 不等于 | "status[!]": 0 |
+| key[~] | LIKE | "name[~]": "test" |
+| key[<>] | BETWEEN | "age[<>]": Slice{18, 60} |
+
+## 缓存系统
+
+三级缓存: **Memory > Redis > Database**
+
+```go
+// 通用缓存
+that.Cache("key", value)           // 设置
+data := that.Cache("key")          // 获取
+that.Cache("key", nil)             // 删除
+
+// Session 缓存
+that.Session("user_id", 123)       // 设置
+userId := that.Session("user_id")  // 获取
+```
+
+## 中间件
+
+```go
+appIns.SetConnectListener(func(that *Context) bool {
+    if that.Session("user_id").Data == nil {
+        that.Display(2, "请先登录")
+        return true  // 终止请求
+    }
+    return false  // 继续处理
+})
+```

 ## 扩展功能

- 微信支付/公众号/小程序 - `dri/wechat/`
- 阿里云服务 - `dri/aliyun/`
- 腾讯云服务 - `dri/tencent/`
- 文件上传下载 - `dri/upload/`, `dri/download/`
- MongoDB - `dri/mongodb/`
- RSA 加解密 - `dri/rsa/`
+- **微信支付/公众号/小程序** - dri/wechat/
+- **阿里云服务** - dri/aliyun/
+- **腾讯云服务** - dri/tencent/
+- **文件上传下载** - dri/upload/, dri/download/
+- **MongoDB** - dri/mongodb/
+- **RSA加解密** - dri/rsa/

 ## License

--- a/cache/cache.go
+++ b/cache/cache.go
@ -265,13 +265,9 @@ func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, err ...*Er
 		}
 		that.Config["db"] = db

-		that.dbCache = &CacheDb{
-			TimeOut:    db.GetCeilInt64("timeout"),
-			DbSet:      db.GetBool("db"),
-			SessionSet: db.GetBool("session"),
-			HistorySet: db.GetBool("history"),
-			Db:         hotimeDb,
-		}
+		that.dbCache = &CacheDb{TimeOut: db.GetCeilInt64("timeout"),
+			DbSet: db.GetBool("db"), SessionSet: db.GetBool("session"),
+			Db: hotimeDb}

 		if err[0] != nil {
 			that.dbCache.SetError(err[0])
--- a/cache/cache_db.go
+++ b/cache/cache_db.go
@ -1,38 +1,11 @@
 package cache

 import (
+	. "code.hoteas.com/golang/hotime/common"
 	"database/sql"
 	"encoding/json"
-	"fmt"
-	"os"
 	"strings"
 	"time"
-
-	. "code.hoteas.com/golang/hotime/common"
-)
-
-// #region agent log
-func debugLog(hypothesisId, location, message string, data map[string]interface{}) {
-	logEntry := fmt.Sprintf(`{"hypothesisId":"%s","location":"%s","message":"%s","data":%s,"timestamp":%d,"sessionId":"debug-session"}`,
-		hypothesisId, location, message, toJSON(data), time.Now().UnixMilli())
-	f, _ := os.OpenFile(`d:\work\hotimev1.5\.cursor\debug.log`, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if f != nil {
-		f.WriteString(logEntry + "\n")
-		f.Close()
-	}
-}
-func toJSON(data map[string]interface{}) string {
-	b, _ := json.Marshal(data)
-	return string(b)
-}
-
-// #endregion
-
-// 表名常量
-const (
-	CacheTableName        = "hotime_cache"
-	CacheHistoryTableName = "hotime_cache_history"
-	DefaultCacheTimeout   = 24 * 60 * 60 // 默认过期时间 24 小时
 )

 type HoTimeDBInterface interface {
@ -51,7 +24,6 @@ type CacheDb struct {
 	TimeOut    int64
 	DbSet      bool
 	SessionSet bool
-	HistorySet bool // 是否开启历史记录
 	Db         HoTimeDBInterface
 	*Error
 	ContextBase
@ -59,468 +31,143 @@ type CacheDb struct {
 }

 func (that *CacheDb) GetError() *Error {
+
 	return that.Error
+
 }

 func (that *CacheDb) SetError(err *Error) {
 	that.Error = err
 }

-// getTableName 获取带前缀的表名
-func (that *CacheDb) getTableName() string {
-	return that.Db.GetPrefix() + CacheTableName
-}
-
-// getHistoryTableName 获取带前缀的历史表名
-func (that *CacheDb) getHistoryTableName() string {
-	return that.Db.GetPrefix() + CacheHistoryTableName
-}
-
-// initDbTable 初始化数据库表
 func (that *CacheDb) initDbTable() {
 	if that.isInit {
 		return
 	}
+	if that.Db.GetType() == "mysql" {

-	dbType := that.Db.GetType()
-	tableName := that.getTableName()
-	historyTableName := that.getHistoryTableName()
-
-	// #region agent log
-	debugLog("F", "cache_db.go:initDbTable", "initDbTable started", map[string]interface{}{
-		"dbType": dbType, "tableName": tableName, "historyTableName": historyTableName, "HistorySet": that.HistorySet,
-	})
-	// #endregion
-
-	// 检查并创建主表
-	if !that.tableExists(tableName) {
-		that.createMainTable(dbType, tableName)
-	}
-
-	// 检查并迁移旧 cached 表
-	oldTableName := that.Db.GetPrefix() + "cached"
-	if that.tableExists(oldTableName) {
-		that.migrateFromCached(dbType, oldTableName, tableName)
-	}
-
-	// 检查并创建历史表（开启历史记录时）
-	historyTableExists := that.tableExists(historyTableName)
-	// #region agent log
-	debugLog("F", "cache_db.go:initDbTable", "history table check", map[string]interface{}{
-		"HistorySet": that.HistorySet, "historyTableName": historyTableName, "exists": historyTableExists,
-		"shouldCreate": that.HistorySet && !historyTableExists,
-	})
-	// #endregion
-	if that.HistorySet && !historyTableExists {
-		that.createHistoryTable(dbType, historyTableName)
-		// #region agent log
-		debugLog("F", "cache_db.go:initDbTable", "createHistoryTable called", map[string]interface{}{
-			"dbType": dbType, "historyTableName": historyTableName,
-		})
-		// #endregion
-	}
-
-	that.isInit = true
-}
-
-// tableExists 检查表是否存在
-func (that *CacheDb) tableExists(tableName string) bool {
-	dbType := that.Db.GetType()
-
-	switch dbType {
-	case "mysql":
 		dbNames := that.Db.Query("SELECT DATABASE()")
+
 		if len(dbNames) == 0 {
-			return false
+			return
 		}
 		dbName := dbNames[0].GetString("DATABASE()")
-		res := that.Db.Query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='" + dbName + "' AND TABLE_NAME='" + tableName + "'")
-		return len(res) != 0
-
-	case "sqlite":
-		res := that.Db.Query(`SELECT name FROM sqlite_master WHERE type='table' AND name='` + tableName + `'`)
-		return len(res) != 0
-
-	case "postgres":
-		res := that.Db.Query(`SELECT tablename FROM pg_tables WHERE schemaname='public' AND tablename='` + tableName + `'`)
-		return len(res) != 0
-	}
-
-	return false
-}
-
-// createMainTable 创建主表
-func (that *CacheDb) createMainTable(dbType, tableName string) {
-	var createSQL string
-
-	switch dbType {
-	case "mysql":
-		createSQL = "CREATE TABLE `" + tableName + "` (" +
-			"`id` int(11) unsigned NOT NULL AUTO_INCREMENT," +
-			"`key` varchar(64) NOT NULL COMMENT '缓存键'," +
-			"`value` text DEFAULT NULL COMMENT '缓存值'," +
-			"`end_time` datetime DEFAULT NULL COMMENT '过期时间'," +
-			"`state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏'," +
-			"`create_time` datetime DEFAULT NULL COMMENT '创建日期'," +
-			"`modify_time` datetime DEFAULT NULL COMMENT '变更时间'," +
-			"PRIMARY KEY (`id`)," +
-			"UNIQUE KEY `uk_key` (`key`)," +
-			"KEY `idx_end_time` (`end_time`)" +
-			") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='缓存管理'"
-
-	case "sqlite":
-		createSQL = `CREATE TABLE "` + tableName + `" (
-			"id" INTEGER PRIMARY KEY AUTOINCREMENT,
-			"key" TEXT NOT NULL UNIQUE,
-			"value" TEXT,
-			"end_time" TEXT,
-			"state" INTEGER DEFAULT 0,
-			"create_time" TEXT,
-			"modify_time" TEXT
-		)`
-
-	case "postgres":
-		createSQL = `CREATE TABLE "` + tableName + `" (
-			"id" SERIAL PRIMARY KEY,
-			"key" VARCHAR(64) NOT NULL UNIQUE,
-			"value" TEXT,
-			"end_time" TIMESTAMP,
-			"state" INTEGER DEFAULT 0,
-			"create_time" TIMESTAMP,
-			"modify_time" TIMESTAMP
-		)`
-		that.Db.Exec(createSQL)
-		// 创建索引
-		that.Db.Exec(`CREATE INDEX "idx_` + tableName + `_end_time" ON "` + tableName + `" ("end_time")`)
-		return
-	}
-
-	that.Db.Exec(createSQL)
-}
-
-// createHistoryTable 创建历史表
-func (that *CacheDb) createHistoryTable(dbType, tableName string) {
-	var createSQL string
-
-	switch dbType {
-	case "mysql":
-		createSQL = "CREATE TABLE `" + tableName + "` (" +
-			"`id` int(11) unsigned NOT NULL AUTO_INCREMENT," +
-			"`hotime_cache_id` int(11) unsigned DEFAULT NULL COMMENT '缓存ID'," +
-			"`key` varchar(64) DEFAULT NULL COMMENT '缓存键'," +
-			"`value` text DEFAULT NULL COMMENT '缓存值'," +
-			"`end_time` datetime DEFAULT NULL COMMENT '过期时间'," +
-			"`state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏'," +
-			"`create_time` datetime DEFAULT NULL COMMENT '创建日期'," +
-			"`modify_time` datetime DEFAULT NULL COMMENT '变更时间'," +
-			"PRIMARY KEY (`id`)," +
-			"KEY `idx_hotime_cache_id` (`hotime_cache_id`)" +
-			") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='缓存历史'"
-
-	case "sqlite":
-		createSQL = `CREATE TABLE "` + tableName + `" (
-			"id" INTEGER PRIMARY KEY AUTOINCREMENT,
-			"hotime_cache_id" INTEGER,
-			"key" TEXT,
-			"value" TEXT,
-			"end_time" TEXT,
-			"state" INTEGER DEFAULT 0,
-			"create_time" TEXT,
-			"modify_time" TEXT
-		)`
-
-	case "postgres":
-		createSQL = `CREATE TABLE "` + tableName + `" (
-			"id" SERIAL PRIMARY KEY,
-			"hotime_cache_id" INTEGER,
-			"key" VARCHAR(64),
-			"value" TEXT,
-			"end_time" TIMESTAMP,
-			"state" INTEGER DEFAULT 0,
-			"create_time" TIMESTAMP,
-			"modify_time" TIMESTAMP
-		)`
-		that.Db.Exec(createSQL)
-		// 创建索引
-		that.Db.Exec(`CREATE INDEX "idx_` + tableName + `_cache_id" ON "` + tableName + `" ("hotime_cache_id")`)
-		return
-	}
-
-	that.Db.Exec(createSQL)
-}
-
-// migrateFromCached 从旧 cached 表迁移数据
-func (that *CacheDb) migrateFromCached(dbType, oldTableName, newTableName string) {
-	var migrateSQL string
-
-	switch dbType {
-	case "mysql":
-		// 去重迁移：取每个 key 的最后一条记录（id 最大）
-		migrateSQL = "INSERT INTO `" + newTableName + "` (`key`, `value`, `end_time`, `state`, `create_time`, `modify_time`) " +
-			"SELECT c.`key`, c.`value`, FROM_UNIXTIME(c.`endtime`), 0, " +
-			"FROM_UNIXTIME(c.`time` / 1000000000), FROM_UNIXTIME(c.`time` / 1000000000) " +
-			"FROM `" + oldTableName + "` c " +
-			"INNER JOIN (SELECT `key`, MAX(id) as max_id FROM `" + oldTableName + "` GROUP BY `key`) m " +
-			"ON c.id = m.max_id"
-
-	case "sqlite":
-		migrateSQL = `INSERT INTO "` + newTableName + `" ("key", "value", "end_time", "state", "create_time", "modify_time") ` +
-			`SELECT c."key", c."value", datetime(c."endtime", 'unixepoch'), 0, ` +
-			`datetime(c."time" / 1000000000, 'unixepoch'), datetime(c."time" / 1000000000, 'unixepoch') ` +
-			`FROM "` + oldTableName + `" c ` +
-			`INNER JOIN (SELECT "key", MAX(id) as max_id FROM "` + oldTableName + `" GROUP BY "key") m ` +
-			`ON c.id = m.max_id`
-
-	case "postgres":
-		migrateSQL = `INSERT INTO "` + newTableName + `" ("key", "value", "end_time", "state", "create_time", "modify_time") ` +
-			`SELECT c."key", c."value", to_timestamp(c."endtime"), 0, ` +
-			`to_timestamp(c."time" / 1000000000), to_timestamp(c."time" / 1000000000) ` +
-			`FROM "` + oldTableName + `" c ` +
-			`INNER JOIN (SELECT "key", MAX(id) as max_id FROM "` + oldTableName + `" GROUP BY "key") m ` +
-			`ON c.id = m.max_id`
-	}
-
-	// 执行迁移
-	_, err := that.Db.Exec(migrateSQL)
-	if err.GetError() == nil {
-		// 迁移成功，删除旧表
-		var dropSQL string
-		switch dbType {
-		case "mysql":
-			dropSQL = "DROP TABLE `" + oldTableName + "`"
-		case "sqlite", "postgres":
-			dropSQL = `DROP TABLE "` + oldTableName + `"`
+		res := that.Db.Query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='" + dbName + "' AND TABLE_NAME='" + that.Db.GetPrefix() + "cached'")
+		if len(res) != 0 {
+			that.isInit = true
+			return
 		}
-		that.Db.Exec(dropSQL)
+
+		_, e := that.Db.Exec("CREATE TABLE `" + that.Db.GetPrefix() + "cached` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `key` varchar(60) DEFAULT NULL, `value` varchar(2000) DEFAULT NULL, `time` bigint(20) DEFAULT NULL, `endtime` bigint(20) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=198740 DEFAULT CHARSET=utf8")
+		if e.GetError() == nil {
+			that.isInit = true
+		}
+
 	}
+
+	if that.Db.GetType() == "sqlite" {
+		res := that.Db.Query(`select * from sqlite_master where type = 'table' and name = '` + that.Db.GetPrefix() + `cached'`)
+
+		if len(res) != 0 {
+			that.isInit = true
+			return
+		}
+		_, e := that.Db.Exec(`CREATE TABLE "` + that.Db.GetPrefix() + `cached" (
+			"id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+				"key" TEXT(60),
+				"value" TEXT(2000),
+				"time" integer,
+				"endtime" integer
+			);`)
+		if e.GetError() == nil {
+			that.isInit = true
+		}
+
+	}
+
 }

-// writeHistory 写入历史记录
-func (that *CacheDb) writeHistory(key string) {
-	if !that.HistorySet {
-		return
-	}
-
-	tableName := that.getTableName()
-	historyTableName := that.getHistoryTableName()
-
-	// 查询当前数据
-	cached := that.Db.Get(tableName, "*", Map{"key": key})
-	if cached == nil {
-		return
-	}
-
-	// 构建历史记录数据
-	historyData := Map{
-		"hotime_cache_id": cached.GetInt64("id"),
-		"key":             cached.GetString("key"),
-		"value":           cached.GetString("value"),
-		"end_time":        cached.GetString("end_time"),
-		"state":           cached.GetInt("state"),
-		"create_time":     cached.GetString("create_time"),
-		"modify_time":     cached.GetString("modify_time"),
-	}
-
-	// 插入历史表
-	that.Db.Insert(historyTableName, historyData)
-
-	// #region agent log
-	logFile3, _ := os.OpenFile(`d:\work\hotimev1.5\.cursor\debug.log`, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if logFile3 != nil {
-		fmt.Fprintf(logFile3, `{"hypothesisId":"C","location":"cache_db.go:writeHistory","message":"history written","data":{"key":"%s","cacheId":%d},"timestamp":%d,"sessionId":"debug-session"}`+"\n", key, cached.GetInt64("id"), time.Now().UnixMilli())
-		logFile3.Close()
-	}
-	// #endregion
-}
-
-// get 获取缓存
+// 获取Cache键只能为string类型
 func (that *CacheDb) get(key string) interface{} {
-	tableName := that.getTableName()
-	cached := that.Db.Get(tableName, "*", Map{"key": key})

-	// #region agent log
-	logFile4, _ := os.OpenFile(`d:\work\hotimev1.5\.cursor\debug.log`, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if logFile4 != nil {
-		found := cached != nil
-		fmt.Fprintf(logFile4, `{"hypothesisId":"D","location":"cache_db.go:get","message":"get query","data":{"key":"%s","found":%t},"timestamp":%d,"sessionId":"debug-session"}`+"\n", key, found, time.Now().UnixMilli())
-		logFile4.Close()
-	}
-	// #endregion
+	cached := that.Db.Get("cached", "*", Map{"key": key})

 	if cached == nil {
 		return nil
 	}
+	//data:=cacheMap[key];
+	if cached.GetInt64("endtime") <= time.Now().Unix() {

-	// 使用字符串比较判断过期（ISO 格式天然支持）
-	endTime := cached.GetString("end_time")
-	nowTime := Time2Str(time.Now())
-	if endTime != "" && endTime <= nowTime {
-		// 惰性删除：过期只返回 nil，不立即删除
-		// 依赖随机清理批量删除过期数据
+		that.Db.Delete("cached", Map{"id": cached.GetString("id")})
 		return nil
 	}

-	// 直接解析 value，不再需要 {"data": value} 包装
-	valueStr := cached.GetString("value")
-	if valueStr == "" {
-		return nil
-	}
+	data := Map{}
+	data.JsonToMap(cached.GetString("value"))

-	var data interface{}
-	err := json.Unmarshal([]byte(valueStr), &data)
-	if err != nil {
-		return nil
-	}
-
-	// #region agent log
-	logFile5, _ := os.OpenFile(`d:\work\hotimev1.5\.cursor\debug.log`, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if logFile5 != nil {
-		fmt.Fprintf(logFile5, `{"hypothesisId":"D","location":"cache_db.go:get","message":"get success","data":{"key":"%s","hasData":true},"timestamp":%d,"sessionId":"debug-session"}`+"\n", key, time.Now().UnixMilli())
-		logFile5.Close()
-	}
-	// #endregion
-
-	return data
+	return data.Get("data")
 }

-// set 设置缓存
-func (that *CacheDb) set(key string, value interface{}, endTime time.Time) {
-	// 直接序列化 value，不再包装
-	bte, _ := json.Marshal(value)
-	nowTime := Time2Str(time.Now())
-	endTimeStr := Time2Str(endTime)
+// key value ,时间为时间戳
+func (that *CacheDb) set(key string, value interface{}, tim int64) {

-	dbType := that.Db.GetType()
-	tableName := that.getTableName()
+	bte, _ := json.Marshal(Map{"data": value})

-	// 使用 UPSERT 语法解决并发问题
-	switch dbType {
-	case "mysql":
-		upsertSQL := "INSERT INTO `" + tableName + "` (`key`, `value`, `end_time`, `state`, `create_time`, `modify_time`) " +
-			"VALUES (?, ?, ?, 0, ?, ?) " +
-			"ON DUPLICATE KEY UPDATE `value`=VALUES(`value`), `end_time`=VALUES(`end_time`), `modify_time`=VALUES(`modify_time`)"
-		that.Db.Exec(upsertSQL, key, string(bte), endTimeStr, nowTime, nowTime)
-
-	case "sqlite":
-		// SQLite: INSERT OR REPLACE 会删除后插入，所以用 UPSERT 语法
-		upsertSQL := `INSERT INTO "` + tableName + `" ("key", "value", "end_time", "state", "create_time", "modify_time") ` +
-			`VALUES (?, ?, ?, 0, ?, ?) ` +
-			`ON CONFLICT("key") DO UPDATE SET "value"=excluded."value", "end_time"=excluded."end_time", "modify_time"=excluded."modify_time"`
-		that.Db.Exec(upsertSQL, key, string(bte), endTimeStr, nowTime, nowTime)
-
-	case "postgres":
-		upsertSQL := `INSERT INTO "` + tableName + `" ("key", "value", "end_time", "state", "create_time", "modify_time") ` +
-			`VALUES ($1, $2, $3, 0, $4, $5) ` +
-			`ON CONFLICT ("key") DO UPDATE SET "value"=EXCLUDED."value", "end_time"=EXCLUDED."end_time", "modify_time"=EXCLUDED."modify_time"`
-		that.Db.Exec(upsertSQL, key, string(bte), endTimeStr, nowTime, nowTime)
-
-	default:
-		// 兼容其他数据库：使用 Update + Insert
-		num := that.Db.Update(tableName, Map{
-			"value":       string(bte),
-			"end_time":    endTimeStr,
-			"modify_time": nowTime,
-		}, Map{"key": key})
-		if num == 0 {
-			that.Db.Insert(tableName, Map{
-				"key":         key,
-				"value":       string(bte),
-				"end_time":    endTimeStr,
-				"state":       0,
-				"create_time": nowTime,
-				"modify_time": nowTime,
-			})
-		}
+	num := that.Db.Update("cached", Map{"value": string(bte), "time": time.Now().UnixNano(), "endtime": tim}, Map{"key": key})
+	if num == int64(0) {
+		that.Db.Insert("cached", Map{"value": string(bte), "time": time.Now().UnixNano(), "endtime": tim, "key": key})
 	}

-	// #region agent log
-	logFile2, _ := os.OpenFile(`d:\work\hotimev1.5\.cursor\debug.log`, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if logFile2 != nil {
-		fmt.Fprintf(logFile2, `{"hypothesisId":"B","location":"cache_db.go:set","message":"set completed","data":{"key":"%s","endTime":"%s","dbType":"%s"},"timestamp":%d,"sessionId":"debug-session"}`+"\n", key, endTimeStr, dbType, time.Now().UnixMilli())
-		logFile2.Close()
-	}
-	// #endregion
-
-	// 写入历史记录
-	that.writeHistory(key)
-
-	// 随机执行删除过期数据命令（5% 概率）
+	//随机执行删除命令
 	if Rand(1000) > 950 {
-		nowTimeStr := Time2Str(time.Now())
-		that.Db.Delete(tableName, Map{"end_time[<]": nowTimeStr})
+		that.Db.Delete("cached", Map{"endtime[<]": time.Now().Unix()})
 	}
 }

-// delete 删除缓存
 func (that *CacheDb) delete(key string) {
-	tableName := that.getTableName()
+
 	del := strings.Index(key, "*")
-	// 如果通配删除
+	//如果通配删除
 	if del != -1 {
 		key = Substr(key, 0, del)
-		that.Db.Delete(tableName, Map{"key[~]": key + "%"})
+		that.Db.Delete("cached", Map{"key": key + "%"})
+
 	} else {
-		that.Db.Delete(tableName, Map{"key": key})
+		that.Db.Delete("cached", Map{"key": key})
 	}
 }

-// Cache 缓存操作入口
-// 用法：
-//   - Cache(key) - 获取缓存
-//   - Cache(key, value) - 设置缓存（使用默认过期时间）
-//   - Cache(key, value, timeout) - 设置缓存（指定过期时间，单位：秒）
-//   - Cache(key, nil) - 删除缓存
 func (that *CacheDb) Cache(key string, data ...interface{}) *Obj {
+
 	that.initDbTable()

-	// #region agent log
-	logFile, _ := os.OpenFile(`d:\work\hotimev1.5\.cursor\debug.log`, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if logFile != nil {
-		op := "get"
-		if len(data) == 1 && data[0] == nil {
-			op = "delete"
-		} else if len(data) >= 1 {
-			op = "set"
-		}
-		fmt.Fprintf(logFile, `{"hypothesisId":"A","location":"cache_db.go:Cache","message":"Cache called","data":{"key":"%s","operation":"%s","dataLen":%d},"timestamp":%d,"sessionId":"debug-session"}`+"\n", key, op, len(data), time.Now().UnixMilli())
-		logFile.Close()
-	}
-	// #endregion
-
-	// 获取缓存
 	if len(data) == 0 {
 		return &Obj{Data: that.get(key)}
 	}
+	tim := time.Now().Unix()

-	// 删除缓存
 	if len(data) == 1 && data[0] == nil {
 		that.delete(key)
 		return &Obj{Data: nil}
 	}

-	// 计算过期时间
-	var timeout int64
 	if len(data) == 1 {
-		// 使用配置的 TimeOut，如果为 0 则使用默认值
-		timeout = that.TimeOut
-		if timeout == 0 {
-			timeout = DefaultCacheTimeout
+		if that.TimeOut == 0 {
+			//that.Time = Config.GetInt64("cacheLongTime")
 		}
-	} else if len(data) >= 2 {
-		// 使用指定的超时时间
+		tim += that.TimeOut
+	}
+	if len(data) == 2 {
 		that.SetError(nil)
-		tempTimeout := ObjToInt64(data[1], that.Error)
-		if that.GetError() == nil && tempTimeout > 0 {
-			timeout = tempTimeout
-		} else {
-			timeout = that.TimeOut
-			if timeout == 0 {
-				timeout = DefaultCacheTimeout
-			}
+		tempt := ObjToInt64(data[1], that.Error)
+
+		if tempt > tim {
+			tim = tempt
+		} else if that.GetError() == nil {
+
+			tim = tim + tempt
 		}
 	}
-
-	endTime := time.Now().Add(time.Duration(timeout) * time.Second)
-	that.set(key, data[0], endTime)
+	that.set(key, data[0], tim)
 	return &Obj{Data: nil}
 }
--- a/code/makecode.go
+++ b/code/makecode.go
@ -120,9 +120,9 @@ func (that *MakeCode) Db2JSON(db *db.HoTimeDB, config Map) {
 	}
 	//idSlice=append(idSlice,nowTables)
 	for _, v := range nowTables {
-		// if v.GetString("name") == "cached" {
-		// 	continue
-		// }
+		if v.GetString("name") == "cached" {
+			continue
+		}
 		if that.TableConfig.GetMap(v.GetString("name")) == nil {
 			if v.GetString("label") == "" {
 				v["label"] = v.GetString("name")
--- a/docs/HoTimeDB_API参考.md
+++ b/docs/HoTimeDB_API参考.md
@ -98,17 +98,17 @@ id := database.Insert("table", dataMap)
 // 返回新插入记录的ID
 ```

-### 批量插入 (Inserts) - 新增
+### 批量插入 (BatchInsert) - 新增
 ```go
 // 使用 []Map 格式，更直观简洁
-affected := database.Inserts("table", []Map{
+affected := database.BatchInsert("table", []Map{
    {"col1": "val1", "col2": "val2", "col3": "val3"},
    {"col1": "val4", "col2": "val5", "col3": "val6"},
 })
 // 返回受影响的行数

 // 支持 [#] 标记直接 SQL
-affected := database.Inserts("log", []Map{
+affected := database.BatchInsert("log", []Map{
    {"user_id": 1, "created_time[#]": "NOW()"},
    {"user_id": 2, "created_time[#]": "NOW()"},
 })
@ -465,7 +465,7 @@ stats := database.Select("order",
 ### 批量操作
 ```go
 // 批量插入（使用 []Map 格式）
-affected := database.Inserts("user", []Map{
+affected := database.BatchInsert("user", []Map{
    {"name": "用户1", "email": "user1@example.com", "status": 1},
    {"name": "用户2", "email": "user2@example.com", "status": 1},
    {"name": "用户3", "email": "user3@example.com", "status": 1},
@ -511,6 +511,3 @@ result := database.Table("order").

 *快速参考版本: 2.0*  
 *更新日期: 2026年1月*
-
-**详细说明：**
- [HoTimeDB 使用说明](HoTimeDB_使用说明.md) - 完整教程
--- a/docs/HoTimeDB_使用说明.md
+++ b/docs/HoTimeDB_使用说明.md
@ -12,7 +12,7 @@ HoTimeDB是一个基于Golang实现的轻量级ORM框架，参考PHP Medoo设计
  - [查询(Select)](#查询select)
  - [获取单条记录(Get)](#获取单条记录get)
  - [插入(Insert)](#插入insert)
-  - [批量插入(Inserts)](#批量插入Inserts)
+  - [批量插入(BatchInsert)](#批量插入batchinsert)
  - [更新(Update)](#更新update)
  - [Upsert操作](#upsert操作)
  - [删除(Delete)](#删除delete)
@ -223,11 +223,11 @@ id := database.Insert("user", common.Map{
 fmt.Println("插入的用户ID:", id)
 ```

-### 批量插入(Inserts)
+### 批量插入(BatchInsert)

 ```go
 // 批量插入多条记录（使用 []Map 格式，更直观）
-affected := database.Inserts("user", []common.Map{
+affected := database.BatchInsert("user", []common.Map{
    {"name": "张三", "email": "zhang@example.com", "age": 25},
    {"name": "李四", "email": "li@example.com", "age": 30},
    {"name": "王五", "email": "wang@example.com", "age": 28},
@ -237,7 +237,7 @@ affected := database.Inserts("user", []common.Map{
 fmt.Printf("批量插入 %d 条记录\n", affected)

 // 支持 [#] 标记直接插入 SQL 表达式
-affected := database.Inserts("log", []common.Map{
+affected := database.BatchInsert("log", []common.Map{
    {"user_id": 1, "action": "login", "created_time[#]": "NOW()"},
    {"user_id": 2, "action": "logout", "created_time[#]": "NOW()"},
 })
@ -808,7 +808,7 @@ A1: 不再需要！现在多条件会自动用 AND 连接。当然，使用 `AND
 A2: 在 `Action` 函数中返回 `false` 即可触发回滚，所有操作都会被撤销。

 ### Q3: 缓存何时会被清除？
-A3: 执行 `Insert`、`Update`、`Delete`、`Upsert`、`Inserts` 操作时会自动清除对应表的缓存。
+A3: 执行 `Insert`、`Update`、`Delete`、`Upsert`、`BatchInsert` 操作时会自动清除对应表的缓存。

 ### Q4: 如何执行复杂的原生SQL？
 A4: 使用 `Query` 方法执行查询，使用 `Exec` 方法执行更新操作。
@ -828,6 +828,3 @@ A7: 框架会自动处理差异（占位符、引号等），代码无需修改
 *最后更新: 2026年1月*

 > 本文档基于HoTimeDB源码分析生成，如有疑问请参考源码实现。该ORM框架参考了PHP Medoo的设计理念，但根据Golang语言特性进行了适配和优化。
-
-**更多参考：**
- [HoTimeDB API 参考](HoTimeDB_API参考.md) - API 速查手册
--- a/db/README.md
+++ b/db/README.md
@ -0,0 +1,252 @@
+# HoTimeDB ORM 文档集合
+
+这是HoTimeDB ORM框架的完整文档集合，包含使用说明、API参考、示例代码和测试数据。
+
+## ⚠️ 重要更新说明
+
+**语法修正通知**：经过对源码的深入分析，发现HoTimeDB的条件查询语法有特定规则：
+- ✅ **单个条件**：可以直接写在Map中 
+- ⚠️ **多个条件**：必须使用`AND`或`OR`包装
+- 📝 所有文档和示例代码已按正确语法更新
+
+## 📚 文档列表
+
+### 1. [HoTimeDB_使用说明.md](./HoTimeDB_使用说明.md)
+**完整使用说明书** - 详细的功能介绍和使用指南
+- 🚀 快速开始
+- ⚙️ 数据库配置
+- 🔧 基本操作 (CRUD)
+- 🔗 链式查询构建器
+- 🔍 条件查询语法
+- 🔄 JOIN操作
+- 📄 分页查询
+- 📊 聚合函数
+- 🔐 事务处理
+- 💾 缓存机制
+- ⚡ 高级特性
+
+### 2. [HoTimeDB_API参考.md](./HoTimeDB_API参考.md)
+**快速API参考手册** - 开发时的速查手册
+- 📖 基本方法
+- 🔧 CRUD操作
+- 📊 聚合函数
+- 📄 分页查询
+- 🔍 条件语法参考
+- 🔗 JOIN语法
+- 🔐 事务处理
+- 🛠️ 工具方法
+
+### 3. [示例代码文件](../examples/hotimedb_examples.go)
+**完整示例代码集合** - 可运行的实际应用示例（语法已修正）
+- 🏗️ 基本初始化和配置
+- 📝 基本CRUD操作
+- 🔗 链式查询操作
+- 🤝 JOIN查询操作
+- 🔍 条件查询语法
+- 📄 分页查询
+- 📊 聚合函数查询
+- 🔐 事务处理
+- 💾 缓存机制
+- 🔧 原生SQL执行
+- 🚨 错误处理和调试
+- ⚡ 性能优化技巧
+- 🎯 完整应用示例
+
+### 4. [test_tables.sql](./test_tables.sql)
+**测试数据库结构** - 快速搭建测试环境
+- 🏗️ 完整的表结构定义
+- 📊 测试数据插入
+- 🔍 索引优化
+- 👁️ 视图示例
+- 🔧 存储过程示例
+
+## 🎯 核心特性
+
+### 🌟 主要优势
+- **类Medoo语法**: 参考PHP Medoo设计，语法简洁易懂
+- **链式查询**: 支持流畅的链式查询构建器
+- **条件丰富**: 支持丰富的条件查询语法
+- **事务支持**: 完整的事务处理机制
+- **缓存集成**: 内置查询结果缓存
+- **读写分离**: 支持主从数据库配置
+- **类型安全**: 基于Golang的强类型系统
+
+### 🔧 支持的数据库
+- ✅ MySQL
+- ✅ SQLite
+- ✅ 其他标准SQL数据库
+
+## 🚀 快速开始
+
+### 1. 安装依赖
+```bash
+go mod init your-project
+go get github.com/go-sql-driver/mysql
+go get github.com/sirupsen/logrus
+```
+
+### 2. 创建测试数据库
+```bash
+mysql -u root -p < test_tables.sql
+```
+
+### 3. 基本使用
+```go
+import (
+    "code.hoteas.com/golang/hotime/db"
+    "code.hoteas.com/golang/hotime/common"
+    "database/sql"
+    _ "github.com/go-sql-driver/mysql"
+)
+
+// 初始化数据库
+database := &db.HoTimeDB{
+    Prefix: "app_",
+    Mode:   2, // 开发模式
+}
+
+database.SetConnect(func() (master, slave *sql.DB) {
+    master, _ = sql.Open("mysql", "user:pass@tcp(localhost:3306)/dbname")
+    return master, master
+})
+
+// 链式查询（链式语法支持单独Where然后用And添加条件）
+users := database.Table("user").
+    Where("status", 1).       // 链式中可以单独Where
+    And("age[>]", 18).        // 用And添加更多条件
+    Order("created_time DESC").
+    Limit(0, 10).
+    Select("id,name,email")
+
+// 或者使用传统语法（多个条件必须用AND包装）
+users2 := database.Select("user", "id,name,email", common.Map{
+    "AND": common.Map{
+        "status": 1,
+        "age[>]": 18,
+    },
+    "ORDER": "created_time DESC",
+    "LIMIT": []int{0, 10},
+})
+```
+
+## ⚠️ 重要语法规则
+
+**条件查询语法规则：**
+- ✅ **单个条件**：可以直接写在Map中
+- ✅ **多个条件**：必须使用`AND`或`OR`包装
+- ✅ **特殊参数**：`ORDER`、`GROUP`、`LIMIT`与条件同级
+
+```go
+// ✅ 正确：单个条件
+Map{"status": 1}
+
+// ✅ 正确：多个条件用AND包装  
+Map{
+    "AND": Map{
+        "status": 1,
+        "age[>]": 18,
+    },
+    "ORDER": "id DESC",
+}
+
+// ❌ 错误：多个条件不用AND包装
+Map{
+    "status": 1,
+    "age[>]": 18,  // 不支持！
+}
+```
+
+## 📝 条件查询语法速查
+
+| 语法 | SQL | 说明 |
+|------|-----|------|
+| `"field": value` | `field = ?` | 等于 |
+| `"field[!]": value` | `field != ?` | 不等于 |
+| `"field[>]": value` | `field > ?` | 大于 |
+| `"field[>=]": value` | `field >= ?` | 大于等于 |
+| `"field[<]": value` | `field < ?` | 小于 |
+| `"field[<=]": value` | `field <= ?` | 小于等于 |
+| `"field[~]": "keyword"` | `field LIKE '%keyword%'` | 包含 |
+| `"field[<>]": [min, max]` | `field BETWEEN ? AND ?` | 区间内 |
+| `"field": [v1, v2, v3]` | `field IN (?, ?, ?)` | 在集合中 |
+| `"field": nil` | `field IS NULL` | 为空 |
+| `"field[#]": "NOW()"` | `field = NOW()` | 直接SQL |
+
+## 🔗 JOIN语法速查
+
+| 语法 | SQL | 说明 |
+|------|-----|------|
+| `"[>]table"` | `LEFT JOIN` | 左连接 |
+| `"[<]table"` | `RIGHT JOIN` | 右连接 |
+| `"[><]table"` | `INNER JOIN` | 内连接 |
+| `"[<>]table"` | `FULL JOIN` | 全连接 |
+
+## 🛠️ 链式方法速查
+
+```go
+db.Table("table")           // 指定表名
+  .Where(key, value)        // WHERE条件
+  .And(key, value)          // AND条件
+  .Or(map)                  // OR条件
+  .LeftJoin(table, on)      // LEFT JOIN
+  .Order(fields...)         // ORDER BY
+  .Group(fields...)         // GROUP BY
+  .Limit(offset, limit)     // LIMIT
+  .Page(page, pageSize)     // 分页
+  .Select(fields...)        // 查询
+  .Get(fields...)           // 获取单条
+  .Count()                  // 计数
+  .Update(data)             // 更新
+  .Delete()                 // 删除
+```
+
+## ⚡ 性能优化建议
+
+### 🔍 查询优化
+- 使用合适的索引字段作为查询条件
+- IN查询会自动优化为BETWEEN（连续数字）
+- 避免SELECT *，指定需要的字段
+- 合理使用LIMIT限制结果集大小
+
+### 💾 缓存使用
+- 查询结果会自动缓存
+- 增删改操作会自动清除缓存
+- `cached`表不参与缓存
+
+### 🔐 事务处理
+- 批量操作使用事务提高性能
+- 事务中避免长时间操作
+- 合理设置事务隔离级别
+
+## 🚨 注意事项
+
+### 🔒 安全相关
+- 使用参数化查询防止SQL注入
+- `[#]`语法需要注意防止注入
+- 敏感数据加密存储
+
+### 🎯 最佳实践
+- 开发时设置`Mode = 2`便于调试
+- 生产环境设置`Mode = 0`
+- 合理设置表前缀
+- 定期检查慢查询日志
+
+## 🤝 与PHP Medoo的差异
+
+1. **类型系统**: 使用`common.Map`和`common.Slice`
+2. **错误处理**: Golang风格的错误处理
+3. **链式调用**: 提供更丰富的链式API
+4. **缓存集成**: 内置缓存功能
+5. **并发安全**: 需要注意并发使用
+
+## 📞 技术支持
+
+- 📧 查看源码：`hotimedb.go`
+- 📖 参考文档：本目录下的各个文档文件
+- 🔧 示例代码：运行`HoTimeDB_示例代码.go`中的示例
+
+---
+
+**HoTimeDB ORM框架 - 让数据库操作更简单！** 🎉
+
+> 本文档基于HoTimeDB源码分析生成，参考了PHP Medoo的设计理念，并根据Golang语言特性进行了优化。
--- a/db/crud.go
+++ b/db/crud.go
@ -307,19 +307,19 @@ func (that *HoTimeDB) Insert(table string, data map[string]interface{}) int64 {
 	return id
 }

-// Inserts 批量插入数据
+// BatchInsert 批量插入数据
 // table: 表名
 // dataList: 数据列表，每个元素是一个 Map
 // 返回受影响的行数
 //
 // 示例:
 //
-//	affected := db.Inserts("user", []Map{
+//	affected := db.BatchInsert("user", []Map{
 //	    {"name": "张三", "age": 25, "email": "zhang@example.com"},
 //	    {"name": "李四", "age": 30, "email": "li@example.com"},
 //	    {"name": "王五", "age": 28, "email": "wang@example.com"},
 //	})
-func (that *HoTimeDB) Inserts(table string, dataList []Map) int64 {
+func (that *HoTimeDB) BatchInsert(table string, dataList []Map) int64 {
 	if len(dataList) == 0 {
 		return 0
 	}
--- a/db/dialect_test.go
+++ b/db/dialect_test.go
@ -1,7 +1,6 @@
 package db

 import (
-	. "code.hoteas.com/golang/hotime/common"
 	"fmt"
 	"strings"
 	"testing"
@ -249,170 +248,6 @@ func TestHoTimeDBHelperMethods(t *testing.T) {
 	})
 }

-// TestWhereWithORCondition 测试 OR 条件处理是否正确添加括号
-func TestWhereWithORCondition(t *testing.T) {
-	// 创建 MySQL 数据库实例
-	mysqlDB := &HoTimeDB{
-		Type:   "mysql",
-		Prefix: "",
-	}
-	mysqlDB.initDialect()
-
-	// 测试 OR 与普通条件组合 (假设 A: 顺序问题)
-	t.Run("OR with normal condition", func(t *testing.T) {
-		data := Map{
-			"OR": Map{
-				"username": "test",
-				"phone":    "123",
-			},
-			"state": 0,
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 1 - OR with normal condition:")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-
-		// 检查 OR 条件是否被括号包裹
-		if !strings.Contains(where, "(") || !strings.Contains(where, ")") {
-			t.Errorf("OR condition should be wrapped with parentheses, got: %s", where)
-		}
-
-		// 检查是否有 AND 连接
-		if !strings.Contains(where, "AND") {
-			t.Errorf("OR condition and normal condition should be connected with AND, got: %s", where)
-		}
-	})
-
-	// 测试纯 OR 条件（无其他普通条件）
-	t.Run("Pure OR condition", func(t *testing.T) {
-		data := Map{
-			"OR": Map{
-				"username": "test",
-				"phone":    "123",
-			},
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 2 - Pure OR condition:")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-
-		// 检查 OR 条件内部应该用 OR 连接
-		if !strings.Contains(where, "OR") {
-			t.Errorf("OR condition should contain OR keyword, got: %s", where)
-		}
-	})
-
-	// 测试多个普通条件与 OR 组合 (假设 A)
-	t.Run("OR with multiple normal conditions", func(t *testing.T) {
-		data := Map{
-			"OR": Map{
-				"username": "test",
-				"phone":    "123",
-			},
-			"state":  0,
-			"status": 1,
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 3 - OR with multiple normal conditions:")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-
-		// 应该有括号
-		if !strings.Contains(where, "(") {
-			t.Errorf("OR condition should be wrapped with parentheses, got: %s", where)
-		}
-	})
-
-	// 测试嵌套 AND/OR 条件 (假设 B, E)
-	t.Run("Nested AND/OR conditions", func(t *testing.T) {
-		data := Map{
-			"OR": Map{
-				"username": "test",
-				"AND": Map{
-					"phone":  "123",
-					"status": 1,
-				},
-			},
-			"state": 0,
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 4 - Nested AND/OR conditions:")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-	})
-
-	// 测试空 OR 条件 (假设 C)
-	t.Run("Empty OR condition", func(t *testing.T) {
-		data := Map{
-			"OR":    Map{},
-			"state": 0,
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 5 - Empty OR condition:")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-	})
-
-	// 测试 OR 与 LIMIT, ORDER 组合 (假设 D)
-	t.Run("OR with LIMIT and ORDER", func(t *testing.T) {
-		data := Map{
-			"OR": Map{
-				"username": "test",
-				"phone":    "123",
-			},
-			"state": 0,
-			"ORDER": "id DESC",
-			"LIMIT": 10,
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 6 - OR with LIMIT and ORDER:")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-	})
-
-	// 测试同时有 OR 和 AND 关键字 (假设 E)
-	t.Run("Both OR and AND keywords", func(t *testing.T) {
-		data := Map{
-			"OR": Map{
-				"username": "test",
-				"phone":    "123",
-			},
-			"AND": Map{
-				"type":   1,
-				"source": "web",
-			},
-			"state": 0,
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 7 - Both OR and AND keywords:")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-	})
-
-	// 测试普通条件在 OR 之前（排序后）(假设 A)
-	t.Run("Normal condition before OR alphabetically", func(t *testing.T) {
-		data := Map{
-			"OR": Map{
-				"username": "test",
-				"phone":    "123",
-			},
-			"active": 1, // 'a' 在 'O' 之前
-		}
-
-		where, params := mysqlDB.where(data)
-		fmt.Println("Test 8 - Normal condition before OR (alphabetically):")
-		fmt.Println("  Generated WHERE:", where)
-		fmt.Println("  Params count:", len(params))
-	})
-}
-
 // 打印测试结果（用于调试）
 func ExampleIdentifierProcessor() {
 	// MySQL 示例
--- a/db/where.go
+++ b/db/where.go
@ -70,8 +70,8 @@ func (that *HoTimeDB) where(data Map) (string, []interface{}) {
 	}
 	sort.Strings(testQu)

-	// 追踪条件数量，用于自动添加 AND
-	condCount := 0
+	// 追踪普通条件数量，用于自动添加 AND
+	normalCondCount := 0

 	for _, k := range testQu {
 		v := data[k]
@ -79,16 +79,8 @@ func (that *HoTimeDB) where(data Map) (string, []interface{}) {
 		// 检查是否是 AND/OR 条件关键字
 		if isConditionKey(k) {
 			tw, ts := that.cond(strings.ToUpper(k), v.(Map))
-			if tw != "" && strings.TrimSpace(tw) != "" {
-				// 与前面的条件用 AND 连接
-				if condCount > 0 {
-					where += " AND "
-				}
-				// 用括号包裹 OR/AND 组条件
-				where += "(" + strings.TrimSpace(tw) + ")"
-				condCount++
-				res = append(res, ts...)
-			}
+			where += tw
+			res = append(res, ts...)
 			continue
 		}

@ -103,11 +95,11 @@ func (that *HoTimeDB) where(data Map) (string, []interface{}) {
 			// 检查是否是 NOT IN（带 [!] 后缀）- NOT IN 空数组永真，跳过即可
 			if !strings.HasSuffix(k, "[!]") {
 				// IN 空数组 -> 生成永假条件
-				if condCount > 0 {
+				if normalCondCount > 0 {
 					where += " AND "
 				}
 				where += "1=0 "
-				condCount++
+				normalCondCount++
 			}
 			continue
 		}
@ -115,11 +107,11 @@ func (that *HoTimeDB) where(data Map) (string, []interface{}) {
 			// 检查是否是 NOT IN（带 [!] 后缀）- NOT IN 空数组永真，跳过即可
 			if !strings.HasSuffix(k, "[!]") {
 				// IN 空数组 -> 生成永假条件
-				if condCount > 0 {
+				if normalCondCount > 0 {
 					where += " AND "
 				}
 				where += "1=0 "
-				condCount++
+				normalCondCount++
 			}
 			continue
 		}
@ -127,11 +119,11 @@ func (that *HoTimeDB) where(data Map) (string, []interface{}) {
 		tv, vv := that.varCond(k, v)
 		if tv != "" {
 			// 自动添加 AND 连接符
-			if condCount > 0 {
+			if normalCondCount > 0 {
 				where += " AND "
 			}
 			where += tv
-			condCount++
+			normalCondCount++
 			res = append(res, vv...)
 		}
 	}
--- a/docs/CodeConfig_代码生成配置规范.md
+++ b/docs/CodeConfig_代码生成配置规范.md
@ -1,757 +0,0 @@
-# 代码生成配置规范
-
-本文档详细说明 HoTime 框架代码生成器的配置体系，包括 `config.json` 中的 `codeConfig`、菜单权限配置和字段规则配置。
-
---
-
-## 配置体系概览
-
-```
-config.json
-└── codeConfig[]              # 代码生成配置数组（支持多套）
-    ├── config                # 菜单权限配置文件路径（如 admin.json）
-    ├── configDB              # 数据库生成的完整配置
-    ├── rule                  # 字段规则配置文件路径（如 rule.json）
-    ├── table                 # 管理员表名
-    ├── name                  # 生成代码的包名
-    └── mode                  # 生成模式
-```
-
---
-
-## 一、config.json 中的 codeConfig
-
-### 配置结构
-
-```json
-{
-    "codeConfig": [
-        {
-            "config": "config/admin.json",
-            "configDB": "config/adminDB.json",
-            "mode": 0,
-            "name": "",
-            "rule": "config/rule.json",
-            "table": "admin"
-        }
-    ]
-}
-```
-
-### 配置项说明
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| config | string | 菜单权限配置文件路径，用于定义菜单结构、权限控制 |
-| configDB | string | 代码生成器输出的完整配置文件（自动生成） |
-| rule | string | 字段规则配置文件路径，定义字段在增删改查中的行为 |
-| table | string | 管理员/用户表名，用于身份验证和权限控制 |
-| name | string | 生成的代码包名，为空则不生成代码文件 |
-| mode | int | 生成模式：0-仅配置不生成代码，非0-生成代码文件 |
-
-### 多配置支持
-
-可以配置多个独立的代码生成实例，适用于多端场景：
-
-```json
-{
-    "codeConfig": [
-        {
-            "config": "config/admin.json",
-            "table": "admin",
-            "rule": "config/rule.json"
-        },
-        {
-            "config": "config/user.json",
-            "table": "user",
-            "rule": "config/rule.json"
-        }
-    ]
-}
-```
-
---
-
-## 二、菜单权限配置（如 admin.json）
-
-### 配置文件更新机制
-
- **首次运行**：代码生成器会根据数据库表结构自动创建配置文件（如 admin.json）
- **后续运行**：配置文件**不会自动更新**，避免覆盖手动修改的内容
- **重新生成**：如需重新生成，删除配置文件后重新运行即可
- **参考更新**：可参考 `configDB` 指定的文件（如 adminDB.json）查看最新的数据库结构变化，手动调整配置
-
-### 完整配置结构
-
-```json
-{
-    "id": "唯一标识（自动生成）",
-    "name": "admin",
-    "label": "管理平台名称",
-    "labelConfig": { ... },
-    "menus": [ ... ],
-    "flow": { ... }
-}
-```
-
-### 2.1 label 配置
-
-定义系统显示名称：
-
-```json
-{
-    "label": "HoTime管理平台"
-}
-```
-
-### 2.2 labelConfig 配置
-
-定义权限的显示文字：
-
-```json
-{
-    "labelConfig": {
-        "show": "开启",
-        "add": "添加",
-        "delete": "删除",
-        "edit": "编辑",
-        "info": "查看详情",
-        "download": "下载清单"
-    }
-}
-```
-
-| 操作 | 说明 |
-|------|------|
-| show | 显示/查看列表权限 |
-| add | 添加数据权限 |
-| delete | 删除数据权限 |
-| edit | 编辑数据权限 |
-| info | 查看详情权限 |
-| download | 下载/导出权限 |
-
-### 2.3 menus 配置
-
-定义菜单结构，支持多级嵌套：
-
-```json
-{
-    "menus": [
-        {
-            "label": "系统管理",
-            "name": "sys",
-            "icon": "Setting",
-            "auth": ["show"],
-            "menus": [
-                {
-                    "label": "用户管理",
-                    "table": "user",
-                    "auth": ["show", "add", "delete", "edit", "info", "download"]
-                },
-                {
-                    "label": "角色管理",
-                    "table": "role",
-                    "auth": ["show", "add", "delete", "edit", "info"]
-                }
-            ]
-        },
-        {
-            "label": "文章管理",
-            "table": "article",
-            "icon": "Document",
-            "auth": ["show", "add", "edit", "info"]
-        }
-    ]
-}
-```
-
-#### menus 字段说明
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| label | string | 菜单显示名称 |
-| name | string | 菜单标识（用于分组，不绑定表时使用） |
-| table | string | 绑定的数据表名（用于自动生成 CRUD） |
-| icon | string | 菜单图标名称 |
-| auth | array | 权限数组，定义该菜单/表拥有的操作权限 |
-| menus | array | 子菜单数组（支持嵌套） |
-
-#### name vs table
-
- **table**: 绑定数据表，拥有该表的增删查改等权限，自动生成 CRUD 接口
- **name**: 自定义功能标识，不绑定表，前端根据 name 和 auth 来显示和操作自定义内容（如首页 home、仪表盘 dashboard 等）
-  - 如果配置了 `menus` 子菜单，则作为分组功能，前端展开显示下级菜单
-  - 如果没有 `menus`，则作为独立的自定义功能入口
-
-**注意**：目前只支持**两级菜单**，不允许更多层级嵌套。
-
-```json
-// 使用 table：绑定数据表，有增删查改权限
-{ "label": "用户管理", "table": "user", "auth": ["show", "add", "edit", "delete"] }
-
-// 使用 name：自定义功能（无子菜单）
-{ "label": "首页", "name": "home", "icon": "House", "auth": ["show"] }
-
-// 使用 name：分组功能（有子菜单）
-{ "label": "系统管理", "name": "sys", "icon": "Setting", "auth": ["show"], "menus": [...] }
-```
-
-#### 自动分组规则
-
-代码生成器在自动生成配置时，会根据表名的 `_` 分词进行自动分组：
-
- 表名 `sys_logs`、`sys_menus`、`sys_config` → 自动归入 `sys` 分组
- 表名 `article`、`article_tag` → 自动归入 `article` 分组
-
-分组的显示名称（label）使用该分组下**第一张表的名字**，如果表有备注则使用备注名。
-
-### 2.4 auth 配置
-
-权限数组定义菜单/表拥有的操作权限：
-
-```json
-{
-    "auth": ["show", "add", "delete", "edit", "info", "download"]
-}
-```
-
-#### 内置权限
-
-| 权限 | 对应接口 | 说明 |
-|------|----------|------|
-| show | /search | 列表查询 |
-| add | /add | 新增数据 |
-| delete | /remove | 删除数据 |
-| edit | /update | 编辑数据 |
-| info | /info | 查看详情 |
-| download | /search?download=1 | 导出数据 |
-
-#### 自定义权限扩展
-
-auth 数组**可以自由增删**，新增的权限项会：
- 在前端菜单/功能中显示
- 在角色管理（role）的权限设置中显示，供管理员分配
-
-```json
-// 示例：为文章表添加自定义权限
-{
-    "label": "文章管理",
-    "table": "article",
-    "auth": ["show", "add", "edit", "delete", "info", "publish", "audit", "top"]
-}
-```
-
-上例中 `publish`（发布）、`audit`（审核）、`top`（置顶）为自定义权限，前端可根据这些权限控制对应按钮的显示和操作。
-
-### 2.5 icon 配置
-
-菜单图标，使用 Element Plus 图标名称：
-
-```json
-{ "icon": "Setting" }    // 设置图标
-{ "icon": "User" }       // 用户图标
-{ "icon": "Document" }   // 文档图标
-{ "icon": "Folder" }     // 文件夹图标
-```
-
-### 2.6 flow 配置
-
-flow 是一个简易的数据权限控制机制，用于限制用户只能操作自己权限范围内的数据。
-
-#### 基本结构
-
-```json
-{
-    "flow": {
-        "role": {
-            "table": "role",
-            "stop": true,
-            "sql": {
-                "id": "role_id"
-            }
-        },
-        "article": {
-            "table": "article",
-            "stop": false,
-            "sql": {
-                "admin_id": "id"
-            }
-        },
-        "org": {
-            "table": "org",
-            "stop": false,
-            "sql": {
-                "parent_ids[~]": ",org_id,"
-            }
-        }
-    }
-}
-```
-
-#### flow 字段说明
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| table | string | 表名 |
-| stop | bool | 是否禁止修改自身关联的数据 |
-| sql | object | 数据过滤条件，自动填充查询/操作条件 |
-
-#### stop 配置详解
-
-`stop` 用于防止用户修改自己当前关联的敏感数据。
-
-**场景示例**：当前登录用户是 admin 表的用户，其 `role_id = 1`
-
-```json
-"role": {
-    "table": "role",
-    "stop": true,
-    "sql": { "id": "role_id" }
-}
-```
-
-**效果**：
- 用户**不能修改** role 表中 `id = 1` 的这行数据（自己的角色）
- 用户**可以修改**其他 role 记录（如果有权限的话）
-
-**典型用途**：
- 防止用户提升自己的角色权限
- 防止用户修改自己所属的组织
-
-#### sql 配置详解
-
-`sql` 用于自动填充数据过滤条件，实现数据隔离。
-
-**格式**：`{ "目标表字段": "当前用户字段" }`
-
-**示例 1：精确匹配**
-
-```json
-"article": {
-    "sql": { "admin_id": "id" }
-}
-```
-
-**效果**：查询/操作 article 表时，自动添加条件 `WHERE admin_id = 当前用户.id`
-
-即：用户只能看到/操作自己创建的文章。
-
-**示例 2：角色关联**
-
-```json
-"role": {
-    "sql": { "id": "role_id" }
-}
-```
-
-**效果**：查询/操作 role 表时，自动添加条件 `WHERE id = 当前用户.role_id`
-
-即：用户只能看到自己的角色。
-
-**示例 3：树形结构（模糊匹配）**
-
-```json
-"org": {
-    "sql": { "parent_ids[~]": ",org_id," }
-}
-```
-
-**效果**：查询/操作 org 表时，自动添加条件 `WHERE parent_ids LIKE '%,用户.org_id,%'`
-
-即：用户只能看到自己组织及其下级组织。
-
-#### sql 条件语法
-
-| 格式 | 含义 | SQL 等价 |
-|------|------|----------|
-| `"field": "user_field"` | 精确匹配 | `field = 用户.user_field` |
-| `"field[~]": ",value,"` | 模糊匹配 | `field LIKE '%,value,%'` |
-
-#### 完整示例
-
-假设当前登录用户数据：
-```json
-{ "id": 5, "role_id": 2, "org_id": 10 }
-```
-
-flow 配置：
-```json
-{
-    "flow": {
-        "role": {
-            "table": "role",
-            "stop": true,
-            "sql": { "id": "role_id" }
-        },
-        "article": {
-            "table": "article",
-            "stop": false,
-            "sql": { "admin_id": "id" }
-        },
-        "org": {
-            "table": "org",
-            "stop": false,
-            "sql": { "parent_ids[~]": ",org_id," }
-        }
-    }
-}
-```
-
-**效果**：
-
-| 表 | 查询条件 | stop 效果 |
-|-----|----------|-----------|
-| role | `WHERE id = 2` | 不能修改 id=2 的角色 |
-| article | `WHERE admin_id = 5` | 可以修改自己的文章 |
-| org | `WHERE parent_ids LIKE '%,10,%'` | 可以修改下级组织 |
-
---
-
-## 三、字段规则配置（rule.json）
-
-定义字段在增删改查操作中的默认行为。
-
-### 配置结构
-
-```json
-[
-    {
-        "name": "id",
-        "add": false,
-        "edit": false,
-        "info": true,
-        "list": true,
-        "must": false,
-        "strict": true,
-        "type": ""
-    }
-]
-```
-
-### 字段属性说明
-
-| 属性 | 类型 | 说明 |
-|------|------|------|
-| name | string | 字段名或字段名包含的关键词 |
-| add | bool | 新增时是否显示该字段 |
-| edit | bool | 编辑时是否显示该字段 |
-| info | bool | 详情页是否显示该字段 |
-| list | bool | 列表页是否显示该字段 |
-| must | bool | 是否必填（详见下方说明） |
-| strict | bool | 是否严格匹配字段名（true=完全匹配，false=包含匹配） |
-| type | string | 字段类型（影响前端控件和数据处理） |
-
-### must 必填字段规则
-
-`must` 字段用于控制前端表单的必填验证：
-
-**自动识别规则**：
-1. **MySQL**：如果字段设置为 `NOT NULL`（即 `IS_NULLABLE='NO'`），自动设为 `must=true`
-2. **SQLite**：如果字段是主键（`pk=1`），自动设为 `must=true`
-
-**规则配置覆盖**：
- `rule.json` 中的 `must` 设置会覆盖数据库的自动识别结果
- 可以将数据库中 NOT NULL 的字段在规则中设为 `must=false`，反之亦然
-
-**前端效果**：
- `must=true` 的字段在新增/编辑表单中显示必填标记（*）
- 提交时前端会验证必填字段
-
-**后端验证**：
- 新增操作时，如果 `must=true` 的字段为空，返回"请求参数不足"
-
-### type 类型说明
-
-| 类型 | 说明 | 前端控件 |
-|------|------|----------|
-| （空） | 普通文本 | 文本输入框 |
-| text | 文本 | 文本输入框 |
-| number | 数字 | 数字输入框 |
-| select | 选择 | 下拉选择框（根据注释自动生成选项） |
-| time | 时间（datetime） | 日期时间选择器 |
-| unixTime | 时间戳 | 日期时间选择器（存储为 Unix 时间戳） |
-| password | 密码 | 密码输入框（自动 MD5 加密） |
-| textArea | 多行文本 | 文本域 |
-| image | 图片 | 图片上传 |
-| file | 文件 | 文件上传 |
-| money | 金额 | 金额输入框 |
-| auth | 权限 | 权限树选择器 |
-| form | 表单 | 动态表单 |
-| index | 索引 | 隐藏字段（用于 parent_ids 等） |
-| table | 动态表 | 表名选择器 |
-| table_id | 动态表ID | 根据 table 字段动态关联 |
-
-### 内置字段规则
-
-以下是框架默认的字段规则，可在 `rule.json` 中覆盖：
-
-#### 主键和索引
-
-```json
-{"name": "id", "add": false, "list": true, "edit": false, "info": true, "strict": true}
-{"name": "sn", "add": false, "list": true, "edit": false, "info": true}
-{"name": "parent_ids", "add": false, "list": false, "edit": false, "info": false, "type": "index", "strict": true}
-{"name": "index", "add": false, "list": false, "edit": false, "info": false, "type": "index", "strict": true}
-```
-
-#### 层级关系
-
-```json
-{"name": "parent_id", "add": true, "list": true, "edit": true, "info": true}
-{"name": "level", "add": false, "list": false, "edit": false, "info": true}
-```
-
-#### 时间字段
-
-```json
-{"name": "create_time", "add": false, "list": false, "edit": false, "info": true, "type": "time", "strict": true}
-{"name": "modify_time", "add": false, "list": true, "edit": false, "info": true, "type": "time", "strict": true}
-{"name": "time", "add": true, "list": true, "edit": true, "info": true, "type": "time"}
-```
-
-#### 状态字段
-
-```json
-{"name": "status", "add": true, "list": true, "edit": true, "info": true, "type": "select"}
-{"name": "state", "add": true, "list": true, "edit": true, "info": true, "type": "select"}
-{"name": "sex", "add": true, "list": true, "edit": true, "info": true, "type": "select"}
-```
-
-#### 敏感字段
-
-```json
-{"name": "password", "add": true, "list": false, "edit": true, "info": false, "type": "password"}
-{"name": "pwd", "add": true, "list": false, "edit": true, "info": false, "type": "password"}
-{"name": "delete", "add": false, "list": false, "edit": false, "info": false}
-{"name": "version", "add": false, "list": false, "edit": false, "info": false}
-```
-
-#### 媒体字段
-
-```json
-{"name": "image", "add": true, "list": false, "edit": true, "info": true, "type": "image"}
-{"name": "img", "add": true, "list": false, "edit": true, "info": true, "type": "image"}
-{"name": "avatar", "add": true, "list": false, "edit": true, "info": true, "type": "image"}
-{"name": "icon", "add": true, "list": false, "edit": true, "info": true, "type": "image"}
-{"name": "file", "add": true, "list": false, "edit": true, "info": true, "type": "file"}
-```
-
-#### 文本字段
-
-```json
-{"name": "info", "add": true, "list": false, "edit": true, "info": true, "type": "textArea"}
-{"name": "content", "add": true, "list": false, "edit": true, "info": true, "type": "textArea"}
-{"name": "description", "add": true, "list": false, "edit": true, "info": true}
-{"name": "note", "add": true, "list": false, "edit": true, "info": true}
-{"name": "address", "add": true, "list": true, "edit": true, "info": true}
-```
-
-#### 特殊字段
-
-```json
-{"name": "amount", "add": true, "list": true, "edit": true, "info": true, "type": "money", "strict": true}
-{"name": "auth", "add": true, "list": false, "edit": true, "info": true, "type": "auth", "strict": true}
-{"name": "rule", "add": true, "list": true, "edit": true, "info": true, "type": "form"}
-{"name": "table", "add": false, "list": true, "edit": false, "info": true, "type": "table"}
-{"name": "table_id", "add": false, "list": true, "edit": false, "info": true, "type": "table_id"}
-```
-
-### 自定义字段规则
-
-在 `rule.json` 中添加项目特定的字段规则：
-
-```json
-[
-    // 项目特定规则
-    {
-        "name": "company_name",
-        "add": true,
-        "edit": true,
-        "info": true,
-        "list": true,
-        "must": true,
-        "strict": true,
-        "type": ""
-    },
-    // 表.字段 形式的精确规则
-    {
-        "name": "user.nickname",
-        "add": true,
-        "edit": true,
-        "info": true,
-        "list": true,
-        "strict": true,
-        "type": ""
-    }
-]
-```
-
---
-
-## 四、配置示例
-
-### 完整的 admin.json 示例
-
-```json
-{
-    "id": "74a8a59407fa7d6c7fcdc85742dbae57",
-    "name": "admin",
-    "label": "后台管理系统",
-    "labelConfig": {
-        "show": "开启",
-        "add": "添加",
-        "delete": "删除",
-        "edit": "编辑",
-        "info": "查看详情",
-        "download": "下载清单"
-    },
-    "menus": [
-        {
-            "label": "系统管理",
-            "name": "sys",
-            "icon": "Setting",
-            "auth": ["show"],
-            "menus": [
-                {
-                    "label": "日志管理",
-                    "table": "logs",
-                    "auth": ["show", "download"]
-                },
-                {
-                    "label": "角色管理",
-                    "table": "role",
-                    "auth": ["show", "add", "delete", "edit", "info"]
-                },
-                {
-                    "label": "组织管理",
-                    "table": "org",
-                    "auth": ["show", "add", "delete", "edit", "info"]
-                },
-                {
-                    "label": "人员管理",
-                    "table": "admin",
-                    "auth": ["show", "add", "delete", "edit", "info", "download"]
-                }
-            ]
-        }
-    ],
-    "flow": {
-        "admin": {
-            "table": "admin",
-            "stop": false,
-            "sql": { "role_id": "role_id" }
-        },
-        "role": {
-            "table": "role",
-            "stop": true,
-            "sql": { "admin_id": "id", "id": "role_id" }
-        },
-        "org": {
-            "table": "org",
-            "stop": false,
-            "sql": { "admin_id": "id" }
-        },
-        "logs": {
-            "table": "logs",
-            "stop": false,
-            "sql": {}
-        }
-    }
-}
-```
-
---
-
-## 五、SQLite 备注替代方案
-
-SQLite 数据库不支持表备注（TABLE COMMENT）和字段备注（COLUMN COMMENT），代码生成器会使用表名/字段名作为默认显示名称。
-
-### 通过配置文件设置备注
-
-利用 HoTime 的配置覆盖机制，可以在配置文件中手动设置显示名称和提示：
-
-**步骤**：
-1. 首次运行，生成配置文件（如 admin.json）
-2. 编辑配置文件中的 `tables` 部分
-
-### 设置表显示名称
-
-在菜单配置中设置 `label`：
-
-```json
-{
-    "menus": [
-        {
-            "label": "用户管理",  // 手动设置表显示名称
-            "table": "user",
-            "auth": ["show", "add", "edit", "delete"]
-        }
-    ]
-}
-```
-
-### 设置字段显示名称和提示
-
-在 `configDB` 文件（如 adminDB.json）中的 `tables.表名.columns` 部分设置：
-
-```json
-{
-    "tables": {
-        "user": {
-            "label": "用户管理",
-            "columns": [
-                {
-                    "name": "id",
-                    "label": "ID",
-                    "type": "number"
-                },
-                {
-                    "name": "name",
-                    "label": "用户名",
-                    "ps": "请输入用户名",  // 前端输入提示
-                    "must": true
-                },
-                {
-                    "name": "phone",
-                    "label": "手机号",
-                    "ps": "请输入11位手机号"
-                },
-                {
-                    "name": "status",
-                    "label": "状态",
-                    "type": "select",
-                    "options": [
-                        {"name": "正常", "value": "0"},
-                        {"name": "禁用", "value": "1"}
-                    ]
-                }
-            ]
-        }
-    }
-}
-```
-
-**注意**：直接编辑的是 `configDB` 指定的文件（如 adminDB.json），该文件会在每次启动时重新生成。如需持久化修改，应将自定义的 columns 配置放入 `config` 指定的文件（如 admin.json）中。
-
---
-
-## 六、配置检查清单
-
-### codeConfig 检查
-
- [ ] config 文件路径正确
- [ ] rule 文件路径正确
- [ ] table 指定的管理员表存在
-
-### 菜单权限配置检查
-
- [ ] 所有 table 指向的表在数据库中存在
- [ ] auth 数组包含需要的权限
- [ ] menus 结构正确（有子菜单用 name，无子菜单用 table）
- [ ] flow 配置的 sql 条件字段存在
-
-### 字段规则配置检查
-
- [ ] strict=true 的规则字段名完全匹配
- [ ] type 类型与前端控件需求一致
- [ ] 敏感字段（password等）的 list 和 info 为 false
--- a/docs/CodeGen_使用说明.md
+++ b/docs/CodeGen_使用说明.md
@ -1,468 +0,0 @@
-# HoTime 代码生成器使用说明
-
-`code` 包提供了 HoTime 框架的自动代码生成功能，能够根据数据库表结构自动生成 CRUD 接口代码和配置文件。
-
-## 目录
-
- [功能概述](#功能概述)
- [配置说明](#配置说明)
- [使用方法](#使用方法)
- [生成规则](#生成规则)
- [自定义规则](#自定义规则)
- [生成的代码结构](#生成的代码结构)
-
---
-
-## 功能概述
-
-代码生成器可以：
-
-1. **自动读取数据库表结构** - 支持 MySQL 和 SQLite
-2. **生成 CRUD 接口** - 增删改查、搜索、分页
-3. **生成配置文件** - 表字段配置、菜单配置、权限配置
-4. **智能字段识别** - 根据字段名自动识别类型和权限
-5. **支持表关联** - 自动识别外键关系
-
---
-
-## 配置说明
-
-在 `config.json` 中配置代码生成：
-
-```json
-{
-    "codeConfig": [
-        {
-            "table": "admin",
-            "config": "config/admin.json",
-            "configDB": "config/adminDB.json",
-            "rule": "config/rule.json",
-            "name": "",
-            "mode": 0
-        }
-    ]
-}
-```
-
-### 配置项说明
-
-| 配置项 | 必须 | 说明 |
-|--------|------|------|
-| `table` | ✅ | 用户表名，用于权限控制的基准表 |
-| `config` | ✅ | 接口描述配置文件路径 |
-| `configDB` | ❌ | 数据库结构配置输出路径，有则每次自动生成 |
-| `rule` | ❌ | 字段规则配置文件，无则使用默认规则 |
-| `name` | ❌ | 生成代码的包名和目录名，空则使用内嵌模式 |
-| `mode` | ❌ | 0=内嵌代码模式，1=生成代码模式 |
-
-### 运行模式
-
- **mode=0（内嵌模式）**：不生成独立代码文件，使用框架内置的通用控制器
- **mode=1（生成模式）**：为每张表生成独立的 Go 控制器文件
-
---
-
-## 使用方法
-
-### 1. 基础配置
-
-```json
-{
-    "mode": 2,
-    "codeConfig": [
-        {
-            "table": "admin",
-            "config": "config/admin.json",
-            "rule": "config/rule.json",
-            "mode": 0
-        }
-    ]
-}
-```
-
-### 2. 启动应用
-
-```go
-package main
-
-import (
-    . "code.hoteas.com/golang/hotime"
-    . "code.hoteas.com/golang/hotime/common"
-)
-
-func main() {
-    app := Init("config/config.json")
-    
-    // 代码生成器在 Init 时自动执行
-    // 会读取数据库结构并生成配置
-    
-    app.Run(Router{
-        // 路由配置
-    })
-}
-```
-
-### 3. 开发模式
-
-在 `config.json` 中设置 `"mode": 2`（开发模式）时：
-
- 自动读取数据库表结构
- 自动生成/更新配置文件
- 自动生成代码（如果 codeConfig.mode=1）
-
---
-
-## 生成规则
-
-### 默认字段规则
-
-代码生成器内置了一套默认的字段识别规则：
-
-| 字段名 | 列表显示 | 新增 | 编辑 | 详情 | 类型 |
-|--------|----------|------|------|------|------|
-| `id` | ✅ | ❌ | ❌ | ✅ | number |
-| `name` | ✅ | ✅ | ✅ | ✅ | text |
-| `status` | ✅ | ✅ | ✅ | ✅ | select |
-| `create_time` | ❌ | ❌ | ❌ | ✅ | time |
-| `modify_time` | ✅ | ❌ | ❌ | ✅ | time |
-| `password` | ❌ | ✅ | ✅ | ❌ | password |
-| `image/img/avatar` | ❌ | ✅ | ✅ | ✅ | image |
-| `file` | ❌ | ✅ | ✅ | ✅ | file |
-| `content/info` | ❌ | ✅ | ✅ | ✅ | textArea |
-| `parent_id` | ✅ | ✅ | ✅ | ✅ | number |
-| `parent_ids/index` | ❌ | ❌ | ❌ | ❌ | index |
-| `delete` | ❌ | ❌ | ❌ | ❌ | - |
-
-### 数据类型映射
-
-数据库字段类型自动映射：
-
-| 数据库类型 | 生成类型 |
-|------------|----------|
-| `int`, `integer`, `float`, `double`, `decimal` | number |
-| `char`, `varchar`, `text`, `blob` | text |
-| `date`, `datetime`, `time`, `timestamp`, `year` | time |
-
-### 字段备注解析
-
-支持从数据库字段备注中提取信息：
-
-```sql
-- 字段备注格式: 标签名:选项1-名称1,选项2-名称2 {提示信息}
-- 例如:
-status TINYINT COMMENT '状态:0-禁用,1-启用 {用户账号状态}'
-```
-
-生成的配置：
-
-```json
-{
-    "name": "status",
-    "label": "状态",
-    "type": "select",
-    "ps": "用户账号状态",
-    "options": [
-        {"name": "禁用", "value": "0"},
-        {"name": "启用", "value": "1"}
-    ]
-}
-```
-
---
-
-## 自定义规则
-
-### rule.json 配置
-
-创建 `config/rule.json` 自定义字段规则：
-
-```json
-[
-    {
-        "name": "id",
-        "list": true,
-        "add": false,
-        "edit": false,
-        "info": true,
-        "must": false,
-        "strict": true,
-        "type": ""
-    },
-    {
-        "name": "status",
-        "list": true,
-        "add": true,
-        "edit": true,
-        "info": true,
-        "must": false,
-        "strict": false,
-        "type": "select"
-    },
-    {
-        "name": "user.special_field",
-        "list": true,
-        "add": true,
-        "edit": true,
-        "info": true,
-        "type": "text",
-        "strict": true
-    }
-]
-```
-
-### 规则字段说明
-
-| 字段 | 说明 |
-|------|------|
-| `name` | 字段名，支持 `表名.字段名` 格式精确匹配 |
-| `list` | 是否在列表中显示 |
-| `add` | 是否在新增表单中显示 |
-| `edit` | 是否在编辑表单中显示 |
-| `info` | 是否在详情中显示 |
-| `must` | 是否必填 |
-| `strict` | 是否严格匹配字段名（false 则模糊匹配） |
-| `type` | 字段类型（覆盖自动识别） |
-
-### 字段类型
-
-| 类型 | 说明 |
-|------|------|
-| `text` | 普通文本输入 |
-| `textArea` | 多行文本 |
-| `number` | 数字输入 |
-| `select` | 下拉选择 |
-| `time` | 时间选择器 |
-| `unixTime` | Unix 时间戳 |
-| `image` | 图片上传 |
-| `file` | 文件上传 |
-| `password` | 密码输入 |
-| `money` | 金额（带格式化） |
-| `index` | 索引字段（不显示） |
-| `tree` | 树形选择 |
-| `form` | 表单配置 |
-| `auth` | 权限配置 |
-
---
-
-## 生成的代码结构
-
-### 内嵌模式 (mode=0)
-
-不生成代码文件，使用框架内置控制器，只生成配置文件：
-
-```
-config/
-├── admin.json      # 接口配置
-├── adminDB.json    # 数据库结构配置（可选）
-└── rule.json       # 字段规则
-```
-
-### 生成模式 (mode=1)
-
-生成独立的控制器代码：
-
-```
-admin/              # 生成的包目录
-├── init.go         # 包初始化和路由注册
-├── user.go         # user 表控制器
-├── role.go         # role 表控制器
-└── ...             # 其他表控制器
-```
-
-### 生成的控制器结构
-
-```go
-package admin
-
-var userCtr = Ctr{
-    "info": func(that *Context) {
-        // 查询单条记录
-    },
-    "add": func(that *Context) {
-        // 新增记录
-    },
-    "update": func(that *Context) {
-        // 更新记录
-    },
-    "remove": func(that *Context) {
-        // 删除记录
-    },
-    "search": func(that *Context) {
-        // 搜索列表（分页）
-    },
-}
-```
-
---
-
-## 配置文件结构
-
-### admin.json 示例
-
-```json
-{
-    "name": "admin",
-    "label": "管理平台",
-    "menus": [
-        {
-            "label": "系统管理",
-            "name": "sys",
-            "icon": "Setting",
-            "menus": [
-                {
-                    "label": "用户管理",
-                    "table": "user",
-                    "auth": ["show", "add", "delete", "edit", "info", "download"]
-                },
-                {
-                    "label": "角色管理",
-                    "table": "role",
-                    "auth": ["show", "add", "delete", "edit", "info"]
-                }
-            ]
-        }
-    ],
-    "tables": {
-        "user": {
-            "label": "用户",
-            "table": "user",
-            "auth": ["show", "add", "delete", "edit", "info", "download"],
-            "columns": [
-                {"name": "id", "type": "number", "label": "ID"},
-                {"name": "name", "type": "text", "label": "用户名"},
-                {"name": "status", "type": "select", "label": "状态", 
-                 "options": [{"name": "禁用", "value": "0"}, {"name": "启用", "value": "1"}]}
-            ],
-            "search": [
-                {"type": "search", "name": "keyword", "label": "请输入关键词"},
-                {"type": "search", "name": "daterange", "label": "时间段"}
-            ]
-        }
-    }
-}
-```
-
---
-
-## 外键关联
-
-### 自动识别
-
-代码生成器会自动识别 `_id` 结尾的字段作为外键：
-
-```sql
-- user 表
-CREATE TABLE user (
-    id INT PRIMARY KEY,
-    name VARCHAR(50),
-    role_id INT,        -- 自动关联 role 表
-    org_id INT          -- 自动关联 org 表
-);
-```
-
-生成的配置会包含 `link` 和 `value` 字段：
-
-```json
-{
-    "name": "role_id",
-    "type": "number",
-    "label": "角色",
-    "link": "role",
-    "value": "name"
-}
-```
-
-### 树形结构
-
-`parent_id` 字段会被识别为树形结构的父级关联：
-
-```json
-{
-    "name": "parent_id",
-    "type": "number",
-    "label": "上级",
-    "link": "org",
-    "value": "name"
-}
-```
-
---
-
-## 权限控制
-
-### 数据权限
-
-配置 `flow` 实现数据权限控制：
-
-```json
-{
-    "flow": {
-        "order": {
-            "table": "order",
-            "stop": false,
-            "sql": {
-                "user_id": "id"
-            }
-        }
-    }
-}
-```
-
- `stop`: 是否禁止修改该表
- `sql`: 数据过滤条件，`user_id = 当前用户.id`
-
-### 操作权限
-
-每张表可配置的权限：
-
-| 权限 | 说明 |
-|------|------|
-| `show` | 查看列表 |
-| `add` | 新增 |
-| `edit` | 编辑 |
-| `delete` | 删除 |
-| `info` | 查看详情 |
-| `download` | 下载导出 |
-
---
-
-## 最佳实践
-
-### 1. 开发流程
-
-1. 设置 `config.json` 中 `mode: 2`（开发模式）
-2. 设计数据库表结构，添加字段备注
-3. 启动应用，自动生成配置
-4. 检查生成的配置文件，按需调整
-5. 生产环境改为 `mode: 0`
-
-### 2. 字段命名规范
-
-```sql
-- 推荐的命名方式
-id              -- 主键
-name            -- 名称
-status          -- 状态（自动识别为 select）
-create_time     -- 创建时间
-modify_time     -- 修改时间
-xxx_id          -- 外键关联
-parent_id       -- 树形结构父级
-avatar          -- 头像（自动识别为 image）
-content         -- 内容（自动识别为 textArea）
-```
-
-### 3. 自定义扩展
-
-如果默认规则不满足需求，可以：
-
-1. 修改 `rule.json` 添加自定义规则
-2. 使用 `mode=1` 生成代码后手动修改
-3. 在生成的配置文件中直接调整字段属性
-
---
-
-## 相关文档
-
- [快速上手指南](QUICKSTART.md)
- [HoTimeDB 使用说明](HoTimeDB_使用说明.md)
- [Common 工具类使用说明](Common_工具类使用说明.md)
--- a/docs/Common_工具类使用说明.md
+++ b/docs/Common_工具类使用说明.md
@ -1,484 +0,0 @@
-# HoTime Common 工具类使用说明
-
-`common` 包提供了 HoTime 框架的核心数据类型和工具函数，包括 `Map`、`Slice`、`Obj` 类型及丰富的类型转换函数。
-
-## 目录
-
- [核心数据类型](#核心数据类型)
-  - [Map 类型](#map-类型)
-  - [Slice 类型](#slice-类型)
-  - [Obj 类型](#obj-类型)
- [类型转换函数](#类型转换函数)
- [工具函数](#工具函数)
- [错误处理](#错误处理)
-
---
-
-## 核心数据类型
-
-### Map 类型
-
-`Map` 是 `map[string]interface{}` 的别名，提供了丰富的链式调用方法。
-
-```go
-import . "code.hoteas.com/golang/hotime/common"
-
-// 创建 Map
-data := Map{
-    "name":   "张三",
-    "age":    25,
-    "score":  98.5,
-    "active": true,
-    "tags":   Slice{"Go", "Web"},
-}
-```
-
-#### 获取值方法
-
-```go
-// 获取字符串
-name := data.GetString("name")           // "张三"
-
-// 获取整数
-age := data.GetInt("age")                // 25
-age64 := data.GetInt64("age")            // int64(25)
-
-// 获取浮点数
-score := data.GetFloat64("score")        // 98.5
-
-// 获取布尔值
-active := data.GetBool("active")         // true
-
-// 获取嵌套 Map
-info := data.GetMap("info")              // 返回 Map 类型
-
-// 获取 Slice
-tags := data.GetSlice("tags")            // 返回 Slice 类型
-
-// 获取时间
-createTime := data.GetTime("create_time") // 返回 *time.Time
-
-// 获取原始值
-raw := data.Get("name")                  // interface{}
-```
-
-#### 向上取整方法
-
-```go
-// 向上取整获取整数
-ceilInt := data.GetCeilInt("score")      // 99
-ceilInt64 := data.GetCeilInt64("score")  // int64(99)
-ceilFloat := data.GetCeilFloat64("score") // 99.0
-```
-
-#### 操作方法
-
-```go
-// 添加/修改值
-data.Put("email", "test@example.com")
-
-// 删除值
-data.Delete("email")
-
-// 转换为 JSON 字符串
-jsonStr := data.ToJsonString()
-
-// 从 JSON 字符串解析
-data.JsonToMap(`{"key": "value"}`)
-```
-
-#### 有序遍历
-
-```go
-// 按 key 字母顺序遍历
-data.RangeSort(func(k string, v interface{}) bool {
-    fmt.Printf("%s: %v\n", k, v)
-    return false // 返回 true 则终止遍历
-})
-```
-
-#### 转换为结构体
-
-```go
-type User struct {
-    Name  string
-    Age   int64
-    Score float64
-}
-
-var user User
-data.ToStruct(&user) // 传入指针，字段名首字母大写匹配
-```
-
---
-
-### Slice 类型
-
-`Slice` 是 `[]interface{}` 的别名，提供类似 Map 的链式调用方法。
-
-```go
-// 创建 Slice
-list := Slice{
-    Map{"id": 1, "name": "Alice"},
-    Map{"id": 2, "name": "Bob"},
-    "text",
-    123,
-}
-```
-
-#### 获取值方法
-
-```go
-// 按索引获取值（类型转换）
-str := list.GetString(2)         // "text"
-num := list.GetInt(3)            // 123
-num64 := list.GetInt64(3)        // int64(123)
-f := list.GetFloat64(3)          // 123.0
-b := list.GetBool(3)             // true (非0为true)
-
-// 获取嵌套类型
-item := list.GetMap(0)           // Map{"id": 1, "name": "Alice"}
-subList := list.GetSlice(0)      // 尝试转换为 Slice
-
-// 获取原始值
-raw := list.Get(0)               // interface{}
-
-// 获取时间
-t := list.GetTime(0)             // *time.Time
-```
-
-#### 向上取整方法
-
-```go
-ceilInt := list.GetCeilInt(3)
-ceilInt64 := list.GetCeilInt64(3)
-ceilFloat := list.GetCeilFloat64(3)
-```
-
-#### 操作方法
-
-```go
-// 修改指定位置的值
-list.Put(0, "new value")
-
-// 转换为 JSON 字符串
-jsonStr := list.ToJsonString()
-```
-
---
-
-### Obj 类型
-
-`Obj` 是一个通用的对象包装器，用于链式类型转换，常用于 `Context` 方法的返回值。
-
-```go
-type Obj struct {
-    Data interface{} // 原始数据
-    Error           // 错误信息
-}
-```
-
-#### 使用示例
-
-```go
-obj := &Obj{Data: "123"}
-
-// 链式类型转换
-i := obj.ToInt()        // 123
-i64 := obj.ToInt64()    // int64(123)
-f := obj.ToFloat64()    // 123.0
-s := obj.ToStr()        // "123"
-b := obj.ToBool()       // true
-
-// 复杂类型转换
-m := obj.ToMap()        // 尝试转换为 Map
-sl := obj.ToSlice()     // 尝试转换为 Slice
-arr := obj.ToMapArray() // 转换为 []Map
-
-// 获取原始值
-raw := obj.ToObj()      // interface{}
-
-// 获取时间
-t := obj.ToTime()       // *time.Time
-
-// 向上取整
-ceil := obj.ToCeilInt()
-ceil64 := obj.ToCeilInt64()
-ceilF := obj.ToCeilFloat64()
-```
-
-#### 在 Context 中的应用
-
-```go
-func handler(that *Context) {
-    // ReqData 返回 *Obj，支持链式调用
-    userId := that.ReqData("user_id").ToInt()
-    name := that.ReqData("name").ToStr()
-    
-    // Session 也返回 *Obj
-    adminId := that.Session("admin_id").ToInt64()
-}
-```
-
---
-
-## 类型转换函数
-
-`common` 包提供了一系列全局类型转换函数。
-
-### 基础转换
-
-```go
-// 转字符串
-str := ObjToStr(123)          // "123"
-str := ObjToStr(3.14)         // "3.14"
-str := ObjToStr(Map{"a": 1})  // JSON 格式字符串
-
-// 转整数
-i := ObjToInt("123")          // 123
-i64 := ObjToInt64("123")      // int64(123)
-
-// 转浮点数
-f := ObjToFloat64("3.14")     // 3.14
-
-// 转布尔
-b := ObjToBool(1)             // true
-b := ObjToBool(0)             // false
-
-// 转 Map
-m := ObjToMap(`{"a": 1}`)     // Map{"a": 1}
-m := ObjToMap(someStruct)     // 结构体转 Map
-
-// 转 Slice
-s := ObjToSlice(`[1, 2, 3]`)  // Slice{1, 2, 3}
-
-// 转 []Map
-arr := ObjToMapArray(slice)   // []Map
-```
-
-### 向上取整转换
-
-```go
-// 向上取整后转整数
-ceil := ObjToCeilInt(3.2)     // 4
-ceil64 := ObjToCeilInt64(3.2) // int64(4)
-ceilF := ObjToCeilFloat64(3.2) // 4.0
-```
-
-### 时间转换
-
-```go
-// 自动识别多种格式
-t := ObjToTime("2024-01-15 10:30:00")  // *time.Time
-t := ObjToTime("2024-01-15")           // *time.Time
-t := ObjToTime(1705298400)             // Unix 秒
-t := ObjToTime(1705298400000)          // Unix 毫秒
-t := ObjToTime(1705298400000000)       // Unix 微秒
-```
-
-### 字符串转换
-
-```go
-// 字符串转 Map
-m := StrToMap(`{"key": "value"}`)
-
-// 字符串转 Slice
-s := StrToSlice(`[1, 2, 3]`)
-
-// 字符串转 int
-i, err := StrToInt("123")
-
-// 字符串数组格式转换
-jsonArr := StrArrayToJsonStr("a1,a2,a3")  // "[a1,a2,a3]"
-strArr := JsonStrToStrArray("[a1,a2,a3]") // ",a1,a2,a3,"
-```
-
-### 错误处理
-
-所有转换函数支持可选的错误参数：
-
-```go
-var e Error
-i := ObjToInt("abc", &e)
-if e.GetError() != nil {
-    // 处理转换错误
-}
-```
-
---
-
-## 工具函数
-
-### 字符串处理
-
-```go
-// 字符串截取（支持中文）
-str := Substr("Hello世界", 0, 7)   // "Hello世"
-str := Substr("Hello", -2, 2)      // "lo" (负数从末尾计算)
-
-// 首字母大写
-upper := StrFirstToUpper("hello")  // "Hello"
-
-// 查找最后出现位置
-idx := IndexLastStr("a.b.c", ".")  // 3
-
-// 字符串相似度（Levenshtein 距离）
-dist := StrLd("hello", "hallo", true)  // 1 (忽略大小写)
-```
-
-### 时间处理
-
-```go
-// 时间转字符串
-str := Time2Str(time.Now())        // "2024-01-15 10:30:00"
-str := Time2Str(time.Now(), 1)     // "2024-01"
-str := Time2Str(time.Now(), 2)     // "2024-01-15"
-str := Time2Str(time.Now(), 3)     // "2024-01-15 10"
-str := Time2Str(time.Now(), 4)     // "2024-01-15 10:30"
-str := Time2Str(time.Now(), 5)     // "2024-01-15 10:30:00"
-
-// 特殊格式
-str := Time2Str(time.Now(), 12)    // "01-15"
-str := Time2Str(time.Now(), 14)    // "01-15 10:30"
-str := Time2Str(time.Now(), 34)    // "10:30"
-str := Time2Str(time.Now(), 35)    // "10:30:00"
-```
-
-### 加密与随机
-
-```go
-// MD5 加密
-hash := Md5("password")            // 32位小写MD5
-
-// 随机数
-r := Rand(3)                       // 3位随机数 (0-999)
-r := RandX(10, 100)                // 10-100之间的随机数
-```
-
-### 数学计算
-
-```go
-// 四舍五入保留小数
-f := Round(3.14159, 2)             // 3.14
-f := Round(3.145, 2)               // 3.15
-```
-
-### 深拷贝
-
-```go
-// 深拷贝 Map/Slice（递归复制）
-original := Map{"a": Map{"b": 1}}
-copied := DeepCopyMap(original).(Map)
-
-// 修改副本不影响原始数据
-copied.GetMap("a")["b"] = 2
-// original["a"]["b"] 仍然是 1
-```
-
---
-
-## 错误处理
-
-### Error 类型
-
-```go
-type Error struct {
-    Logger *logrus.Logger  // 可选的日志记录器
-    error                  // 内嵌错误
-}
-```
-
-### 使用示例
-
-```go
-var e Error
-
-// 设置错误
-e.SetError(errors.New("something wrong"))
-
-// 获取错误
-if err := e.GetError(); err != nil {
-    fmt.Println(err)
-}
-
-// 配合日志自动记录
-e.Logger = logrusLogger
-e.SetError(errors.New("will be logged"))
-```
-
-### 在类型转换中使用
-
-```go
-var e Error
-data := Map{"count": "abc"}
-
-count := data.GetInt("count", &e)
-if e.GetError() != nil {
-    // 转换失败，count = 0
-    fmt.Println("转换失败:", e.GetError())
-}
-```
-
---
-
-## 最佳实践
-
-### 1. 链式调用处理请求数据
-
-```go
-func handler(that *Context) {
-    // 推荐：使用 Obj 链式调用
-    userId := that.ReqData("user_id").ToInt()
-    page := that.ReqData("page").ToInt()
-    if page < 1 {
-        page = 1
-    }
-    
-    // 处理 Map 数据
-    user := that.Db.Get("user", "*", Map{"id": userId})
-    if user != nil {
-        name := user.GetString("name")
-        age := user.GetInt("age")
-    }
-}
-```
-
-### 2. 安全的类型转换
-
-```go
-// 带错误检查的转换
-var e Error
-data := someMap.GetInt("key", &e)
-if e.GetError() != nil {
-    // 使用默认值
-    data = 0
-}
-
-// 简单场景直接转换（失败返回零值）
-data := someMap.GetInt("key")  // 失败返回 0
-```
-
-### 3. 处理数据库查询结果
-
-```go
-// 查询返回 Map
-user := that.Db.Get("user", "*", Map{"id": 1})
-if user != nil {
-    name := user.GetString("name")
-    createTime := user.GetTime("create_time")
-}
-
-// 查询返回 []Map
-users := that.Db.Select("user", "*", Map{"status": 1})
-for _, u := range users {
-    fmt.Printf("ID: %d, Name: %s\n", u.GetInt("id"), u.GetString("name"))
-}
-```
-
---
-
-## 相关文档
-
- [快速上手指南](QUICKSTART.md)
- [HoTimeDB 使用说明](HoTimeDB_使用说明.md)
- [代码生成器使用说明](CodeGen_使用说明.md)
--- a/docs/DatabaseDesign_数据库设计规范.md
+++ b/docs/DatabaseDesign_数据库设计规范.md
@ -1,408 +0,0 @@
-# 数据库设计规范
-
-本文档定义了 HoTime 框架代码生成器所依赖的数据库设计规范。遵循这些规范可以确保代码生成器正确识别表关系、自动生成 CRUD 接口和管理后台。
-
---
-
-## 表命名规则
-
-### 1. 关于表名前缀
-
-一般情况下**没必要强行添加前缀分组**，直接使用业务含义命名即可：
-
-```
-推荐：user、org、role、article
-```
-
-**可以使用前缀的场景**：当项目较大、表较多时，可以用前缀进行模块分组（如 `sys_`、`cms_`），代码生成器会根据 `_` 分词自动将同前缀的表归为一组。
-
-```
-sys_user、sys_role、sys_org    → 自动归入 sys 分组
-cms_article、cms_category      → 自动归入 cms 分组
-```
-
-**使用前缀的注意事项**：
- 必须遵循外键全局唯一性规则（见下文）
- 前缀分组后，关联 ID 命名会更复杂，容易产生重复
- **外键名不允许重复指向不同的表**
-
-### 2. 可使用简称
-
-较长的表名可以使用常见简称：
-
-| 全称 | 简称 |
-|------|------|
-| organization | org |
-| category | ctg |
-| configuration | config |
-| administrator | admin |
-
-### 3. 关联表命名
-
-多对多关联表使用 `主表_关联表` 格式：
-
-```
-user_org      -- 用户与组织的关联
-user_role     -- 用户与角色的关联
-article_tag   -- 文章与标签的关联
-```
-
---
-
-## 字段命名规则
-
-### 1. 主键字段
-
-所有表的主键统一命名为 `id`，使用自增整数。
-
-```sql
-`id` int(11) NOT NULL AUTO_INCREMENT
-```
-
-### 2. 外键字段
-
-外键使用 `完整表名_id` 格式：
-
-```
-user_id       -- 指向 user 表
-org_id        -- 指向 org 表
-role_id       -- 指向 role 表
-app_category_id -- 指向 app_category 表
-```
-
-### 3. 关联表引用
-
-引用关联表时使用 `关联表名_id`：
-
-```
-user_org_id   -- 指向 user_org 表
-user_role_id  -- 指向 user_role 表
-```
-
-### 4. 外键全局唯一性（重要）
-
-**每个 `xxx_id` 字段名必须全局唯一指向一张表**，代码生成器通过 `_id` 后缀自动识别外键关系。
-
-```
-✅ 正确设计：
- user_id      只能指向 user 表
- org_id       只能指向 org 表
- user_org_id  只能指向 user_org 表
- sys_user_id  只能指向 sys_user 表（如果使用前缀分组）
-
-❌ 错误设计：
- dd_id 作为"钉钉外部系统ID"，但系统中存在 dd 表
-  → 代码生成器会误判为指向 dd 表的外键
- 同时存在 user 表和 sys_user 表，都使用 user_id
-  → 外键名重复，代码生成器无法正确识别
-```
-
-**使用前缀分组时的外键命名**：
-
-如果使用了表名前缀（如 `sys_user`），外键应使用完整表名：
-
-| 表名 | 外键命名 |
-|------|----------|
-| sys_user | sys_user_id |
-| sys_org | sys_org_id |
-| cms_article | cms_article_id |
-
-**非外键业务标识字段**：避免使用 `xxx_id` 格式
-
-| 业务含义 | 错误命名 | 正确命名 |
-|----------|----------|----------|
-| 设备唯一标识 | device_id | device_uuid / device_sn |
-| 钉钉用户ID | dingtalk_user_id | dt_user_id / dingtalk_uid |
-| 微信OpenID | wechat_id | wechat_openid |
-| 外部系统编号 | external_id | external_code / external_sn |
-
-### 5. 外键智能匹配机制
-
-代码生成器会按以下优先级自动匹配外键关联的表：
-
-1. **完全匹配**：`user_id` → 查找 `user` 表
-2. **带前缀的完全匹配**：如果没找到，尝试 `user_id` → 查找 `sys_user` 表（默认前缀）
-3. **去除字段前缀匹配**：如果字段有前缀且找不到对应表，会去掉前缀匹配
-
-**示例**：`admin_user_id` 字段的匹配过程：
-1. 先查找 `admin_user` 表 → 如果存在，关联到 `admin_user` 表
-2. 如果不存在，去掉前缀查找 `user` 表 → 如果存在，关联到 `user` 表
-
-**使用场景**：当一张表需要记录多个用户（如创建人、审核人、处理人）时：
-
-```sql
-CREATE TABLE `order` (
-    `id` int(11) NOT NULL AUTO_INCREMENT,
-    `user_id` int(11) COMMENT '下单用户',
-    `audit_user_id` int(11) COMMENT '审核人',
-    `handle_user_id` int(11) COMMENT '处理人',
-    ...
-);
-```
-
-如果系统中没有 `audit_user` 和 `handle_user` 表，代码生成器会自动将 `audit_user_id` 和 `handle_user_id` 识别为指向 `user` 表的外键。
-
-### 6. 关联表冗余外键
-
-关联表应包含必要的冗余外键便于查询：
-
-```sql
-- user_app 表（用户与应用的关联）
-CREATE TABLE user_app (
-    id int(11) NOT NULL AUTO_INCREMENT,
-    user_id int(11) DEFAULT NULL COMMENT '用户ID',
-    app_id int(11) DEFAULT NULL COMMENT '应用ID',
-    app_category_id int(11) DEFAULT NULL COMMENT '应用分类ID（冗余，便于按分类查询）',
-    ...
-);
-```
-
-### 7. 层级关系字段
-
-树形结构的表使用以下字段：
-
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| parent_id | int | 父级ID，顶级为 NULL 或 0 |
-| parent_ids | varchar(255) | 完整层级路径，格式：`,1,3,5,`（从根到当前，逗号分隔） |
-| level | int | 层级深度，从 0 开始 |
-
-**示例**：
-
-```
-id=1, parent_id=NULL, parent_ids=",1,",      level=0  -- 顶级
-id=3, parent_id=1,    parent_ids=",1,3,",    level=1  -- 一级
-id=5, parent_id=3,    parent_ids=",1,3,5,",  level=2  -- 二级
-```
-
-`parent_ids` 的设计便于快速查询所有子级：
-```sql
-SELECT * FROM org WHERE parent_ids LIKE '%,3,%'  -- 查询id=3的所有子级
-```
-
---
-
-## 时间字段类型
-
-不同数据库使用对应的时间类型：
-
-| 数据库 | 类型 | 示例 |
-|--------|------|------|
-| MySQL | datetime | `2024-01-15 10:30:00` |
-| SQLite | TEXT | `2024-01-15 10:30:00` |
-| PostgreSQL | timestamp | `2024-01-15 10:30:00` |
-
---
-
-## 表注释规则
-
-### 表备注命名建议
-
-表备注建议使用"XX管理"格式，便于在管理后台显示：
-
-```sql
-- MySQL 表备注示例
-CREATE TABLE `user` (
-    ...
-) COMMENT='用户管理';
-
-CREATE TABLE `article` (
-    ...
-) COMMENT='文章管理';
-
-CREATE TABLE `order` (
-    ...
-) COMMENT='订单管理';
-```
-
-### SQLite 表备注
-
-SQLite 不支持表备注，代码生成器会使用表名作为默认显示名称。如需自定义，可在配置文件中手动设置 `label`（详见代码生成配置规范）。
-
---
-
-## 字段注释规则
-
-### 注释语法格式
-
-字段注释支持以下格式组合：
-
-```
-显示名称:选项值 附加备注{前端提示}
-```
-
-| 部分 | 分隔符 | 用途 |
-|------|--------|------|
-| 显示名称 | 无 | 前端表单/列表的字段标签 |
-| 选项值 | `:` 冒号 | select 类型的下拉选项（格式：`值-名称,值-名称`） |
-| 附加备注 | 空格 | 仅在数据库中查看，不传递给前端 |
-| 前端提示 | `{}` | 存储到 `ps` 字段，用于前端显示提示文字 |
-
-### 选择类型字段
-
-使用 `标签:值-名称,值-名称` 格式，代码生成器会自动解析为下拉选项：
-
-```sql
-`state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏'
-`sex` int(1) DEFAULT '0' COMMENT '性别:0-未知,1-男,2-女'
-`status` int(2) DEFAULT '0' COMMENT '审核状态:0-待审核,1-已通过,2-已拒绝'
-```
-
-### 普通字段
-
-直接使用中文说明：
-
-```sql
-`name` varchar(50) DEFAULT NULL COMMENT '名称'
-`phone` varchar(20) DEFAULT NULL COMMENT '手机号'
-`email` varchar(100) DEFAULT NULL COMMENT '邮箱'
-```
-
-### 附加备注（空格后）
-
-空格后的内容**不会传递给前端**，仅供数据库设计时参考：
-
-```sql
-`user_id` int(11) COMMENT '用户ID 关联user表的主键'
-`amount` decimal(10,2) COMMENT '金额 单位为元，精确到分'
-```
-
-### 前端提示（{}内）
-
-`{}` 中的内容存储到 `ps` 字段，前端可用于显示输入提示：
-
-```sql
-`phone` varchar(20) COMMENT '手机号{请输入11位手机号}'
-`email` varchar(100) COMMENT '邮箱{格式：xxx@xxx.com}'
-`content` text COMMENT '内容{支持HTML格式}'
-```
-
-### 组合使用
-
-```sql
-- 完整格式示例
-`status` int(2) DEFAULT '0' COMMENT '状态:0-待审核,1-已通过,2-已拒绝 业务状态流转字段{选择当前审核状态}'
-```
-
-解析结果：
- `label` = "状态"
- `options` = [{name:"待审核", value:"0"}, {name:"已通过", value:"1"}, {name:"已拒绝", value:"2"}]
- `ps` = "选择当前审核状态"
- 空格后的"业务状态流转字段"不会传递给前端
-
-### SQLite 字段备注
-
-SQLite 不支持字段备注（COMMENT），代码生成器会使用字段名作为默认显示名称。如需自定义，可在配置文件中手动设置（详见代码生成配置规范）。
-
---
-
-## 必有字段规则
-
-每张业务表必须包含以下三个字段：
-
-### MySQL
-
-```sql
-`state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏',
-`create_time` datetime DEFAULT NULL COMMENT '创建日期',
-`modify_time` datetime DEFAULT NULL COMMENT '变更时间',
-```
-
-### SQLite
-
-```sql
-"state" INTEGER DEFAULT 0,      -- 状态:0-正常,1-异常,2-隐藏
-"create_time" TEXT DEFAULT NULL, -- 创建日期
-"modify_time" TEXT DEFAULT NULL, -- 变更时间
-```
-
-### PostgreSQL
-
-```sql
-"state" INTEGER DEFAULT 0,           -- 状态:0-正常,1-异常,2-隐藏
-"create_time" TIMESTAMP DEFAULT NULL, -- 创建日期
-"modify_time" TIMESTAMP DEFAULT NULL, -- 变更时间
-```
-
---
-
-## 完整建表示例
-
-### MySQL 示例
-
-```sql
-- 用户表
-CREATE TABLE `user` (
-    `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
-    `name` varchar(50) DEFAULT NULL COMMENT '用户名',
-    `phone` varchar(20) DEFAULT NULL COMMENT '手机号',
-    `password` varchar(64) DEFAULT NULL COMMENT '密码',
-    `org_id` int(11) DEFAULT NULL COMMENT '组织ID',
-    `role_id` int(11) DEFAULT NULL COMMENT '角色ID',
-    `avatar` varchar(255) DEFAULT NULL COMMENT '头像',
-    `sex` int(1) DEFAULT '0' COMMENT '性别:0-未知,1-男,2-女',
-    `state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏',
-    `create_time` datetime DEFAULT NULL COMMENT '创建日期',
-    `modify_time` datetime DEFAULT NULL COMMENT '变更时间',
-    PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
-
-- 组织表（树形结构）
-CREATE TABLE `org` (
-    `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
-    `name` varchar(100) DEFAULT NULL COMMENT '组织名称',
-    `parent_id` int(11) DEFAULT NULL COMMENT '父级ID',
-    `parent_ids` varchar(255) DEFAULT NULL COMMENT '层级路径',
-    `level` int(2) DEFAULT '0' COMMENT '层级深度',
-    `sort` int(5) DEFAULT '0' COMMENT '排序',
-    `state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏',
-    `create_time` datetime DEFAULT NULL COMMENT '创建日期',
-    `modify_time` datetime DEFAULT NULL COMMENT '变更时间',
-    PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='组织表';
-
-- 用户组织关联表
-CREATE TABLE `user_org` (
-    `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
-    `user_id` int(11) DEFAULT NULL COMMENT '用户ID',
-    `org_id` int(11) DEFAULT NULL COMMENT '组织ID',
-    `state` int(2) DEFAULT '0' COMMENT '状态:0-正常,1-异常,2-隐藏',
-    `create_time` datetime DEFAULT NULL COMMENT '创建日期',
-    `modify_time` datetime DEFAULT NULL COMMENT '变更时间',
-    PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户组织关联表';
-```
-
-### SQLite 示例
-
-```sql
-- 用户表
-CREATE TABLE "user" (
-    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
-    "name" TEXT DEFAULT NULL,
-    "phone" TEXT DEFAULT NULL,
-    "password" TEXT DEFAULT NULL,
-    "org_id" INTEGER DEFAULT NULL,
-    "role_id" INTEGER DEFAULT NULL,
-    "avatar" TEXT DEFAULT NULL,
-    "sex" INTEGER DEFAULT 0,
-    "state" INTEGER DEFAULT 0,
-    "create_time" TEXT DEFAULT NULL,
-    "modify_time" TEXT DEFAULT NULL
-);
-```
-
---
-
-## 规范检查清单
-
-在设计数据库时，请确认：
-
- [ ] 表名无系统前缀
- [ ] 主键统一为 `id`
- [ ] 外键格式为 `表名_id`
- [ ] 所有 `xxx_id` 字段都指向实际存在的表
- [ ] 非外键业务标识不使用 `xxx_id` 格式
- [ ] 树形表包含 parent_id、parent_ids、level
- [ ] 所有表包含 state、create_time、modify_time
- [ ] 选择字段注释格式正确（`标签:值-名称`）
--- a/docs/QUICKSTART.md
+++ b/docs/QUICKSTART.md
@ -1,529 +0,0 @@
-# HoTime 快速上手指南
-
-5 分钟入门 HoTime 框架。
-
-## 安装
-
-```bash
-go get code.hoteas.com/golang/hotime
-```
-
-## 最小示例
-
-```go
-package main
-
-import (
-    . "code.hoteas.com/golang/hotime"
-    . "code.hoteas.com/golang/hotime/common"
-)
-
-func main() {
-    appIns := Init("config/config.json")
-    
-    appIns.Run(Router{
-        "app": {
-            "test": {
-                "hello": func(that *Context) {
-                    that.Display(0, Map{"message": "Hello World"})
-                },
-            },
-        },
-    })
-}
-```
-
-访问: `http://localhost:8081/app/test/hello`
-
-## 配置文件
-
-创建 `config/config.json`:
-
-```json
-{
-    "port": "8081",
-    "mode": 2,
-    "sessionName": "HOTIME",
-    "tpt": "tpt",
-    "defFile": ["index.html", "index.htm"],
-    "db": {
-        "mysql": {
-            "host": "localhost",
-            "port": "3306",
-            "name": "your_database",
-            "user": "root",
-            "password": "your_password",
-            "prefix": ""
-        }
-    },
-    "cache": {
-        "memory": {
-            "db": true,
-            "session": true,
-            "timeout": 7200
-        }
-    }
-}
-```
-
-### 配置项说明
-
-| 配置项 | 默认值 | 说明 |
-|--------|--------|------|
-| `port` | 80 | HTTP 服务端口，0 为不启用 |
-| `tlsPort` | - | HTTPS 端口，需配合 tlsCert/tlsKey |
-| `tlsCert` | - | HTTPS 证书路径 |
-| `tlsKey` | - | HTTPS 密钥路径 |
-| `mode` | 0 | 0=生产, 1=测试, 2=开发(输出SQL) |
-| `tpt` | tpt | 静态文件目录 |
-| `sessionName` | HOTIME | Session Cookie 名称 |
-| `modeRouterStrict` | false | 路由大小写敏感，false=忽略大小写 |
-| `crossDomain` | - | 跨域设置，空=不开启，auto=智能开启，或指定域名 |
-| `logFile` | - | 日志文件路径，如 `logs/20060102.txt` |
-| `logLevel` | 0 | 日志等级，0=关闭，1=打印 |
-| `webConnectLogShow` | true | 是否显示访问日志 |
-| `defFile` | ["index.html"] | 目录默认访问文件 |
-
-### 数据库配置
-
-```json
-{
-    "db": {
-        "mysql": {
-            "host": "127.0.0.1",
-            "port": "3306",
-            "name": "database_name",
-            "user": "root",
-            "password": "password",
-            "prefix": "app_",
-            "slave": {
-                "host": "127.0.0.1",
-                "port": "3306",
-                "name": "database_name",
-                "user": "root",
-                "password": "password"
-            }
-        },
-        "sqlite": {
-            "path": "config/data.db",
-            "prefix": ""
-        }
-    }
-}
-```
-
-> MySQL 配置 `slave` 项即启用主从读写分离
-
-### 缓存配置
-
-```json
-{
-    "cache": {
-        "memory": {
-            "db": true,
-            "session": true,
-            "timeout": 7200
-        },
-        "redis": {
-            "host": "127.0.0.1",
-            "port": 6379,
-            "password": "",
-            "db": true,
-            "session": true,
-            "timeout": 1296000
-        },
-        "db": {
-            "db": true,
-            "session": true,
-            "timeout": 2592000
-        }
-    }
-}
-```
-
-缓存优先级: **Memory > Redis > DB**，自动穿透与回填
-
-### 错误码配置
-
-```json
-{
-    "error": {
-        "1": "内部系统异常",
-        "2": "访问权限异常",
-        "3": "请求参数异常",
-        "4": "数据处理异常",
-        "5": "数据结果异常"
-    }
-}
-```
-
-> 自定义错误码建议从 10 开始
-
-## 路由系统
-
-HoTime 使用三层路由结构：`模块/控制器/方法`
-
-```go
-appIns.Run(Router{
-    "模块名": {
-        "控制器名": {
-            "方法名": func(that *Context) {
-                // 处理逻辑
-            },
-        },
-    },
-})
-```
-
-### 路由路径
-
-```go
-// 获取路由信息
-module := that.RouterString[0]    // 模块
-controller := that.RouterString[1] // 控制器
-action := that.RouterString[2]     // 方法
-
-// 完整请求路径
-fullPath := that.HandlerStr // 如 /app/user/login
-```
-
-## 请求参数获取
-
-### 新版推荐方法（支持链式调用）
-
-```go
-// 获取 URL 查询参数 (?id=1)
-id := that.ReqParam("id").ToInt()
-name := that.ReqParam("name").ToStr()
-
-// 获取表单参数 (POST form-data / x-www-form-urlencoded)
-username := that.ReqForm("username").ToStr()
-age := that.ReqForm("age").ToInt()
-
-// 获取 JSON Body 参数 (POST application/json)
-data := that.ReqJson("data").ToMap()
-items := that.ReqJson("items").ToSlice()
-
-// 统一获取（自动判断来源，优先级: JSON > Form > URL）
-userId := that.ReqData("user_id").ToInt()
-status := that.ReqData("status").ToStr()
-```
-
-### 类型转换方法
-
-```go
-obj := that.ReqData("key")
-
-obj.ToStr()      // 转字符串
-obj.ToInt()      // 转 int
-obj.ToInt64()    // 转 int64
-obj.ToFloat64()  // 转 float64
-obj.ToBool()     // 转 bool
-obj.ToMap()      // 转 Map
-obj.ToSlice()    // 转 Slice
-obj.Data         // 获取原始值（interface{}）
-```
-
-### 文件上传
-
-```go
-// 单文件上传
-file, header, err := that.ReqFile("avatar")
-if err == nil {
-    defer file.Close()
-    // header.Filename - 文件名
-    // header.Size - 文件大小
-}
-
-// 多文件上传（批量）
-files, err := that.ReqFiles("images")
-if err == nil {
-    for _, fh := range files {
-        file, _ := fh.Open()
-        defer file.Close()
-        // 处理每个文件
-    }
-}
-```
-
-### 传统方法（兼容）
-
-```go
-// GET/POST 参数
-name := that.Req.FormValue("name")
-
-// URL 参数
-id := that.Req.URL.Query().Get("id")
-
-// 请求头
-token := that.Req.Header.Get("Authorization")
-```
-
-## 响应数据
-
-### Display 方法
-
-```go
-// 成功响应 (status=0)
-that.Display(0, Map{"user": user, "token": token})
-// 输出: {"status":0, "result":{"user":..., "token":...}}
-
-// 错误响应 (status>0)
-that.Display(1, "系统内部错误")
-// 输出: {"status":1, "result":{"type":"内部系统异常", "msg":"系统内部错误"}, "error":{...}}
-
-that.Display(2, "请先登录")
-// 输出: {"status":2, "result":{"type":"访问权限异常", "msg":"请先登录"}, "error":{...}}
-
-that.Display(3, "参数不能为空")
-// 输出: {"status":3, "result":{"type":"请求参数异常", "msg":"参数不能为空"}, "error":{...}}
-```
-
-### 错误码含义
-
-| 错误码 | 类型 | 使用场景 |
-|--------|------|----------|
-| 0 | 成功 | 请求成功 |
-| 1 | 内部系统异常 | 环境配置、文件权限等基础运行环境错误 |
-| 2 | 访问权限异常 | 未登录或登录异常 |
-| 3 | 请求参数异常 | 参数不足、类型错误等 |
-| 4 | 数据处理异常 | 数据库操作或第三方请求返回异常 |
-| 5 | 数据结果异常 | 无法返回要求的格式 |
-
-### 自定义响应
-
-```go
-// 自定义 Header
-that.Resp.Header().Set("Content-Type", "application/json")
-
-// 直接写入
-that.Resp.Write([]byte("raw data"))
-
-// 自定义响应函数
-that.RespFunc = func() {
-    // 自定义响应逻辑
-}
-```
-
-## 中间件
-
-```go
-// 全局中间件（请求拦截）
-appIns.SetConnectListener(func(that *Context) bool {
-    // 放行登录接口
-    if len(that.RouterString) >= 3 && that.RouterString[2] == "login" {
-        return false
-    }
-    
-    // 检查登录状态
-    if that.Session("user_id").Data == nil {
-        that.Display(2, "请先登录")
-        return true  // 返回 true 终止请求
-    }
-    return false  // 返回 false 继续处理
-})
-```
-
-## Session 与缓存
-
-```go
-// Session 操作
-that.Session("user_id", 123)          // 设置
-userId := that.Session("user_id")     // 获取 *Obj
-that.Session("user_id", nil)          // 删除
-
-// 链式获取
-id := that.Session("user_id").ToInt64()
-name := that.Session("username").ToStr()
-
-// 通用缓存
-that.Cache("key", "value")            // 设置
-data := that.Cache("key")             // 获取
-that.Cache("key", nil)                // 删除
-```
-
-三级缓存自动运作：**Memory → Redis → Database**
-
-## 数据库操作（简要）
-
-### 基础 CRUD
-
-```go
-// 查询列表
-users := that.Db.Select("user", "*", Map{"status": 1})
-
-// 查询单条
-user := that.Db.Get("user", "*", Map{"id": 1})
-
-// 插入
-id := that.Db.Insert("user", Map{"name": "test", "age": 18})
-
-// 批量插入
-affected := that.Db.Inserts("user", []Map{
-    {"name": "user1", "age": 20},
-    {"name": "user2", "age": 25},
-})
-
-// 更新
-rows := that.Db.Update("user", Map{"name": "new"}, Map{"id": 1})
-
-// 删除
-rows := that.Db.Delete("user", Map{"id": 1})
-```
-
-### 链式查询
-
-```go
-users := that.Db.Table("user").
-    LeftJoin("order", "user.id=order.user_id").
-    Where("status", 1).
-    And("age[>]", 18).
-    Order("id DESC").
-    Page(1, 10).
-    Select("*")
-```
-
-### 条件语法速查
-
-| 语法 | 说明 | 示例 |
-|------|------|------|
-| `key` | 等于 | `"id": 1` |
-| `key[>]` | 大于 | `"age[>]": 18` |
-| `key[<]` | 小于 | `"age[<]": 60` |
-| `key[>=]` | 大于等于 | `"age[>=]": 18` |
-| `key[<=]` | 小于等于 | `"age[<=]": 60` |
-| `key[!]` | 不等于 | `"status[!]": 0` |
-| `key[~]` | LIKE | `"name[~]": "test"` |
-| `key[<>]` | BETWEEN | `"age[<>]": Slice{18, 60}` |
-| `key` | IN | `"id": Slice{1, 2, 3}` |
-
-### 事务
-
-```go
-success := that.Db.Action(func(tx db.HoTimeDB) bool {
-    tx.Update("user", Map{"balance[#]": "balance - 100"}, Map{"id": 1})
-    tx.Insert("order", Map{"user_id": 1, "amount": 100})
-    return true  // 返回 true 提交，false 回滚
-})
-```
-
-> **更多数据库操作**：参见 [HoTimeDB 使用说明](HoTimeDB_使用说明.md)
-
-## 日志记录
-
-```go
-// 创建操作日志（自动插入 logs 表）
-that.Log = Map{
-    "type":   "login",
-    "action": "用户登录",
-    "data":   Map{"phone": phone},
-}
-// 框架会自动添加 time, admin_id/user_id, ip 等字段
-```
-
-## 扩展功能
-
-| 功能 | 路径 | 说明 |
-|------|------|------|
-| 微信支付/公众号/小程序 | `dri/wechat/` | 微信全套 SDK |
-| 阿里云服务 | `dri/aliyun/` | 企业认证等 |
-| 腾讯云服务 | `dri/tencent/` | 企业认证等 |
-| 文件上传 | `dri/upload/` | 文件上传处理 |
-| 文件下载 | `dri/download/` | 文件下载处理 |
-| MongoDB | `dri/mongodb/` | MongoDB 驱动 |
-| RSA 加解密 | `dri/rsa/` | RSA 加解密工具 |
-
-## 完整示例
-
-```go
-package main
-
-import (
-    . "code.hoteas.com/golang/hotime"
-    . "code.hoteas.com/golang/hotime/common"
-)
-
-func main() {
-    appIns := Init("config/config.json")
-    
-    // 登录检查中间件
-    appIns.SetConnectListener(func(that *Context) bool {
-        // 放行登录接口
-        if len(that.RouterString) >= 3 && that.RouterString[2] == "login" {
-            return false
-        }
-        if that.Session("user_id").Data == nil {
-            that.Display(2, "请先登录")
-            return true
-        }
-        return false
-    })
-
-    appIns.Run(Router{
-        "api": {
-            "user": {
-                "login": func(that *Context) {
-                    phone := that.ReqData("phone").ToStr()
-                    password := that.ReqData("password").ToStr()
-                    
-                    if phone == "" || password == "" {
-                        that.Display(3, "手机号和密码不能为空")
-                        return
-                    }
-                    
-                    user := that.Db.Get("user", "*", Map{
-                        "phone": phone,
-                        "password": Md5(password),
-                    })
-                    
-                    if user == nil {
-                        that.Display(3, "账号或密码错误")
-                        return
-                    }
-                    
-                    that.Session("user_id", user.GetInt64("id"))
-                    that.Display(0, Map{"user": user})
-                },
-                
-                "info": func(that *Context) {
-                    userId := that.Session("user_id").ToInt64()
-                    user := that.Db.Get("user", "*", Map{"id": userId})
-                    that.Display(0, Map{"user": user})
-                },
-                
-                "list": func(that *Context) {
-                    page := that.ReqData("page").ToInt()
-                    if page == 0 {
-                        page = 1
-                    }
-                    
-                    users := that.Db.Table("user").
-                        Where("status", 1).
-                        Order("id DESC").
-                        Page(page, 10).
-                        Select("id,name,phone,created_at")
-                    
-                    total := that.Db.Count("user", Map{"status": 1})
-                    
-                    that.Display(0, Map{
-                        "list":  users,
-                        "total": total,
-                        "page":  page,
-                    })
-                },
-                
-                "logout": func(that *Context) {
-                    that.Session("user_id", nil)
-                    that.Display(0, "退出成功")
-                },
-            },
-        },
-    })
-}
-```
-
---
-
-**下一步**：
- [HoTimeDB 使用说明](HoTimeDB_使用说明.md) - 完整数据库教程
- [HoTimeDB API 参考](HoTimeDB_API参考.md) - API 速查手册
--- a/docs/ROADMAP_改进规划.md
+++ b/docs/ROADMAP_改进规划.md
@ -1,183 +0,0 @@
-# HoTime 改进规划
-
-本文档记录 HoTime 框架的待改进项和设计思考，供后续版本迭代参考。
-
---
-
-## 一、备注语法优化
-
-### 现状
-
-当前字段备注语法使用空格、冒号、大括号组合：
-
-```sql
-`status` int COMMENT '状态:0-正常,1-异常 这是数据库备注{这是前端提示}'
-```
-
-### 问题
-
- 多种分隔符混用，不够直观
- 显示名称如需包含特殊字符可能冲突
-
-### 改进方向
-
-使用 `|` 作为统一分隔符，保持干净清爽：
-
-```sql
-- 方案 A：简洁直观
-`status` int COMMENT '状态|0-正常,1-异常|请选择状态'
-- 解析：显示名称|选项|提示
-
-- 方案 B：保持兼容，空格后内容仍作为数据库备注
-`status` int COMMENT '状态|0-正常,1-异常|请选择状态 这是数据库备注'
-```
-
-### 待确认
-
- [ ] 是否需要保留空格后的数据库备注功能
- [ ] 如果只有提示没有选项，如何表示（如 `名称||请输入名称`）
- [ ] 是否向后兼容旧语法
-
---
-
-## 二、SQLite 备注支持
-
-### 现状
-
-SQLite 不支持表/字段备注，需要手动在配置文件中设置。
-
-### 问题
-
-SQLite 项目配置工作量大，不够"快速开发"。
-
-### 待探索方案
-
-1. **配置文件方案（当前）**：通过 admin.json 手动配置，学习成本可接受
-2. **轻量级方案**：考虑是否有更简单的替代方案，但不增加复杂度
-
-### 暂时结论
-
-当前方案虽不完美，但符合"简单好用"原则，暂不改动。
-
---
-
-## 三、软删除支持
-
-### 现状
-
-框架暂不支持软删除。
-
-### 设计考量
-
-软删除存在以下问题：
- 数据安全性：软删除的数据仍可被恢复或误用
- 查询复杂度：所有查询需要额外过滤条件
- 存储膨胀：删除的数据持续占用空间
-
-### 待探索方案
-
-1. **可选软删除**：通过配置决定某张表是否启用软删除
-2. **日志表方案**：独立的操作日志表，只写不删不改
-   - 记录所有增删改操作
-   - 原表正常物理删除
-   - 需要时可从日志恢复
-3. **归档表方案**：删除时移动到归档表
-
-### 倾向方案
-
-日志表方案更符合数据安全和审计需求：
-
-```sql
-CREATE TABLE `_operation_log` (
-    `id` int AUTO_INCREMENT,
-    `table_name` varchar(100) COMMENT '操作表名',
-    `record_id` int COMMENT '记录ID',
-    `operation` varchar(20) COMMENT '操作类型:insert,update,delete',
-    `old_data` text COMMENT '操作前数据（JSON）',
-    `new_data` text COMMENT '操作后数据（JSON）',
-    `operator_id` int COMMENT '操作人ID',
-    `operator_table` varchar(100) COMMENT '操作人表名',
-    `create_time` datetime COMMENT '操作时间',
-    PRIMARY KEY (`id`)
-) COMMENT='操作日志';
-```
-
-### 待确认
-
- [ ] 是否所有表都记录日志
- [ ] 日志保留策略（永久/定期归档）
- [ ] 是否提供恢复接口
-
---
-
-## 四、多对多关联表增强
-
-### 现状
-
-关联表（如 `user_role`）按普通表处理，生成标准 CRUD。
-
-### 可能的增强
-
-1. **自动识别**：只有两个 `_id` 外键的表识别为关联表
-2. **专用接口**：生成关联管理接口（批量绑定/解绑）
-3. **级联查询**：自动生成带关联数据的查询
-
-### 待确认
-
- [ ] 是否需要此功能
- [ ] 如何保持简单性
-
---
-
-## 五、自动填充字段扩展
-
-### 现状
-
-自动填充：
- `create_time`：新增时自动填充当前时间
- `modify_time`：新增/编辑时自动填充当前时间
-
-### 可能的扩展
-
-| 字段 | 填充时机 | 填充内容 |
-|------|----------|----------|
-| create_by | 新增 | 当前用户ID |
-| modify_by | 新增/编辑 | 当前用户ID |
-| create_ip | 新增 | 客户端IP |
-
-### 待确认
-
- [ ] 是否需要扩展
- [ ] 字段命名规范
-
---
-
-## 六、版本控制/乐观锁
-
-### 现状
-
-`version` 字段规则存在但未启用。
-
-### 待确认
-
- [ ] 是否需要支持乐观锁
- [ ] 如果不需要，是否从默认规则中移除
-
---
-
-## 改进优先级
-
-| 优先级 | 改进项 | 状态 |
-|--------|--------|------|
-| 高 | 备注语法优化（`\|` 分隔符） | 待设计 |
-| 中 | 软删除/日志表支持 | 待设计 |
-| 低 | 多对多关联表增强 | 待评估 |
-| 低 | 自动填充字段扩展 | 待评估 |
-
---
-
-## 更新记录
-
-| 日期 | 内容 |
-|------|------|
-| 2026-01-24 | 初始版本，记录分析结果和待改进项 |
--- a/example/main.go
+++ b/example/main.go
@ -44,7 +44,7 @@ func main() {
 					results["6_pagination"] = testPagination(that)

 					// 7. 批量插入测试
-					results["7_batch_insert"] = testInserts(that)
+					results["7_batch_insert"] = testBatchInsert(that)

 					// 8. Upsert 测试
 					results["8_upsert"] = testUpsert(that)
@ -86,7 +86,7 @@ func main() {
 				"join":        func(that *Context) { that.Display(0, testJoinQuery(that)) },
 				"aggregate":   func(that *Context) { that.Display(0, testAggregate(that)) },
 				"pagination":  func(that *Context) { that.Display(0, testPagination(that)) },
-				"batch":       func(that *Context) { that.Display(0, testInserts(that)) },
+				"batch":       func(that *Context) { that.Display(0, testBatchInsert(that)) },
 				"upsert":      func(that *Context) { that.Display(0, testUpsert(that)) },
 				"transaction": func(that *Context) { that.Display(0, testTransaction(that)) },
 				"rawsql":      func(that *Context) { that.Display(0, testRawSQL(that)) },
@ -650,14 +650,14 @@ func testPagination(that *Context) Map {
 }

 // ==================== 7. 批量插入测试 ====================
-func testInserts(that *Context) Map {
+func testBatchInsert(that *Context) Map {
 	result := Map{"name": "批量插入测试", "tests": Slice{}}
 	tests := Slice{}

 	// 7.1 批量插入
-	test1 := Map{"name": "Inserts 批量插入"}
+	test1 := Map{"name": "BatchInsert 批量插入"}
 	timestamp := time.Now().UnixNano()
-	affected1 := that.Db.Inserts("test_batch", []Map{
+	affected1 := that.Db.BatchInsert("test_batch", []Map{
 		{"name": fmt.Sprintf("批量测试1_%d", timestamp), "title": "标题1", "state": 1},
 		{"name": fmt.Sprintf("批量测试2_%d", timestamp), "title": "标题2", "state": 1},
 		{"name": fmt.Sprintf("批量测试3_%d", timestamp), "title": "标题3", "state": 1},
@ -668,9 +668,9 @@ func testInserts(that *Context) Map {
 	tests = append(tests, test1)

 	// 7.2 带 [#] 的批量插入
-	test2 := Map{"name": "Inserts 带 [#] 标记"}
+	test2 := Map{"name": "BatchInsert 带 [#] 标记"}
 	timestamp2 := time.Now().UnixNano()
-	affected2 := that.Db.Inserts("test_batch", []Map{
+	affected2 := that.Db.BatchInsert("test_batch", []Map{
 		{"name": fmt.Sprintf("带时间测试1_%d", timestamp2), "title": "标题带时间1", "state": 1, "create_time[#]": "NOW()"},
 		{"name": fmt.Sprintf("带时间测试2_%d", timestamp2), "title": "标题带时间2", "state": 1, "create_time[#]": "NOW()"},
 	})
--- a/examples/hotimedb_examples.go
+++ b/examples/hotimedb_examples.go
@ -766,12 +766,12 @@ correctUsers4 := db.Select("user", "*", common.Map{
 	_ = db
 }

-// InsertsExample 批量插入示例
-func InsertsExample(database *db.HoTimeDB) {
+// BatchInsertExample 批量插入示例
+func BatchInsertExample(database *db.HoTimeDB) {
 	fmt.Println("\n=== 批量插入示例 ===")

 	// 批量插入用户（使用 []Map 格式）
-	affected := database.Inserts("user", []common.Map{
+	affected := database.BatchInsert("user", []common.Map{
 		{"name": "批量用户1", "email": "batch1@example.com", "age": 25, "status": 1},
 		{"name": "批量用户2", "email": "batch2@example.com", "age": 30, "status": 1},
 		{"name": "批量用户3", "email": "batch3@example.com", "age": 28, "status": 1},
@ -779,7 +779,7 @@ func InsertsExample(database *db.HoTimeDB) {
 	fmt.Printf("批量插入了 %d 条用户记录\n", affected)

 	// 批量插入日志（使用 [#] 标记直接 SQL）
-	logAffected := database.Inserts("log", []common.Map{
+	logAffected := database.BatchInsert("log", []common.Map{
 		{"user_id": 1, "action": "login", "ip": "192.168.1.1", "created_time[#]": "NOW()"},
 		{"user_id": 2, "action": "logout", "ip": "192.168.1.2", "created_time[#]": "NOW()"},
 		{"user_id": 3, "action": "view", "ip": "192.168.1.3", "created_time[#]": "NOW()"},
@ -838,7 +838,7 @@ func RunAllFixedExamples() {
 	fmt.Println("所有示例代码已修正完毕，语法正确！")
 	fmt.Println("")
 	fmt.Println("新增功能示例说明：")
-	fmt.Println("  - InsertsExample(db): 批量插入示例，使用 []Map 格式")
+	fmt.Println("  - BatchInsertExample(db): 批量插入示例，使用 []Map 格式")
 	fmt.Println("  - UpsertExample(db):      插入或更新示例")
 }

--- a/log/logrus.go
+++ b/log/logrus.go
@ -2,13 +2,12 @@ package log

 import (
 	"fmt"
+	log "github.com/sirupsen/logrus"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"time"
-
-	log "github.com/sirupsen/logrus"
 )

 func GetLog(path string, showCodeLine bool) *log.Logger {
@ -74,98 +73,41 @@ func (that *MyHook) Fire(entry *log.Entry) error {
 	return nil
 }

-// 最大框架层数限制 - 超过这个层数后不再跳过，防止误过滤应用层
-const maxFrameworkDepth = 10
-
-// isHoTimeFrameworkFile 判断是否是 HoTime 框架文件
-// 更精确的匹配：只有明确属于框架的文件才会被跳过
-func isHoTimeFrameworkFile(file string) bool {
-	// 1. logrus 日志库内部文件
-	if strings.HasPrefix(file, "logrus/") {
-		return true
-	}
-
-	// 2. Go 运行时文件
-	if strings.HasPrefix(file, "runtime/") {
-		return true
-	}
-
-	// 3. HoTime 框架核心文件 - 通过包含 "hotime" 或框架特有文件名来识别
-	// 检查路径中是否包含 hotime 框架标识
-	lowerFile := strings.ToLower(file)
-	if strings.Contains(lowerFile, "hotime") {
-		// 是 hotime 框架的一部分，检查是否是核心模块
-		frameworkDirs := []string{"/db/", "/common/", "/code/", "/cache/", "/log/", "/dri/"}
-		for _, dir := range frameworkDirs {
-			if strings.Contains(file, dir) {
-				return true
-			}
-		}
-		// 框架核心文件（在 hotime 根目录下的 .go 文件）
-		if strings.HasSuffix(file, "application.go") ||
-			strings.HasSuffix(file, "context.go") ||
-			strings.HasSuffix(file, "session.go") ||
-			strings.HasSuffix(file, "const.go") ||
-			strings.HasSuffix(file, "type.go") ||
-			strings.HasSuffix(file, "var.go") ||
-			strings.HasSuffix(file, "mime.go") {
-			return true
-		}
-	}
-
-	// 4. 直接匹配框架核心目录（用于没有完整路径的情况）
-	// 只匹配 "db/xxx.go" 这种在框架核心目录下的文件
-	frameworkCoreDirs := []string{"db/", "common/", "code/", "cache/"}
-	for _, dir := range frameworkCoreDirs {
-		if strings.HasPrefix(file, dir) {
-			// 额外检查：确保不是用户项目中同名目录
-			// 框架文件通常有特定的文件名
-			frameworkFiles := []string{
-				"query.go", "crud.go", "where.go", "builder.go", "db.go",
-				"dialect.go", "aggregate.go", "transaction.go", "identifier.go",
-				"error.go", "func.go", "map.go", "obj.go", "slice.go",
-				"makecode.go", "template.go", "config.go",
-				"cache.go", "cache_db.go", "cache_memory.go", "cache_redis.go",
-			}
-			for _, f := range frameworkFiles {
-				if strings.HasSuffix(file, f) {
-					return true
+// 对caller进行递归查询, 直到找到非logrus包产生的第一个调用.
+// 因为filename我获取到了上层目录名, 因此所有logrus包的调用的文件名都是 logrus/...
+// 因此通过排除logrus开头的文件名, 就可以排除所有logrus包的自己的函数调用
+func findCaller(skip int) string {
+	file := ""
+	line := 0
+	for i := 0; i < 10; i++ {
+		file, line = getCaller(skip + i)
+		if !strings.HasPrefix(file, "logrus") {
+			j := 0
+			for true {
+				j++
+				if file == "common/error.go" {
+					file, line = getCaller(skip + i + j)
+				}
+				if file == "db/hotimedb.go" {
+					file, line = getCaller(skip + i + j)
+				}
+				if file == "code/makecode.go" {
+					file, line = getCaller(skip + i + j)
+				}
+				if strings.Index(file, "common/") == 0 {
+					file, line = getCaller(skip + i + j)
+				}
+				if strings.Contains(file, "application.go") {
+					file, line = getCaller(skip + i + j)
+				}
+				if j == 5 {
+					break
 				}
 			}
-		}
-	}

-	return false
-}
-
-// 对caller进行递归查询, 直到找到非框架层产生的第一个调用.
-// 遍历调用栈，跳过框架层文件，找到应用层代码
-// 使用层数限制确保不会误过滤应用层同名目录
-func findCaller(skip int) string {
-	frameworkCount := 0 // 连续框架层计数
-
-	// 遍历调用栈，找到第一个非框架文件
-	for i := 0; i < 20; i++ {
-		file, line := getCaller(skip + i)
-		if file == "" {
 			break
 		}
-
-		if isHoTimeFrameworkFile(file) {
-			frameworkCount++
-			// 层数限制：如果已经跳过太多层，停止跳过
-			if frameworkCount >= maxFrameworkDepth {
-				return fmt.Sprintf("%s:%d", file, line)
-			}
-			continue
-		}
-
-		// 找到非框架文件，返回应用层代码位置
-		return fmt.Sprintf("%s:%d", file, line)
 	}
-
-	// 如果找不到应用层，返回最初的调用者
-	file, line := getCaller(skip)
 	return fmt.Sprintf("%s:%d", file, line)
 }

--- a/var.go
+++ b/var.go
@ -107,7 +107,6 @@ var ConfigNote = Map{
 			"timeout": "默认60 * 60 * 24 * 30，非必须，过期时间，超时自动删除",
 			"db":      "默认false，非必须，缓存数据库，启用后能减少数据库的读写压力",
 			"session": "默认true，非必须，缓存web session，同时缓存session保持的用户缓存",
-			"history": "默认false，非必须，是否开启缓存历史记录，开启后每次新增/修改缓存都会记录到历史表，历史表一旦创建不会自动删除",
 		},
 		"redis": Map{
 			"host":     "默认服务ip：127.0.0.1，必须，如果需要使用redis服务时配置，",