4 GROM 教程 (golang)

已于 2022-05-31 10:32:18 修改
阅读量1.1k 收藏 5
点赞数 4
分类专栏： GROM(golang) 文章标签： go mysql
于 2020-08-29 08:45:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44908159/article/details/108290198
版权

在这里插入图片描述

4 GROM 教程

链式操作

链式操作

Method Chaining，Gorm 实现了链式操作接口，所以你可以把代码写成这样：

db, err := gorm.Open("postgres", "user=gorm dbname=gorm sslmode=disable")

// 创建一个查询
tx := db.Where("name = ?", "jinzhu")

// 添加更多条件
if someCondition {
  tx = tx.Where("age = ?", 20)
} else {
  tx = tx.Where("age = ?", 30)
}

if yetAnotherCondition {
  tx = tx.Where("active = ?", 1)
}

在调用立即执行方法前不会生成 Query 语句，有时候这会很有用。

比如你可以抽取一个函数来处理一些通用逻辑。

立即执行方法

Immediate methods ，立即执行方法是指那些会立即生成 SQL 语句并发送到数据库的方法, 他们一般是 CRUD 方法，比如：

Create, First, Find, Take, Save, UpdateXXX, Delete, Scan, Row, Rows…

这有一个基于上面链式方法代码的立即执行方法的例子：

tx.Find(&user)

生成的 Sql

SELECT * FROM users where name = 'jinzhu' AND age = 30 AND active = 1;

范围

Scopes，Scope 是建立在链式操作的基础之上的。

基于它，你可以抽取一些通用逻辑，写出更多可重用的函数库。

func AmountGreaterThan1000(db *gorm.DB) *gorm.DB {
  return db.Where("amount > ?", 1000)
}

func PaidWithCreditCard(db *gorm.DB) *gorm.DB {
  return db.Where("pay_mode_sign = ?", "C")
}

func PaidWithCod(db *gorm.DB) *gorm.DB {
  return db.Where("pay_mode_sign = ?", "C")
}

func OrderStatus(status []string) func (db *gorm.DB) *gorm.DB {
  return func (db *gorm.DB) *gorm.DB {
    return db.Scopes(AmountGreaterThan1000).Where("status IN (?)", status)
  }
}

db.Scopes(AmountGreaterThan1000, PaidWithCreditCard).Find(&orders)
// 查找所有金额大于 1000 的信用卡订单

db.Scopes(AmountGreaterThan1000, PaidWithCod).Find(&orders)
// 查找所有金额大于 1000 的 COD 订单

db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)
// 查找所有金额大于 1000 且已付款或者已发货的订单

多个立即执行方法

Multiple Immediate Methods，在 GORM 中使用多个立即执行方法时，后一个立即执行方法会复用前一个 立即执行方法的条件 (不包括内联条件) 。

db.Where("name LIKE ?", "jinzhu%").Find(&users, "id IN (?)", []int{1, 2, 3}).Count(&count)

生成的 Sql

SELECT * FROM users WHERE name LIKE 'jinzhu%' AND id IN (1, 2, 3)

SELECT count(*) FROM users WHERE name LIKE 'jinzhu%'

线程安全

所有链式方法都会创建并克隆一个新的 DB 对象 (共享一个连接池)，GORM 在多 goroutine 中是并发安全的。

错误处理

Go的错误处理是很重要的

建议您在调用任何 立即执行方法 后进行错误检查

错误处理

GORM中的错误处理与惯用的Go代码不同，因为它具有可链接的API，但仍然易于实现。

如果发生任何错误，GORM将设置* gorm.DB的错误字段，可以这样检查：

if err := db.Where("name = ?", "jinzhu").First(&user).Error; err != nil {
  // error 处理...
}

或者

if result := db.Where("name = ?", "jinzhu").First(&user); result.Error != nil {
  // error 处理...
}

错误

处理数据时，通常会发生多个错误。 GORM提供了一个API来将所有错误作为切片返回：

// 如果发生了一个以上的错误， `GetErrors` 以`[]error`形式返回他们
errors := db.First(&user).Limit(10).Find(&users).GetErrors()

fmt.Println(len(errors))

for _, err := range errors {
  fmt.Println(err)
}

记录未找到错误

RecordNotFound，GORM提供了处理 RecordNotFound 错误的快捷方式。如果有多个错误，它将逐一检查这些错误是否为 RecordNotFound 错误。

// 检查是否为 RecordNotFound 错误
db.Where("name = ?", "hello world").First(&user).RecordNotFound()

if db.Model(&user).Related(&credit_card).RecordNotFound() {
  // 未找到记录
}

if err := db.Where("name = ?", "jinzhu").First(&user).Error; gorm.IsRecordNotFoundError(err) {
  // 未找到记录
}

钩子

对象生命周期

Hooks(一般称之为钩子函数)的功能是在运行创建/查询/更新/删除语句之前或者之后执行。

如果你为一个 model 定义了一个具体的方法，它将会在运行 创建，更新，查询，删除时自动被调用，并且如果任何回调函数函数返回一个错误，GORM 将会停止接下来的操作并且回滚当前的事务。

钩子函数

创建对象时

Creating an object，创建对象时可用的 hooks

// 开始事务
BeforeSave
BeforeCreate
// 在关联前保存
// 更新时间戳 `CreatedAt`, `UpdatedAt`
// save self
// 重新加载具有默认值的字段，其值为空
// 在关联后保存
AfterCreate
AfterSave
// 提交或回滚事务

示例代码

func (u *User) BeforeSave() (err error) {
  if !u.IsValid() {
    err = errors.New("can't save invalid data")
  }
  return
}

func (u *User) AfterCreate(scope *gorm.Scope) (err error) {
  if u.ID == 1 {
    scope.DB().Model(u).Update("role", "admin")
  }
  return
}

注意 在 GORM 中 Save/Delete 操作默认是基于事务完成， 所以相关更改在提交事务之前是不可见的。 如果你想在你的 hooks 中看到这些变化，你可以在你的 hooks 中接收当前事务的参数，比如：

func (u *User) AfterCreate(tx *gorm.DB) (err error) {
  tx.Model(u).Update("role", "admin")
  return
}

更新对象时

Updating an object，更新对象时可用的 hooks

// begin transaction 开始事物
BeforeSave
BeforeUpdate
// save before associations 保存前关联
// update timestamp `UpdatedAt` 更新 `UpdatedAt` 时间戳
// save self 保存自己
// save after associations 保存后关联
AfterUpdate
AfterSave
// commit or rollback transaction 提交或回滚事务

代码实例:

func (u *User) BeforeUpdate() (err error) {
  if u.readonly() {
    err = errors.New("read only user")
  }
  return
}

// 在一个事务中更新数据
func (u *User) AfterUpdate(tx *gorm.DB) (err error) {
  if u.Confirmed {
    tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("verfied", true)
  }
  return
}

删除对象时

Deleting an object，删除对象时可用的 hooks

// begin transaction 开始事务
BeforeDelete
// delete self 删除自己
AfterDelete
// commit or rollback transaction 提交或回滚事务

代码实例:

// 在一个事务中更新数据
func (u *User) AfterDelete(tx *gorm.DB) (err error) {
  if u.Confirmed {
    tx.Model(&Address{}).Where("user_id = ?", u.ID).Update("invalid", false)
  }
  return
}

查询对象时

Querying an object，查询对象时可用的 hooks

// load data from database 从数据库加载数据
// Preloading (eager loading) 预加载（加载）
AfterFind

代码实例:

func (u *User) AfterFind() (err error) {
  if u.MemberShip == "" {
    u.MemberShip = "user"
  }
  return
}

事务

GORM 默认会将单个的 create, update, delete操作封装在事务内进行处理，以确保数据的完整性。

如果你想把多个 create, update, delete 操作作为一个原子操作，Transaction 就是用来完成这个的。

事务

要在事务中执行一系列操作，通常您可以参照下面的流程来执行。

func CreateAnimals(db *gorm.DB) error {
  return db.Transaction(func(tx *gorm.DB) error {
    // 在事务中做一些数据库操作 (这里应该使用 'tx' ，而不是 'db')
    if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
      // 返回任意 err ，整个事务都会 rollback
      return err
    }

    if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
      return err
    }

    // 返回 nil ，事务会 commit
    return nil
  })
}

手动控制的事务

// 开始事务
tx := db.Begin()

// 在事务中做一些数据库操作 (这里应该使用 'tx' ，而不是 'db')
tx.Create(...)

// ...

// 有错误时，手动调用事务的 Rollback()
tx.Rollback()

// 无错误时，手动调用事务的 Commit()
tx.Commit()

一个具体的例子

func CreateAnimals(db *gorm.DB) error {
  // 请注意，事务一旦开始，你就应该使用 tx 作为数据库句柄
  tx := db.Begin()
  defer func() {
    if r := recover(); r != nil {
      tx.Rollback()
    }
  }()

  if err := tx.Error; err != nil {
    return err
  }

  if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  return tx.Commit().Error
}

迁移

自动迁移

自动迁移你的模型，使之保持最新状态。

警告： 自动迁移 只会 创建表、缺失的列、缺失的索引， 不会 更改现有列的类型或删除未使用的列，以此来保护您的数据。

db.AutoMigrate(&User{})

db.AutoMigrate(&User{}, &Product{}, &Order{})

// 创建表时添加表后缀
db.Set("gorm:table_options", "ENGINE=InnoDB").AutoMigrate(&User{})

其它迁移工具

GORM 的自动迁移在大多数情况下都会正常工作，但如果你需要更严格的迁移工具， GORM 提供了通用 DB interface ，这可能对你有帮助。

// 返回 `*sql.DB`
db.DB()

更多详细信息请参阅 通用接口。

模型方法

Has Table

// 检查模型 User 的表是否存在
db.HasTable(&User{})

// 检查表 users 是否存在
db.HasTable("users")

Create Table

// 为模型 `User` 创建表
db.CreateTable(&User{})

// 创建表时会追加 “ENGINE=InnoDB” 到 SQL 语句中。
db.Set("gorm:table_options", "ENGINE=InnoDB").CreateTable(&User{})

Drop table

// 删除模型 `User` 的表
db.DropTable(&User{})

// 删除表 `users`
db.DropTable("users")

// 删除模型 `User` 的表和表 `products`
db.DropTableIfExists(&User{}, "products")

ModifyColumn

修改列类型为给定的值

// 修改模型 `User` 的 description 列的类型为 `text` 
db.Model(&User{}).ModifyColumn("description", "text")

DropColumn

// 删除模型 `User` 的 description 列
db.Model(&User{}).DropColumn("description")

Add Indexes

// 为 `name` 列添加名为 `idx_user_name` 的普通索引
db.Model(&User{}).AddIndex("idx_user_name", "name")

// 为 `name` 和 `age` 两列添加名为 `idx_user_name_age` 的普通索引
db.Model(&User{}).AddIndex("idx_user_name_age", "name", "age")

// 添加唯一索引
db.Model(&User{}).AddUniqueIndex("idx_user_name", "name")

// 为多列添加唯一索引
db.Model(&User{}).AddUniqueIndex("idx_user_name_age", "name", "age")

Remove Index

// 删除索引
db.Model(&User{}).RemoveIndex("idx_user_name")

Add Foreign Key

// 添加外键
// 第一个参数： 外键字段
// 第二个参数：目标表名(字段)
// 第三个参数：删除时
// 第四个参数： 更新时
db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")

Remove ForeignKey

db.Model(&User{}).RemoveForeignKey("city_id", "cities(id)")

SQL 生成器

执行原生SQL

执行原生 SQL 时，不支持与其它方法的链式操作

db.Exec("DROP TABLE users;")
db.Exec("UPDATE orders SET shipped_at=? WHERE id IN (?)", time.Now(), []int64{11,22,33})

// Scan
type Result struct {
  Name string
  Age  int
}

var result Result
db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)

sql.Row 和 sql.Rows

通过 *sql.Row 或 *sql.Rows 获取查询结果

row := db.Table("users").Where("name = ?", "jinzhu").Select("name, age").Row() // (*sql.Row)
row.Scan(&name, &age)

rows, err := db.Model(&User{}).Where("name = ?", "jinzhu").Select("name, age, email").Rows() // (*sql.Rows, error)
defer rows.Close()
for rows.Next() {
  ...
  rows.Scan(&name, &age, &email)
  ...
}

// 原生 SQL
rows, err := db.Raw("select name, age, email from users where name = ?", "jinzhu").Rows() // (*sql.Rows, error)
defer rows.Close()
for rows.Next() {
  ...
  rows.Scan(&name, &age, &email)
  ...
}

将 sql.Rows 扫描至 model

rows, err := db.Model(&User{}).Where("name = ?", "jinzhu").Select("name, age, email").Rows() // (*sql.Rows, error)
defer rows.Close()

for rows.Next() {
  var user User
  // ScanRows 扫描一行记录到 user
  db.ScanRows(rows, &user)

  // do something
}
}

通过数据库接口 sql.DB

GORM 提供了 DB方法 ，可以从当前 *gorm.DB 连接内，获取一个通用的数据库接口*sql.DB

// 获取通用 sql.DB 并使用其方法
db.DB()

// Ping
db.DB().Ping()

注意 如果数据库底层连接的不是一个 *sql.DB（比如在一个事务中），那么该方法会返回 nil。

连接池

// SetMaxIdleCons 设置连接池中的最大闲置连接数。
db.DB().SetMaxIdleConns(10)

// SetMaxOpenCons 设置数据库的最大连接数量。
db.DB().SetMaxOpenConns(100)

// SetConnMaxLifetiment 设置连接的最大可复用时间。
db.DB().SetConnMaxLifetime(time.Hour)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

行走的皮卡丘
关注
专栏目录
Golang GORM 详解
canduecho的专栏
06-14 1969
GORM 是基于 Go 语言的 ORM 库，可使开发者对数据库使用更为方便，支持多种数据库。它提供了许多功能，例如查询构建器、关系映射、事务等。如果要禁用这种自动复数形式的表名名规则还可以用定义表名，可以在模型定义中使用标记该表名，使其与模型的名称保持一致。gorm.ModelAge int在这个示例代码中，我们定义了一个 User 结构体，使用了标记表名为user。并在中自动迁移表结构。此时我们在数据库中看到的表名将为user，而非默认的users。
1.golang : gorm + gin实现restful 接口
linux_player_c（系统&开发）
08-20 7047
golang : gorm + gin实现restful 接口 gorm操作数据库 golang可以使用gorm工具对数据库进行操作,实现对数据的一系列操作. gorm的中文文档如下: https://jasperxu.github.io/gorm-zh/ 主要实现的功能如下: 全功能ORM（几乎） 关联（包含一个，包含多个，属于，多对多，多种包含） Callbacks（创建/...
gorm使用教程 —— Golang（清晰、简洁思路）
qq_61465103的博客
11-14 2020
gorm使用教程 —— Golang（清晰、简洁思路）
GORM教程
weixin_44961320的博客
07-26 1698
无
go语言操作Gorm
qq_53088003的博客
06-06 532
几分钟带你快速掌握go语言操作Gorm
gorm快速上手
新法的博客
03-08 1954
ORM全称是:Object Relational Mapping(对象关系映射)，其主要作用是在编程中，把面向对象的概念跟数据库中表的概念对应起来。举例来说就是，我定义一个对象，那就对应着一张表，这个对象的实例，就对应着表中的一条记录。​ 对于数据来说，最重要最常用的是表:表中有列, orm就是将一张表映射成一个类，表中的列映射成类中的一个类。java 、python，但是针对go语言而言，struct，就是列如何映射，是因为列可以映射成struct中的类型，int->int,但是有另一个问题?
GORM快速入门
EGXXM的博客
05-12 695
crud 指的creat retrieve update delete增加，查询，更新，删除四种操作 ORM,对象关系映射，是一种框架格式，显示了映射关系 迁移 创建表，查看表，重命名表，删除表 type User struct { ID int Name string } func main() { db, err := gorm.Open(mysql.New(mysql.Config{ DSN: "root:123456@tcp(127.0.0.1:3306)/db1?charset=
grom:一个强大的命令行工具，用于将mysql表字段转换为golang模型结构
05-29
Grom 是一个强大的命令行工具，可以将 mysql 表字段转换为 golang 模型结构。 它的全称是 golang 关系对象映射（GROM）。 安装 使用以下方法下载软件包： $ go get -u github.com/sliveryou/grom 要从源代码构建...
golang gorm中格式化时间问题详解
09-19
在Golang中，GORM是一个流行的ORM库，用于简化数据库操作。在处理时间相关的数据时，GORM提供了方便的功能，但同时也存在一些限制。本文主要探讨了如何在GORM中处理时间格式化的问题。 首先，GORM默认可以自动管理...
Gin中使用GROM操作数据库-mysql数据（一）
09-27
charset=utf8mb4&parseTime=True&loc=Local" // 替换为实际的数据库连接字符串 db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) if err != nil { panic("failed to connect database") } defer db....
Grom学习之路
yyq1102394156的博客
06-18 1310
Grom学习之路（一） 一、orm的背景 1、作用 （1）通过操作结构体对象，来达到操作数据库表的目的； （2）通过结构体对象，来生成数据库表； 2、优点： 二、grom的连接数据库，建表 1、因为grom只能对表进行操作，所以需要搭配sql语句来 ...
GORM快速入门（只需一篇即可学会）
最新发布
席万里的博客
05-07 1347
GORM快速入门
GROM学习之路（一）
yyq1102394156的博客
05-26 482
GROM学习之路（一） 一、定义 解释：相当于UCML平台的对应关系，将数据库中的数据对应成对象实例。 二、Orm的执行流程 1、导入包； import ( "github.com/astaxie/beego/orm" _ "github.com/go-sql-driver/mysql" ) 2、注册驱动和数据库； dsn := "root:root@tcp(localhost:3306)/testorm?charset=utf8mb4&parseTime=true&loc=PRC
Grom之数据查询
weixin_52690231的博客
05-03 4449
Grom之数据查询
grom的理解与掌握
hightower的博客
05-07 888
前言 什么是gorm gorm是一种数据库操作辅助工具，在我们go的结构体和数据库之间产生映射，让我们对数据库的关系，标的内容，直观的体现在结构体上，使用结构体即可完成增删改查操作 使用gorm进行数据库操作 gorm如何链接数据库 导入gorm-------导入mysql驱动器----------使用open链接得到数据库操作对象(以mysql为例) do,err:=gorm.Open(“mysql”,“user:password@/dbname?charset=utf8&parseTime=Tr
Go gorm库(详细版)
原来45的博客
04-11 2525
go gorm mysql
Gorm新手入门教程
qq_39298872的博客
09-12 2798
Gorm新手入门教程 官网：gorm中文官网 教程所在github地址： 一、 环境配置 安装 go get -u gorm.io/gorm # mysql驱动 本文以mysql驱动为例 go get -u gorm.io/driver/mysql # sqlite 驱动 go get -u gorm.io/driver/sqlite 二 、mysql数据库连接 dsn := "用户名:密码@tcp(ip:port)/dbName?charset=utf8mb4&parseTime=True&
Golang Gorm 创建HOOK
小楼一夜听春雨，深巷明朝卖杏花
09-14 627
钩子函数比较简单，就是实现before create的一个方法。创建的时候，在插入数据之前，想要做一些事情。
如何优雅的使用 GORM 来实现 MySQL 事务
Trouvailless的博客
09-08 1618
为了确保数据一致性，在项目中会经常用到事务处理，回滚操作还是比较常见的需求；事务处理可以用来维护数据库的完整性，保证成批的sql语句要么全部都执行，要么全不执行，对于MySQL事务相信大家应该都不陌生，这篇文章主要总结一下在Go语言中Gorm是如何实现事务的；感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。
grom 连接数据库
05-26
在 Python 中使用 grom 连接数据库需要进行以下步骤： 1. 安装 grom 库 可以使用 pip 命令进行安装： ``` pip install grom ``` 2. 连接数据库 使用 grom.connect() 方法连接数据库，该方法接受一个字典参数，其中包含数据库连接信息。 例如连接 MySQL 数据库： ```python import grom db_config = { 'host': 'localhost', 'port': 3306, 'user': 'root', 'password': 'password', 'database': 'test_db' } conn = grom.connect('mysql', **db_config) ``` 3. 执行 SQL 查询 使用 conn.execute() 方法执行 SQL 查询并返回结果。 例如查询表中所有数据： ```python result = conn.execute('SELECT * FROM test_table') for row in result: print(row) ``` 这就是使用 grom 连接数据库的基本步骤，你可以根据自己的需要进行进一步的操作和优化。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

行走的皮卡丘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值