GORM 的使用

邹业盛 2022-04-06 04:05 更新
  1. 介绍与安装
  2. 连接和 Hello World
  3. 模型
  4. 简单查询
  5. 模型的关联与查询
  6. 事务
  7. 连接池
  8. 其它

1. 介绍与安装

GORM 是 go 的一个 ORM 框架,它在 https://gorm.io

受限于 go 是静态语言的限制, GORM 的能力和 API 自然没法做得像动态语言的 ORM 那样强大与好用。

安装:

go get -u gorm.io/gorm

要连接具体的数据库,需要的驱动是单独安装的,比如:

go get -u gorm.io/driver/sqlite
go get -u gorm.io/driver/mysql

2. 连接和 Hello World

package main

import "gorm.io/gorm"
import "gorm.io/driver/sqlite"

func main() {
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if (err != nil) {
        panic(err)
    }
    var n string
    db.Raw("select 'Hello World'").Scan(&n)
    print(n)
}

使用 Open() 获取一个连接, 第二个参数是一组配置。

如果是 MySQL 的话,大概长这样:

mysql.Open("app:[email protected](127.0.0.1:3306)/test?charset=utf8mb4")

最简单的,直接使用 Raw() 方法,就可以查询了。

结果的处理,是填坑位(地址)的形式。即先申明一些变量,然后把变量地址作为第二个参数传入,地址和类型的匹配,需要你自己处理好。

Raw() 可以有多个参数,对应预编译的形式:

db.Raw("select ?", "Hello World").Scan(&n)

3. 模型

模型在语法实现上就是一个结构体:

type User struct {
  ID uint
  Name string
}

对于模型,GORM 自己有一些约定,拿上面的定义来说,它默认为:

当然,这些约定不知道也没有关系,我们按自己的需要配置这些信息就好了,不用去管它的默认规则(我个人反感“约定大于配置”)。

表名可以用 TableName() 方法:

type User struct {
  ID uint
  Name string
}

func (User) TableName() string {
    return "user"
}

字段名,是否索引,主键等一系列信息,是由结构体字段的标签来额外标注的:

package main

import "log"
import "os"
import "time"
import "gorm.io/gorm"
import "gorm.io/driver/sqlite"
// import "gorm.io/driver/mysql"
import "gorm.io/gorm/logger"


type User struct {
    Id uint `gorm:"column:id; type:INTEGER; primaryKey;"`
    Name string `gorm:"column:name; type:varchar(48); not null; default:''; index:idx_user_name;"`
    Age uint `gorm:"column:age; type:INTEGER; not null; default:1; index:idx_user_age;"`
}

func (User) TableName() string {
    return "user"
}


var newLogger = logger.New(
    log.New(os.Stdout, "\n", log.LstdFlags),
    logger.Config{
        SlowThreshold: 200 * time.Millisecond,
        LogLevel: logger.Info,
        IgnoreRecordNotFoundError: false,
        Colorful: false,
    },
)

func main() {
    db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{ Logger: newLogger, })
    // db, err := gorm.Open(mysql.Open("[email protected](127.0.0.1:3306)/gorm"), &gorm.Config{ Logger: newLogger, })
    if (err != nil) {
        panic(err)
    }
    db.Migrator().CreateTable(&User{})
}

模型定义好之后,就可以查询了。

接下来,我们会在大部分时候使用 sqlite 的内存数据库方式,方便演示。

创建表可以使用 Migrator 里面的 CreateTable()

同时,为了可以把 CreateTable() 执行时对应的 SQL 语句打印出来,我们还在上面的代码中配置了 Logger

在打印出日志的时候,因为 GORM 默认会搞上颜色,这在我个人的 VIM 环境下是不能正常显示的,所以,要通过自定义 Logger 的方式,把 Colorful 关掉。

执行上面的代码,就可以看到建表及建索引的语句:

CREATE TABLE `user` (`id` INTEGER,`name` varchar(48) NOT NULL DEFAULT "",`age` INTEGER NOT NULL DEFAULT 1,PRIMARY KEY (`id`))

CREATE INDEX `idx_user_age` ON `user`(`age`)

CREATE INDEX `idx_user_name` ON `user`(`name`)  

标签那部分,基本算是纯人肉吧,空格都不能随便多,又难看,也不具备多种类型数据库的兼容性(比如后面的 AUTO_INCREMENT 就不能在 sqlite 中使用):

type User struct {
    Id uint `gorm:"column:id; type:INTEGER; primaryKey;"`
    Name string `gorm:"column:name; type:varchar(48); not null; default:''; index:idx_user_name;"`
    Age uint `gorm:"column:age; type:INTEGER; not null; default:1; index:idx_user_age;"`
}

完整的标签功能,可以参考:https://gorm.io/zh_CN/docs/models.html#%E5%AD%97%E6%AE%B5%E6%A0%87%E7%AD%BE

4. 简单查询

4.1. 创建

user := User{Name: "first", Age: 19}
db.Create(&user)

user2 := User{Name: "first", Age: 19}
db.Create(&user2)
print(user.Id, user2.Id)

如果你在之后需要获取 Id 的话,需要将 User{} 提前存下来。

创建有可能失败。假设 Age 上有唯一约束:

user := User{Name: "first", Age: 1}
db.Create(&user)

user2 := User{Name: "first", Age: 1}
result := db.Create(&user2)

print(user2.Id, user2.Age, "\n")
if(result.Error != nil){
    print(result.Error.Error())
}

db.Create() 返回的 result 就是一个 DB 接口,当有错误时它的 Error 属性不为空, Error 属性是一个 Error 接口。

4.2. 删除

db.Delete(&User{}, "id = ?", 1)
result := db.Where("id = ?", 1).Where("name = ?", "first").Delete(&User{})
if(result.Error != nil){
    print(result.Error.Error())
}

4.3. 修改

db.Model(&User{}).Where("id = 1").Update("name", "xx")

要吐槽一下了:

4.4. 查询

查询要返回条目,所以还是典型的埋坑的形式:

var user User;
user = User{Name: "first", Age: 1}; db.Create(&user)
user = User{Name: "second", Age: 2}; db.Create(&user)
user = User{Name: "third", Age: 3}; db.Create(&user)

var userList []User
db.Limit(2).Find(&userList)
for _, o := range userList {
    println(o.Name)
}

注意,那个 Limit(2) 不能放在 Find() 的后面。

带条件查询:

var userList []User
db.Where(" (name = ?) or (age = ?)", "first", 3).Limit(2).Find(&userList)
for _, o := range userList {
    println(o.Name)
}

反正就是带占位符的手写,随便怎么写了。

结构化的条件:

db.Where(map[string]interface{}{"name": "first", "age": 1}).Limit(2).Find(&userList)

排序和 Offset :

var userList []User
db.Limit(1).Offset(1).Order("age desc").Find(&userList, "age > ?", 1)
for _, o := range userList {
    println(o.Name)
}

可以看到 Find 可以直接使用后面的参数声明查询条件。

4.5. “裸查”

最后,是一个“裸查”的形式,语意上不依赖模型:

var userList []User
db.Table("user").Limit(1).Offset(1).Order("age desc").Where("age > ?", 1).Scan(&userList)
for _, o := range userList {
    println(o.Name)
}

从这里可以看出,查询本身对模型没啥依赖,模型的最大作用,只是为响应提供了结构参考。

4.6. Count

var count int64
db.Table("user").Count(&count)
println(count)

count 的类型,需要是 int64 。

4.7. 限定字段

有两种方式。一是使用 Select 方法。二是坑位的类型使用属性更少的单独的结构体。

var userList []User
db.Select("name").Limit(2).Find(&userList)
for _, o := range userList {
    println(o.Name)
}

定义小结构体:

type MiniUser struct {
    Id uint
    Name string
}

func (MiniUser) TableName() string {
    return "user"
}

查询时要先用 Model()

var userList []MiniUser
db.Model(&User{}).Limit(2).Find(&userList)
for _, o := range userList {
    println(o.Name)
}

4.8. 子查询

查询的过滤,和“创建”等过程一样的,都是会返回 DB 对象。这个对象,可以整体作为过滤条件传入:

var userList []User
sub := db.Table("user").Select("name").Where("age = 1")
db.Where("name in (?)", sub).Limit(1).Find(&userList)
for _, o := range userList {
    println(o.Name)
}

4.9. JOIN

人肉的,没啥好说。

type Result struct {
    Name string
    Type string
}

var userList []Result
db.Table("user").
   Select("user.name, account.type").
   Joins("left join account on user.id == account.user_id").
   Where("user.name in (?, ?)", "first", "second").
   Scan(&userList)
for _, o := range userList {
    println(o.Name, o.Type)
}

5. 模型的关联与查询

GORM 在模型层面支持关联关系的配置,查询方面也可以直接完成相应的对接。

一般说关系模型的时候,会有一对一,一对多,多对多三种类型。实际使用中,“一对一”可以看成是“一对多”的特殊情况。而“多对多”可以自己在中间表中通过两个“一对多”关系处理。所以,下面只关注 GORM 的一对多机制。

GORM 的一对多机制,是通过“嵌入模型”和“外键定义”两步完成的。(官方网站把 Belongs To 说成是“一对一”我觉得是不合适的)。

type User struct {
    Id uint `gorm:"column:id; type:INTEGER AUTO_INCREMENT; primaryKey;"`
    Name string `gorm:"column:name; type:varchar(48); not null; default:''; index:idx_user_name;"`
    Age uint `gorm:"column:age; type:INTEGER; not null; index:idx_user_age;"`
}

type Account struct {
    Id uint `gorm:"column:id; type:INTEGER AUTO_INCREMENT; primaryKey;"`
    Type string `gorm:"column:type; type:varchar(48); not null; default:''; index:idx_account_type;"`
    UserId uint `gorm:"column:user_id; type:INTEGER; index: idx_account_user_id;"`
    UserObj User `gorm:"foreignKey:UserId;references:Id;"`
}

func (User) TableName() string {
    return "user"
}

func (Account) TableName() string {
    return "account"
}

(注意,这里的 Id 中的 type 属性的 AUTO_INCREMENT ,在 sqlite 中不能正常工作的,需要删除它。标签手动写语句的方式,还是比较原始啊。)

这样,一个“一对多”的关系就定义好了。这里如果使用 Migrator ,则在 Account 中是会创建相应的外键约束的。不想要这个外键约束的话(我就不要想),可以在连接配置中处理:

db, err := gorm.Open(mysql.Open("[email protected](127.0.0.1:3306)/gorm"), &gorm.Config{
    Logger: newLogger,
    DisableForeignKeyConstraintWhenMigrating: true,
})

查询时,可以通过额外的操作,来自动填充上 Account 实例的 UserObj 属性:

var accountList []Account
db.Preload("UserObj").Where("type = ?", "special").Find(&accountList)
for _, o := range accountList {
    println(o.Type, o.UserId, o.UserObj.Name)
}

使用 Preload("UserObj") 可以指定要关联的属性,查询时,就会通过额外的查询把 UserObj 的值取出来,并填充到对应的 Account 实例上。这里注意,使用 Preload 查询时,是通过单独的 SQL 完成关联模型查询的,不是 join ,不是子查询。

SELECT * FROM `user` WHERE `user`.`id` IN (2,3)
SELECT * FROM `account` WHERE type = "special"

前面的代码,会有这两条 SQL 被执行。

如果要使用 join 来查询,可以用 Joins 代替 Preload

var accountList []Account
db.Joins("UserObj").Where("type = ?", "special").Find(&accountList)
for _, o := range accountList {
    println(o.Type, o.UserId, o.UserObj.Name)
}

这样查询的 SQL 会变成一条:

SELECT
    `account`.`id`,`account`.`type`,`account`.`user_id`,
    `UserObj`.`id` AS `UserObj__id`,`UserObj`.`name` AS ` UserObj__name`,
    `UserObj`.`age` AS `UserObj__age`
FROM
    `account`
LEFT JOIN
    `user` `UserObj`
ON
    `account`.`user_id` = `UserObj`.`id`
WHERE
    type = "special"

可能这个比较符合日常使用的预期。

6. 事务

在说事务的一些操作之前,要先把 GORM 默认的事务行为搞清楚。

官方的文档上说 “GORM 会在事务里执行写入操作(创建、更新、删除)” ,不过我自己搞不懂这句话什么意思。

session := db

var user User;
user = User{Name: "first", Age: 1}; session.Create(&user)
user = User{Name: "second", Age: 1}; session.Create(&user)
user = User{Name: "third", Age: 3}; session.Create(&user)

time.Sleep(time.Second * 20)

上面实例中,等待的 20 秒期间,已经可以在数据库中查询到 Create 的三条记录了。

官方并没有说清楚,这里所谓的在“事务”中的创建行为,它在什么时候会被“提交”。

好在总是可以手动控制事务:

db.Delete(&User{}, "id > 0")
db.Delete(&Account{}, "id > 0")

session := db.Begin()

var user User;
user = User{Name: "first", Age: 1}; session.Create(&user)
user = User{Name: "second", Age: 1}; session.Create(&user)
user = User{Name: "third", Age: 3}; session.Create(&user)

time.Sleep(time.Second * 20)
session.Commit()

这样写,等待的 20 秒就查询不到 Create 的内容了。

还可以通过回调的形式,声明一个事务片段:

db.Delete(&User{}, "id > 0")
db.Delete(&Account{}, "id > 0")

session := db.Begin()

var user User;

session.Transaction(func(tx *gorm.DB) error {
    user = User{Name: "first", Age: 1}; tx.Create(&user)
    return errors.New("rollback")
});

user = User{Name: "second", Age: 1}; session.Create(&user)
user = User{Name: "third", Age: 3}; session.Create(&user)

time.Sleep(time.Second * 20)
session.Commit()

使用 Transaction ,里面返回非 Nil 的内容事务就会回滚。上面的代码,在等待的 20 秒间查询不到内容。20 之后,可以查询到 Create 的两条内容。

session.Rollback() 用来回滚 session 事务。

Commit() 或者 Rollback() 都可能失败,调用它们返回的也仍然是 DB 对象(有 Error 属性):

session := db.Begin()

var user User;

session.Transaction(func(tx *gorm.DB) error {
    user = User{Name: "first", Age: 1}; tx.Create(&user)
    return errors.New("rollback")
});

user = User{Name: "second", Age: 1}; session.Create(&user)
user = User{Name: "third", Age: 3}; session.Create(&user)

session.Commit()
sdb := session.Rollback()
if(sdb.Error != nil){
    println(sdb.Error.Error())
}

可以看到,在需要的时候,还是得自己手动判断一下结果状态。实际项目上,这类信息至少应该打印到日志中,以便发现代码中可能存在的逻辑问题。

7. 连接池

go 的这种类似多线程的模型,就需要连接池来实现涉及数据库读写的并发行为。要配置连接池的时候,一般先确定三个参数:

连接池是 go 官方模块带的, GORM 中通过 db.DB() 方法,可以得到 *sql.DB ,它里面有配置连接池的实现。

package main

import "time"
import "github.com/gin-gonic/gin"

import "gorm.io/gorm"
import "gorm.io/driver/mysql"

func main() {

    db, _ := gorm.Open(mysql.Open("[email protected](127.0.0.1:3306)/gorm"), &gorm.Config{})

    sqlDB, _ := db.DB()
    sqlDB.SetMaxOpenConns(1)
    // sqlDB.SetMaxIdleConns(1)
    // sqlDB.SetConnMaxLifetime(time.Hour)

    router := gin.Default()
    router.GET("/", func(c *gin.Context){
        var n float32
        session := db.Begin()
        session.Raw("select RAND()").Scan(&n)
        time.Sleep(5 * time.Second)
        c.String(200, `Hello World %f`, n)
        session.Commit()
    })

    router.Run("0.0.0.0:8888")
}

使用 curl 测试以上代码,可以看到,当设置了 SetMaxOpenConns 之后,服务端的实现看起来就没有并发能力了。

8. 其它

对于“主从”,“分表”等机制, GORM 有现成的中间件实现(我觉得依靠客户端应用层面手动做这些事挻原始的)。

评论
©2010-2022 zouyesheng.com All rights reserved. Powered by GitHub , txt2tags , MathJax