golang mysql select * 优化

初学者使用golang mysql做查询时,一般直接使用原生的select * from table来查询数据:

type UserInfo struct {
 Id int64
 Name string
 Sex string
 //...
}
func GetUserInfo(uid int64) (info UserInfo, err error) {
 Db := lib.MysqlConn()
 sql := fmt.Sprintf("select * from user where uid=%d", uid)
 rows, err := Db.Query(sql)
 if err != nil {
 return info, err
 }
 defer Db.Close()
 if rows.Next() {
 var (
 id int64
 name string
 sex string
 //...
 )
 //得一个个的字段罗列出来
 err = rows.Scan(&id, &name, &sex, //...)
 info = UserInfo{
 Id: id,
 Name: name,
 Sex: sex,
 //...
 }
 }
 return info, nil
}

后来数据表结构变动直接导致GetUserInfo()报错了,因为字段对应不上了。然后优化了一版:

func GetUserInfo(uid int64) (info UserInfo, err error) {
 Db := lib.MysqlConn()
 sql := fmt.Sprintf("select `id`,`user_name`,`sex`,... from user where uid=%d", uid)
 rows, err := Db.Query(sql)
 if err != nil {
 return
 }
 defer Db.Close()
 if rows.Next() {
 //得一个个的字段罗列出来
 err = rows.Scan(&info.Id, &info.Name, &info.Sex, //...)
 if err != nil {
 return
 }
 }
 return
}

此时问题解决了,然后继续写类似的代码。
时间久了,就发现这样写好累,每次都得把所有的字段都罗列出来,而且上下一一对应。
所以就想能不能自动生成上下对应的变量,然后直接用变量来替换上。
如是,就用到了golang的反射,先定义一个结构体和数据表的字段一一对应,并在字段说明里面定义数据库的字段名:

type UserInfo struct {
	Id int64 `sql:"id"`
	Name string `sql:"user_name"`
	Sex string `sql:"sex"`
	//...
}

可以使用反射提取出类似`sql:"id"`里面id,然后拼装起来,具体如下

func (ui *UserInfo) allFields() (sqlFields string) {
	arr := []string{}
	el := reflect.TypeOf(ui).Elem()
	for i := 0; i < el.NumField(); i++ {
		arr = append(arr, el.Field(i).Tag.Get("sql"))
	}
	sqlFields = "`" + strings.Join(arr, "`,`") + "`"
	return
}

所以上面的函数中sql语句的定义就改为了:

//...
sql := fmt.Sprintf("select "+info.allFields()+" from user where uid=%d", uid)
//...

问题又来了,

rows.Scan(&info.Id, &info.Name, &info.Sex, //...)

rows.Scan怎么优化?
这里实际上就是每个字段的地址,如果取出该变量的地址,组成一个切片,然后展开切片就可以了,再来定义方法:

func (ui *UserInfo) allValues() (sqlValues []interface{}) {
	vl := reflect.ValueOf(ui).Elem()
	num := reflect.TypeOf(ui).Elem().NumField()
	for i := 0; i < num; i++ {
		sqlValues = append(sqlValues, vl.Field(i).Addr().Interface())
	}
	return
}
func GetUserInfo(uid int64) (info UserInfo, err error) {
	Db := lib.MysqlConn()
	sql := fmt.Sprintf("select "+info.allFields()+" from user where uid=%d", uid)
	rows, err := Db.Query(sql)
	if err != nil {
		return
	}
	defer Db.Close()
	if rows.Next() {
		//获取每个字段的切片
		fields := info.allValues()
		err = rows.Scan(fields...)
		if err != nil {
			return
		}
	}
	return
}

把 info.allFields()和info.allValues()合并在一起返回:

type UserInfo struct {
	Id int64 `sql:"id"`
	Name string `sql:"user_name"`
	Sex string `sql:"sex"`
	//...
}
func (ui *UserInfo) allFieldsAndValues() (sqlFields string, sqlValues []interface{}) {
	arr := []string{}
	el := reflect.TypeOf(ui).Elem()
	vl := reflect.ValueOf(ui).Elem()
	for i := 0; i < el.NumField(); i++ {
		arr = append(arr, el.Field(i).Tag.Get("sql"))
		sqlValues = append(sqlValues, vl.Field(i).Addr().Interface())
	}
	sqlFields = "`" + strings.Join(arr, "`,`") + "`"
	return
}
func GetUserInfo(uid int64) (info UserInfo, err error) {
	Db := lib.MysqlConn()
	sqlFields, sqlValues := info.allFieldsAndValues()
	sql := fmt.Sprintf("select "+sqlFields+" from user where uid=%d", uid)
	rows, err := Db.Query(sql)
	if err != nil {
		return
	}
	defer Db.Close()
	if rows.Next() {
		err = rows.Scan(sqlValues...)
	}
	return
}

现在封装起来后就方便多了,不担心数据表结构变动:这里只需要修改结构体UserInfo的信息。
现在又有一个方法需要批量的获取UserInfo,方法UserInfo.allFieldsAndValues()就大有用处了:

func GetAllUserInfo() (all []UserInfo, err error) {
	Db := lib.MysqlConn()
	info := UserInfo{}
	sqlFields, sqlValues := info.allFieldsAndValues()
	rows, err := Db.Query("select " + sqlFields + " from user ")
	if err != nil {
		return
	}
	defer Db.Close()
	for rows.Next() {
		err = rows.Scan(sqlValues...)
		if err != nil {
			return
		}
		all = append(all, info)
		info = UserInfo{}
	}
	return
}

这里在循环内[for rows.Next(){//...}]因为结构体的传值是值传递,all = append(all, info)操作的是info的一个拷贝。
用完之后在把变量info的值给重置掉:info = UserInfo{}。最后返回all。

Go语言中有的传参是值传递(传值),是一个副本,一个拷贝。
因为拷贝的内容有时候是非引用类型(int、string、struct等这些),这样就在函数中就无法修改原内容数据;
有的是引用类型(指针、map、slice、chan等这些),这样就可以修改原内容数据

文章来源于 https://www.lixiaocheng.com/read/703

• 编辑
• 预览