ToB企服应用市场:ToB评测及商务社交产业平台

标题: Gorm 入门介绍与基本使用 [打印本页]

---

作者: 丝    时间: 2024-3-28 14:17
标题: Gorm 入门介绍与基本使用
Gorm 入门介绍与基本使用


目录

• Gorm 入门介绍与基本使用
  
  
  
  • 一、ORM简介
    
    
    
    • 1.1 什么是ORM
      
    • 1.2 使用ORM的好处
      
      
      
      • 1.2.1 避免直接操作SQL语句
        
      • 1.2.2 提高代码的可维护性
        
      • 1.2.3 跨数据库兼容性
        
      
      
    • 1.3 使用ORM的缺点
      
      
      
      • 1.3.1 学习成本
        
      • 1.3.2 性能开销
        
      
      
    • 1.4 ORM解析过程
      
      
      
      • 1.4.1 模型定义
        
      • 1.4.2 数据验证
        
      • 1.4.3 映射关系
        
      • 1.4.4 CRUD操作
        
      • 1.4.5 SQL生成与执行
        
      
      
    
    
  • 二、Gorm 介绍与安装
    
    
    
    • 2.1 介绍
      
    • 2.2 相关文档
      
    • 2.3 安装
      
    
    
  • 三、Gorm 连接数据库
    
    
    
    • 3.1 快速连接 MySQL
      
    • 3.2 MySQL数据库配置解析
      
    • 3.3 自定义 MySQL 驱动
      
    • 3.4 现有的数据库连接mysql
      
    • 3.5 切换数据库驱动
      
    • 3.6 编写新驱动
      
    • 3.7 连接PostgreSQL
      
      
      
      • 3.7.1 连接PostgreSQ举例
        
      • 3.7.2 连接PostgreSQL配置解析
        
      • 3.7.3 自定义 PostgreSQL 驱动
        
      • 3.7.4 现有的数据库连接PostgreSQL
        
      
      
    • 3.8 连接SQLite
      
      
      
      • 3.8.1 连接SQLite举例
        
      • 3.8.2 连接SQLite配置解析
        
      
      
    • 3.9 连接SQL Server
      
      
      
      • 3.9.1 连接SQL Server举例
        
      • 3.9.2 连接SQL Server配置解析
        
      
      
    • 3.10 连接TiDB
      
      
      
      • 3.10.1 连接TiDB举例
        
      • 3.10.2 连接TiDB配置解析
        
      
      
    • 3.10 连接Clickhouse
      
      
      
      • 3.10.1 连接Clickhouse举例
        
      • 3.10.2 连接Clickhouse配置解析
        
      
      
    
    
  • 四、连接池
    
  • 五、MySQL 其他配置
    
  • 六、加入日志打印sql
    
    
    
    • 6.1 打印日志
      
    • 6.2 日志级别
      
    • 6.3 Debug
      
    • 6.4 具体代码
      
    
    
  • 七、参考文档
    
  
  

一、ORM简介

1.1 什么是ORM

ORM（Object-Relational Mapping）是一种编程技术，它将对象和关系数据库之间的映射抽象出来，使得开发者可以通过面向对象的方式操作数据库，而不用直接处理SQL语句，相当于在业务逻辑层和数据库层之间一座桥梁。在Golang中，有一款优秀的ORM框架叫做Gorm，它提供了强大的功能，使得数据库操作变得更加简单和灵活。
1.2 使用ORM的好处

使用ORM的好处主要包括：
1.2.1 避免直接操作SQL语句

ORM框架可以屏蔽底层数据库的细节，开发者不需要编写复杂的SQL语句，从而降低了开发的难度。
1.2.2 提高代码的可维护性

通过使用ORM，代码变得更加清晰、简洁，易于理解和维护。ORM框架通常提供了模型定义、数据验证等功能，使得开发者可以更专注于业务逻辑。
1.2.3 跨数据库兼容性

ORM框架通常提供了对多种数据库的支持，开发者可以轻松切换数据库而无需修改大量代码。
1.3 使用ORM的缺点

使用ORM也有一些缺点，主要包括：
1.3.1 学习成本

学习使用ORM框架需要一定的时间，尤其是对于初学者来说，需要掌握框架的各种功能和用法。
1.3.2 性能开销

ORM框架可能引入一些性能开销，尤其是在处理大量数据时。开发者需要在性能和开发效率之间做出权衡。
1.4 ORM解析过程

ORM框架的解析过程包括以下步骤：
1.4.1 模型定义

开发者需要定义数据模型，通常是一个结构体，表示数据库中的表结构。
1.4.2 数据验证

ORM框架通常提供了数据验证的功能，确保数据的合法性和完整性。
1.4.3 映射关系

ORM框架会建立数据模型与数据库表之间的映射关系，将结构体的字段与表的列进行对应。
1.4.4 CRUD操作

开发者可以通过ORM框架进行CRUD（Create、Read、Update、Delete）操作，而不用直接编写SQL语句。
1.4.5 SQL生成与执行

最终，ORM框架会根据开发者的操作生成相应的SQL语句，并执行在数据库中。
通过以上步骤，开发者可以使用ORM框架方便地进行数据库操作，提高开发效率。
在接下来的部分，我们将深入学习Gorm框架的使用，从入门到精通。
二、Gorm 介绍与安装

2.1 介绍

Gorm是一款用于Golang的ORM框架，它提供了丰富的功能，包括模型定义、数据验证、关联查询等。Gorm的设计目标是简洁而强大，使得开发者能够更轻松地进行数据库操作。
一些Gorm的特性包括：

• 模型定义和操作：
  
  
  
  • 全功能 ORM
    
  • 关联 (Has One，Has Many，Belongs To，Many To Many，多态，单表继承)
    
  • Create，Save，Update，Delete，Find 中的钩子方法
    
  • 支持 Preload、Joins 的预加载
    
  • 批量插入，FindInBatches，Find/Create with Map，使用 SQL 表达式、Context Valuer 进行 CRUD
    
  • 复合主键，索引，约束
    
  
  
• 事务处理和数据库操作：
  
  
  
  • 事务，嵌套事务，Save Point，Rollback To Saved Point
    
  • Context、预编译模式、DryRun 模式
    
  • SQL 构建器，Upsert，数据库锁，Optimizer/Index/Comment Hint，命名参数，子查询
    
  • Auto Migration
    
  
  
• 其他功能：
  
  
  
  • 自定义 Logger
    
  • 灵活的可扩展插件 API：Database Resolver（多数据库，读写分离）、Prometheus…
    
  • 每个特性都经过了测试的重重考验
    
  • 开发者友好
    
  
  

最新版本2.x，比1.x有较大改动，注意:Gorm最新地址为https://github.com/go-gorm/gorm，之前https://github.com/jinzhu/gorm地址为v1旧版本
2.2 相关文档

• Gorm最新源码地址:https://github.com/go-gorm/gorm
  
• V1版本地址：https://github.com/jinzhu/gorm
  
• 中文文档地址：https://gorm.io/zh_CN/docs/
  

2.3 安装

要使用Gorm，首先需要安装它。可以使用Go的包管理工具go get进行安装：

1. # 安装gorm
2. go get -u gorm.io/gorm
3. # 如果要使用`mysql`， `GORM` 做了二次 封装，安装对应数据库的驱动
4. go get -u gorm.io/driver/mysql

复制代码

安装完成后，可以在项目中引入Gorm：

1. import "gorm.io/gorm"

复制代码

接下来，我们将学习如何连接数据库并开始使用Gorm。
三、Gorm 连接数据库

3.1 快速连接 MySQL

连接MySQL数据库是Gorm的常见用法。以下是一个简单的例子：

1. package main
3. import (
4.         "gorm.io/driver/mysql"
5.         "gorm.io/gorm"
6. )
8. type Product struct {
9.         gorm.Model
10.         Code  string
11.         Price uint
12. }
14. func main() {
15.         dsn := "root:123456@tcp(127.0.0.1:3306)/demo?charset=utf8mb4&parseTime=True&loc=Local"
16.         db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
17.         if err != nil {
18.                 panic("failed to connect database")
19.         }
21.         // 迁移 schema
22.         db.AutoMigrate(&Product{})
24.         // Create
25.         db.Create(&Product{Code: "D42", Price: 100})
27.         // Read
28.         var product Product
29.         db.First(&product, 1)                 // 根据整型主键查找
30.         db.First(&product, "code = ?", "D42") // 查找 code 字段值为 D42 的记录
32.         // Update - 将 product 的 price 更新为 200
33.         db.Model(&product).Update("Price", 200)
34.         // Update - 更新多个字段
35.         db.Model(&product).Updates(Product{Price: 200, Code: "F42"}) // 仅更新非零值字段
36.         db.Model(&product).Updates(map[string]interface{}{"Price": 200, "Code": "F42"})
38.         // Delete - 删除 product
39.         db.Delete(&product, 1)
40. }

复制代码

请注意替换username、password和dbname为你自己的数据库信息。这里使用了MySQL数据库，你也可以根据需要选择其他数据库。
3.2 MySQL数据库配置解析

1. dsn := "username:password@tcp(localhost:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"

复制代码

上述连接字符串（DSN）中的参数有：

• username:password：数据库用户名和密码。
  
• tcp(localhost:3306)：数据库地址和端口。
  
• /dbname：数据库名称。
  
• charset=utf8mb4：设置字符集为UTF-8。
  
• parseTime=True：启用时间解析。
  
• loc=Local：设置时区。
  

你可以根据实际情况调整这些参数。
3.3 自定义 MySQL 驱动

GORM 允许通过 DriverName 选项自定义 MySQL 驱动，例如：

1. package main
3. import (
4.         _ "example.com/my_mysql_driver"
5.         "gorm.io/driver/mysql"
6.         "gorm.io/gorm"
7. )
9. func main() {
10.         db, err := gorm.Open(mysql.New(mysql.Config{
11.                 DriverName: "my_mysql_driver",
12.                 DSN:        "gorm:gorm@tcp(localhost:9910)/gorm?charset=utf8&parseTime=True&loc=Local", // data source name, 详情参考：https://github.com/go-sql-driver/mysql#dsn-data-source-name
13.         }), &gorm.Config{})
14. }

复制代码

3.4 现有的数据库连接mysql

GORM 允许通过一个现有的数据库连接来初始化 *gorm.DB

1. import (
2.         "database/sql"
3.         "gorm.io/driver/mysql"
4.         "gorm.io/gorm"
5. )
7. func main() {
8.         sqlDB, err := sql.Open("mysql", "mydb_dsn")
9.         gormDB, err := gorm.Open(mysql.New(mysql.Config{
10.                 Conn: sqlDB,
11.         }), &gorm.Config{})
12. }

复制代码

3.5 切换数据库驱动

Gorm支持多种数据库，你可以根据需要选择不同的数据库驱动。上面的例子中我们使用了MySQL的驱动，如果要连接其他数据库，只需更改导入的数据库驱动即可。
例如，如果要连接SQLite数据库，可以使用以下驱动：

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

复制代码

然后在gorm.Open()中使用sqlite.Open()。
3.6 编写新驱动

GORM 官方支持的数据库类型有：MySQL, PostgreSQL, SQLite, SQL Server 和 TiDB
有些数据库可能兼容 mysql、postgres 的方言，在这种情况下，你可以直接使用这些数据库的方言。
对于其它不兼容的情况，您可以自行编写一个新驱动，这需要实现 方言接口。
参考官网文档：【编写新驱动】
3.7 连接PostgreSQL

3.7.1 连接PostgreSQ举例

1. package main
3. import (
4.         "gorm.io/driver/postgres"
5.         "gorm.io/gorm"
6. )
8. type User struct {
9.         gorm.Model
10.         Name string
11.         Age  int
12. }
14. func main() {
15.         dsn := "host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai"
16.         db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
17.         if err != nil {
18.                 panic("failed to connect database")
19.         }
20.         defer db.DB()
22.         // Migrate the schema
23.         db.AutoMigrate(&User{})
24. }

复制代码

我们使用 pgx 作为 postgres 的 database/sql 驱动，默认情况下，它会启用 prepared statement 缓存，你可以这样禁用它：

1. // https://github.com/go-gorm/postgres
2. db, err := gorm.Open(postgres.New(postgres.Config{
3.   DSN: "user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai",
4.   PreferSimpleProtocol: true, // disables implicit prepared statement usage
5. }), &gorm.Config{})

复制代码

3.7.2 连接PostgreSQL配置解析

1. dsn := "host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai"

复制代码

上述示例中的 DSN 解析如下：

• user=gorm：数据库用户名。
  
• password=gorm：数据库密码。
  
• dbname=gorm：数据库名称。
  
• port=9920：数据库连接端口。
  
• sslmode=disable：禁用 SSL 模式。
  
• TimeZone=Asia/Shanghai：设置时区。
  

根据实际情况，你需要替换这些值为你的 PostgreSQL 数据库连接信息。
3.7.3 自定义 PostgreSQL 驱动

GORM 允许通过 DriverName 选项自定义 PostgreSQL 驱动，例如：

1. import (
2.   _ "github.com/GoogleCloudPlatform/cloudsql-proxy/proxy/dialers/postgres"
3.   "gorm.io/gorm"
4. )
6. db, err := gorm.Open(postgres.New(postgres.Config{
7.   DriverName: "cloudsqlpostgres",
8.   DSN: "host=project:region:instance user=postgres dbname=postgres password=password sslmode=disable",
9. })

复制代码

3.7.4 现有的数据库连接PostgreSQL

GORM 允许通过一个现有的数据库连接来初始化 *gorm.DB

1. import (
2.   "database/sql"
3.   "gorm.io/driver/postgres"
4.   "gorm.io/gorm"
5. )
7. sqlDB, err := sql.Open("pgx", "mydb_dsn")
8. gormDB, err := gorm.Open(postgres.New(postgres.Config{
9.   Conn: sqlDB,
10. }), &gorm.Config{})

复制代码

3.8 连接SQLite

3.8.1 连接SQLite举例

1. package main
3. import (
4.         "gorm.io/driver/sqlite"
5.         "gorm.io/gorm"
6. )
8. type Product struct {
9.         gorm.Model
10.         Code  string
11.         Price uint
12. }
14. func main() {
15.         dsn := "test.db" // SQLite数据库文件路径
16.         db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
17.         if err != nil {
18.                 panic("failed to connect database")
19.         }
20.         defer db.DB()
22.         // 迁移 schema
23.         db.AutoMigrate(&Product{})
25.         // 创建记录
26.         db.Create(&Product{Code: "D42", Price: 100})
28.         // 查询记录
29.         var product Product
30.         db.First(&product, 1)
31.         db.First(&product, "code = ?", "D42")
33.         // 更新记录
34.         db.Model(&product).Update("Price", 200)
35.         db.Model(&product).Updates(Product{Price: 200, Code: "F42"})
36.         db.Model(&product).Updates(map[string]interface{}{"Price": 200, "Code": "F42"})
38.         // 删除记录
39.         db.Delete(&product, 1)
40. }

复制代码

3.8.2 连接SQLite配置解析

1. dsn := "test.db"

复制代码

上述示例中的 test.db 是 SQLite 数据库文件的路径。你可以根据实际情况调整文件路径。
3.9 连接SQL Server

3.9.1 连接SQL Server举例

1. package main
3. import (
4.         "gorm.io/driver/sqlserver"
5.         "gorm.io/gorm"
6. )
7. type Product struct {
8.         gorm.Model
9.         Code  string
10.         Price uint
11. }
13. func main() {
14.         dsn := "sqlserver://gorm:LoremIpsum86@localhost:9930?database=gorm"
15.         db, err := gorm.Open(sqlserver.Open(dsn), &gorm.Config{})
16.         if err != nil {
17.                 panic("failed to connect database")
18.         }
19.         defer db.DB()
21.         // 迁移 schema
22.         db.AutoMigrate(&Product{})
24.         // 创建记录
25.         db.Create(&Product{Code: "D42", Price: 100})
27.         // 查询记录
28.         var product Product
29.         db.First(&product, 1)
30.         db.First(&product, "code = ?", "D42")
32.         // 更新记录
33.         db.Model(&product).Update("Price", 200)
34.         db.Model(&product).Updates(Product{Price: 200, Code: "F42"})
35.         db.Model(&product).Updates(map[string]interface{}{"Price": 200, "Code": "F42"})
37.         // 删除记录
38.         db.Delete(&product, 1)
39. }

复制代码

3.9.2 连接SQL Server配置解析

1. dsn := "sqlserver://gorm:LoremIpsum86@localhost:9930?database=gorm"

复制代码

上述示例中的 DSN 解析如下：

• gormoremIpsum86：用户名和密码。
  
• localhost:9930：数据库服务器地址和端口。
  
• database=gorm：数据库名称。
  

3.10 连接TiDB

3.10.1 连接TiDB举例

iDB 兼容 MySQL 协议。 因此你可以按照 MySQL 一节来创建与 TiDB 的连接。
在使用 TiDB 时有一些值得注意的内容：

• 您可以在结构体中使用 gorm:"primaryKey;default:auto_random()" 标签从而调用 TiDB 的 AUTO_RANDOM 功能。
  
• TiDB supported SAVEPOINT from v6.2.0, please notice the version of TiDB when you use this feature.
  
• TiDB supported FOREIGN KEY from v6.6.0, please notice the version of TiDB when you use this feature.
  

1. package main
3. import (
4.         "fmt"
5.         "gorm.io/driver/mysql"
6.         "gorm.io/gorm"
7. )
9. type Product struct {
10.         ID    uint `gorm:"primaryKey;default:auto_random()"`
11.         Code  string
12.         Price uint
13. }
15. func main() {
16.         dsn := "root:@tcp(127.0.0.1:4000)/test"
17.         db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
18.         if err != nil {
19.                 panic("failed to connect database")
20.         }
22.         db.AutoMigrate(&Product{})
24.         insertProduct := &Product{Code: "D42", Price: 100}
26.         db.Create(insertProduct)
27.         fmt.Printf("insert ID: %d, Code: %s, Price: %d\n",
28.                 insertProduct.ID, insertProduct.Code, insertProduct.Price)
30.         readProduct := &Product{}
31.         db.First(&readProduct, "code = ?", "D42") // find product with code D42
33.         fmt.Printf("read ID: %d, Code: %s, Price: %d\n",
34.                 readProduct.ID, readProduct.Code, readProduct.Price)
35. }

复制代码

3.10.2 连接TiDB配置解析

1. dsn := "root:@tcp(127.0.0.1:4000)/test"

复制代码

• root: 数据库用户名。在这里，用户名是 "root"。
  
• @: 分隔用户名和密码的分隔符。
  
• "": 数据库密码。在这里，密码是空字符串，表示没有密码。
  
• tcp(127.0.0.1:4000): 数据库服务器的地址和端口。在这里，MySQL 服务器位于本地主机（127.0.0.1），端口是 4000。
  
• /test: 数据库名称。在这里，数据库名是 "test"。
  

3.10 连接Clickhouse

3.10.1 连接Clickhouse举例

1. package main
3. import (
4.         "gorm.io/driver/clickhouse"
5.         "gorm.io/gorm"
6. )
8. type User struct {
9.         gorm.Model
10.         Name string
11.         Age  int
12. }
14. func main() {
15.         dsn := "tcp://localhost:9000?database=gorm&username=gorm&password=gorm&read_timeout=10&write_timeout=20"
16.         db, err := gorm.Open(clickhouse.Open(dsn), &gorm.Config{})
17.         if err != nil {
18.                 panic("failed to connect database")
19.         }
21.         // 自动迁移 (这是GORM自动创建表的一种方式--译者注)
22.         db.AutoMigrate(&User{})
23.         // 设置表选项
24.         db.Set("gorm:table_options", "ENGINE=Distributed(cluster, default, hits)").AutoMigrate(&User{})
26.         // 插入
27.         db.Create(&user)
29.         // 查询
30.         db.Find(&user, "id = ?", 10)
32.         // 批量插入
33.         var users = []User{user1, user2, user3}
34.         db.Create(&users)
35.         // ...
36. }

复制代码

3.10.2 连接Clickhouse配置解析

1. dsn := "tcp://localhost:9000?database=gorm&username=gorm&password=gorm&read_timeout=10&write_timeout=20"

复制代码

上述示例中的 DSN 解析如下：

• tcp://localhost:9000: ClickHouse 服务器的地址和端口。在这里，ClickHouse 服务器位于本地主机（localhost），端口是 9000。这是 ClickHouse 的默认端口。
  
• ?: 连接参数的起始标志。
  
• database=gorm: 数据库名称。在这里，数据库名是 "gorm"。
  
• username=gorm: 数据库用户名。在这里，用户名是 "gorm"。
  
• password=gorm: 数据库密码。在这里，密码是 "gorm"。
  
• read_timeout=10: 读取超时时间。在这里，设置为 10 秒。
  
• write_timeout=20: 写入超时时间。在这里，设置为 20 秒。
  

你需要根据实际情况替换这些值。
四、连接池

GORM 使用 database/sql 来维护连接池

1. sqlDB, err := db.DB()
3. // SetMaxIdleConns sets the maximum number of connections in the idle connection pool.
4. sqlDB.SetMaxIdleConns(10)
6. // SetMaxOpenConns sets the maximum number of open connections to the database.
7. sqlDB.SetMaxOpenConns(100)
9. // SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
10. sqlDB.SetConnMaxLifetime(time.Hour)

复制代码

五、MySQL 其他配置

注意：想要正确的处理 time.Time ，您需要带上 parseTime 参数， (更多参数) 要支持完整的 UTF-8 编码，您需要将 charset=utf8 更改为 charset=utf8mb4 查看 此文章 获取详情

MySQl 驱动程序提供了 一些高级配置 可以在初始化过程中使用，例如：

1. db, err := gorm.Open(mysql.New(mysql.Config{
2.   DSN: "gorm:gorm@tcp(127.0.0.1:3306)/gorm?charset=utf8&parseTime=True&loc=Local", // DSN data source name
3.   DefaultStringSize: 256, // string 类型字段的默认长度
4.   DisableDatetimePrecision: true, // 禁用 datetime 精度，MySQL 5.6 之前的数据库不支持
5.   DontSupportRenameIndex: true, // 重命名索引时采用删除并新建的方式，MySQL 5.7 之前的数据库和 MariaDB 不支持重命名索引
6.   DontSupportRenameColumn: true, // 用 `change` 重命名列，MySQL 8 之前的数据库和 MariaDB 不支持重命名列
7.   SkipInitializeWithVersion: false, // 根据当前 MySQL 版本自动配置
8. }), &gorm.Config{})

复制代码

六、加入日志打印sql

6.1 打印日志

Gorm 有一个 默认 logger 实现，默认情况下，它会打印慢 SQL 和错误
Logger 接受的选项不多，您可以在初始化时自定义它，例如：

1. newLogger := logger.New(
2.   log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer（日志输出的目标，前缀和日志包含的内容——译者注）
3.   logger.Config{
4.     SlowThreshold: time.Second,   // 慢 SQL 阈值
5.     LogLevel:      logger.Silent, // 日志级别
6.     IgnoreRecordNotFoundError: true,   // 忽略ErrRecordNotFound（记录未找到）错误
7.     Colorful:      false,         // 禁用彩色打印
8.   },
9. )
11. // 全局模式
12. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{
13.   Logger: newLogger,
14. })
16. // 新建会话模式
17. tx := db.Session(&Session{Logger: newLogger})
18. tx.First(&user)
19. tx.Model(&user).Update("Age", 18)

复制代码

6.2 日志级别

GORM 定义了这些日志级别：Silent、Error、Warn、Info

1. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{
2.   Logger: logger.Default.LogMode(logger.Silent),
3. })

复制代码

6.3 Debug

Debug 单个操作，将当前操作的 log 级别调整为 logger.Info

1. db.Debug().Where("name = ?", "jinzhu").First(&User{})

复制代码

6.4 具体代码

1. package main
3. import (
4.         "gorm.io/driver/mysql"
5.         "gorm.io/gorm"
6.         "gorm.io/gorm/logger"
7.         "log"
8.         "os"
9.         "time"
10. )
12. type  User struct {
13.         ID int
14. }
15. func main() {
16.         // 日志配置
17.         newLogger := logger.New(
18.                 log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer（日志输出的目标，前缀和日志包含的内容——译者注）
19.                 logger.Config{
20.                         SlowThreshold:             time.Second, // 慢 SQL 阈值
21.                         LogLevel:                  logger.Info, // 日志级别为info
22.                         IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
23.                         Colorful:                  true,        // 彩色打印
24.                 },
25.         )
27.         dsn := "root:123@tcp(127.0.0.1:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
28.         db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
29.                 Logger: newLogger,
30.         })
31.         if err != nil {
32.                 panic(err) // 如果数据库不存在会报错
33.         }
34.         db.AutoMigrate(&User{})
35. }

复制代码

七、参考文档

• GORM 官网文档： https://gorm.io/zh_CN/docs/models.html
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4