gorm 基础示例

本篇文档将指导你如何使用 golang 和 gorm 构建一个简单的应用程序，并实现 CRUD（创建、读取、更新、删除）功能。

Gorm 是 Golang 语言中最流行的 ORM 工具之一。

开始前准备

相关软件的简单介绍：

  • Gorm：基于 golang 的一个神奇的全功能 ORM 库，本次教程主要通过使用 gorm.io/gorm 和 gorm.io/driver/mysql 这两个库来让 Go 连接到 MatrixOne 数据库并完成 CRUD 操作。

环境配置

在你开始之前，确认你已经下载并安装了如下软件：

  • 确认你已完成单机部署 MatrixOne。通过 MySQL 客户端连接 MatrixOne 并创建一个命名为 test 的数据库：
  1. mysql> create database test;
  1. #To check with Golang installation and its version
  2. go version

  • 确认你已完成安装 MySQL 客户端。

  • 确认你已经安装 gorm.io/gorm 以及 gorm.io/driver/mysql，使用 go get 命令安装，代码如下：

  1. go get -u gorm.io/gorm
  2. go get -u gorm.io/driver/mysql

你可以参考 Golang 连接 MatrixOne 服务了解如何通过 Gorm 连接到 MatrixOne，本篇文档将指导你如何实现 CRUD（创建、读取、更新、删除）。

新建表

作为对象关系映射器（ORM）工具，Gorm 允许开发人员创建 GO 类来映射关系数据库中的表。 在下面的代码示例中，将创建一个 USER 类，这里的类名和属性名称必须使用大写英文开头以保证 public 访问，否则不能创建。USER 类在 GORM 的作用下将转化为一条 SQL 语句，创建表名为 users 的表。 新建一个 gorm_create.go 的文本文件，将以下代码拷贝粘贴到文件内：

  1. package main
  2. import (
  3.     "fmt"
  5.     "gorm.io/driver/mysql"
  6.     "gorm.io/gorm"
  7.     "gorm.io/gorm/logger"
  8. )
  9. // user model
  10. type USER struct {
  11.     ID       uint `gorm:"primaryKey"`
  12.     CNAME    string
  13.     CADDRESS string
  14. }
  16. func getDBConn() *gorm.DB {
  17.     dsn := "root:111@tcp(127.0.0.1:6001)/test?charset=utf8mb4&parseTime=True&loc=Local" //MO
  18.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  19.     // Logger: logger.Default.LogMode(logger.Info), //print SQL
  20.   })
  21.     // get connection
  22.     if err != nil {
  23.         fmt.Println("Database Connection Failed") //Connection failed
  24.     } else {
  25.         fmt.Println("Database Connection Succeed") //Connection succeed
  26.     }
  27.     return db
  28. }
  30. func main() {
  31.     //get *gorm.DB
  32.     db := getDBConn()
  34.     // auto create table
  35.     db.AutoMigrate(&USER{})
  36. }

你可以取消注释 Logger: logger.Default.LogMode(logger.Info) 以把转化后的 SQL 输出出来。 打开终端，使用以下代码运行此 go 文件：

  1. go run gorm_create.go

你可以使用 MySQL 客户端验证表是否创建成功：

  1. mysql> show tables;
  2. +----------------+
  3. | Tables_in_test |
  4. +----------------+
  5. | users          |
  6. +----------------+
  7. 1 row in set (0.01 sec)

插入数据

下面的演示中，将指导你在刚刚创建的 users 表中插入两条数据记录，这里的 ID 默认是自增的，也可以指定为固定的值。 新建一个 gorm_insert.go 的文本文件，将以下代码拷贝粘贴到文件内：

  1. package main
  2. import (
  3.     "fmt"
  5.     "gorm.io/driver/mysql"
  6.     "gorm.io/gorm"
  7.     "gorm.io/gorm/logger"
  8. )
  9. // user model
  10. type USER struct {
  11.     ID       uint `gorm:"primaryKey"`
  12.     CNAME    string
  13.     CADDRESS string
  14. }
  16. func getDBConn() *gorm.DB {
  17.     dsn := "root:111@tcp(127.0.0.1:6001)/test?charset=utf8mb4&parseTime=True&loc=Local" //MO
  18.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  19.     // get connection
  20.     if err != nil {
  21.         fmt.Println("Database Connection Failed") //Connection failed
  22.     } else {
  23.         fmt.Println("Database Connection Succeed") //Connection succeed
  24.     }
  25.     return db
  26. }
  28. func main() {
  29.     //get *gorm.DB
  30.     db := getDBConn()
  32.     // auto create table
  33.     db.AutoMigrate(&USER{})
  35.   // **Insert users**
  36.     users := []USER{
  37.         {
  38.             // ID: 1, //autoincrement
  39.             CNAME:    "lili",
  40.             CADDRESS: "Shanghai"},
  41.         {
  42.             ID:       111,
  43.             CNAME:    "zhang",
  44.             CADDRESS: "Biejing",
  45.         },
  46.     }
  48.     db.Create(users)
  50. }

打开终端，使用以下代码运行此 go 文件：

  1. go run gorm_insert.go

同样的，终端也会输出 SQL 语句，你可以使用 MySQL 客户端验证表是否成功插入数据：

  1. mysql> select * from users;
  2. +------+-------+----------+
  3. | id   | cname | caddress |
  4. +------+-------+----------+
  5. |    1 | lili  | Shanghai |
  6. |  111 | zhang | Biejing  |
  7. +------+-------+----------+
  8. 2 rows in set (0.01 sec)

查询数据

下面的演示中，将指导你用条件查询部分数据，查询 CNAME=zhang 的数据。 新建一个 gorm_query.go 的文本文件，将以下代码拷贝粘贴到文件内：

  1. package main
  2. import (
  3.     "fmt"
  5.     "gorm.io/driver/mysql"
  6.     "gorm.io/gorm"
  7.     "gorm.io/gorm/logger"
  8. )
  9. // user model
  10. type USER struct {
  11.     ID       uint `gorm:"primaryKey"`
  12.     CNAME    string
  13.     CADDRESS string
  14. }
  16. func getDBConn() *gorm.DB {
  17.     dsn := "root:111@tcp(127.0.0.1:6001)/test?charset=utf8mb4&parseTime=True&loc=Local" //MO
  18.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  19.     // get connection
  20.     if err != nil {
  21.         fmt.Println("Database Connection Failed") //Connection failed
  22.     } else {
  23.         fmt.Println("Database Connection Succeed") //Connection succeed
  24.     }
  25.     return db
  26. }
  28. func main() {
  29.     //get *gorm.DB
  30.     db := getDBConn()
  32.     // auto create table
  33.     db.AutoMigrate(&USER{})
  35.   // **Query—— String condition** 
  36.     res := USER{}
  37.     tx := db.Where("CNAME = ? ", "zhang").Find(&USER{}).Scan(&res)
  38.     if tx.Error != nil {
  39.         fmt.Println(tx.Error)
  40.         return
  41.     }
  42.     fmt.Println(res)
  44. }

打开终端，使用以下代码运行此 go 文件：

  1. go run gorm_query.go

终端的输出结果中将包含以下数据：

  1. {111 zhang Biejing}

更新数据

下面的演示中，将指导你如何更新数据。 新建一个 gorm_update.go 的文本文件，将以下代码拷贝粘贴到文件内：

  1. package main
  2. import (
  3.     "fmt"
  5.     "gorm.io/driver/mysql"
  6.     "gorm.io/gorm"
  7.     "gorm.io/gorm/logger"
  8. )
  9. // user model
  10. type USER struct {
  11.     ID       uint `gorm:"primaryKey"`
  12.     CNAME    string
  13.     CADDRESS string
  14. }
  16. func getDBConn() *gorm.DB {
  17.     dsn := "root:111@tcp(127.0.0.1:6001)/test?charset=utf8mb4&parseTime=True&loc=Local" //MO
  18.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  19.     // get connection
  20.     if err != nil {
  21.         fmt.Println("Database Connection Failed") //Connection failed
  22.     } else {
  23.         fmt.Println("Database Connection Succeed") //Connection succeed
  24.     }
  25.     return db
  26. }
  28. func main() {
  29.     //get *gorm.DB
  30.     db := getDBConn()
  32.     // auto create table
  33.     db.AutoMigrate(&USER{})
  35.   // **Update** 
  36.     aUser := USER{}
  37.     tx := db.Where("CNAME = ? ", "zhang").Find(&USER{}).Scan(&aUser)
  38.     if tx.Error != nil {
  39.         fmt.Println(tx.Error)
  40.         return
  41.     }
  42.     res:=db.Model(&aUser).Update("CADDRESS", "HongKong")
  43.   if res.Error != nil {
  44.         fmt.Println(tx.Error)
  45.         return
  46.     }
  48. }

打开终端，使用以下代码运行此 go 文件：

  1. go run gorm_update.go

你可以使用 MySQL 客户端验证表是否更新成功：

  1. mysql> select * from users;
  2. +------+-------+----------+
  3. | id   | cname | caddress |
  4. +------+-------+----------+
  5. |  111 | zhang | HongKong |
  6. |    1 | lili  | Shanghai |
  7. +------+-------+----------+
  8. 2 rows in set (0.00 sec)

删除数据

下面的演示中，将指导你如何进行单条数据的删除。需要注意的是，在删除单条记录时，需要指定主键，否则可能会触发批量删除。 新建一个 gorm_delete.go 的文本文件，将以下代码拷贝粘贴到文件内：

  1. package main
  2. import (
  3.     "fmt"
  5.     "gorm.io/driver/mysql"
  6.     "gorm.io/gorm"
  7.     "gorm.io/gorm/logger"
  8. )
  9. // user model
  10. type USER struct {
  11.     ID       uint `gorm:"primaryKey"`
  12.     CNAME    string
  13.     CADDRESS string
  14. }
  16. func getDBConn() *gorm.DB {
  17.     dsn := "root:111@tcp(127.0.0.1:6001)/test?charset=utf8mb4&parseTime=True&loc=Local" //MO
  18.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
  19.     // get connection
  20.     if err != nil {
  21.         fmt.Println("Database Connection Failed") //Connection failed
  22.     } else {
  23.         fmt.Println("Database Connection Succeed") //Connection succeed
  24.     }
  25.     return db
  26. }
  28. func main() {
  29.     //get *gorm.DB
  30.     db := getDBConn()
  32.     // auto create table
  33.     db.AutoMigrate(&USER{})
  35.   // **Delete** 
  36.     aUser := USER{}
  37.     tx := db.Where("CNAME = ? ", "zhang").Find(&USER{}).Scan(&aUser)
  38.     if tx.Error != nil {
  39.         fmt.Println(tx.Error)
  40.         return
  41.     }
  42.     res := db.Delete(&aUser)
  43.     if res.Error != nil {
  44.         fmt.Println(tx.Error)
  45.         return
  46.     }
  48. }

打开终端，使用以下代码运行此 go 文件：

  1. go run gorm_delete.go

你可以使用 MySQL 客户端验证表是否删除成功：

  1. mysql> select * from users;
  2. +------+-------+----------+
  3. | id   | cname | caddress |
  4. +------+-------+----------+
  5. |    1 | lili  | Shanghai |
  6. +------+-------+----------+
  7. 1 row in set (0.00 sec)

以上仅是 GORM 中 CRUD 操作的部分演示，更多的用法和案例可以参考 GORM 官方指南