gorm 教程三 gen自动代码生成工具

package main
import "gorm.io/gen"
func main() {
  g := gen.NewGenerator(gen.Config{
    //  设置输出路径
    OutPath: "../query",
    Mode: gen.WithoutContext|gen.WithDefaultQuery|gen.WithQueryInterface, // 选择生成模式
  })
//  建立数据库连接
  gormdb, _ := gorm.Open(mysql.Open("root:@(127.0.0.1:3306)/demo?charset=utf8mb4&parseTime=True&loc=Local"))
  g.UseDB(gormdb) // 选择数据库连接
  // 为结构模型生成基本类型安全的 DAO API。用户的以下约定
  g.ApplyBasic(
  // Generate struct `User` based on table `users`
  g.GenerateModel("users"),
  // Generate struct `Employee` based on table `users`
  g.GenerateModelAs("users", "Employee"),
// Generate struct `User` based on table `users` and generating options
  g.GenerateModel("users", gen.FieldIgnore("address"), gen.FieldType("id", "int64")),
  )
g.ApplyBasic(
// 从当前数据库的所有表生成结构
g.GenerateAllTable()...,
)
  // 生成代码
  g.Execute()
}

type CommonMethod struct {
    ID   int32
    Name *string
}
func (m *CommonMethod) IsEmpty() bool {
    if m == nil {
        return true
    }
    return m.ID == 0
}
func (m *CommonMethod) GetName() string {
    if m == nil || m.Name == nil {
        return ""
    }
    return *m.Name
}
// 将 IsEmpty 方法添加到生成的“People”结构中
g.GenerateModel("people", gen.WithMethod(CommonMethod{}.IsEmpty))
// 将CommonMethod上定义的所有方法添加到生成的“User”结构中
g.GenerateModel("user", gen.WithMethod(CommonMethod))

type Person struct {
  // ...
}
func (m *Person) IsEmpty() bool {
  if m == nil {
    return true
  }
  return m.ID == 0
}
// Generated User struct
type User struct {
  // ...
}
func (m *User) IsEmpty() bool {
  if m == nil {
    return true
  }
  return m.ID == 0
}
func (m *User) GetName() string {
  if m == nil || m.Name == nil {
    return ""
  }
  return *m.Name
}

type CommonMethod struct {
    ID   int32
    Name *string
}
// TableName 
func (m CommonMethod) TableName() string {
    return "@@table"
}
// TableName table name with gorm NamingStrategy
func (m CommonMethod) TableName(namer schema.Namer) string {
    if namer == nil {
        return "@@table"
    }
    return namer.TableName("@@table")
}
// 生成的“user”结构的表名方法
g.GenerateModel("user", gen.WithMethod(CommonMethod{}.TableName))
// 自定义生成的所有结构的表名方法
g.WithOpts(gen.WithMethod(CommonMethod{}.TableName))
// 为生成的所有结构设置默认 DIY 表名方法
g.WithOpts(gen.WithMethod(gen.DefaultMethodTableWithNamer))

g := gen.NewGenerator(gen.Config{
  // 如果希望可为空字段生成属性为指针类型，请将 FieldNullable 设置为 true
  FieldNullable: true,
  // 如果要分配在“创建”API 中具有默认值的字段，请将 FieldCoverable 设置为 true
  FieldCoverable: true,
  // 如果要生成具有无符号整数类型的字段，请将字段可签名设置为 true
  FieldSignable: true,
  // 如果要从数据库生成索引标记，请将 FieldWithIndexTag 设置为 true
  FieldWithIndexTag: true,
  // 如果要从数据库生成类型标记，请将 FieldWithTypeTag 设置为 true
  FieldWithTypeTag: true,
  // if you need unit tests for query code, set WithUnitTest true
  WithUnitTest: true,
})

//  设置获取数据库名称函数
WithDbNameOpts(opts ...model.SchemaNameOpt)
//  指定表名命名策略，仅在从数据库同步表时有效
WithTableNameStrategy(ns func(tableName string) (targetTableName string))
// 指定模型结构名称命名策略，仅在从数据库同步表时有效
// 如果返回空字符串，则将忽略该表
WithModelNameStrategy(ns func(tableName string) (modelName string))
// 指定文件名命名策略，仅在从数据库同步表时有效
WithFileNameStrategy(ns func(tableName string) (fileName string))
// 指定 JSON 标记命名策略
WithJSONTagNameStrategy(ns func(columnName string) (tagContent string))
// 指定数据类型映射关系，仅在从 DB 同步表时工作
WithDataTypeMap(newMap map[string]func(gorm.ColumnType) (dataType string))
// 指定导入包路径
WithImportPkgPath(paths ...string)
// 指定全局模型选项
WithOpts(opts ...ModelOpt)

var dataMap = map[string]func(gorm.ColumnType) (dataType string){
    // int mapping
    "int": func(columnType gorm.ColumnType) (dataType string) {
        if n, ok := columnType.Nullable(); ok && n {
            return "*int32"
        }
        return "int32"
    },
    // bool mapping
    "tinyint": func(columnType gorm.ColumnType) (dataType string) {
        ct, _ := columnType.ColumnType()
        if strings.HasPrefix(ct, "tinyint(1)") {
            return "bool"
        }
        return "byte"
    },
}
g.WithDataTypeMap(dataMap)

go install gorm.io/gen/tools/gentool@latest

Usage of gentool:
 -c string
      配置文件路径
 -db string
       选择数据库种类
 -dsn string
       设置数据库连接地址
 -fieldNullable
       当字段可为空时，使用指针生成
 -fieldWithIndexTag
       使用 GORM 索引标签生成字段
 -fieldWithTypeTag
       生成带有 GORM 列类型标记的字段
 -modelPkgName string
       生成的模型代码的包名称
 -outFile string
       查询代码文件名，默认：gen.go
 -outPath string
      指定输出目录
 -tables string
       输入所需的数据表或将其留空
 -onlyModel
       仅生成模型
 -withUnitTest
       为查询代码生成单元测试
 -fieldSignable
       检测整数字段的无符号类型，调整生成的数据类型

--tables="orders"       # generate from `orders`
--tables="orders,users" # generate from `orders` and `users`
--tables=""             # generate from all tables

version: "0.1"
database:
  # consult[https://gorm.io/docs/connecting_to_the_database.html]"
  dsn : "username:password@tcp(address:port)/db?charset=utf8mb4&parseTime=true&loc=Local"
  # input mysql or postgres or sqlite or sqlserver. consult[https://gorm.io/docs/connecting_to_the_database.html]
  db  : "mysql"
  # enter the required data table or leave it blank.You can input : orders,users,goods
  tables  : "user"
  # specify a directory for output
  outPath :  "./dao/query"
  # query code file name, default: gen.go
  outFile :  ""
  # generate unit test for query code
  withUnitTest  : false
  # generated model code's package name
  modelPkgName  : ""
  # generate with pointer when field is nullable
  fieldNullable : false
  # generate field with gorm index tag
  fieldWithIndexTag : false
  # generate field with gorm column type tag
  fieldWithTypeTag  : false