Gorm基本使用

文章目录 Gorm安装连接数据库自动创建表增删改查模型定义一对多多对多

Gorm 安装

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

连接数据库

	dsn := "username:passwd@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(db)

自动创建表

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

type User struct {
	Id       int64 `gorm:"primary_key" json:"id"` // 设置id为主键
	Username string
	Password string
}

func main() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/test_db?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(db)
	db.AutoMigrate(User{}) // 自动创建表结构

增删改查

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

type User struct {
	Id       int64 `gorm:"primary_key" json:"id"`
	Username string
	Password string
}

func main() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/test_db?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err)
	}

	db.Create(&User{
		Id:       1,
		Username: "test",
		Password: "123456",
	})  
  // 新增一条数据,相当于INSERT INTO `test_db`.`users` (`id`,`username`,`password`) VALUES (1, 'test', '123456');

	db.Model(User{
		Id: 1,
	}).Update("username", "test2")  
  // 更新用户名为test2,相当于 update user set username="test2" where id = 1

	db.Delete(&User{Id: 3}) 
  // 删除id是1的用户，相当于delete from user where id = 3

	db.Where("username = ?", "test3").Delete(&User{})
  // 相当于delete from user where username = "test3"

	u := User{Id: 1}
	db.First(&u)
	fmt.Println(u)
  // 查询id是1的用户，只查一条  select * from user where id = 1 limit 1;
  
	users := []User{}
	db.Find(&users)
	fmt.Println(users)
  // 查询user表下的所有书籍， select * from user;

}

模型定义

type User struct {
	Id           int64 `gorm:"primary_key" json:"id"`
	Name         string
	CreatedAt    *time.Time `json:"createdAt" gorm:"column:create_at"`
	Email        string     `gorm:"type:varchar(100);unique_index"` // 唯一索引
	Role         string     `gorm:"size:255"`                       //设置字段的大小为255个字 节
	MemberNumber *string    `gorm:"unique;not null"`                // 设置 memberNumber 字段唯一且不为空
	Num          int        `gorm:"AUTO_INCREMENT"`                 // 设置 Num字段自增
	Address      string     `gorm:"index:addr"`                     // 给Address 创建一个 名字是 `addr`的索引
	IgnoreMe     int        `gorm:"-"`                              //忽略这个字段
}

标签	说明
Column	指定列的名称
Type	指定列的类型
Size	指定列的大小，默认是 255
PRIMARY_KEY	指定一个列作为主键
UNIQUE	指定一个唯一的列
DEFAULT	指定一个列的默认值
PRECISION	指定列的数据的精度
NOT NULL	指定列的数据不为空
AUTO_INCREMENT	指定一个列的数据是否自增
INDEX	创建带或不带名称的索引，同名创建复合索引
UNIQUE_INDEX	类似 索引 ，创建一个唯一的索引
EMBEDDED	将 struct 设置为 embedded
EMBEDDED_PREFIX	设置嵌入式结构的前缀名称
-	忽略这些字段

一对多

package main

import (
	"encoding/json"
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

/*
constraint:OnUpdate:CASCADE 【当User表更新，也会同步给CreditCards】 // 外键约束 
OnDelete:SET NULL 【当User中数据被删除时，CreditCard关联设置为 NULL，不删除记录】 
*/
type User struct {
	gorm.Model
	Username    string       `json:"username" gorm:"column:username"`
	CreditCards []CreditCard `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}

type CreditCard struct {
	gorm.Model
	Number string
	UserID uint
}

func main() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/test_db?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err)
	}

	db.AutoMigrate(User{}, CreditCard{})

	user := User{
		Model:    gorm.Model{},
		Username: "lalala",
		CreditCards: []CreditCard{
			{Number: "0001"},
			{Number: "0002"},
		},
	}
	db.Create(&user)
	
  // 为已存在的user添加creditcards，增加 *** 作
	u := User{Username: "lalala"}
	db.Model(&u).Association("CreditCards").Append([]CreditCard{
		{Number: "0003"},
	})
	strUser, _ := json.Marshal(&u)
	fmt.Println(string(strUser))
	
  // Association方法，需要先查询User。根据User中的外键，来查询CreditCard的信息
	db.First(&u)
	db.Model(&u).Association("CreditCards").Find(&u.CreditCards)
	strUser1, _ := json.Marshal(&u)
	fmt.Println(string(strUser1))

  // preload预加载，在查询 User 时先去获取 CreditCard 的记录
	u2 := []User{}
	db.Preload("CreditCards").Find(&u2)
	strUser2, _ := json.Marshal(&u)
	fmt.Println(string(strUser2))
}

多对多 多对多就是双向一对多Many to Many 会在两个 model 中添加一张连接表。

package main

import (
	"encoding/json"
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"time"
)

type Person struct {
	ID        uint
	Name      string
	Addresses []Address `gorm:"many2many:person_addresses;"`  
}

type Address struct {
	ID   uint
	Name string
}

type PersonAddresses struct {
	PersonID  int `gorm:"primaryKey"`
	AddressID int `gorm:"primaryKey"`
	CreatedAt time.Time
	DeletedAt gorm.DeletedAt
}

func main() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/test_db?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println(err)
	}

  // 自动创建表结构
	db.AutoMigrate(Person{}, Address{})

  // 创建数据
	persons := Person{
		ID:   1,
		Name: "qwer",
		Addresses: []Address{
			{ID: 1, Name: "bdm"},
			{ID: 2, Name: "asd"},
		},
	}
	db.Create(&persons)

  // Preload查询的两种方式
  // 1、获取 name="zhangsan" 用户的地址
	persons2 := []Person{}
	db.Preload("Addresses").Find(&persons2)
	strPerson2, _ := json.Marshal(&persons2)
	fmt.Println(string(strPerson2))
	
  // 2、获取 name="zhangsan" 用户的地址
	person3 := Person{Name: "zhangsan"}
	db.Preload("Addresses").Find(&person3)
	strPerson3, _ := json.Marshal(&person3)
	fmt.Println(string(strPerson3))
}