Go语言中设计与实现基础ORM：避免常见陷阱与最佳实践

package main

import (
    "fmt"
    "hash/crc32"
)

// 假设这是我们的数据库模型
type ddPerson struct {
    pID      int
    fName    string
    lName    string
    job      string
    location string
}

type ddDB struct {
    people []ddPerson
}

// 模拟磁盘数据库的初始数据
var ddb = ddDB{
    people: []ddPerson{
        {pID: 1, fName: "John", lName: "Doe", job: "Engineer", location: "New York"},
        {pID: 2, fName: "Jane", lName: "Smith", job: "Designer", location: "Los Angeles"},
        {pID: 3, fName: "Danielle", lName: "White", job: "Artist", location: "Chicago"},
    },
}

func main() {
    // 1. 读取数据到内存
    memDB := ddb // 注意：这里是浅拷贝，实际应用中需要深拷贝或通过DB连接读取

    // 2. 创建初始哈希映射
    peopleMap := make(map[int]uint32)
    for _, v := range memDB.people {
        hash := []byte(fmt.Sprintf("%#v", v)) // 将结构体转换为字节数组进行哈希
        peopleMap[v.pID] = crc32.ChecksumIEEE(hash)
        // fmt.Printf("%v: %v %v \t(%v %v) - crc sum: %v\n", v.pID, v.fName, v.lName, v.job, v.location, peopleMap[v.pID])
    }
    fmt.Printf("初始内存中人数: %v\n", len(memDB.people))

    // 3. 模拟内存中的数据变更（删除Danielle）
    var tmpSlice []ddPerson
    for _, v := range memDB.people {
        if v.fName == "Danielle" {
            continue
        }
        tmpSlice = append(tmpSlice, v)
    }
    memDB.people = tmpSlice
    fmt.Printf("删除后内存中人数: %v\n", len(memDB.people))

    // 4. 模拟保存操作，检测变更
    // 检查删除或新增
    if len(peopleMap) > len(memDB.people) {
        fmt.Println("检测到删除操作...")
        // 实际应用中需要找出具体被删除的ID
    } else if len(peopleMap) < len(memDB.people) {
        fmt.Println("检测到新增操作...")
        // 实际应用中需要找出具体新增的记录
    }

    // 检查更新
    tMap := make(map[int]uint32)
    for _, v := range memDB.people {
        hash := []byte(fmt.Sprintf("%#v", v))
        currentHash := crc32.ChecksumIEEE(hash)
        tMap[v.pID] = currentHash

        if originalHash, ok := peopleMap[v.pID]; ok && currentHash != originalHash {
            fmt.Println("检测到内存模型中数据更新...")
            // 在这里写入变更到数据库
            // ddb.people = memDB.people // 模拟写入
        }
    }

    // 更新哈希映射以备下次比较
    peopleMap = tMap
    fmt.Println("变更检测完成。")
}

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql" // 导入数据库驱动，例如MySQL
    "log"
    "time"
)

// Person 结构体映射数据库中的 'people' 表
type Person struct {
    ID        int       `db:"id"`
    FirstName string    `db:"first_name"`
    LastName  string    `db:"last_name"`
    Job       string    `db:"job"`
    Location  string    `db:"location"`
    CreatedAt time.Time `db:"created_at"`
    UpdatedAt time.Time `db:"updated_at"`
}

// 假设的数据库连接字符串
const dsn = "user:password@tcp(127.0.0.1:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local"

// 初始化数据库连接
func initDB() *sql.DB {
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatalf("无法连接到数据库: %v", err)
    }
    // 设置连接池参数
    db.SetMaxOpenConns(10)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(5 * time.Minute)

    if err = db.Ping(); err != nil {
        log.Fatalf("数据库连接失败: %v", err)
    }
    fmt.Println("成功连接到数据库！")
    return db
}

// 模拟数据库表创建（实际应用中通常通过迁移工具完成）
func createTable(db *sql.DB) {
    query := `
    CREATE TABLE IF NOT EXISTS people (
        id INT AUTO_INCREMENT PRIMARY KEY,
        first_name VARCHAR(255) NOT NULL,
        last_name VARCHAR(255) NOT NULL,
        job VARCHAR(255),
        location VARCHAR(255),
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
    );`
    _, err := db.Exec(query)
    if err != nil {
        log.Fatalf("创建表失败: %v", err)
    }
    fmt.Println("表 'people' 检查或创建成功。")
}

// CreatePerson 将一个Person对象插入到数据库中
func CreatePerson(db *sql.DB, p *Person) error {
    stmt, err := db.Prepare("INSERT INTO people (first_name, last_name, job, location) VALUES (?, ?, ?, ?)")
    if err != nil {
        return fmt.Errorf("准备插入语句失败: %w", err)
    }
    defer stmt.Close()

    res, err := stmt.Exec(p.FirstName, p.LastName, p.Job, p.Location)
    if err != nil {
        return fmt.Errorf("执行插入操作失败: %w", err)
    }

    id, err := res.LastInsertId()
    if err != nil {
        return fmt.Errorf("获取最后插入ID失败: %w", err)
    }
    p.ID = int(id)
    fmt.Printf("成功插入人员: %s %s, ID: %d\n", p.FirstName, p.LastName, p.ID)
    return nil
}

// GetPersonByID 根据ID从数据库中读取一个Person对象
func GetPersonByID(db *sql.DB, id int) (*Person, error) {
    p := &Person{}
    row := db.QueryRow("SELECT id, first_name, last_name, job, location, created_at, updated_at FROM people WHERE id = ?", id)
    err := row.Scan(&p.ID, &p.FirstName, &p.LastName, &p.Job, &p.Location, &p.CreatedAt, &p.UpdatedAt)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, fmt.Errorf("未找到ID为 %d 的人员", id)
        }
        return nil, fmt.Errorf("扫描人员数据失败: %w", err)
    }
    fmt.Printf("成功读取人员: %+v\n", p)
    return p, nil
}

// GetAllPeople 从数据库中读取所有Person对象
func GetAllPeople(db *sql.DB) ([]Person, error) {
    rows, err := db.Query("SELECT id, first_name, last_name, job, location, created_at, updated_at FROM people")
    if err != nil {
        return nil, fmt.Errorf("查询所有人员失败: %w", err)
    }
    defer rows.Close()

    var people []Person
    for rows.Next() {
        p := Person{}
        err := rows.Scan(&p.ID, &p.FirstName, &p.LastName, &p.Job, &p.Location, &p.CreatedAt, &p.UpdatedAt)
        if err != nil {
            return nil, fmt.Errorf("扫描人员数据失败: %w", err)
        }
        people = append(people, p)
    }

    if err = rows.Err(); err != nil {
        return nil, fmt.Errorf("遍历结果集错误: %w", err)
    }
    fmt.Printf("成功读取所有人员 (%d 人)\n", len(people))
    return people, nil
}

// UpdatePerson 更新数据库中的一个Person对象
func UpdatePerson(db *sql.DB, p *Person) error {
    stmt, err := db.Prepare("UPDATE people SET first_name = ?, last_name = ?, job = ?, location = ? WHERE id = ?")
    if err != nil {
        return fmt.Errorf("准备更新语句失败: %w", err)
    }
    defer stmt.Close()

    res, err := stmt.Exec(p.FirstName, p.LastName, p.Job, p.Location, p.ID)
    if err != nil {
        return fmt.Errorf("执行更新操作失败: %w", err)
    }

    rowsAffected, err := res.RowsAffected()
    if err != nil {
        return fmt.Errorf("获取受影响行数失败: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("未找到ID为 %d 的人员进行更新", p.ID)
    }
    fmt.Printf("成功更新人员: %s %s, ID: %d\n", p.FirstName, p.LastName, p.ID)
    return nil
}

// DeletePerson 根据ID从数据库中删除一个Person对象
func DeletePerson(db *sql.DB, id int) error {
    stmt, err := db.Prepare("DELETE FROM people WHERE id = ?")
    if err != nil {
        return fmt.Errorf("准备删除语句失败: %w", err)
    }
    defer stmt.Close()

    res, err := stmt.Exec(id)
    if err != nil {
        return fmt.Errorf("执行删除操作失败: %w", err)
    }

    rowsAffected, err := res.RowsAffected()
    if err != nil {
        return fmt.Errorf("获取受影响行数失败: %w", err)
    }
    if rowsAffected == 0 {
        return fmt.Errorf("未找到ID为 %d 的人员进行删除", id)
    }
    fmt.Printf("成功删除ID为 %d 的人员\n", id)
    return nil
}

func main() {
    db := initDB()
    defer db.Close()
    createTable(db) // 确保表存在

    // 示例操作
    // 1. 创建新人员
    newPerson := &Person{FirstName: "Alice", LastName: "Johnson", Job: "Developer", Location: "San Francisco"}
    err := CreatePerson(db, newPerson)
    if err != nil {
        log.Printf("创建人员失败: %v", err)
    }

    // 2. 读取人员
    person, err := GetPersonByID(db, newPerson.ID)
    if err != nil {
        log.Printf("读取人员失败: %v", err)
    } else {
        fmt.Printf("读取到的人员信息: %+v\n", person)
    }

    // 3. 更新人员
    if person != nil {
        person.Job = "Senior Developer"
        person.Location = "New York"
        err = UpdatePerson(db, person)
        if err != nil {
            log.Printf("更新人员失败: %v", err)
        }
    }

    // 4. 读取所有人员
    allPeople, err := GetAllPeople(db)
    if err != nil {
        log.Printf("获取所有人员失败: %v", err)
    } else {
        for _, p := range allPeople {
            fmt.Printf(" - ID: %d, Name: %s %s\n", p.ID, p.FirstName, p.LastName)
        }
    }

    // 5. 删除人员
    if newPerson.ID != 0 {
        err = DeletePerson(db, newPerson.ID)
        if err != nil {
            log.Printf("删除人员失败: %v", err)
        }
    }
}