likes
comments
collection

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

作者站长头像
站长
· 阅读数 127

GORM 的那些困扰

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

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 对自己的定位就是通过代码生成,让 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 感兴趣的同学可以看一下 gendemo 目录下的代码。

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

go get -u gorm.io/gen

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

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

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

  • 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.DB
var 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 User
type 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连接关键字ANDOR,会将它们去除。
  • 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 Generating
2022/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.go
2022/08/18 17:12:01 generate query file: /Users/ag9920/go/src/github.com/ag9920/db-demo/gendemo/dal/query/users.gen.go
2022/08/18 17:12:01 generate query file: /Users/ag9920/go/src/github.com/ag9920/db-demo/gendemo/dal/query/gen.go
2022/08/18 17:12:01 Generate code done.

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

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

其中,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=@id
func (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 以及官方文档,相信对于 gorm-gen 熟练会帮助业务开发提效,安全。

感谢阅读!欢迎在评论区交流!