尝试用golang 1.18泛型实现orm

这几天golang社区对泛型的讨论非常多的，一片热火朝天的景象。对我们广大gopher来说总归是好事。

泛型很有可能会颠覆我们之前的很多设计，带着这种疑问和冲动，我准备尝试用golang泛型实现几个orm的常见功能。

本文并没完全实现通用的orm，只是探讨其实现的一种方式提供各位读者做借鉴。

创建Table

虽然golang有了泛型，但是目前在标准库sql底层还没有改造，目前还有很多地方需要用到reflect。

func CreateTable[T any](db *sql.DB) {
    var a T
    t := reflect.TypeOf(a)
    tableName := strings.ToLower(t.Name())

    var desc string
    for i := 0; i < t.NumField(); i++ {
        columnsName := strings.ToLower(t.Field(i).Name)
        var columnType string
        switch t.Field(i).Type.Kind() {
        case reflect.Int:
            columnType = "integer"
        case reflect.String:
            columnType = "text"
        }
        desc += columnsName + " " + columnType
        if i < t.NumField()-1 {
            desc += ","
        }
    }
    sqlStmt := fmt.Sprintf(`create table if not exists %s (%s);`, tableName, desc)
    _, err := db.Exec(sqlStmt)
    if err != nil {
        log.Printf("%q: %s\n", err, sqlStmt)
        return
    }
}

调用方式

type Person struct {
    ID   int
    Name string
    Age  int
}

type Student struct {
    ID   int
    Name string
    No   string
}

var db sql.DB
//init db
//...
CreateTable[Person](db)
CreateTable[Student](db)

这个部分跟传统的orm使用上没有太大区别，没办法不使用反射的情况下，泛型的方式可能变得有点繁琐。

写入数据

func Create[T any](db *sql.DB, a T) {
    //没有办法这边还是得使用反射
    t := reflect.TypeOf(a)
    tableName := strings.ToLower(t.Name())

    var columns []string
    var spacehold []string
    for i := 0; i < t.NumField(); i++ {
        columns = append(columns, strings.ToLower(t.Field(i).Name))
        spacehold = append(spacehold, "?")
    }

    tx, err := db.Begin()
    if err != nil {
        log.Fatal(err)
    }
    stmt, err := tx.Prepare(
        fmt.Sprintf("insert into %s(%s) values(%s)",
            tableName,
            strings.Join(columns, ","),
            strings.Join(spacehold, ",")))

    if err != nil {
        log.Fatal(err)
    }
    defer stmt.Close()

    v := reflect.ValueOf(a)

    var values []any

    for i := 0; i < t.NumField(); i++ {
        if v.FieldByName(t.Field(i).Name).CanInt() {
            values = append(values, v.FieldByName(t.Field(i).Name).Int())
        } else {
            values = append(values, v.FieldByName(t.Field(i).Name).String())
        }
    }
    _, err = stmt.Exec(values...)
    if err != nil {
        panic(err)
    }
    tx.Commit()
}

调用方式

var p1 = Person{
    ID:   1,
    Name: "wida",
}
Create[Person](db, p1)
var s1 = Student{
    ID:   1,
    Name: "wida",
    No:   "1111",
}
Create[Person](db, p1)
Create[Student](db, s1)

和创建table类似，写入数据好像比没有之前的orm有优势。

读取数据

读取数据是非常高频的操作，所以我们稍作封装。

type Client struct {
    db *sql.DB
}

type Query[T any] struct {
    client *Client
}

func NewQuery[T any](c *Client) *Query[T] {
    return &Query[T]{
        client: c,
    }
}
//反射到struct
func ToStruct[T any](rows *sql.Rows, to T) error {
    v := reflect.ValueOf(to)
    if v.Elem().Type().Kind() != reflect.Struct {
        return errors.New("Expect a struct")
    }

    scanDest := []any{}
    columnNames, _ := rows.Columns()

    addrByColumnName := map[string]any{}

    for i := 0; i < v.Elem().NumField(); i++ {
        oneValue := v.Elem().Field(i)
        columnName := strings.ToLower(v.Elem().Type().Field(i).Name)
        addrByColumnName[columnName] = oneValue.Addr().Interface()
    }

    for _, columnName := range columnNames {
        scanDest = append(scanDest, addrByColumnName[columnName])
    }
    return rows.Scan(scanDest...)
}

func (q *Query[T]) FetchAll(ctx context.Context) ([]T, error) {
    var items []T

    var a T
    t := reflect.TypeOf(a)

    tableName := strings.ToLower(t.Name())
    rows, err := q.client.db.Query("SELECT * FROM " + tableName)
    if err != nil {
        return nil, err
    }

    for rows.Next() {
        var c T
        ToStruct(rows, &c)
        items = append(items, c)
    }
    return items, nil
}

调用方式

var client = &Client{
    db: db,
}

{
    query := NewQuery[Person](client)
    all, err := query.FetchAll(context.Background())
    if err != nil {
        log.Fatal(err)
    }
    for _, person := range all {
        log.Println(person)
    }
}
{
    query := NewQuery[Student](client)
    all, err := query.FetchAll(context.Background())
    if err != nil {
        log.Fatal(err)
    }
    for _, person := range all {
        log.Println(person)
    }
}

稍微比原先的orm方式有了多一点想象空间，比如 在[T any]做更明确的约束，比如要求实现Filter定制方法。

总结

鉴于本人能力还认证有限，目前还没有发现泛型对orm剧烈的改进和突破的可能。未来如果go对底层sql做出改动，或者实现诸如Rust那种Enum方式，可能会带来更多的惊喜。

---