1. 首页
  2. 默认
  3. 正文

GORM 强大的代码生成工具 —— gorm/gen

2022年11月1日 417点热度 0人点赞 0条评论

来源：juejin.cn/post/7133150674400837668


GORM 的那些困扰


GORM 进入到 2.0 时代之后解决了很多 jinzhu/gorm 时代的问题，整体的扩展性以及功能也更强大。但总有一些绕不开的问题困扰着我们。


?点击领取
Go后端开发大厂面试题手册

SQL 注入


Object Relational Mapping 的定位就是帮助开发者减轻心智负担，你不用再去思考业务 object 和 数据表 relation 之间的对应，ORM 框架来帮你完成。我们只需要简单的在 object 上加上 tag，剩下怎么拼 SQL，怎么 Scan 数据后写入 object 就交给 ORM 来完成。业务开发者不需要操心这个。


问题就在这里，这样的定位势必导致 ORM 被反射和 interface{} 满天飞，你既然要通用，按照 Golang 目前的能力，就势必要在运行时做类型转换，用各种反射黑科技。


但是，反射顶多能告诉你当前是什么，不能来校验。因为 ORM 是不感知业务的。

要求它来校验输入数据的类型，格式，合法性是不现实的。使用方法十分灵活的查询接口很容易造成研发对接口的误用，从而导致SQL注入。


复杂 SQL


GORM作为ORM框架并没有提供任何辅助代码开发的功能，导致面对较为复杂的数据库表查询场景时，开发者需逐条手写数据表中的列与对应结构体的成员变量，单调且重复的查询功能也需要手动复制，稍不注意就会造成不易察觉的拼写错误。


其实在 Golang 泛型比较弱的情况下，使用【代码生成】依然是解决个性化场景的经典方案，这样绕开了 interface{}，我们就可以做更多校验，也省去了断言。


GORM 其实也是基于这个思路，推出了自己的【代码生成工具】：Gen。


gorm-gen


Gen: Friendly & Safer GORM powered by Code Generation

这里需要说明，Gen 并不是一个三方突发奇想做的库，而是作为 GORM 的官方工具，在 go-gorm 组织下提供的。本身也是由 jinzhu 大佬和相关同学一起维护，所以大家可以放心，这是个官方的解决方案。


我们可以使用 GORM，也可以用 Gen 来生成代码，只是 API 层的两种实现，底层的能力都是一样的。


gen[1] 对自己的定位就是通过代码生成，让 GORM 更加友好（针对复杂SQL场景也能处理），也更加安全（增加类型校验）。


  • CRUD or DIY query method code generation
  • Auto migration from database to code
  • Transactions, Nested Transactions, Save Point, RollbackTo to Saved Point
  • Competely compatible with GORM
  • Developer Friendly
  • Multiple Generate modes


从真正使用上来说，我觉得最核心的 feature 在于：


  1. 字段类型校验，过滤参数错误，为数字、字符串、布尔类型、时间类型硬编码制定差异化类型安全的表达式方法，杜绝了 SQL 注入的风险，能跑就安全；

  2. 映射数据库表像，DB 里面有数据表就能生成对应的 Golang 结构体；

  3. 用注释的形式描述查询的逻辑后，一键即可生成对应的安全可靠查询API。

此外还有一个好处是，我们用 GORM 来 Find 数据时，总还是要先声明结果，然后把指针传入 API，由 GORM 进行填充，而有了 Gen 之后，直接返回对应的数据结构，免于提前实例化数据后在注入API的繁琐。


复杂 SQL 怎么解


通过 interface 指明我们希望查询的语义，自动生成查询代码，这个可以说是 gorm-gen 最香的能力了。原因很简单：


  • 根据表结构倒回来生成结构体，这件事情非常低频，大多数情况下我们是先有一个 Persistent Object，再去创建表；

  • 类型安全，很重要，但对业务本身的能力上没有加成，也很难量化怎样算做的好，大家感触不深。


所以，大家最关心的能力还是，能不能我定义个接口，说清楚我需要什么数据（或者 sql 提供出来），你自己来生成查询代码，gorm 的封装，类型安全，数据转换等等，一切都由工具搞定，作为业务开发者，我只管调用从你生成的方法就行。能不能做到？


能！这就是 gorm-gen 带来的能力。这一节我们直接来实战演练一下。


本节实例源码在 db-demo[2] 感兴趣的同学可以看一下 gendemo 目录下的代码。


我们还是通过 go get 添加 gen 的依赖

go get -u gorm.io/gen


然后在项目中 import "gorm.io/gen" 进来即可。


首先我们创建一个 gendemo 目录，准备一些业务结构体，这些就是我们的 PO（需要持久化的对象）。目录结构如下：


  • cmd/generate：用于存放 gorm-gen 的代码生成逻辑；
  • dal/model：我们的业务结构定义(model.go)，以及希望 gorm-gen 生成实现的接口定义（method.go)；
  • generate.sh：一个bash 脚本，启动代码生成。


我们来看看每个文件干了什么。


  • dal.go


这里很简单，只是维护了内存中的数据库连接，完成初始化，和业务无关。

package dal
import ( "fmt" "sync"
 "gorm.io/gorm"
 "gorm.io/driver/sqlite"
 "github.com/ag9920/db-demo/gendemo/dal/model")
var DB *gorm.DBvar once sync.Once
func init() { once.Do(func() {  DB = ConnectDB().Debug()  _ = DB.AutoMigrate(&model.User{}, &model.Passport{}) })}
func ConnectDB() (conn *gorm.DB) { conn, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{}) if err != nil {  panic(fmt.Errorf("cannot establish db connection: %w", err)) } return conn}

  • model.go


这里我们定义了两个业务模型：User 以及 Passport。

package model
import ( "database/sql/driver" "fmt" "strings" "time"
 "gorm.io/gorm")
type Username string
type Password string
func (p *Password) Scan(src interface{}) error { *p = Password(fmt.Sprintf("@%v@", src)) return nil}
func (p *Password) Value() (driver.Value, error) { *p = Password(strings.Trim(string(*p), "@")) return p, nil}
type User struct { gorm.Model        // ID uint CreatAt time.Time UpdateAt time.Time DeleteAt gorm.DeleteAt If it is repeated with the definition will be ignored ID         uint   `gorm:"primary_key"` Name       string `gorm:"column:name"` Age        int    `gorm:"column:age;type:varchar(64)"` Role       string `gorm:"column:role;type:varchar(64)"` Friends    []User `gorm:"-"` // only local used gorm ignore}
type Passport struct { ID        int Username  Username // will be field.String Password  Password // will be field.Field because type Password set Scan and Value LoginTime time.Time}

  • method.go


这里定义了我们希望实现的接口定义。这里本质上就是通过【注释】告诉 gen，我们希望获取什么样的数据，sql 怎么生成。所以注释的写法很重要。大家先看下代码，我们下面会说：

package model
import "gorm.io/gen"
type Method interface { // Where("name=@name and age=@age") FindByNameAndAge(name string, age int) (gen.T, error) //sql(select id,name,age from users where age>18) FindBySimpleName() ([]gen.T, error)
 //sql(select id,name,age from @@table where age>18 //{{if cond1}}and id=@id {{end}} //{{if name == ""}}and @@col=@name{{end}}) FindByIDOrName(cond1 bool, id int, col, name string) (gen.T, error)
 //sql(select * from users) FindAll() ([]gen.M, error)
 //sql(select * from users limit 1) FindOne() gen.M
 //sql(select address from users limit 1) FindAddress() (gen.T, error)}
// only used to Usertype UserMethod interface { //where(id=@id) FindByID(id int) (gen.T, error)
 //select * from users where age>18 FindAdult() ([]gen.T, error)
 //select * from @@table // {{where}} //  {{if role=="user"}} //   id=@id //  {{else if role=="admin"}} //   role="user" or rule="normal-admin" //  {{else}} //   role="user" or role="normal-admin" or role="admin" //  {{end}} // {{end}} FindByRole(role string, id int)
 //update users // {{set}} //  update_time=now(), //  {{if name != ""}} //   name=@name //  {{end}} // {{end}} // where id=@id UpdateUserName(name string, id int) error}


注释的内容可以描述gorm的Where查询内容，也可以是一个完整的SQL查询语句。


  • 最简单的注释可以直接用 Where 来指明对应关系即可，如：
// Where("name=@name and age=@age")FindByNameAndAge(name string, age int) (gen.T, error)

  • 直接写 sql
//sql(select id,name,age from users where age>18)FindBySimpleName() ([]gen.T, error)

  • sql 带子句
//sql(select id,name,age from @@table where age>18//{{if cond1}}and id=@id {{end}}//{{if name == ""}}and @@col=@name{{end}})FindByIDOrName(cond1 bool, id int, col, name string) (gen.T, error)

下面两个小节我们来看一下注释的规则：

占位符


  • gen.T 用于返回数据的结构体，会根据生成结构体或者数据库表结构自动生成

  • gen.M 表示map[string]interface{},用于返回数据

  • gen.RowsAffected 用于执行SQL进行更新或删除时候,用于返回影响行数

  • @@table 查询的表名，如果没有传参，会根据结构体或者表名自动生成

  • @@<name> 当表名或者字段名可控时候，用@@占位，name为可变参数名，需要函数传入。

  • @<name> 当数据可控时候，用@占位，name为可变参数名，需要函数传入

  • 出于安全拼接考虑，like查询不支持在SQL中拼接%，如需要拼接，需要在调用函数参数中拼接好。


子句


  • 逻辑操作必须包裹在{{}}中，如{{if}},结束语句必须是 {{end}}, 所有的语句都可以嵌套。{{}}中的语法除了{{end}}其它的都是Golang语法；

  • {{if}} 支持通过满足条件拼接字符串到SQL；

  • where 只有在where子句不为空时候插入where，若子句的开头为 where连接关键字AND 或 OR，会将它们去除。

  • set 只有在set子句不为空时候插入set，若子句的开头为,会将它们去除。

  • for 通过遍历数组并将其内容插入到SQL中,需要注意之前的连接词。

  • 所有子句需要用{{end}} 结束子句，支持嵌套使用

OK，现在我们有了业务 Model，有了我们希望生成的接口。该让 gorm-gen 出场了！

首先我们切换到 cmd/generate 包，看看我们需要做什么来告诉 gorm-gen 如何生成：


  • generate.go
package main
import ( "github.com/ag9920/db-demo/gendemo/dal/model" "gorm.io/gen")
func main() {
 g := gen.NewGenerator(gen.Config{  OutPath: "../../dal/query",  Mode:    gen.WithDefaultQuery, })
 g.ApplyBasic(model.Passport{}, model.User{})
 g.ApplyInterface(func(model.Method) {}, model.User{}) g.ApplyInterface(func(model.UserMethod) {}, model.User{})
 g.Execute()}

  • 我们通过 gen.NewGenerator 来构造一个【代码生成器】，指定我们要生成的代码要放到 dal 下面的 query 子包，生成模式暂时用 default 就ok。

  • 调用 ApplyBasic 基于两个 model 来生成基础 DAL 代码；

  • 调用 ApplyInterface，指明我们希望基于什么 model 和 interface 来生成自定义的接口实现。

  • 最后调用 Execute 方法来触发生成。

好了，我们切换到外层的 generate.sh

#!/bin/bash
PROJECT_DIR=$(dirname "$0")GENERATE_DIR="$PROJECT_DIR/cmd/generate"
cd "$GENERATE_DIR" || exit
echo "Start Generating"go run .

这里来调用 go run 启动我们的 main 函数即可。

万事俱备，我们来执行一下：

$ ./generate.sh
Start Generating2022/08/18 17:12:01 Start generating code.2022/08/18 17:12:01 generate query file: /Users/ag9920/go/src/github.com/ag9920/db-demo/gendemo/dal/query/passports.gen.go2022/08/18 17:12:01 generate query file: /Users/ag9920/go/src/github.com/ag9920/db-demo/gendemo/dal/query/users.gen.go2022/08/18 17:12:01 generate query file: /Users/ag9920/go/src/github.com/ag9920/db-demo/gendemo/dal/query/gen.go2022/08/18 17:12:01 Generate code done.

Bingo，任务完成。此时，我们再来看看 dal 目录，你会发现多了个 query 文件夹


其中，passports.gen.go 以及 users.gen.go 分别对应我们的两个model，很直观。而 gen.go 则是通用的查询代码。我们来看看里面有什么：

  • gen.go
// Code generated by gorm.io/gen. DO NOT EDIT.// Code generated by gorm.io/gen. DO NOT EDIT.// Code generated by gorm.io/gen. DO NOT EDIT.
package query
import ( "context" "database/sql"
 "gorm.io/gorm")
var ( Q        = new(Query) Passport *passport User     *user)
func SetDefault(db *gorm.DB) { *Q = *Use(db) Passport = &Q.Passport User = &Q.User}
func Use(db *gorm.DB) *Query { return &Query{  db:       db,  Passport: newPassport(db),  User:     newUser(db), }}
type Query struct { db *gorm.DB
 Passport passport User     user}
func (q *Query) Available() bool { return q.db != nil }
func (q *Query) clone(db *gorm.DB) *Query { return &Query{  db:       db,  Passport: q.Passport.clone(db),  User:     q.User.clone(db), }}
type queryCtx struct { Passport *passportDo User     *userDo}
func (q *Query) WithContext(ctx context.Context) *queryCtx { return &queryCtx{  Passport: q.Passport.WithContext(ctx),  User:     q.User.WithContext(ctx), }}
func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error { return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...)}
func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx { return &QueryTx{q.clone(q.db.Begin(opts...))}}
type QueryTx struct{ *Query }
func (q *QueryTx) Commit() error { return q.db.Commit().Error}
func (q *QueryTx) Rollback() error { return q.db.Rollback().Error}
func (q *QueryTx) SavePoint(name string) error { return q.db.SavePoint(name).Error}
func (q *QueryTx) RollbackTo(name string) error { return q.db.RollbackTo(name).Error}

这里很好理解，其实就是把我们的 DAL 操作都封装了起来，提供了常见的 WithContext, Transaction 等方法。业务只需要构造出一个 gorm 链接，传入 SetDefault 就能使用。


  • user.go

自动生成的数据访问方法比较多，而且还有我们指定的两个接口实现。这里我们就不贴完整代码了，感兴趣的同学可以到上面的源码仓库了解。这里我们抽出几个典型的代码片段看一下。


//Where("name=@name and age=@age")func (u userDo) FindByNameAndAge(name string, age int) (result *model.User, err error) { params := make(map[string]interface{}, 0)
 var generateSQL strings.Builder params["name"] = name params["age"] = age generateSQL.WriteString("name=@name and age=@age ")
 var executeSQL *gorm.DB if len(params) > 0 {  executeSQL = u.UnderlyingDB().Where(generateSQL.String(), params).Take(&result) } else {  executeSQL = u.UnderlyingDB().Where(generateSQL.String()).Take(&result) } err = executeSQL.Error return}
//sql(select id,name,age from users where age>18)func (u userDo) FindBySimpleName() (result []*model.User, err error) { var generateSQL strings.Builder generateSQL.WriteString("select id,name,age from users where age>18 ")
 var executeSQL *gorm.DB executeSQL = u.UnderlyingDB().Raw(generateSQL.String()).Find(&result) err = executeSQL.Error return}
//sql(select id,name,age from @@table where age>18//{{if cond1}}and id=@id {{end}}//{{if name == ""}}and @@col=@name{{end}})func (u userDo) FindByIDOrName(cond1 bool, id int, col string, name string) (result *model.User, err error) { params := make(map[string]interface{}, 0)
 var generateSQL strings.Builder generateSQL.WriteString("select id,name,age from users where age>18 ") if cond1 {  params["id"] = id  generateSQL.WriteString("and id=@id ") } if name == "" {  params["name"] = name  generateSQL.WriteString("and " + u.Quote(col) + "=@name ") }
 var executeSQL *gorm.DB if len(params) > 0 {  executeSQL = u.UnderlyingDB().Raw(generateSQL.String(), params).Take(&result) } else {  executeSQL = u.UnderlyingDB().Raw(generateSQL.String()).Take(&result) } err = executeSQL.Error return}

看到了么？这就是基于我们的 interface 生成的实现。gorm-gen 很贴心的把我们的注释也搬了过来，我们可以参照着对比一下。


其实本质就是用我们给的 SQL， 对变量进行填充，通过 GORM 提供的 Raw 和 Exec 接口拿到最后的结果。属于最上层的封装，但可以大大减轻我们的负担，简单的 SQL 可能还看不出来，我们对比一下复杂的：


//select * from @@table// {{where}}//  {{if role=="user"}}//   id=@id//  {{else if role=="admin"}}//   role="user" or rule="normal-admin"//  {{else}}//   role="user" or role="normal-admin" or role="admin"//  {{end}}// {{end}}func (u userDo) FindByRole(role string, id int) { params := make(map[string]interface{}, 0)
 var generateSQL strings.Builder generateSQL.WriteString("select * from users ") var whereSQL0 strings.Builder if role == "user" {  params["id"] = id  whereSQL0.WriteString("id=@id ") } else if role == "admin" {  whereSQL0.WriteString("role=\"user\" or rule=\"normal-admin\" ") } else {  whereSQL0.WriteString("role=\"user\" or role=\"normal-admin\" or role=\"admin\" ") } helper.JoinWhereBuilder(&generateSQL, whereSQL0)
 if len(params) > 0 {  _ = u.UnderlyingDB().Exec(generateSQL.String(), params) } else {  _ = u.UnderlyingDB().Exec(generateSQL.String()) } return}
//update users// {{set}}//  update_time=now(),//  {{if name != ""}}//   name=@name//  {{end}}// {{end}}//where id=@idfunc (u userDo) UpdateUserName(name string, id int) (err error) { params := make(map[string]interface{}, 0)
 var generateSQL strings.Builder generateSQL.WriteString("update users ") var setSQL0 strings.Builder setSQL0.WriteString("update_time=now(), ") if name != "" {  params["name"] = name  setSQL0.WriteString("name=@name ") } helper.JoinSetBuilder(&generateSQL, setSQL0) params["id"] = id generateSQL.WriteString("where id=@id ")
 var executeSQL *gorm.DB if len(params) > 0 {  executeSQL = u.UnderlyingDB().Exec(generateSQL.String(), params) } else {  executeSQL = u.UnderlyingDB().Exec(generateSQL.String()) } err = executeSQL.Error return}

Where，Set 现在都可以根据实际的数据情况进行调整。只要我们把注释写对，生成的代码就是安全的，非常方便。


这里也可以看出，gorm-gen 提供的【SQL模板】 => 【接口实现】的能力还是非常灵活的，子句和占位符同时使用，基本上大部分场景都可以覆盖。


基础 API


除此之外，我们通过 ApplyBasic 生成的基础的访问代码也非常有用，这是对 GORM API 的加强，还是基于users.gen.go，我们看一下生成的代码什么样：


func (u userDo) Create(values ...*model.User) error { if len(values) == 0 {  return nil } return u.DO.Create(values)}
func (u userDo) CreateInBatches(values []*model.User, batchSize int) error { return u.DO.CreateInBatches(values, batchSize)}
// Save : !!! underlying implementation is different with GORM// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)func (u userDo) Save(values ...*model.User) error { if len(values) == 0 {  return nil } return u.DO.Save(values)}
func (u userDo) First() (*model.User, error) { if result, err := u.DO.First(); err != nil {  return nil, err } else {  return result.(*model.User), nil }}
func (u userDo) Take() (*model.User, error) { if result, err := u.DO.Take(); err != nil {  return nil, err } else {  return result.(*model.User), nil }}
func (u userDo) Last() (*model.User, error) { if result, err := u.DO.Last(); err != nil {  return nil, err } else {  return result.(*model.User), nil }}
func (u userDo) Find() ([]*model.User, error) { result, err := u.DO.Find() return result.([]*model.User), err}
func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) { buf := make([]*model.User, 0, batchSize) err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {  defer func() { results = append(results, buf...) }()  return fc(tx, batch) }) return results, err}
func (u userDo) FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error { return u.DO.FindInBatches(result, batchSize, fc)}

调用生成的代码


其实这一步就更简单了，我们在 dal/query 目录下已经有了生成的代码，回忆一下，在 gen.go 里面我们还有对外暴露的方法来获取到这个 DAO：


import ( "context" "database/sql"
 "gorm.io/gorm")
var ( Q        = new(Query) Passport *passport User     *user)
func SetDefault(db *gorm.DB) { *Q = *Use(db) Passport = &Q.Passport User = &Q.User}
func Use(db *gorm.DB) *Query { return &Query{  db:       db,  Passport: newPassport(db),  User:     newUser(db), }}
type Query struct { db *gorm.DB
 Passport passport User     user}

最终我们是靠这个 Query 对象来作为 DAO，对外提供查询，更新能力。所以这里我们有两种方案：


  1. 调用 SetDefault 之后，直接引用两个对象对应的分别的 DAO：Passport 或 User。

  2. 通过 Use 方法，传入一个 gorm.DB 链接，拿到一个 *Query 对象，这里已经包含了两个模型的 DAO，也可以直接使用。


这里我们引用官方的最佳实践，来看看结合生成的代码，可以如何完成增删改查，非常方便：


import ( "context" "fmt"
 "gorm.io/hints"
 "github.com/ag9920/db-demo/gendemo/dal" "github.com/ag9920/db-demo/gendemo/dal/model" "github.com/ag9920/db-demo/gendemo/dal/query")
var q = query.Use(dal.DB.Debug())
func Create(ctx context.Context) { var err error ud := q.User.WithContext(ctx)
 userData := &model.User{ID: 1, Name: "modi"} // INSERT INTO `users` (`created_at`,`updated_at`,`deleted_at`,`name`,`age`,`role`,`id`) VALUES ('2021-09-13 20:05:51.389','2021-09-13 20:05:51.389',NULL,'modi',0,'',1) err = ud.Create(userData)
 userDataArray := []*model.User{{ID: 2, Name: "A"}, {ID: 3, Name: "B"}} err = ud.CreateInBatches(userDataArray, 2) // INSERT INTO `users` (`created_at`,`updated_at`,`deleted_at`,`name`,`age`,`role`,`id`) VALUES ('2021-09-13 20:05:51.403','2021-09-13 20:05:51.403',NULL,'A',0,'',2),('2021-09-13 20:05:51.403','2021-09-13 20:05:51.403',NULL,'B',0,'',3)
 userData.Name = "new name" err = ud.Save(userData) // INSERT INTO `users` (`created_at`,`updated_at`,`deleted_at`,`name`,`age`,`role`,`id`) VALUES ('2021-09-13 20:05:51.389','2021-09-13 20:05:51.409',NULL,'new name',0,'',1) ON DUPLICATE KEY UPDATE `updated_at`=VALUES(`updated_at`),`deleted_at`=VALUES(`deleted_at`),`name`=VALUES(`name`),`age`=VALUES(`age`),`role`=VALUES(`role`)}
func Delete(ctx context.Context) { var err error u, ud := q.User, q.User.WithContext(ctx)
 _, err = ud.Where(u.ID.Eq(1)).Delete() // UPDATE `users` SET `deleted_at`='2021-09-13 20:05:51.418' WHERE `users`.`id` = 1 AND `users`.`deleted_at` IS NULL
 _, err = ud.Where(u.ID.In(2, 3)).Delete() // UPDATE `users` SET `deleted_at`='2021-09-13 20:05:51.428' WHERE `users`.`id` IN (2,3) AND `users`.`deleted_at` IS NULL
 _, err = ud.Where(u.ID.Gt(100)).Unscoped().Delete() // DELETE FROM `users` WHERE `users`.`id` > 100}

func Query(ctx context.Context) { var err error var user *model.User var users []*model.User
 u, ud := q.User, q.User.WithContext(ctx)
 /*--------------Basic query-------------*/ user, err = ud.Take() // SELECT * FROM `users` WHERE `users`.`deleted_at` IS NULL LIMIT 1 fmt.Printf("query 1 item: %+v", user)
 user, err = ud.Where(u.ID.Gt(100), u.Name.Like("%T%")).Take() // SELECT * FROM `users` WHERE `users`.`id` > 100 AND `users`.`name` LIKE '%T%' AND `users`.`deleted_at` IS NULL LIMIT 1 fmt.Printf("query conditions got: %+v", user)
 user, err = ud.Where(ud.Columns(u.ID).In(ud.Select(u.ID.Min()))).First() // SELECT * FROM `users` WHERE `users`.`id` IN (SELECT MIN(`users`.`id`) FROM `users` WHERE `users`.`deleted_at` IS NULL) AND `users`.`deleted_at` IS NULL // ORDER BY `users`.`id` LIMIT 1 fmt.Printf("subquery 1 got item: %+v", user)
 user, err = ud.Where(ud.Columns(u.ID).Eq(ud.Select(u.ID.Max()))).First() // SELECT * FROM `users` WHERE `users`.`id` = (SELECT MAX(`users`.`id`) FROM `users` WHERE `users`.`deleted_at` IS NULL) AND `users`.`deleted_at` IS NULL // ORDER BY `users`.`id` LIMIT 1 fmt.Printf("subquery 2 got item: %+v", user)
 users, err = ud.Distinct(u.Name).Find() // SELECT DISTINCT `users`.`name` FROM `users` WHERE `users`.`deleted_at` IS NULL fmt.Printf("select distinct got: %d", len(users))
 /*--------------Diy query-------------*/ user, err = ud.FindByNameAndAge("tom", 29) // SELECT * FROM `users` WHERE name='tom' and age=29 AND `users`.`deleted_at` IS NULL fmt.Printf("FindByNameAndAge: %+v", user)}

总结


今天我们通过定义接口，生成实现代码这个场景作为切入点，了解了 gorm-gen 的最核心功能。其实生成的代码还是非常简洁，且功能强大的。并且支持从 table 直接生成业务结构。建议大家仔细看看我们的 demo 以及官方文档[1]，相信对于 gorm-gen 熟练会帮助业务开发提效，安全。


参考资料


[1]gen: https://github.com/go-gorm/gen
[2]db-demo: https://github.com/ag9920/db-demo


程序员技术交流群

扫码进群记得备注：城市、昵称和技术方向。

  1. 「Go工具箱」强烈推荐：一个能让http请求回放的工具
  2. 【GoLand教程】详解 GoLand 用户界面
  3. Golang 基于 flag 库实现一个命令行工具

92120GORM 强大的代码生成工具 —— gorm/gen
标签：
最后更新：2022年11月1日

这个人很懒，什么都没留下

文章评论

Bootstrap 5入门指南 IDEA2022.3最新版永久激活教程（亲测有效） 转需！几百款中文永久版软件及安装方法（含百度云、天翼云下载） 50 万用户无人付费，Kite 停止开发！ 50w人白嫖！历经 8 年研发的 Python 代码补全神器 Kite 停止开发 有效的phpstorm正式版激活码，配合插件可永久破解！ 软件安装目录大全 Pycharm 2022 Pycharm激活码-PyCharm 2022.2.1中文版激活教程 （更新）Python编辑开发PyCharm pro 2022.2.4 for Mac 中文破解版下载（附激活码） Go语言爱好者周刊：第 170 期 — Gopher 图片集 GoLand 迎来五周年，同时发布 2022.3：有彩蛋 GoLand迎来五周年，2022.3发布 互联网摸鱼日报（2022-12-03） 《怪物猎人：崛起》即将登陆Xbox及PS平台
Selenium WebDriver中执行JS语句那些事 955.WLB 的 VS Code 插件，提醒你五点半按时下班！ Go语言爱好者周刊：第 48 期 Java学习三分钟之Spring概述 Excel公式操作大全 nodejs 图片处理工具 gm 的使用！ 基于HTML5 canvas的纯JS二维码生成 GitHub 发现了 studygolang 项目依赖的漏洞 uniapp页面通信方法总汇 拒绝躺平与内卷，创意人用 idea 征服你——2022 中国幼狮 winner 谈创意 Go1.18 新特性：多 Module 工作区模式 表情包 | 排队升天中 再见Office！WPS的这8个免费功能，我一用就爱上了！ 神器 ffmpeg —— 操作视频，极度舒适 古祝由医学课程视频13集 百度网盘云分享
标签聚合
tiktok caddy https goland 2022 芯片 游戏 软件 linux 开发 idea 2022 激活 科技 农业 前端 xbox python 表情包 web3 世界杯 m3u8 编程语言排行 网盘 二手车 机器学习
other

COPYRIGHT © 2022 编程网. ALL RIGHTS RESERVED.

Theme Kratos Made By Seaton Jiang