非零基础快速入门Go 语言数据库中间件_ GORM

向右看齐 2023-01-13 10:12 171阅读 0赞

# 非零基础快速入门Go 语言数据库中间件\_ GORM #

> Java中有 Mybatis Go 中自然有与之对标的中间件 GORM
> 
> 本文参考 Gorm 官网，以最快的速度上手 Go针对数据库的增删改查
> 
> 由于现在针对数据库中间件更多只是使用其单表功能 因为让数据库做复杂运算会造成性能压力 所以我们更多的将数据的运算下放到业务逻辑中处理 所以我抛去了很多中间件的高级特性

##  ##

GORM 是一个全功能 ORM （Object/Relation Mapping）框架

说是 ORM 框架，我们自然先声明出我们的 Obeject

### 文章目录 ###

*  非零基础快速入门Go 语言数据库中间件\_ GORM
 *   *  
     *  模型定义
     *  创建
     *  查询
     *   *  
     *  更新
     *  删除

## 模型定义 ##

模型是标准的 struct

type User struct {
        
      ID           uint    
      Name         string
      Email        *string
      Age          uint8
      Birthday     *time.Time
      MemberNumber sql.NullString
      ActivatedAt  sql.NullTime
      CreatedAt    time.Time
      UpdatedAt    time.Time
    }

> 约定大于配置

GORM 倾向于约定，而不是配置。默认情况下，GORM 使用 `ID` 作为主键，使用结构体名的 `蛇形复数` 作为表名，字段名的 `蛇形` 作为列名，并使用 `CreatedAt`、`UpdatedAt` 字段追踪创建、更新时间

遵循 GORM 已有的约定，可以减少您的配置和代码量

## 创建 ##

> 创建记录

//Object
    user := User{
        Name: "Jinzhu", Age: 18, Birthday: time.Now()}
    //通过数据的指针来创建
    result := db.Create(&user) 
    
    user.ID             // 返回插入数据的主键
    result.Error        // 返回 error
    result.RowsAffected // 返回插入记录的条数

> 批量插入

要有效地插入大量记录，请将一个 `slice` 传递给 `Create` 方法。 将切片数据传递给 Create 方法，GORM 将生成一个单一的 SQL 语句来插入所有数据，并回填主键的值，钩子方法也会被调用。

var users = []User{
        {
        Name: "jinzhu1"}, {
        Name: "jinzhu2"}, {
        Name: "jinzhu3"}}
    db.Create(&users)
    
    for _, user := range users {
        
      user.ID // 1,2,3
    }

## 查询 ##

> 检索单个对象

GORM 提供了 `First`、`Take`、`Last` 方法，以便从数据库中检索单个对象。当查询数据库时它添加了 `LIMIT 1` 条件，且没有找到记录时，它会返回 `ErrRecordNotFound` 错误

如果你想避免`ErrRecordNotFound`错误，你可以使用`Find`，比如`db.Limit(1).Find(&user)`，`Find`方法可以接受struct和slice的数据。

`First`, `Last`方法将按主键排序查找第一/最后一条记录，只有在用struct查询或提供model value时才有效，如果当前model没有定义主键，将按第一个字段排序，例如：

> 用主键检索

如果主键是数值类型

db.First(&user, 10)
    // SELECT * FROM users WHERE id = 10;
    
    db.Find(&users, []int{
        1,2,3})
    // SELECT * FROM users WHERE id IN (1,2,3);

如果主键是像 uuid 这样的字符串，您需要这要写：

db.First(&user, "id = ?", "1b74413f-f3b8-409f-ac47-e8c062e3472a")
    // SELECT * FROM users WHERE id = "1b74413f-f3b8-409f-ac47-e8c062e3472a";

> 检索全部对象

// 获取全部记录
    result := db.Find(&users)
    // SELECT * FROM users;
    
    result.RowsAffected // 返回找到的记录数，相当于 `len(users)`
    result.Error        // returns error

###  ###

> 添加查询条件

// 获取第一条匹配的记录
    db.Where("name = ?", "jinzhu").First(&user)
    // SELECT * FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;
    
    // IN
    db.Where("name IN (?)", []string{
        "jinzhu", "jinzhu 2"}).Find(&users)
    // SELECT * FROM users WHERE name IN ('jinzhu','jinzhu 2');
    
    // LIKE
    db.Where("name LIKE ?", "%jin%").Find(&users)
    // SELECT * FROM users WHERE name LIKE '%jin%';
    
    // AND
    db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)
    // SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;
    
    // Time
    db.Where("updated_at > ?", lastWeek).Find(&users)
    // SELECT * FROM users WHERE updated_at > '2000-01-01 00:00:00';
    
    // BETWEEN
    db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)
    // SELECT * FROM users WHERE created_at BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

> Struct条件查询

// Struct
    db.Where(&User{
        Name: "jinzhu", Age: 20}).Find(&user)
    // SELECT * FROM users WHERE name = "jinzhu" AND age = 20 ORDER BY id LIMIT 1;
    
    
    // 主键切片条件
    db.Where([]int64{
        20, 21, 22}).Find(&users)
    // SELECT * FROM users WHERE id IN (20, 21, 22);

> **注意** 当使用结构作为条件查询时，GORM 只会查询非零值字段。这意味着如果您的字段值为 `0`、`''`、`false` 或其他 [零值][Link 1]，该字段不会被用于构建查询条件，例如：

db.Where(&User{Name: "jinzhu", Age: 0}).Find(&users)
    // SELECT * FROM users WHERE name = "jinzhu";

你可以使用 map 来构建查询条件，它会使用所有的值，例如：

db.Where(map[string]interface{
        }{
        "Name": "jinzhu", "Age": 0}).Find(&users)
    // SELECT * FROM users WHERE name = "jinzhu" AND age = 0;

> Not条件

构建 NOT 条件，用法与 `Where` 类似

db.Not("name = ?", "jinzhu").First(&user)
    // SELECT * FROM users WHERE NOT name = "jinzhu" ORDER BY id LIMIT 1;
    
    // Not In
    db.Not(map[string]interface{
        }{
        "name": []string{
        "jinzhu", "jinzhu 2"}}).Find(&users)
    // SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");
    
    // Struct
    db.Not(User{
        Name: "jinzhu", Age: 18}).First(&user)
    // SELECT * FROM users WHERE name <> "jinzhu" AND age <> 18 ORDER BY id LIMIT 1;
    
    // 不在主键切片中的记录
    db.Not([]int64{
        1,2,3}).First(&user)
    // SELECT * FROM users WHERE id NOT IN (1,2,3) ORDER BY id LIMIT 1;

> Or 条件

db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users)
    // SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';
    
    // Struct
    db.Where("name = 'jinzhu'").Or(User{
        Name: "jinzhu 2", Age: 18}).Find(&users)
    // SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);
    
    // Map
    db.Where("name = 'jinzhu'").Or(map[string]interface{
        }{
        "name": "jinzhu 2", "age": 18}).Find(&users)
    // SELECT * FROM users WHERE name = 'jinzhu' OR (name = 'jinzhu 2' AND age = 18);

> **选择特定字段**

选择您想从数据库中检索的字段，默认情况下会选择全部字段

为了调高性能，我们经常需要返回我们只要返回的字段，减少数据库检索次数

db.Select("name", "age").Find(&users)
    // SELECT name, age FROM users;
    
    db.Select([]string{
        "name", "age"}).Find(&users)
    // SELECT name, age FROM users;
    
    db.Table("users").Select("COALESCE(age,?)", 42).Rows()
    // SELECT COALESCE(age,'42') FROM users;

> Order排序

指定从数据库检索记录时的排序方式

db.Order("age desc, name").Find(&users)
    // SELECT * FROM users ORDER BY age desc, name;
    
    // 多个 order
    db.Order("age desc").Order("name").Find(&users)
    // SELECT * FROM users ORDER BY age desc, name;

> **分页Limit & Offset**

`Limit` 指定获取记录的最大数量 `Offset` 指定在开始返回记录之前要跳过的记录数量

db.Limit(3).Find(&users)
    // SELECT * FROM users LIMIT 3;
    
    db.Offset(3).Find(&users)
    // SELECT * FROM users OFFSET 3;
    
    db.Limit(10).Offset(5).Find(&users)
    // SELECT * FROM users OFFSET 5 LIMIT 10;

## 更新 ##

> 保存所有字段

`Save` 会保存所有的字段，即使字段是零值

db.First(&user)
    user.Name = "jinzhu 2"
    user.Age = 100
    db.Save(&user)
    // UPDATE users SET name='jinzhu 2', age=100, birthday='2016-01-01', updated_at = '2013-11-17 21:34:10' WHERE id=111;

> 更新单个列

当使用 `Update` 更新单个列时，你需要指定条件，否则会返回 `ErrMissingWhereClause` 错误，当使用了 `Model` 方法，且该对象主键有值，该值会被用于构建条件，例如：

// 条件更新
    db.Model(&User{
        }).Where("active = ?", true).Update("name", "hello")
    // UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE active=true;
    
    // User 的 ID 是 `111`
    db.Model(&user).Update("name", "hello")
    // UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;
    
    // 根据条件和 model 的值进行更新
    db.Model(&user).Where("active = ?", true).Update("name", "hello")
    // UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111 AND active=true;

> 更新多列

`Updates` 方法支持 `struct` 和 `map[string]interface{}` 参数。当使用 `struct` 更新时，默认情况下，GORM 只会更新非零值的字段

// 根据 `struct` 更新属性，只会更新非零值的字段
    db.Model(&user).Updates(User{
        Name: "hello", Age: 18, Active: false})
    // UPDATE users SET name='hello', age=18, updated_at = '2013-11-17 21:34:10' WHERE id = 111;
    
    // 根据 `map` 更新属性
    db.Model(&user).Updates(map[string]interface{
        }{
        "name": "hello", "age": 18, "active": false})
    // UPDATE users SET name='hello', age=18, active=false, updated_at='2013-11-17 21:34:10' WHERE id=111;

> **注意** 当通过 struct 更新时，GORM 只会更新非零字段。 如果您想确保指定字段被更新，你应该使用 `Select` 更新选定字段，或使用 `map` 来完成更新操作

> 更新选定字段

如果您想要在更新时选定、忽略某些字段，您可以使用 `Select`、`Omit`

// 使用 Map 进行 Select
    // User's ID is `111`:
    db.Model(&user).Select("name").Updates(map[string]interface{
        }{
        "name": "hello", "age": 18, "active": false})
    // UPDATE users SET name='hello' WHERE id=111;
    
    db.Model(&user).Omit("name").Updates(map[string]interface{
        }{
        "name": "hello", "age": 18, "active": false})
    // UPDATE users SET age=18, active=false, updated_at='2013-11-17 21:34:10' WHERE id=111;
    
    // 使用 Struct 进行 Select（会 select 零值的字段）
    db.Model(&user).Select("Name", "Age").Updates(User{
        Name: "new_name", Age: 0})
    // UPDATE users SET name='new_name', age=0 WHERE id=111;
    
    // Select 所有字段（查询包括零值字段的所有字段）
    db.Model(&user).Select("*").Update(User{
        Name: "jinzhu", Role: "admin", Age: 0})
    
    // Select 除 Role 外的所有字段（包括零值字段的所有字段）
    db.Model(&user).Select("*").Omit("Role").Update(User{
        Name: "jinzhu", Role: "admin", Age: 0})

> 批量更新

如果您尚未通过 `Model` 指定记录的主键，则 GORM 会执行批量更新

// 根据 struct 更新
    db.Model(User{
        }).Where("role = ?", "admin").Updates(User{
        Name: "hello", Age: 18})
    // UPDATE users SET name='hello', age=18 WHERE role = 'admin;
    
    // 根据 map 更新
    db.Table("users").Where("id IN ?", []int{
        10, 11}).Updates(map[string]interface{
        }{
        "name": "hello", "age": 18})
    // UPDATE users SET name='hello', age=18 WHERE id IN (10, 11);

> 如果在没有任何条件的情况下执行批量更新，默认情况下，GORM 不会执行该操作，并返回 `ErrMissingWhereClause` 错误

> 更新反馈

获取受更新影响的行数

result.RowsAffected // 更新的记录数
    result.Error        // 更新的错误

## 删除 ##

> 删除一条记录

删除一条记录时，删除对象需要指定主键，否则会触发 [批量 Delete][Delete]

// Email 的 ID 是 `10`
    db.Delete(&email)
    // DELETE from emails where id = 10;
    
    // 带额外条件的删除
    db.Where("name = ?", "jinzhu").Delete(&email)
    // DELETE from emails where id = 10 AND name = "jinzhu";

> 根据主键删除

db.Delete(&User{
        }, 10)
    // DELETE FROM users WHERE id = 10;
    
    db.Delete(&User{
        }, "10")
    // DELETE FROM users WHERE id = 10;
    
    db.Delete(&users, []int{
        1,2,3})
    // DELETE FROM users WHERE id IN (1,2,3);

> 批量删除

如果指定的值不包括主属性，那么 GORM 会执行批量删除，它将删除所有匹配的记录

db.Where("email LIKE ?", "%jinzhu%").Delete(Email{
        })
    // DELETE from emails where email LIKE "%jinzhu%";
    
    db.Delete(Email{
        }, "email LIKE ?", "%jinzhu%")
    // DELETE from emails where email LIKE "%jinzhu%";

> 阻止全局删除

如果在没有任何条件的情况下执行批量删除，GORM 不会执行该操作，并返回 `ErrMissingWhereClause` 错误

[Link 1]: https://tour.golang.org/basics/12
[Delete]: https://gorm.io/zh_CN/docs/delete.html#batch_delete