785 lines
21 KiB
Go
785 lines
21 KiB
Go
package main
|
||
|
||
import (
|
||
"database/sql"
|
||
"fmt"
|
||
"log"
|
||
|
||
// 实际使用时请替换为正确的导入路径
|
||
// "code.hoteas.com/golang/hotime/cache"
|
||
// "code.hoteas.com/golang/hotime/common"
|
||
// "code.hoteas.com/golang/hotime/db"
|
||
"code.hoteas.com/golang/hotime/cache"
|
||
"code.hoteas.com/golang/hotime/common"
|
||
"code.hoteas.com/golang/hotime/db"
|
||
_ "github.com/go-sql-driver/mysql"
|
||
"github.com/sirupsen/logrus"
|
||
)
|
||
|
||
// HoTimeDB使用示例代码集合 - 修正版
|
||
// 本文件包含了各种常见场景的完整示例代码，所有条件查询语法已修正
|
||
|
||
// 示例1: 基本初始化和配置
|
||
func Example1_BasicSetup() {
|
||
// 创建数据库实例
|
||
database := &db.HoTimeDB{
|
||
Prefix: "app_", // 设置表前缀
|
||
Mode: 2, // 开发模式，输出SQL日志
|
||
Type: "mysql", // 数据库类型
|
||
}
|
||
|
||
// 设置日志
|
||
logger := logrus.New()
|
||
database.Log = logger
|
||
|
||
// 设置连接函数
|
||
database.SetConnect(func(err ...*common.Error) (master, slave *sql.DB) {
|
||
// 主数据库连接
|
||
master, dbErr := sql.Open("mysql", "root:password@tcp(localhost:3306)/testdb?charset=utf8&parseTime=true")
|
||
if dbErr != nil {
|
||
log.Fatal("数据库连接失败:", dbErr)
|
||
}
|
||
|
||
// 从数据库连接（可选，用于读写分离）
|
||
slave = master // 这里使用同一个连接，实际项目中可以连接到从库
|
||
|
||
return master, slave
|
||
})
|
||
|
||
fmt.Println("数据库初始化完成")
|
||
}
|
||
|
||
// 示例2: 基本CRUD操作（修正版）
|
||
func Example2_BasicCRUD_Fixed(db *db.HoTimeDB) {
|
||
// 创建用户
|
||
fmt.Println("=== 创建用户 ===")
|
||
userId := db.Insert("user", common.Map{
|
||
"name": "张三",
|
||
"email": "zhangsan@example.com",
|
||
"age": 25,
|
||
"status": 1,
|
||
"balance": 1000.50,
|
||
"created_time[#]": "NOW()",
|
||
})
|
||
fmt.Printf("新用户ID: %d\n", userId)
|
||
|
||
// 查询用户（单条件，可以不用AND）
|
||
fmt.Println("\n=== 查询用户 ===")
|
||
user := db.Get("user", "*", common.Map{
|
||
"id": userId,
|
||
})
|
||
if user != nil {
|
||
fmt.Printf("用户信息: %+v\n", user)
|
||
}
|
||
|
||
// 更新用户（多条件必须用AND包装）
|
||
fmt.Println("\n=== 更新用户 ===")
|
||
affected := db.Update("user", common.Map{
|
||
"name": "李四",
|
||
"age": 26,
|
||
"updated_time[#]": "NOW()",
|
||
}, common.Map{
|
||
"AND": common.Map{
|
||
"id": userId,
|
||
"status": 1, // 确保只更新正常状态的用户
|
||
},
|
||
})
|
||
fmt.Printf("更新记录数: %d\n", affected)
|
||
|
||
// 软删除用户
|
||
fmt.Println("\n=== 软删除用户 ===")
|
||
affected = db.Update("user", common.Map{
|
||
"deleted_at[#]": "NOW()",
|
||
"status": 0,
|
||
}, common.Map{
|
||
"id": userId, // 单条件，不需要AND
|
||
})
|
||
fmt.Printf("软删除记录数: %d\n", affected)
|
||
}
|
||
|
||
// 示例3: 条件查询语法（修正版）
|
||
func Example3_ConditionQuery_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== 条件查询语法示例 ===")
|
||
|
||
// ✅ 正确：单个条件
|
||
users1 := db.Select("user", "*", common.Map{
|
||
"status": 1,
|
||
})
|
||
fmt.Printf("活跃用户: %d个\n", len(users1))
|
||
|
||
// ✅ 正确：多个条件用AND包装
|
||
users2 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"status": 1,
|
||
"age[>]": 18,
|
||
"age[<=]": 60,
|
||
},
|
||
})
|
||
fmt.Printf("活跃的成年用户: %d个\n", len(users2))
|
||
|
||
// ✅ 正确：OR条件
|
||
users3 := db.Select("user", "*", common.Map{
|
||
"OR": common.Map{
|
||
"level": "vip",
|
||
"balance[>]": 5000,
|
||
},
|
||
})
|
||
fmt.Printf("VIP或高余额用户: %d个\n", len(users3))
|
||
|
||
// ✅ 正确：条件 + 特殊参数
|
||
users4 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"status": 1,
|
||
"age[>=]": 18,
|
||
},
|
||
"ORDER": "created_time DESC",
|
||
"LIMIT": 10,
|
||
})
|
||
fmt.Printf("最近的活跃成年用户: %d个\n", len(users4))
|
||
|
||
// ✅ 正确：复杂嵌套条件
|
||
users5 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"status": 1,
|
||
"OR": common.Map{
|
||
"age[<]": 30,
|
||
"level": "vip",
|
||
},
|
||
},
|
||
"ORDER": []string{"level DESC", "created_time DESC"},
|
||
"LIMIT": []int{0, 20},
|
||
})
|
||
fmt.Printf("年轻或VIP的活跃用户: %d个\n", len(users5))
|
||
|
||
// ✅ 正确：模糊查询
|
||
users6 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"name[~]": "张", // 姓名包含"张"
|
||
"email[~!]": "gmail", // 邮箱以gmail开头
|
||
"status": 1,
|
||
},
|
||
})
|
||
fmt.Printf("姓张的gmail活跃用户: %d个\n", len(users6))
|
||
|
||
// ✅ 正确：范围查询
|
||
users7 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"age[<>]": []int{18, 35}, // 年龄在18-35之间
|
||
"balance[><]": []float64{0, 100}, // 余额不在0-100之间
|
||
"status": 1,
|
||
},
|
||
})
|
||
fmt.Printf("18-35岁且余额>100的活跃用户: %d个\n", len(users7))
|
||
|
||
// ✅ 正确：IN查询
|
||
users8 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"id": []int{1, 2, 3, 4, 5}, // ID在指定范围内
|
||
"status[!]": []int{0, -1}, // 状态不为0或-1
|
||
},
|
||
})
|
||
fmt.Printf("指定ID的活跃用户: %d个\n", len(users8))
|
||
}
|
||
|
||
// 示例4: 链式查询操作（正确版）
|
||
func Example4_ChainQuery_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== 链式查询示例 ===")
|
||
|
||
// 链式查询（链式语法允许单独的Where，然后用And添加更多条件）
|
||
users := db.Table("user").
|
||
Where("status", 1). // 链式中可以单独Where
|
||
And("age[>=]", 18). // 然后用And添加条件
|
||
And("age[<=]", 60). // 再添加条件
|
||
Or(common.Map{ // 或者用Or添加OR条件组
|
||
"level": "vip",
|
||
"balance[>]": 5000,
|
||
}).
|
||
Order("created_time DESC", "id ASC"). // 排序
|
||
Limit(0, 10). // 限制结果
|
||
Select("id,name,email,age,balance,level")
|
||
|
||
fmt.Printf("链式查询到 %d 个用户\n", len(users))
|
||
for i, user := range users {
|
||
fmt.Printf("用户%d: %s (年龄:%v, 余额:%v)\n",
|
||
i+1,
|
||
user.GetString("name"),
|
||
user.Get("age"),
|
||
user.Get("balance"))
|
||
}
|
||
|
||
// 链式统计查询
|
||
count := db.Table("user").
|
||
Where("status", 1).
|
||
And("age[>=]", 18).
|
||
Count()
|
||
fmt.Printf("符合条件的用户总数: %d\n", count)
|
||
}
|
||
|
||
// 示例5: JOIN查询操作（修正版）
|
||
func Example5_JoinQuery_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== JOIN查询示例 ===")
|
||
|
||
// 链式JOIN查询
|
||
orders := db.Table("order").
|
||
LeftJoin("user", "order.user_id = user.id").
|
||
LeftJoin("product", "order.product_id = product.id").
|
||
Where("order.status", "paid"). // 链式中单个条件可以直接Where
|
||
And("order.created_time[>]", "2023-01-01"). // 用And添加更多条件
|
||
Order("order.created_time DESC").
|
||
Select(`
|
||
order.id as order_id,
|
||
order.amount,
|
||
order.status,
|
||
order.created_time,
|
||
user.name as user_name,
|
||
user.email as user_email,
|
||
product.title as product_title,
|
||
product.price as product_price
|
||
`)
|
||
|
||
fmt.Printf("链式JOIN查询到 %d 个订单\n", len(orders))
|
||
for _, order := range orders {
|
||
fmt.Printf("订单ID:%v, 用户:%s, 商品:%s, 金额:%v\n",
|
||
order.Get("order_id"),
|
||
order.GetString("user_name"),
|
||
order.GetString("product_title"),
|
||
order.Get("amount"))
|
||
}
|
||
|
||
// 传统JOIN语法（多个条件必须用AND包装）
|
||
orders2 := db.Select("order",
|
||
common.Slice{
|
||
common.Map{"[>]user": "order.user_id = user.id"},
|
||
common.Map{"[>]product": "order.product_id = product.id"},
|
||
},
|
||
"order.*, user.name as user_name, product.title as product_title",
|
||
common.Map{
|
||
"AND": common.Map{
|
||
"order.status": "paid",
|
||
"order.created_time[>]": "2023-01-01",
|
||
},
|
||
})
|
||
|
||
fmt.Printf("传统JOIN语法查询到 %d 个订单\n", len(orders2))
|
||
}
|
||
|
||
// 示例6: 分页查询（修正版）
|
||
func Example6_PaginationQuery_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== 分页查询示例 ===")
|
||
|
||
page := 2
|
||
pageSize := 10
|
||
|
||
// 获取总数（单条件）
|
||
total := db.Count("user", common.Map{
|
||
"AND": common.Map{
|
||
"status": 1,
|
||
"deleted_at": nil,
|
||
},
|
||
})
|
||
|
||
// 分页数据（链式方式）
|
||
users := db.Table("user").
|
||
Where("status", 1).
|
||
And("deleted_at", nil).
|
||
Order("created_time DESC").
|
||
Page(page, pageSize).
|
||
Select("id,name,email,created_time")
|
||
|
||
// 使用传统方式的分页查询
|
||
users2 := db.Page(page, pageSize).PageSelect("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"status": 1,
|
||
"deleted_at": nil,
|
||
},
|
||
"ORDER": "created_time DESC",
|
||
})
|
||
|
||
// 计算分页信息
|
||
totalPages := (total + pageSize - 1) / pageSize
|
||
offset := (page - 1) * pageSize
|
||
|
||
fmt.Printf("总记录数: %d\n", total)
|
||
fmt.Printf("总页数: %d\n", totalPages)
|
||
fmt.Printf("当前页: %d\n", page)
|
||
fmt.Printf("每页大小: %d\n", pageSize)
|
||
fmt.Printf("偏移量: %d\n", offset)
|
||
fmt.Printf("链式查询当前页记录数: %d\n", len(users))
|
||
fmt.Printf("传统查询当前页记录数: %d\n", len(users2))
|
||
|
||
for i, user := range users {
|
||
fmt.Printf(" %d. %s (%s) - %v\n",
|
||
offset+i+1,
|
||
user.GetString("name"),
|
||
user.GetString("email"),
|
||
user.Get("created_time"))
|
||
}
|
||
}
|
||
|
||
// 示例7: 聚合函数查询（修正版）
|
||
func Example7_AggregateQuery_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== 聚合函数查询示例 ===")
|
||
|
||
// 基本统计
|
||
userCount := db.Count("user")
|
||
activeUserCount := db.Count("user", common.Map{"status": 1})
|
||
totalBalance := db.Sum("user", "balance", common.Map{"status": 1})
|
||
|
||
fmt.Printf("总用户数: %d\n", userCount)
|
||
fmt.Printf("活跃用户数: %d\n", activeUserCount)
|
||
fmt.Printf("活跃用户总余额: %.2f\n", totalBalance)
|
||
|
||
// 分组统计（正确语法）
|
||
stats := db.Select("user",
|
||
"level, COUNT(*) as user_count, AVG(age) as avg_age, SUM(balance) as total_balance",
|
||
common.Map{
|
||
"status": 1, // 单条件，不需要AND
|
||
"GROUP": "level",
|
||
"ORDER": "user_count DESC",
|
||
})
|
||
|
||
fmt.Println("\n按等级分组统计:")
|
||
for _, stat := range stats {
|
||
fmt.Printf("等级:%v, 用户数:%v, 平均年龄:%v, 总余额:%v\n",
|
||
stat.Get("level"),
|
||
stat.Get("user_count"),
|
||
stat.Get("avg_age"),
|
||
stat.Get("total_balance"))
|
||
}
|
||
|
||
// 关联统计（修正版）
|
||
orderStats := db.Select("order",
|
||
common.Slice{
|
||
common.Map{"[>]user": "order.user_id = user.id"},
|
||
},
|
||
"user.level, COUNT(order.id) as order_count, SUM(order.amount) as total_amount",
|
||
common.Map{
|
||
"AND": common.Map{
|
||
"order.status": "paid",
|
||
"order.created_time[>]": "2023-01-01",
|
||
},
|
||
"GROUP": "user.level",
|
||
"ORDER": "total_amount DESC",
|
||
})
|
||
|
||
fmt.Println("\n用户等级订单统计:")
|
||
for _, stat := range orderStats {
|
||
fmt.Printf("等级:%v, 订单数:%v, 总金额:%v\n",
|
||
stat.Get("level"),
|
||
stat.Get("order_count"),
|
||
stat.Get("total_amount"))
|
||
}
|
||
}
|
||
|
||
// 示例8: 事务处理（修正版）
|
||
func Example8_Transaction_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== 事务处理示例 ===")
|
||
|
||
// 模拟转账操作
|
||
fromUserId := int64(1)
|
||
toUserId := int64(2)
|
||
amount := 100.0
|
||
|
||
success := db.Action(func(tx db.HoTimeDB) bool {
|
||
// 检查转出账户余额（单条件）
|
||
fromUser := tx.Get("user", "balance", common.Map{"id": fromUserId})
|
||
if fromUser == nil {
|
||
fmt.Println("转出用户不存在")
|
||
return false
|
||
}
|
||
|
||
fromBalance := fromUser.GetFloat64("balance")
|
||
if fromBalance < amount {
|
||
fmt.Println("余额不足")
|
||
return false
|
||
}
|
||
|
||
// 扣减转出账户余额（多条件必须用AND）
|
||
affected1 := tx.Update("user", common.Map{
|
||
"balance[#]": fmt.Sprintf("balance - %.2f", amount),
|
||
"updated_time[#]": "NOW()",
|
||
}, common.Map{
|
||
"AND": common.Map{
|
||
"id": fromUserId,
|
||
"balance[>=]": amount, // 再次确保余额足够
|
||
},
|
||
})
|
||
|
||
if affected1 == 0 {
|
||
fmt.Println("扣减余额失败")
|
||
return false
|
||
}
|
||
|
||
// 增加转入账户余额（单条件）
|
||
affected2 := tx.Update("user", common.Map{
|
||
"balance[#]": fmt.Sprintf("balance + %.2f", amount),
|
||
"updated_time[#]": "NOW()",
|
||
}, common.Map{
|
||
"id": toUserId,
|
||
})
|
||
|
||
if affected2 == 0 {
|
||
fmt.Println("增加余额失败")
|
||
return false
|
||
}
|
||
|
||
// 记录转账日志
|
||
logId := tx.Insert("transfer_log", common.Map{
|
||
"from_user_id": fromUserId,
|
||
"to_user_id": toUserId,
|
||
"amount": amount,
|
||
"status": "success",
|
||
"created_time[#]": "NOW()",
|
||
})
|
||
|
||
if logId == 0 {
|
||
fmt.Println("记录日志失败")
|
||
return false
|
||
}
|
||
|
||
fmt.Printf("转账成功: 用户%d -> 用户%d, 金额:%.2f\n", fromUserId, toUserId, amount)
|
||
return true
|
||
})
|
||
|
||
if success {
|
||
fmt.Println("事务执行成功")
|
||
} else {
|
||
fmt.Println("事务回滚")
|
||
if db.LastErr.GetError() != nil {
|
||
fmt.Println("错误原因:", db.LastErr.GetError())
|
||
}
|
||
}
|
||
}
|
||
|
||
// 示例9: 缓存机制（修正版）
|
||
func Example9_CacheSystem_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== 缓存机制示例 ===")
|
||
|
||
// 设置缓存（实际项目中需要配置缓存参数）
|
||
db.HoTimeCache = &cache.HoTimeCache{}
|
||
|
||
// 第一次查询（会缓存结果）
|
||
fmt.Println("第一次查询（会缓存）...")
|
||
users1 := db.Select("user", "*", common.Map{
|
||
"status": 1, // 单条件
|
||
"LIMIT": 10,
|
||
})
|
||
fmt.Printf("查询到 %d 个用户\n", len(users1))
|
||
|
||
// 第二次相同查询（从缓存获取）
|
||
fmt.Println("第二次相同查询（从缓存获取）...")
|
||
users2 := db.Select("user", "*", common.Map{
|
||
"status": 1, // 单条件
|
||
"LIMIT": 10,
|
||
})
|
||
fmt.Printf("查询到 %d 个用户\n", len(users2))
|
||
|
||
// 更新操作会清除缓存
|
||
fmt.Println("执行更新操作（会清除缓存）...")
|
||
affected := db.Update("user", common.Map{
|
||
"updated_time[#]": "NOW()",
|
||
}, common.Map{
|
||
"id": 1, // 单条件
|
||
})
|
||
fmt.Printf("更新 %d 条记录\n", affected)
|
||
|
||
// 再次查询（重新从数据库获取并缓存）
|
||
fmt.Println("更新后再次查询（重新缓存）...")
|
||
users3 := db.Select("user", "*", common.Map{
|
||
"status": 1, // 单条件
|
||
"LIMIT": 10,
|
||
})
|
||
fmt.Printf("查询到 %d 个用户\n", len(users3))
|
||
}
|
||
|
||
// 示例10: 性能优化技巧（修正版）
|
||
func Example10_PerformanceOptimization_Fixed(db *db.HoTimeDB) {
|
||
fmt.Println("=== 性能优化技巧示例 ===")
|
||
|
||
// IN查询优化（连续数字自动转为BETWEEN）
|
||
fmt.Println("IN查询优化示例...")
|
||
users := db.Select("user", "*", common.Map{
|
||
"id": []int{1, 2, 3, 4, 5, 10, 11, 12, 13, 20}, // 单个IN条件，会被优化
|
||
})
|
||
fmt.Printf("查询到 %d 个用户\n", len(users))
|
||
fmt.Println("执行的SQL:", db.LastQuery)
|
||
|
||
// 批量插入（使用事务）
|
||
fmt.Println("\n批量插入示例...")
|
||
success := db.Action(func(tx db.HoTimeDB) bool {
|
||
for i := 1; i <= 100; i++ {
|
||
id := tx.Insert("user_batch", common.Map{
|
||
"name": fmt.Sprintf("批量用户%d", i),
|
||
"email": fmt.Sprintf("batch%d@example.com", i),
|
||
"status": 1,
|
||
"created_time[#]": "NOW()",
|
||
})
|
||
if id == 0 {
|
||
return false
|
||
}
|
||
|
||
// 每10个用户输出一次进度
|
||
if i%10 == 0 {
|
||
fmt.Printf("已插入 %d 个用户\n", i)
|
||
}
|
||
}
|
||
return true
|
||
})
|
||
|
||
if success {
|
||
fmt.Println("批量插入完成")
|
||
} else {
|
||
fmt.Println("批量插入失败")
|
||
}
|
||
|
||
// 索引友好的查询（修正版）
|
||
fmt.Println("\n索引友好的查询...")
|
||
recentUsers := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{
|
||
"created_time[>]": "2023-01-01", // 假设created_time有索引
|
||
"status": 1, // 假设status有索引
|
||
},
|
||
"ORDER": "created_time DESC", // 利用索引排序
|
||
"LIMIT": 20,
|
||
})
|
||
fmt.Printf("查询到 %d 个近期用户\n", len(recentUsers))
|
||
}
|
||
|
||
// 完整的应用示例（修正版）
|
||
func CompleteExample_Fixed() {
|
||
fmt.Println("=== HoTimeDB完整应用示例（修正版） ===")
|
||
|
||
// 初始化数据库
|
||
database := &db.HoTimeDB{
|
||
Prefix: "app_",
|
||
Mode: 1, // 测试模式
|
||
Type: "mysql",
|
||
}
|
||
|
||
// 设置连接
|
||
database.SetConnect(func(err ...*common.Error) (master, slave *sql.DB) {
|
||
// 这里使用实际的数据库连接字符串
|
||
dsn := "root:password@tcp(localhost:3306)/testdb?charset=utf8mb4&parseTime=True&loc=Local"
|
||
master, dbErr := sql.Open("mysql", dsn)
|
||
if dbErr != nil {
|
||
log.Fatal("数据库连接失败:", dbErr)
|
||
}
|
||
return master, master
|
||
})
|
||
|
||
// 用户管理系统示例
|
||
fmt.Println("\n=== 用户管理系统 ===")
|
||
|
||
// 1. 创建用户
|
||
userId := database.Insert("user", common.Map{
|
||
"name": "示例用户",
|
||
"email": "example@test.com",
|
||
"password": "hashed_password",
|
||
"age": 28,
|
||
"status": 1,
|
||
"level": "normal",
|
||
"balance": 500.00,
|
||
"created_time[#]": "NOW()",
|
||
})
|
||
fmt.Printf("创建用户成功，ID: %d\n", userId)
|
||
|
||
// 2. 用户登录更新（多条件用AND）
|
||
database.Update("user", common.Map{
|
||
"last_login[#]": "NOW()",
|
||
"login_count[#]": "login_count + 1",
|
||
}, common.Map{
|
||
"AND": common.Map{
|
||
"id": userId,
|
||
"status": 1,
|
||
},
|
||
})
|
||
|
||
// 3. 创建订单
|
||
orderId := database.Insert("order", common.Map{
|
||
"user_id": userId,
|
||
"amount": 299.99,
|
||
"status": "pending",
|
||
"created_time[#]": "NOW()",
|
||
})
|
||
fmt.Printf("创建订单成功，ID: %d\n", orderId)
|
||
|
||
// 4. 订单支付（使用事务，修正版）
|
||
paymentSuccess := database.Action(func(tx db.HoTimeDB) bool {
|
||
// 更新订单状态（单条件）
|
||
affected1 := tx.Update("order", common.Map{
|
||
"status": "paid",
|
||
"paid_time[#]": "NOW()",
|
||
}, common.Map{
|
||
"id": orderId,
|
||
})
|
||
|
||
if affected1 == 0 {
|
||
return false
|
||
}
|
||
|
||
// 扣减用户余额（多条件用AND）
|
||
affected2 := tx.Update("user", common.Map{
|
||
"balance[#]": "balance - 299.99",
|
||
}, common.Map{
|
||
"AND": common.Map{
|
||
"id": userId,
|
||
"balance[>=]": 299.99, // 确保余额足够
|
||
},
|
||
})
|
||
|
||
if affected2 == 0 {
|
||
fmt.Println("余额不足或用户不存在")
|
||
return false
|
||
}
|
||
|
||
// 记录支付日志
|
||
logId := tx.Insert("payment_log", common.Map{
|
||
"user_id": userId,
|
||
"order_id": orderId,
|
||
"amount": 299.99,
|
||
"type": "order_payment",
|
||
"status": "success",
|
||
"created_time[#]": "NOW()",
|
||
})
|
||
|
||
return logId > 0
|
||
})
|
||
|
||
if paymentSuccess {
|
||
fmt.Println("订单支付成功")
|
||
} else {
|
||
fmt.Println("订单支付失败")
|
||
}
|
||
|
||
// 5. 查询用户订单列表（链式查询）
|
||
userOrders := database.Table("order").
|
||
LeftJoin("user", "order.user_id = user.id").
|
||
Where("order.user_id", userId). // 链式中单个条件可以直接Where
|
||
Order("order.created_time DESC").
|
||
Select(`
|
||
order.id,
|
||
order.amount,
|
||
order.status,
|
||
order.created_time,
|
||
order.paid_time,
|
||
user.name as user_name
|
||
`)
|
||
|
||
fmt.Printf("\n用户订单列表 (%d个订单):\n", len(userOrders))
|
||
for _, order := range userOrders {
|
||
fmt.Printf(" 订单ID:%v, 金额:%v, 状态:%s, 创建时间:%v\n",
|
||
order.Get("id"),
|
||
order.Get("amount"),
|
||
order.GetString("status"),
|
||
order.Get("created_time"))
|
||
}
|
||
|
||
// 6. 生成统计报表（修正版）
|
||
stats := database.Select("order",
|
||
common.Slice{
|
||
common.Map{"[>]user": "order.user_id = user.id"},
|
||
},
|
||
`
|
||
DATE(order.created_time) as date,
|
||
COUNT(order.id) as order_count,
|
||
SUM(order.amount) as total_amount,
|
||
AVG(order.amount) as avg_amount
|
||
`,
|
||
common.Map{
|
||
"AND": common.Map{
|
||
"order.status": "paid",
|
||
"order.created_time[>]": "2023-01-01",
|
||
},
|
||
"GROUP": "DATE(order.created_time)",
|
||
"ORDER": "date DESC",
|
||
"LIMIT": 30,
|
||
})
|
||
|
||
fmt.Printf("\n最近30天订单统计:\n")
|
||
for _, stat := range stats {
|
||
fmt.Printf("日期:%v, 订单数:%v, 总金额:%v, 平均金额:%v\n",
|
||
stat.Get("date"),
|
||
stat.Get("order_count"),
|
||
stat.Get("total_amount"),
|
||
stat.Get("avg_amount"))
|
||
}
|
||
|
||
fmt.Println("\n示例执行完成！")
|
||
}
|
||
|
||
// 语法对比示例
|
||
func SyntaxComparison() {
|
||
fmt.Println("=== HoTimeDB语法对比 ===")
|
||
|
||
// 模拟数据库对象
|
||
var db *db.HoTimeDB
|
||
|
||
fmt.Println("❌ 错误语法示例（不支持）:")
|
||
fmt.Println(`
|
||
// 这样写是错误的，多个条件不能直接放在根Map中
|
||
wrongUsers := db.Select("user", "*", common.Map{
|
||
"status": 1, // ❌ 错误
|
||
"age[>]": 18, // ❌ 错误
|
||
"ORDER": "id DESC",
|
||
})
|
||
`)
|
||
|
||
fmt.Println("✅ 正确语法示例:")
|
||
fmt.Println(`
|
||
// 单个条件可以直接写
|
||
correctUsers1 := db.Select("user", "*", common.Map{
|
||
"status": 1, // ✅ 正确，单个条件
|
||
})
|
||
|
||
// 多个条件必须用AND包装
|
||
correctUsers2 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{ // ✅ 正确，多个条件用AND包装
|
||
"status": 1,
|
||
"age[>]": 18,
|
||
},
|
||
"ORDER": "id DESC", // ✅ 正确，特殊参数与条件同级
|
||
})
|
||
|
||
// OR条件
|
||
correctUsers3 := db.Select("user", "*", common.Map{
|
||
"OR": common.Map{ // ✅ 正确，OR条件
|
||
"level": "vip",
|
||
"balance[>]": 1000,
|
||
},
|
||
})
|
||
|
||
// 嵌套条件
|
||
correctUsers4 := db.Select("user", "*", common.Map{
|
||
"AND": common.Map{ // ✅ 正确，嵌套条件
|
||
"status": 1,
|
||
"OR": common.Map{
|
||
"age[<]": 30,
|
||
"level": "vip",
|
||
},
|
||
},
|
||
"ORDER": "created_time DESC",
|
||
"LIMIT": 20,
|
||
})
|
||
`)
|
||
|
||
// 实际不执行查询，只是展示语法
|
||
_ = db
|
||
}
|
||
|
||
// 运行所有修正后的示例
|
||
func RunAllFixedExamples() {
|
||
fmt.Println("开始运行HoTimeDB所有修正后的示例...")
|
||
fmt.Println("注意：实际运行时需要确保数据库连接正确，并且相关表存在")
|
||
|
||
// 展示语法对比
|
||
SyntaxComparison()
|
||
|
||
fmt.Println("请根据实际环境配置数据库连接后运行相应示例")
|
||
fmt.Println("所有示例代码已修正完毕，语法正确！")
|
||
}
|
||
|
||
func main() {
|
||
// 运行语法对比示例
|
||
RunAllFixedExamples()
|
||
}
|