golang 生成对应的数据表struct定义操作

作者: 北美田哥
来源: 51数据库
2021-06-26

在开发过程中，常常需要将数据库表对应到golang的一个struct，特别是使用一些orm工具，sqlx库等，我是个懒人，即使数据表的字段不多，我也懒得去一个个对应的敲入代码，更别提数据表字段比较多的情况了，码农的时间，不能浪费在这啊，对吧？所以我在想，是不是有办法可以自动生成。

我在工作时，用得最多的是mysql了，因此

本文针对mysql的数据表来自动生成golang 的struct定义

mysql有个自带的数据库information_schema，里面的信息量比较多，朋友们可以去百度下，我这里用到了表columns，它的字段包含数据库名、表名、字段名、字段类型等，利用这个表的数据，把对应的表的字段信息读取出来，然后再根据golang的语法规则，生成文件就可以了。

大致思路确定了，开始动手。

我采用sqlx进行数据库的访问，首先定义一个struct来表示columns的数据，这里我只需要几个字段，因此，没有把表columns的所有字段都对应到struct：

type fieldinfo struct {
 colname    string `db:"column_name"`
 datatype   string `db:"data_type"`
 colcomment string `db:"column_comment"`
 isnullable string `db:"is_nullable"`
}

需要指定生成的struct对应的是哪个库、哪个表，最终的golang文件保存地址

这里利用命令行参数来输入：

var dbname= flag.string("db", "", "the database name")
var tblname = flag.string("tbl", "", "the table name to export")
var savepath = flag.string("path", "./", "the path to save file")

另外，我们项目习惯使用下划线“_”来分割单词，比如info_user，表示user表，而生成的struct名称为infouser，字段名也是类似规则

因此定义了如下函数来处理这种情况：

func fmtfielddefine(src string) string {
 temp := strings.split(src, "_") // 有下划线的，需要拆分
 var str string
 for i := 0; i < len(temp); i++ {
  b := []rune(temp[i])
  for j := 0; j < len(b); j++ {
   if j == 0 {
    // 首字母大写转换
    b[j] -= 32
    str += string(b[j])
   } else {
    str += string(b[j])
   }
  }
 } 
 return str
}

即把下划线去掉，且将单词的首字母改为大写。

有些字段，在设计数据库时，是可空的，information_schema->columns中有个字段is_nullable专门表示，而golang的sql有几个类型对应：sql.nullstring、sql.nullbool、sql.nullfloat64、sql.nullint64，基本上是可以满足使用要求的了。

有人可能会有疑问，假如字段类型为date、timestamp等，该对应哪种呢？通常第三方的类库会转为string类型，那么就对应sql.nullstring好了。不过我这里没有进行这方面的处理。

前期工作做好了，开始编码：

func main() {
 flag.parse()
 fmt.println("table name -->", *tblname) 
 dns := fmt.sprintf("%s:%s@tcp(%s)/%s?charset=utf-8", dbuser, dbpwd, dbhost, "information_schema") 
 db := sqlx.mustconnect("mysql", dns)
 
 var fs []fieldinfo
 err := db.select(&fs, "select column_name, data_type, column_comment, is_nullable from columns where table_name=? and table_schema=?", *tblname, *dbname)
 if err != nil {
  fmt.println(err)
  panic(err)
 }
 
 if len(fs) > 0 {
  var buffer bytes.buffer
  buffer.writestring("package models\n")
  buffer.writestring("type " + fmtfielddefine(*tblname) + " struct {\n")
  for _, v := range fs {
   buffer.writestring("" + fmtfielddefine(v.colname) + " ")
   switch v.datatype {
   case "int", "tinyint", "smallint":
    if v.isnullable == "yes" {
     buffer.writestring("sql.nullint64 ")
    } else {
     buffer.writestring("int ")
    }
   case "bigint":
    if v.isnullable == "yes" {
     buffer.writestring("sql.nullint64 ")
    } else {
     buffer.writestring("int64 ")
    }
   case "char", "varchar", "longtext", "text", "tinytext":
    if v.isnullable == "yes" {
     buffer.writestring("sql.nullstring ")
    } else {
     buffer.writestring("string ")
    }
   case "date", "datetime", "timestamp":
    buffer.writestring("time.time ")
   case "double", "float":
    if v.isnullable == "yes" {
     buffer.writestring("sql.nullfloat64 ")
    } else {
     buffer.writestring("float64 ")
    }
   default:
    // 其他类型当成string处理
    if v.isnullable == "yes" {
     buffer.writestring("sql.nullstring ")
    } else {
     buffer.writestring("string ")
    }
   }
 
   buffer.writestring(fmt.sprintf("`db:"%s" json:"%s"`\n", v.colname, v.colname))
 
  }
  buffer.writestring(`}`) 
  fmt.println(buffer.string()) 
  filename := *savepath + "\" + *tblname + ".go"
  f, _ := os.create(filename)
  f.write([]byte(buffer.string()))
  f.close()
 
  cmd := exec.command("goimports", "-w", filename)
  cmd.run()
 } else {
  fmt.println("查询不到数据")
 }
}

我把每个字段的tag，包括db和json的都加了了，在代码最后，使用goimport工具添加需要import的package，它连format的工作都做了，实在不错。

以下是我生成的一个用户购物概要表的struct定义：

package models 
import (
 "database/sql"
 "time"
)
 
type infousershoppingsummary struct {
 id            int            `db:"id" json:"id"`
 transactionid sql.nullstring `db:"transaction_id" json:"transaction_id"`
 outtradeno    sql.nullstring `db:"out_trade_no" json:"out_trade_no"`
 wuid          int            `db:"wu_id" json:"wu_id"`
 wdid          int            `db:"wd_id" json:"wd_id"`
 totalfee      float64        `db:"total_fee" json:"total_fee"`
 paystaus      sql.nullint64  `db:"pay_staus" json:"pay_staus"`
 createtime    time.time      `db:"create_time" json:"create_time"`
 updatetime    time.time      `db:"update_time" json:"update_time"`
 address       sql.nullstring `db:"address" json:"address"`
}

补充：golang之方法（自定义类型，struct）

方法的使用，请看本天师的代码

//golang的方法定义
//golang中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，不仅仅是struct
//定义：func (recevier type) methodname(参数列表)(返回值列表){}
//方法和函数的区别
/*
1，函数调用：function(variable，参数列表)
2， 方法，variable.function(参数列表)
方法的控制，通过大小写空格控制
 */

package main
//golang的方法定义
//golang中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，不仅仅是struct
//定义：func (recevier type) methodname(参数列表)(返回值列表){}
import "fmt"
type integer int
func (p integer) print() {
    fmt.println("p is:", p)
}
//这里传递的是副本，想改变p的值，需要传递指针
func (p *integer) set(b integer) {
    *p = b
}
type student struct {
    name  string
    age   int
    score int
    sex   int
}
//这里需要接受指针 *student（接收者），否则修改不了值
func (p *student) init(name string, age int, score int) {
    p.name = name
    p.age = age
    p.score = score
    fmt.println(p)
}
func (p student) get() student {
    return p
}
func main() {
    var stu student
    //修改地址的写法(&stu).init
    //但是go可以自动知道，接受者是指针，这里stu就传递地址
    stu.init("stu", 18, 99)
    stu1 := stu.get()
    fmt.println(stu1)
    //type integer方法
    var a integer
    a = 100
    a.print()
    a.set(1000)
    a.print()
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。如有错误或未考虑完全的地方，望不吝赐教。