Golang框架GoooQo v0.1.4发布：基于OQM的CRUD开发框架

GoooQo v0.1.4的发布带来了几个实用的新特性，特别是对OR子句构建的支持和事务管理的改进。以下是针对这些更新的技术分析和示例代码：

1. 结构体数组/基本类型数组构建OR子句

这个功能允许开发者通过数组直接构建OR查询条件，大大简化了复杂查询的编写：

package main

import (
    "github.com/goooqo/goooqo"
    "fmt"
)

type User struct {
    ID   int    `db:"id"`
    Name string `db:"name"`
    Age  int    `db:"age"`
}

func main() {
    // 初始化GoooQo
    db := goooqo.NewDB("your-connection-string")
    
    // 使用结构体数组构建OR查询
    users := []User{
        {Name: "Alice", Age: 25},
        {Name: "Bob", Age: 30},
        {Name: "Charlie", Age: 35},
    }
    
    var result []User
    err := db.Model(&User{}).
        WhereOrArray(users).
        Find(&result)
    
    if err != nil {
        fmt.Printf("查询错误: %v\n", err)
        return
    }
    
    // 生成的SQL类似于:
    // SELECT * FROM users WHERE (name = 'Alice' AND age = 25) 
    // OR (name = 'Bob' AND age = 30) 
    // OR (name = 'Charlie' AND age = 35)
    
    // 基本类型数组的OR查询
    ids := []int{1, 2, 3, 4, 5}
    var usersById []User
    err = db.Model(&User{}).
        Where("id IN (?)", ids).
        Find(&usersById)
}

2. JSON缩进配置

新的JSON配置选项允许控制API响应的格式化：

package main

import (
    "github.com/goooqo/goooqo"
    "encoding/json"
)

func main() {
    // 配置JSON输出
    config := goooqo.Config{
        JSONIndent: true,      // 启用缩进
        JSONPrefix: "",        // 前缀字符串
        JSONIndentString: "  ", // 两个空格缩进
    }
    
    db := goooqo.NewDBWithConfig("your-connection-string", config)
    
    // 查询并返回JSON响应
    user := User{ID: 1, Name: "John", Age: 28}
    
    // 自动使用配置的JSON格式
    jsonData, err := json.MarshalIndent(user, config.JSONPrefix, config.JSONIndentString)
    if err != nil {
        panic(err)
    }
    
    fmt.Println(string(jsonData))
    // 输出:
    // {
    //   "id": 1,
    //   "name": "John",
    //   "age": 28
    // }
}

3. 恐慌事务恢复机制

这个特性增强了事务的健壮性，防止panic导致数据库连接泄露：

package main

import (
    "github.com/goooqo/goooqo"
    "fmt"
)

func main() {
    db := goooqo.NewDB("your-connection-string")
    
    // 自动恢复的事务
    err := db.Transaction(func(tx *goooqo.Tx) error {
        // 执行多个操作
        user1 := User{Name: "User1", Age: 25}
        if err := tx.Create(&user1); err != nil {
            return err
        }
        
        // 如果这里发生panic，事务会自动回滚并恢复
        someRiskyOperation()
        
        user2 := User{Name: "User2", Age: 30}
        return tx.Create(&user2)
    })
    
    if err != nil {
        fmt.Printf("事务执行失败: %v\n", err)
    }
}

func someRiskyOperation() {
    // 可能引发panic的操作
    panic("unexpected error")
}

4. 回调式事务

提供更灵活的事务控制方式：

package main

import (
    "github.com/goooqo/goooqo"
    "context"
    "fmt"
)

func main() {
    db := goooqo.NewDB("your-connection-string")
    ctx := context.Background()
    
    // 回调式事务
    err := db.WithTransaction(ctx, func(ctx context.Context, tx *goooqo.Tx) error {
        // 在事务中执行操作
        user := User{Name: "TransactionUser", Age: 40}
        
        // 插入记录
        if err := tx.Model(&User{}).Create(&user); err != nil {
            return err
        }
        
        // 更新记录
        user.Age = 41
        if err := tx.Model(&User{}).Where("id = ?", user.ID).Update(&user); err != nil {
            return err
        }
        
        // 查询验证
        var updatedUser User
        if err := tx.Model(&User{}).Where("id = ?", user.ID).First(&updatedUser); err != nil {
            return err
        }
        
        fmt.Printf("更新后的用户年龄: %d\n", updatedUser.Age)
        return nil
    })
    
    if err != nil {
        fmt.Printf("回调事务失败: %v\n", err)
    }
}

5. IntId核心类型

新增的IntId类型简化了ID处理：

package main

import (
    "github.com/goooqo/goooqo"
    "fmt"
)

type Product struct {
    ID   goooqo.IntId `db:"id" json:"id"`
    Name string       `db:"name" json:"name"`
    Price float64     `db:"price" json:"price"`
}

func main() {
    db := goooqo.NewDB("your-connection-string")
    
    // 创建记录
    product := Product{
        Name:  "Laptop",
        Price: 999.99,
    }
    
    // IntId会自动处理ID的生成和验证
    err := db.Model(&Product{}).Create(&product)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("创建的产品ID: %d\n", product.ID)
    
    // 使用IntId进行查询
    var retrieved Product
    err = db.Model(&Product{}).
        Where("id = ?", product.ID).
        First(&retrieved)
    
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("检索到的产品: %+v\n", retrieved)
}

6. SQL日志记录重构

改进的SQL日志记录提供更详细的调试信息：

package main

import (
    "github.com/goooqo/goooqo"
    "log"
)

func main() {
    // 配置SQL日志
    config := goooqo.Config{
        LogSQL:      true,
        LogLevel:    goooqo.LogLevelDebug,
        Logger:      log.Default(),
    }
    
    db := goooqo.NewDBWithConfig("your-connection-string", config)
    
    // 执行查询时会记录详细的SQL信息
    var users []User
    err := db.Model(&User{}).
        Where("age > ?", 20).
        Where("name LIKE ?", "J%").
        Limit(10).
        Find(&users)
    
    if err != nil {
        panic(err)
    }
    
    // 日志输出示例:
    // [DEBUG] SQL: SELECT * FROM users WHERE age > ? AND name LIKE ? LIMIT ?
    // [DEBUG] Params: [20, "J%", 10]
    // [DEBUG] Execution time: 2.345ms
}

这些更新使GoooQo在查询构建、事务管理和调试方面更加完善。OR子句构建特别有用，它能显著减少复杂查询的代码量。事务恢复机制则提高了应用程序的稳定性。