Go 编程实例【反射写SQL 插入】

向右看齐 2023-10-09 19:23 33阅读 0赞

#### 阅读目录 ####

*  写一个简单函数创建一个 SQL 插入
 *   *  SQL插入通用问题
     *  使用 reflect 包实现SQL插入通用
     *  实现 insert into order(OrdId,CustomerId) values(456,56)
     *  我们应该使用反射吗？

## 写一个简单函数创建一个 SQL 插入 ##

package main
    
    import (
        "fmt"
    )
    
    type order struct {
        
        ordId      int
        customerId int
    }
    
    func main() {
        
        o := order{
        
            ordId:      1234,
            customerId: 567,
        }
        fmt.Println(o)
    }

[root@localhost test]# go run main.go 
    {
        1234 567}
    [root@localhost test]#

需要编写一个函数，接收结构体变量 `o` 作为参数，返回下面的 SQL 插入语句。

package main
    
    import (
    	"fmt"
    )
    
    type order struct {
        
    	ordId      int
    	customerId int
    }
    
    func createQuery(o order) string {
        
    	i := fmt.Sprintf("insert into order values(%d, %d)", o.ordId, o.customerId)
    	return i
    }
    
    func main() {
        
    	o := order{
        
    		ordId:      1234,
    		customerId: 567,
    	}
    	fmt.Println(createQuery(o))
    }

[root@localhost test]# go run main.go 
    insert into order values(1234, 567)
    [root@localhost test]#

### SQL插入通用问题 ###

package main
    
    type order struct {
        
        ordId      int
        customerId int
    }
    
    type employee struct {
        
        name string
        id int
        address string
        salary int
        country string
    }
    
    func createQuery(q interface{
        }) string {
        
    }
    
    func main() {
        
    
    }

例如，如果我们传入下面的结构体：

o := order {
        ordId: 1234,
        customerId: 567
    }
    
    createQuery 函数应该返回：
    
    insert into order values (1234, 567)

类似地，如果我们传入：

e := employee {
            name: "Naveen",
            id: 565,
            address: "Science Park Road, Singapore",
            salary: 90000,
            country: "Singapore",
        }
    
    该函数会返回：
    insert into employee values("Naveen", 565, "Science Park Road, Singapore", 90000, "Singapore")

由于 createQuery 函数应该适用于任何结构体，因此它接收 interface\{\} 作为参数。

createQuery 函数应该适用于所有的结构体。

### 使用 reflect 包实现SQL插入通用 ###

在 Go 语言中，`reflect`\[5\] 实现了运行时反射。

reflect 包会帮助识别 `interface{}` 变量的底层具体类型和具体值。

这正是我们所需要的。  
createQuery 函数接收 interface\{\} 参数，根据它的具体类型和具体值，创建 SQL 插入语句。

package main
    
    import (
    	"fmt"
    	"reflect"
    )
    
    type order struct {
        
    	ordId      int
    	customerId int
    }
    
    type employee struct {
        
    	name    string
    	id      int
    	address string
    	salary  int
    	country string
    }
    
    func createQuery(q interface{
        }) {
        
    	if reflect.ValueOf(q).Kind() == reflect.Struct {
        
    		t := reflect.TypeOf(q).Name()
    		query := fmt.Sprintf("insert into %s values(", t)
    		v := reflect.ValueOf(q)
    		for i := 0; i < v.NumField(); i++ {
        
    			switch v.Field(i).Kind() {
        
    			case reflect.Int:
    				if i == 0 {
        
    					query = fmt.Sprintf("%s%d", query, v.Field(i).Int())
    				} else {
        
    					query = fmt.Sprintf("%s, %d", query, v.Field(i).Int())
    				}
    			case reflect.String:
    				if i == 0 {
        
    					query = fmt.Sprintf("%s\"%s\"", query, v.Field(i).String())
    				} else {
        
    					query = fmt.Sprintf("%s, \"%s\"", query, v.Field(i).String())
    				}
    			default:
    				fmt.Println("Unsupported type")
    				return
    			}
    		}
    		query = fmt.Sprintf("%s)", query)
    		fmt.Println(query)
    		return
    
    	}
    	fmt.Println("unsupported type")
    }
    
    func main() {
        
    	o := order{
        
    		ordId:      456,
    		customerId: 56,
    	}
    	createQuery(o)
    
    	e := employee{
        
    		name:    "Naveen",
    		id:      565,
    		address: "Coimbatore",
    		salary:  90000,
    		country: "India",
    	}
    	createQuery(e)
    	i := 90
    	createQuery(i)
    }

[root@localhost test]# go run main.go 
    insert into order values(456, 56)
    insert into employee values("Naveen", 565, "Coimbatore", 90000, "India")
    unsupported type
    [root@localhost test]#

Name() 方法，从该结构体的 reflect.Type 获取了结构体的名字。

### 实现 insert into order(OrdId,CustomerId) values(456,56) ###

[root@localhost test]# go run main.go 
    insert into order(OrdId,CustomerId) values(456,56)
    [root@localhost test]#

package main
    
    import (
    	"fmt"
    	"reflect"
    	"strconv"
    )
    
    // 定义 Order 结构体
    type Order struct {
        
    	OrdId      int
    	CustomerId int
    }
    
    // 定义插入数据函数
    func InsertData(tableName string, data interface{
        }) {
        
    	// 获取数据类型和值
    	dataType := reflect.TypeOf(data)
    	dataValue := reflect.ValueOf(data)
    
    	// 构造 SQL 语句
    	sql := "insert into " + tableName + "("
    	for i := 0; i < dataType.NumField(); i++ {
        
    		sql += dataType.Field(i).Name + ","
    	}
    	sql = sql[:len(sql)-1] + ") values("
    
    	for i := 0; i < dataType.NumField(); i++ {
        
    		if dataType.Field(i).Type.Kind() == reflect.String {
        
    			sql += "'" + dataValue.Field(i).String() + "',"
    		} else {
        
    			sql += strconv.Itoa(int(dataValue.Field(i).Int())) + ","
    		}
    	}
    	sql = sql[:len(sql)-1] + ")"
    
    	// 执行 SQL 语句
    	fmt.Println(sql)
    }
    
    // 使用示例
    func main() {
        
    	order := Order{
        
    		OrdId:      456,
    		CustomerId: 56,
    	}
    	InsertData("order", order)
    }

### 我们应该使用反射吗？ ###

> 清晰优于聪明。而反射并不是一目了然的。

反射是 Go 语言中非常强大和高级的概念，我们应该小心谨慎地使用它。

使用反射编写清晰和可维护的代码是十分困难的。

你应该尽可能避免使用它，只在必须用到它时，才使用反射。