- 定义model
package mysqltest
import (
"errors"
"fmt"
"gorm.io/gorm"
)
type Product struct {
gorm.Model
ID uint `gorm:"primarykey"`
Name string `gorm:"column:name"`
Price float64 `gorm:"column:price_value"`
Test string `gorm:"-"`
}
type Tabler interface {
TableName() string
}
// 修改表名
func (recv Product) TableName() string {
return "product"
}
// 钩子
func (recv *Product) BeforeCreate(tx *gorm.DB) (err error) {
if recv.Name == "haha" {
fmt.Println("不合法哈")
return errors.New("不合法哈")
} else {
return nil
}
}
- helper
package mysqltest
import (
"fmt"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/clause"
)
var db *gorm.DB
func Initdb() {
dsn := "ellis:ellis@tcp(192.168.214.134:3306)/go_db?charset=utf8mb4&parseTime=True&loc=Local"
var err error
db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
})
if err != nil {
panic(err)
}
}
func Create(value interface{
}) {
d := db.Create(value)
fmt.Printf("d.RowsAffected: %v\n", d.RowsAffected)
}
func InitTable(table interface{
}) {
db.AutoMigrate(table)
}
// 根据选择的字段插入
func CreateBySelectFields(fields []string, value interface{
}) {
db.Select(fields).Create(value)
}
// 批量插入
func CreateMulti(value interface{
}) {
d := db.Create(value)
fmt.Printf("d.RowsAffected: %v\n", d.RowsAffected)
}
// 批量插入
func CreateBatch(value interface{
}) {
d := db.CreateInBatches(value, 100)
fmt.Printf("d.RowsAffected: %v\n", d.RowsAffected)
}
// 忽略钩子
func CreateIgnoreHook(value interface{
}) {
db.Session(&gorm.Session{
SkipHooks: true}).Create(value)
}
// 通过map创建
func CreateByMap(value map[string]interface{
}, model interface{
}) {
db.Model(model).Create(value)
}
// 冲突啥也不做
func DoNothingWhenInsert(value interface{
}) {
db.Clauses(clause.OnConflict{
DoNothing: true}).Create(value)
}
// 通过主键查找
func FindByKey(value interface{
}) {
db.Find(value, 1)
}
// 查找后映射到map类型
func FindAndConvertToMap(value interface{
}, result *map[string]interface{
}) {
db.Model(value).First(result)
}
// 多主键查找
func FindByMultiKey(value interface{
}, keys []int) {
db.Find(value, keys)
}
// 条件查找
func FindByCondition(value interface{
}) {
db.Where("name=?", "haha").Order("id desc").Find((value))
}
// struct 查找，会忽略0值，例如传入ID=0，这个ID=0不会作为查询条件
func FindByStruct(value interface{
}, condition interface{
}) {
db.Where(condition).Find(value)
}
// 指定结构体查询字段
func FindByStructWithReturnFields(value interface{
}, condition interface{
}, returnFields ...string) {
db.Where(condition, returnFields).Order("id desc").Find(value)
}
- main
package main
import (
"ellis/mysqltest"
"fmt"
)
func main() {
mysqltest.Initdb()
// 创建数据库
mysqltest.InitTable(&mysqltest.Product{
})
var value mysqltest.Product
mysqltest.FindByKey(&value)
fmt.Printf("value: %v\n", value)
// 映射到map
result := map[string]interface{
}{
}
mysqltest.FindAndConvertToMap(mysqltest.Product{
}, &result)
fmt.Printf("result: %v\n", result)
// 多主键查找
var products1 []mysqltest.Product
mysqltest.FindByMultiKey(&products1, []int{
1, 2, 3})
for _, v := range products1 {
fmt.Printf("v: %v\n", v)
}
// 条件查找
var products2 []mysqltest.Product
mysqltest.FindByCondition(&products2)
for _, v := range products2 {
fmt.Printf("v: %v\n", v)
}
// struct 查找
var products3 []mysqltest.Product
// ID 为0的被忽略
produce := mysqltest.Product{
Name: "haha", ID: 0}
mysqltest.FindByStruct(&products3, produce)
for _, v := range products3 {
fmt.Printf("v: %v\n", v)
}
// map 查找
var products4 []mysqltest.Product
// ID 为0的被忽略
produce1 := map[string]interface{
}{
"Name": "haha", "ID": 0}
mysqltest.FindByStruct(&products4, produce1)
for _, v := range products4 {
fmt.Printf("v: %v\n", v)
}
// struct 查找，可以设置使用的struct的key
var products []mysqltest.Product
// ID 为0的被忽略
produce2 := mysqltest.Product{
Name: "haha"}
mysqltest.FindByStructWithReturnFields(&products, produce2, "name", "id")
for _, v := range products {
fmt.Printf("v: %v\n", v)
}
}
https://gorm.io/docs/query.html
https://gorm.io/docs/advanced_query.html