grom的理解与掌握

前言

什么是gorm
gorm是一种数据库操作辅助工具，在我们go的结构体和数据库之间产生映射，让我们对数据库的关系，标的内容，直观的体现在结构体上，使用结构体即可完成增删改查操作

使用gorm进行数据库操作

gorm如何链接数据库
导入gorm-------导入mysql驱动器----------使用open链接得到数据库操作对象(以mysql为例)
do,err:=gorm.Open(“mysql”,“user:password@/dbname?charset=utf8&parseTime=True$loc=Local”)
defer db.Close()
自动化创建数据库表
gorm支持自动迁移模式 使用AutoMigrate 方法来帮助我们自动化创建数据库表
db.AutoMigrate(&Product{})
代码实例

type HelloWord struct{
      gorm.Model
      Name string
      Sex    bool
      Age   int
}

func main(){
     db.err:=gorm.Open("mysql","root:123456@/ginclass?charset=utf8&parseTime=True$loc=Local")
     if err!=nil{
          panic(err)
}
db.AutoMigrate(&HelloWord{})
defer db.close()
}

最简单的增删改查
增：Create (跟结构体指针地址)

type HelloWord struct{
      gorm.Model
      Name string
      Sex    bool
      Age   int
}

func main(){
     db.err:=gorm.Open("mysql","root:123456@/ginclass?charset=utf8&parseTime=True$loc=Local")
     if err!=nil{
          panic(err)
}
db.AutoMigrate(&HelloWord{})

db.Create(&HelloWord{
        Name:"qm",
        Sex:true,
        Age:18,
})
defer db.close()
}

删：Delete (跟结构体指针地址)或者会根据主键自动去查询单条或者查询单条或者根据条件删除多条

db.Deleter(&HelloWord{},"id=?",1)

db.Where("id in (?)",[]int {1,2}).Unscoped().Delete(&HelloWord{})

改：Update 更新单一数据 还有Updates 更新数据中指定内容Save更新所有内容

db.Where(:"id = ?",1).First(&HelloWord{}).Update(:"name","qimiao")

db.Where(:"id in (?)",[]int{1,2}).Find(&[]HelloWord{}).Updates(map[string]interface{}{
            "Name":"qimiaoshuai",
            "Sex":true,
            "Age":26,
})

查：First(跟结构体示例指针地址) Find(跟结构体切片指针地址)
条件：Where Or 填写简单的sql查询语句执行得到model
模型：model

gorm结构体的创建技巧和结合gin使用

注：上图第一列是tag设置

type User struct{
        gorm.Model
        Name string `gorm:primary_key;column:'user_name';type:'varchar(100)';"`
}

func (u User)TableName()string{
        return "qm_users"
}

func main(){
       db,_:=gorm.Open("mysql","root:123456@ginclass?charset=utf8&parseTime=True$loc=Local")
       db.AutoMigrate(&User{})
       defer db.Close()
}

type Class struct{
       gorm.Model
       ClassName string
       Students []Student
 }
 type Student struct{
      gorm.Model
      StudentName string
      ClassId uint
      IDCard IDCard
      Teachers []Teachers  `gorm:"many2many:student_teachers;"`
    }
type IDCard struct{
     gorm.Model
     StudentID uint
     Num   int
}

type Teacher struct{
       gorm.Model
       TeacherName string
       Students []Student `gorm:"many2many:student_teachers;"`
}

func main(){
       db,_:=gorm.Open("mysql","root:123456@ginclass?charset=utf8&parseTime=True$loc=Local")
       db.AutoMigrate(&Teacher{},&Class{},&Student{},&IDCard{})
       s:=Student{
             StudentName:"qm",
             IDCard:i,
        }
        i:=IDCard{
               Num:123456,
       }
       t:=Teacher{
               TeacherName:"老师傅“，
                Students: []Student{s},
      }
      c:=Class{
             ClassName:"XXX的班级“，
             Students: []Student{s},
      }
      _ := db.Create(&c).Error
      _:=db.Create(&t).Error
      
       defer db.Close()
}

配合gin框架
结构体和上文一样，就是main函数里需要变换

func main(){
       db,_:=gorm.Open("mysql","root:123456@ginclass?charset=utf8&parseTime=True$loc=Local")
       db.AutoMigrate(&Teacher{},&Class{},&Student{},&IDCard{})
       defer db.Close()
       r:=gin.Default()
       r.POST("/student", func(c *gin.Context){
             var student Student
             _=c.BindJSON(&student)
             db.Create(student)
})
        r.GET("/student/:id",func(c *gin.Context){
             id := c.Param("ID")
             var student Student
             _ = c.BindJSON(&student)
             db.Preload().First(&student,"id = ?",id)
             c.JSON(200,gin.H{
                   "s":student,
             })
})
     r.Run(":8080")
}