链接：https://gorm.io/zh_CN/docs/connecting_to_the_database.html

快速入门

image.png
image.png
image.png
使用gorm之前必须要建立一个数据库。gorm只能操作表。
导入gorm包的时候要导入mysql包，因为MySQL包导入时init函数自动运行驱动。

  1. package main
  3. import (
  4.     "database/sql"
  5.     "log"
  6.     "os"
  7.     "time"
  9.     "gorm.io/driver/mysql"//源码的init函数会执行MySQL驱动
  10.     "gorm.io/gorm"
  11.     "gorm.io/gorm/logger"
  12. )
  14. type Product struct {
  15.     gorm.Model
  16.     Code  sql.NullString
  17.     Price uint
  18. }
  20. func main() {
  21.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  22.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  23.     //设置全局的logger，这个logger在我们执行每个sql语句的时候会打印每一行sql
  24.     //sql才是最重要的，本着这个原则我尽量的给大家看到每个api背后的sql语句是什么
  25.     newLogger := logger.New(
  26.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  27.         logger.Config{
  28.             SlowThreshold: time.Second,   // 慢 SQL 阈值
  29.             LogLevel:      logger.Info, // Log level
  30.             Colorful:      true,         // 禁用彩色打印
  31.         },
  32.     )
  34.     // 全局模式，提前建立数据库gorm_test
  35.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  36.         Logger: newLogger,
  37.     })
  38.     if err != nil {
  39.         panic(err)
  40.     }
  41.     //定义一个表结构， 将表结构直接生成对应的表 - migrations
  42.     // 迁移 schema
  43.     _ = db.AutoMigrate(&Product{}) //此处应该有sql语句
  45.     // 新增
  46.     db.Create(&Product{Code: sql.NullString{"D42", true}, Price: 100})
  48.     // Read
  49.     var product Product
  50.     db.First(&product, 1) // 根据整形主键查找
  51.     db.First(&product, "code = ?", "D42") // 查找 code 字段值为 D42 的记录
  53.     // Update - 将 product 的 price 更新为 200
  54.     db.Model(&product).Update("Price", 200)
  55.     // Update - 更新多个字段
  56.     db.Model(&product).Updates(Product{Price: 200, Code:sql.NullString{"", true}}) // 仅更新非零值字段
  57.     //如果我们去更新一个product 只设置了price：200
  58.     //db.Model(&product).Updates(map[string]interface{}{"Price": 200, "Code": "F42"})
  60.     // Delete - 删除 product， 并没有执行delete语句，逻辑删除
  61.     db.Delete(&product, 1)
  62. }

没放logger之前image.png

  1. package main
  3. import (
  4.     "log"
  5.     "os"
  6.     "time"
  8.     "gorm.io/driver/mysql"
  9.     "gorm.io/gorm"
  10.     "gorm.io/gorm/logger"
  11. )
  13. type User struct {
  14.     UserID        uint `gorm:"primarykey"`
  15.     Name string `gorm:"column:user_name;type:varchar(50);index:idx_user_name;unique;default:'bobby'"`
  16. }
  18. func main() {
  19.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  20.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  22.     newLogger := logger.New(
  23.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  24.         logger.Config{
  25.             SlowThreshold: time.Second,   // 慢 SQL 阈值
  26.             LogLevel:      logger.Info, // Log level
  27.             Colorful:      true,         // 禁用彩色打印
  28.         },
  29.     )
  31.     // 全局模式
  32.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  33.         Logger: newLogger,
  34.     })
  35.     if err != nil {
  36.         panic(err)
  37.     }
  38.     _ = db.AutoMigrate(&User{}) //此处应该有sql语句
  40.     db.Create(&User{})
  42. }

通过creat插入记录

  1. package main
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "log"
  7.     "os"
  8.     "time"
  10.     "gorm.io/driver/mysql"
  11.     "gorm.io/gorm"
  12.     "gorm.io/gorm/logger"
  13. )
  15. type User struct {
  16.     ID           uint
  17.     Name         string
  18.     Email        *string
  19.     Age          uint8
  20.     Birthday     *time.Time
  21.     MemberNumber sql.NullString
  22.     ActivedAt    sql.NullTime
  23.     CreatedAt    time.Time
  24.     UpdatedAt    time.Time
  25. }
  27. func main() {
  28.     a := []int{1,2,3}
  29.     b := a[:]
  30.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  31.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  33.     newLogger := logger.New(
  34.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  35.         logger.Config{
  36.             SlowThreshold: time.Second,   // 慢 SQL 阈值
  37.             LogLevel:      logger.Info, // Log level
  38.             Colorful:      true,         // 禁用彩色打印
  39.         },
  40.     )
  42.     // 全局模式
  43.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  44.         Logger: newLogger,
  45.     })
  46.     if err != nil {
  47.         panic(err)
  48.     }
  49.     _ = db.AutoMigrate(&User{}) //此处应该有sql语句
  50.     user := User{
  51.         Name : "bobby2",
  52.     }
  53.     fmt.Println(user.ID)
  54.     result := db.Create(&user)
  55.     fmt.Println(user.ID)             // 返回插入数据的主键
  56.     fmt.Println(result.Error)        // 返回 error
  57.     fmt.Println(result.RowsAffected) // 返回插入记录的条数
  58.     //db.Model(&User{ID:1}).Update("Name", "")
  59.     //updates语句不会更新零值，但是update语句会更新
  60.     //empty := ""
  61.     //db.Model(&User{ID:1}).Updates(User{Email: &empty})
  62.     //解决仅更新非零值字段的方法有两种
  63.     /*
  64.     1. 将string 设置为 *string
  65.     2. 使用sql的NULLxxx来解决
  66.      */
  68. }
  1. package main
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "log"
  7.     "os"
  8.     "time"
  10.     "gorm.io/driver/mysql"
  11.     "gorm.io/gorm"
  12.     "gorm.io/gorm/logger"
  13. )
  15. type User struct {
  16.     ID           uint
  17.     Name         string
  18.     Email        *string
  19.     Age          uint8
  20.     Birthday     *time.Time
  21.     MemberNumber sql.NullString
  22.     ActivedAt    sql.NullTime
  23.     CreatedAt    time.Time
  24.     UpdatedAt    time.Time
  25. }
  27. func main() {
  28.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  29.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  31.     newLogger := logger.New(
  32.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  33.         logger.Config{
  34.             SlowThreshold: time.Second,   // 慢 SQL 阈值
  35.             LogLevel:      logger.Info, // Log level
  36.             Colorful:      true,         // 禁用彩色打印
  37.         },
  38.     )
  40.     // 全局模式
  41.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  42.         Logger: newLogger,
  43.     })
  44.     if err != nil {
  45.         panic(err)
  46.     }
  48.     //单一的 SQL 语句
  49.     var users = []User{{Name: "bobby1"}, {Name: "bobby2"}, {Name: "bobby3"}}
  50.     //db.Create(&users)
  52.     //为什么不一次性提交所有的 还要分批次，因为sql语句有长度限制
  53.     db.CreateInBatches(users, 10000)//这里的10000指的是一次提交10000个sql语句
  55.     for _, user := range users {
  56.         fmt.Println(user.ID) // 1,2,3
  57.     }
  59.     db.Model(&User{}).Create(map[string]interface{}{
  60.         "Name": "jinzhu", "Age": 18,
  61.     })
  62. }

image.png
image.png

  1. package main
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "log"
  7.     "os"
  8.     "time"
  10.     "gorm.io/driver/mysql"
  11.     "gorm.io/gorm"
  12.     "gorm.io/gorm/logger"
  13. )
  15. type User struct {
  16.     ID           uint
  17.     Name         string
  18.     Email        *string
  19.     Age          uint8
  20.     Birthday     *time.Time
  21.     MemberNumber sql.NullString
  22.     ActivedAt    sql.NullTime
  23.     CreatedAt    time.Time
  24.     UpdatedAt    time.Time
  25. }
  27. func main() {
  28.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  29.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  31.     newLogger := logger.New(
  32.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  33.         logger.Config{
  34.             SlowThreshold: time.Second, // 慢 SQL 阈值
  35.             LogLevel:      logger.Info, // Log level
  36.             Colorful:      true,        // 禁用彩色打印
  37.         },
  38.     )
  40.     // 全局模式
  41.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  42.         Logger: newLogger,
  43.     })
  44.     if err != nil {
  45.         panic(err)
  46.     }
  48.     //通过first查询单个数据, 获取第一条记录（主键升序）
  49.     //var user User
  50.     //db.First(&user)
  53.     //通过主键查询
  54.     //我们不能给user赋值
  55.     //result := db.First(&user, []int{1,2,3})
  56.     //if errors.Is(result.Error, gorm.ErrRecordNotFound){
  57.     //    fmt.Println("未找到")
  58.     //}
  59.     //fmt.Println(user.ID)
  61.     //检索全部对象
  62.     var users []User
  63.     result := db.Find(&users)
  64.     fmt.Println("总共记录:", result.RowsAffected)
  65.     for _, user := range users{
  66.         fmt.Println(user.ID)
  67.     }
  68. }

image.png
image.png

  1. package main
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "log"
  7.     "math/rand"
  8.     "os"
  9.     "time"
  11.     "gorm.io/driver/mysql"
  12.     "gorm.io/gorm"
  13.     "gorm.io/gorm/logger"
  14. )
  16. type User struct {
  17.     ID           uint
  18.     MyName         string `gorm:"column:name"`
  19.     Email        *string
  20.     Age          uint8
  21.     Birthday     *time.Time
  22.     MemberNumber sql.NullString
  23.     ActivedAt    sql.NullTime
  24.     CreatedAt    time.Time
  25.     UpdatedAt    time.Time
  26. }
  28. type BaseModel struct {
  29.     ID int32 `gorm:"primarykey;type:int" json:"id"` //为什么使用int32， bigint
  30.     CreatedAt time.Time `gorm:"column:add_time" json:"-"`
  31.     UpdatedAt time.Time `gorm:"column:update_time" json:"-"`
  32.     DeletedAt gorm.DeletedAt `json:"-"`
  33.     IsDeleted bool `json:"-"`
  34. }
  36. type OrderInfo struct{
  37.     BaseModel
  39.     User int32 `gorm:"type:int;index"`
  40.     OrderSn string `gorm:"type:varchar(30);index"` //订单号，我们平台自己生成的订单号
  41.     PayType string `gorm:"type:varchar(20) comment 'alipay(支付宝)， wechat(微信)'"`
  43.     //status大家可以考虑使用iota来做
  44.     Status string `gorm:"type:varchar(20)  comment 'PAYING(待支付), TRADE_SUCCESS(成功)， TRADE_CLOSED(超时关闭), WAIT_BUYER_PAY(交易创建), TRADE_FINISHED(交易结束)'"`
  45.     TradeNo string `gorm:"type:varchar(100) comment '交易号'"` //交易号就是支付宝的订单号 查账
  46.     OrderMount float32
  47.     PayTime *time.Time `gorm:"type:datetime"`
  49.     Address string `gorm:"type:varchar(100)"`
  50.     SignerName string `gorm:"type:varchar(20)"`
  51.     SingerMobile string `gorm:"type:varchar(11)"`
  52.     Post string `gorm:"type:varchar(20)"`
  53. }
  55. type OrderGoods struct{
  56.     BaseModel
  58.     Order int32 `gorm:"type:int;index"`
  59.     Goods int32 `gorm:"type:int;index"`
  61.     //把商品的信息保存下来了 ， 字段冗余， 高并发系统中我们一般都不会遵循三范式  做镜像 记录
  62.     GoodsName string `gorm:"type:varchar(100);index"`
  63.     GoodsImage string `gorm:"type:varchar(200)"`
  64.     GoodsPrice float32
  65.     Nums int32 `gorm:"type:int"`
  66. }
  68. func GenerateOrderSn(userId int32) string{
  69.     //订单号的生成规则
  70.     /*
  71.         年月日时分秒+用户id+2位随机数
  72.     */
  73.     now := time.Now()
  74.     rand.Seed(time.Now().UnixNano())
  75.     orderSn := fmt.Sprintf("%d%d%d%d%d%d%d%d",
  76.         now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Nanosecond(),
  77.         userId, rand.Intn(90)+10,
  78.     )
  79.     return orderSn
  80. }
  82. func main() {
  83.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  84.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  86.     newLogger := logger.New(
  87.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  88.         logger.Config{
  89.             SlowThreshold: time.Second, // 慢 SQL 阈值
  90.             LogLevel:      logger.Info, // Log level
  91.             Colorful:      true,        // 禁用彩色打印
  92.         },
  93.     )
  95.     // 全局模式
  96.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  97.         Logger: newLogger,
  98.     })
  99.     if err != nil {
  100.         panic(err)
  101.     }
  102.     //通过where查询
  103.     //var user User
  104.     //var users []User
  105.     //db.Where("name = ?", "bobby").First(&user)
  106.     //db.Where(&User{MyName:"bobby"}).First(&user)
  107.     //db.Where(&User{MyName:"bobby1", Age: 0}).Find(&users)
  108.     //db.Where(map[string]interface{}{"name": "bobby", "age":0}).Find(&users)
  109.     //for _, user := range users{
  110.     //    fmt.Println(user.ID)
  111.     //}
  112.     _ = db.AutoMigrate(OrderInfo{}, OrderGoods{})
  114.     tx := db.Begin()
  115.     order := OrderInfo{
  116.         OrderSn: GenerateOrderSn(1),
  117.         OrderMount: 44.2,
  118.         Address: "北京市",
  119.         SignerName: "bobby",
  120.         SingerMobile: "18787878787",
  121.         Post: "请尽快发货",
  122.     }
  123.     if result := tx.Save(&order); result.RowsAffected == 0 {
  124.         tx.Rollback()
  125.         fmt.Println("创建订单失败")
  126.     }
  128.     var orderGoods []*OrderGoods
  130.     orderGoods = append(orderGoods, &OrderGoods{
  131.         Order:      order.ID,
  132.         Goods:      421,
  133.         GoodsName:  "烟台红富士苹果12个 净重2.6kg以上 单果190-240g 新生鲜水果",
  134.         GoodsImage: "https://py-go.oss-cn-beijing.aliyuncs.com/goods_images/df392d01993cdab9de740fe17798bda1",
  135.         GoodsPrice: 44.9,
  136.         Nums:       1,
  137.     })
  139.     for _, orderGood := range orderGoods {
  140.         orderGood.Order = order.ID
  141.     }
  143.     //批量插入orderGoods
  144.     if result := tx.CreateInBatches(orderGoods, 100); result.RowsAffected == 0 {
  145.         tx.Rollback()
  146.         fmt.Println("创建订单失败")
  147.     }
  148.     tx.Commit()
  150.     //查询方式条件有三种 1. string 2. struct 3. map
  152. }

image.png
image.png
image.png
image.png
image.png

  1. package main
  3. import (
  4.     "log"
  5.     "os"
  6.     "time"
  8.     "gorm.io/driver/mysql"
  9.     "gorm.io/gorm"
  10.     "gorm.io/gorm/logger"
  11. )
  13. // `User` 属于 `Company`，`CompanyID` 是外键
  14. type User struct {
  15.     gorm.Model
  16.     Name      string
  17.     CompanyID int //数据库中存储的字段company_id
  18.     Company   Company
  19. }
  21. type Company struct {
  22.     ID   int
  23.     Name string
  24. }
  27. func main() {
  28.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  29.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  31.     newLogger := logger.New(
  32.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  33.         logger.Config{
  34.             SlowThreshold: time.Second, // 慢 SQL 阈值
  35.             LogLevel:      logger.Info, // Log level
  36.             Colorful:      true,        // 禁用彩色打印
  37.         },
  38.     )
  40.     // 全局模式
  41.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  42.         Logger: newLogger,
  43.     })
  44.     if err != nil {
  45.         panic(err)
  46.     }
  48.     //db.AutoMigrate(&User{}) //新建了user表和company表，并设置了外键
  50.     //db.Create(&User{
  51.     //    Name:      "bobby",
  52.     //    Company: Company{
  53.     //        Name:"慕课网",
  54.     //    },
  55.     //})
  57.     db.Create(&User{
  58.         Name:      "bobby2",
  59.         Company: Company{
  60.             ID:1,
  61.         },
  62.     })
  66. }
  1. package main
  3. import (
  4.     "database/sql"
  5.     "gorm.io/gorm/schema"
  6.     "log"
  7.     "os"
  8.     "time"
  10.     "gorm.io/driver/mysql"
  11.     "gorm.io/gorm"
  12.     "gorm.io/gorm/logger"
  13. )
  15. type Language struct {
  16.     gorm.Model
  17.     Name string
  18.     AddTime sql.NullTime //每个记录创建的时候自动加上当前时间加入到AddTime中
  19. }
  21. //func (l *Language) BeforeCreate(tx *gorm.DB) (err error){
  22. //    l.AddTime = time.Now()
  23. //    return
  24. //}
  27. //在gorm中可以通过给某一个struct添加TableName方法来自定义表名
  28. func (Language) TableName() string{
  29.     return "my_language"
  30. }
  32. /*
  33. 1. 我们自己定义表名是什么
  34. 2. 统一的给所有的表名加上一个前缀
  35. */
  36. func main() {
  37.     // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  38.     dsn := "root:root@tcp(192.168.0.104:3306)/gorm_test?charset=utf8mb4&parseTime=True&loc=Local"
  40.     newLogger := logger.New(
  41.         log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
  42.         logger.Config{
  43.             SlowThreshold: time.Second, // 慢 SQL 阈值
  44.             LogLevel:      logger.Info, // Log level
  45.             Colorful:      true,        // 禁用彩色打印
  46.         },
  47.     )
  49.     // 全局模式
  50.     //NamingStrategy和Tablename不能同时配置，
  51.     db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
  52.         NamingStrategy:schema.NamingStrategy{//配置表名前缀
  53.             TablePrefix: "mxshop_",
  54.         },
  55.         Logger: newLogger,
  56.     })
  57.     if err != nil {
  58.         panic(err)
  59.     }
  61.     db.AutoMigrate(&Language{})
  62.     db.Create(&Language{
  63.         Name:"python",
  64.     })
  65. }