在Go中建立自定義ORM

定義核心目標：實現結構體到數據庫表的映射、自動生成SQL語句（INSERT、SELECT）、使用reflect進行結構體反射操作；2. 使用struct標籤如db:"column_name"將結構體字段映射到數據庫列；3. 構建Insert函數：通過反射遍歷結構體字段，提取標籤和值，動態生成INSERT語句並執行；4. 實現Select函數：通過反射創建結果切片元素，使用rows.Scan將查詢結果填充到結構體字段中；5. 可選支持主鍵和更新：通過擴展標籤如pk:"true"識別主鍵字段以生成WHERE條件；6. 使用接口提升擴展性：定義Model接口並通過TableName方法自動獲取表名；7. 認識局限性：缺乏JOIN、關係處理、遷移等功能，性能受反射影響，但適合學習或小型項目。構建自定義ORM的核心在於理解數據映射與SQL抽像機制，其目的不是替代成熟框架，而是掌握底層原理並滿足特定場景需求。

Building a custom ORM (Object-Relational Mapper) in Go might sound like a daunting task, but it's a great way to understand how data layers work and how Go's powerful reflection and interface system can be leveraged to abstract SQL operations. While mature ORMs like GORM or SQLx exist, rolling your own—even as a learning exercise—gives you insight into what happens under the hood.

Here's a practical breakdown of how to build a minimal but functional custom ORM in Go.

1. Define the Core Goals

Before writing any code, decide what your ORM should do. A basic ORM typically handles:

• Mapping structs to database tables
• Automatically generating SQL queries (INSERT, SELECT, UPDATE, DELETE)
• Scanning query results into structs
• Handling basic relationships (optional, for advanced versions)

For this example, we'll focus on:

• Struct-to-table mapping via tags
• Insert and Select operations
• Using database/sql with reflect for introspection

2. Use Struct Tags for Mapping

Go's reflect package allows you to inspect structs at runtime. Use struct tags to map fields to column names.

 type User struct {
    ID int `db:"id"`
    Name string `db:"name"`
    Email string `db:"email"`
}

We'll use the db tag to indicate the corresponding database column.

3. Build a Simple Insert Function

Here's how to dynamically generate an INSERT query:

 import (
    "database/sql"
    "fmt"
    "reflect"
)

func Insert(db *sql.DB, tableName string, obj interface{}) error {
    v := reflect.ValueOf(obj).Elem()
    t := reflect.TypeOf(obj).Elem()

    var columns []string
    var placeholders []string
    var args []interface{}

    for i := 0; i < v.NumField(); i {
        field := t.Field(i)
        column := field.Tag.Get("db")
        if column == "" {
            continue
        }

        value := v.Field(i).Interface()
        columns = append(columns, column)
        placeholders = append(placeholders, "?")
        args = append(args, value)
    }

    query := fmt.Sprintf(
        "INSERT INTO %s (%s) VALUES (%s)",
        tableName,
        join(columns, ", "),
        join(placeholders, ", "),
    )

    _, err := db.Exec(query, args...)
    return err
}

Note: Use ? for MySQL/SQLite, $1 for PostgreSQL. Adjust placeholder style accordingly.

4. Implement a Generic Select Function

Now, let's scan results back into a struct:

 func Select(db *sql.DB, query string, dest interface{}) error {
    rows, err := db.Query(query)
    if err != nil {
        return err
    }
    defer rows.Close()

    destValue := reflect.ValueOf(dest).Elem()
    sliceType := destValue.Type().Elem() // element type of the slice

    var results []reflect.Value

    for rows.Next() {
        elem := reflect.New(sliceType).Elem()
        values := make([]interface{}, elem.NumField())

        for i := 0; i < elem.NumField(); i {
            field := elem.Type().Field(i)
            column := field.Tag.Get("db")
            if column == "" {
                continue
            }
            values[i] = elem.Field(i).Addr().Interface()
        }

        err := rows.Scan(values...)
        if err != nil {
            return err
        }

        results = append(results, elem)
    }

    for _, r := range results {
        destValue.Set(reflect.Append(destValue, r))
    }

    return rows.Err()
}

Usage:

 var users []User
err := Select(db, "SELECT id, name, email FROM users", &users)

5. Handle Primary Keys and Updates (Optional)

To support UPDATE , you need to know the primary key. You can extend the tag:

 ID int `db:"id" pk:"true"`

Then, during update, find the PK field and generate a WHERE clause.

6. Use Interfaces for Extensibility

Define a simple interface to make your ORM feel more cohesive:

 type Model interface {
    TableName() string
}

func (u User) TableName() string {
    return "users"
}

Now your Insert function can call obj.TableName() instead of requiring the table name as a parameter.

7. Limitations and Trade-offs

Building your own ORM means you'll face challenges:

• No support for JOINs or relations (without extra work)
• SQL injection risk if you don't use parameterized queries
• Poor performance if reflection is overused
• No migrations, hooks, or advanced querying

But for small projects or embedded tools, a lightweight ORM can be sufficient.

Final Thoughts

A custom ORM in Go is totally feasible thanks to reflect and strong typing. You don't need to replace GORM—this is more about learning how ORMs work, or creating a minimal data layer tailored to your app's needs.

Start small: support INSERT and SELECT on basic structs. Then incrementally add features like filters, updates, or transactions.

It's not about reinventing the wheel—it's about knowing how the wheel works.

Basically, that's how you start building your own ORM in Go.

以上是在Go中建立自定義ORM的詳細內容。更多資訊請關注PHP中文網其他相關文章！