gorm快捷查询手册

#gorm.model
type Model struct{
    Id uint `gorm:primaryKey`
    CreatedAt time.Time
    UpdatedAt time.Time
    DeletedAt gorm.DeletedAt `gorm:"index"`
}
#模型定义
type User struct{
    gorm.Model
    Nmae string
}

#连接
dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})

#字段标签:column/type/size/primaryKey/unique/default/precision/scale/not null/autoincremen/
#autoCreateTime/autoUpdateTime/index/unqueindex/check/<-/->/-/
#特性:关联、Create/Save/Update/Find、预加载、事务、批量、SQL构建器、子查询、索引、Migration

###############################Select
db.First(&user)
db.Task(&user)
result:=db.Last(&user)
result.RowsAffected
result.Error
db.Model(&User{}).First(&result)
db.Table('users').Take(&result)
#主键检索
db.First(&user,10)
db.Find(&users,[]int{1,2,3})
db.Find(&users)
#where-string
db.Where("name =?","jinzhu").First(&user)
db.Where("name <> ?","jinzhu").Find(&users)
db.Where("name IN ?",[]string{"jinzhu","jin"}).Find(&users)
db.Where("name Like ?","%jin%").Find(&users)
db.Where("name = ? AND age < ?","jnzhu","22").Find(&users)
db.Where("created_at BETWEEM ? AND ?",lastweek,today).Find(&users)
#where-Struct&Map
db.Where(&User{Name:"jinzhu"}).First(&user)
db.Where(map[string]interface{}{"name":"jinzhiu"}).Find(&users)
db.Where([]int64{20,21,22}).Find(&users)
#内联where
db.First(&user,"id =?","string_p")
db.Find(&user,"name =？"，"jinzhu")
db.Find(&users,"name <> ?","jinzhu")
db.Find(&users,User{Age:20})
db.Find(&users,map[stirng]interface{"age":20})
#NOT where
db.Not("name =?","jinzhu").First(&user)
db.Not(map[string]interface{}{"name":[]string{"jinzhu"}}).Find(&users)
db.Not(User{Name:"jinzhu"}).First(&user)
db.Not([]int64{1,2}).First(&user)
#OR where
db.Where("role = ?","admin").Or("role =？","sp_amdin").Find(&users)
db.Where("name =?","jin").Or(User{name:"lin"}).Find(&users)
db.Where("name = ?","jinzhu").Or(map[string]interface{"name":"jinzhu"})

#Field
db.Select("name","age").Find(&users)
db.Select([]string{"name","age"}).Find(&users)
db.Table("users").Select("COALESE(age,?)",42).Rows()
#Order
db.Order("age desc,name").Find(&users)
db.Order("age desc").Order("name").Find(&users)
db.Clauses(......)
#Limit&Offset
db.Limit(3).Find(&users)
db.Limit(10).Find(&users1).Limit(-10).Find(&users)
db.Offset(3).Find(&users)
db.Limit(10).Offset(1).Find(&users)
db.Offset(10).Find(&user1).Offset(-1).Find(&user2)
#Group&Having
db.Model(&users{}).Select("name","sum(age)").Where("name like ?","group%").Group("name").First(&result)
db.Model(&User{}).Select("name").Group("name").Having("name =?","group").Find(&result)
db.Table("orders").Select("name").Group("name").Rows()
#Distinct
db.Distinct("name","age").Order("name","age").Find(&results)
#Joins
db.Model(&User{}).Select("user.name","email").Joins("left join on email.user_id=user_id").Scan(&result{})
db.Table("users").Select("users.name,eaml").Joins("left join eaml on eami.uid =user.id").Rows()
db.Table("users").Select("users.name,eaml").Joins("left join eaml on eami.uid =user.id").Scan(&result{})
db.Joins("JOIN email ON emails.uid=users.id").Where("age =?","666").Find(&user)
db.Joins("commany").Find(&users)
db.Table("users").Select("name").Where("name=?","An").Scan(&result)
db.raw("SELECT name FROM users WHERE name =?","li").scan(&result)
##############################高级查询
db.Model(&user{}).Limit(10).Find(&APIUser{]})
db.Clauses(clause.locking{Strength:"UPDATE"}).Find(&user)
db.Where("amount > (?)",db.Table('orders').Select("AVG(amount)").Find(&orders))
sbQuery:=db.Select("AVG(age)").Where("name LIKE ?","name%").Table("users")
db.Select("AVG(age)").Group("name").Having("AVG(age)>(?)",sbQuery).Find(&result)
db.Table("(?) as u",db.Model(&user{})).Select("name","age")->Where("age = ?",18).Find(&user{})
db.Where(db.Where("pizza =?","person")).Where(db.Where("size =?","small").Or("size=?","med")).Or(db.Where("pizz=?","hzz").Find(&pizza{}).Statement
db.Where("name1=@name OR name2=@name",sql.Named("name","jinzhju")).Find(&user)
db.Where("name1 = @name OR name2 =@name",map[string]interface{}{"name":"jinzhu"}).First(&user)
var result map[string]interface{}
db.Model(&user{}).First(&result,"id =?",1)
db.Table("user").Find(&result)
#FirstOrInit
db.FirstOrInit(&user,User{Name:"lin"})
db.Where(&user,User{Name:"lin"})->FirstOrInit(&user)
db.FirstOrInit(&user,map[string]interface{}{"name":"jinzhu"})
db.Where(&user,User{Name:"lin"}).Attrs(User{Age:20}).FirstOrInit(&user)
db.Where(&user,User{Name:"lin"}).Attrs("age",20).FirstOrInit(&user)
db.Where(User{Name:"lin"}).Assign(User{Name:"lin"}).FirstOrInit(&user)
db.FirstOrCreate(&user,User{Name:"non"})
db.Where(User{Name:"jinzhu"}).FirstOrCreate(&user)
db.Where(User{Name:"non"}).Attrs(User{Age:20}).FirstOrCreate(&user)
db.Where(User{Name:"jinzhu"}).Attrs(User{Age:20}).FirstOrCreate(&user)
db.Where(User{Name:"non"}).Assign(User{Age:20}).FirstOrCreate(&user)
db.Where(User{Name:"jin"}).Assign(User{Age:20}).FirstOrCreate(&user)
#FindInBatches
result:=db.Where("process =?",false).FindInBatches(&result,100,
    func(tx *gorm.DB,batch init)error{
        for _,result:=range result{}
    }
)
func(u *User)AfterFind(tx *gorm.DB)(err error){    
}
#pluck
db.Model(&users).Pluck("age",&age)
db.Model(&users{}).Pluck("name",&names)
db.Table("deleted-user").Pluck("name",&name)
db.Model(&user{}).Distinct().Pluck("name",&names)
db.Select("name","age").Scan(&users)
#Scopes
func Amound(db *gorm.DB) *gorm.DB{
    return db.Where("amount >?",1000)
}
db.Scopes(Amound).Find(&ordes)
#count
db.Model(&User{}).Where("name =?","jinzhu").Or("name =?","jinzhu").Count(&count)
db.Table("deleted_user").Count(&user)
db.Model(&User{}).Distinct("name").Count(&count)
##############################UPDATE
db.First(&user)
user.Name="jinzhu"
db.Save(&user)
db.Model(&User{}).Where("active =?",true).Update("name","hello")
db.Model(&user).Update("name","hello")
db.Model(&user).Where("active =?",true).Update("name","hello")
db.Model(&user).Updates(User{Name:"hello",Age:19})
db.Model(&user).Update(map[string]interface{]{"name":"hellow"}})
db.Model(&user).Select("name").Updates(map[string]interface{}{"name":"Li"})
db.Model(&result).Select("Name","age").Updates(User{Name:"new"})
#Hook
func (u *User)BeforeUpdate(tx *gorm.DB)(err error){
    return 
}
#批量更新
db.Model(User{}).Where("role =?","amdin").Updates(User{Name:"LI"})
db.Table("users").Where("id IN ?",[]int{10,11}).Updates(map[string]interface{}{"name":"liu"})
db.Model(&User{}).Update("name","jinzhu").Error
db.Model(&User{}).Where("1=1").Update("name","jinzhu")
db.Exec("UPDATE user SET name =?","jinzhu")
db.Session(&gorm.Sesion{AllowGlobalUpdate:true}).Model(&user{}).Update("name","jinzhu")
#更新的记录
result.RowsAffected
#根据子查询进行更新
db.Model(&user).Update("company_name",db.Model(&company{}).Select("name").Where("comp.id =user.company_id")))
db.Model(&user).UpdateColumn("name","hello")
db.Model(&user).UpdateColumns(User{Name:"he",Age:18})
db.Model(&user).Select("name","age").UpdateColums(User{Name:"he",Age:18})
##############################DELETE
db.Delete(&email)
db.Where("name =?","jinzhu").Delete(&eamil)
db.Delete(&User{},10)
db.Delete(&user,[]int{1,2,3})
func(u *User)BeforeDelete(tx *gorm.DB){
    return
}
db.Where("email LIKE ?","%jinzhu%"),Delete(Email{})
#软删除gorm.deleteat
#原生SQL
db.Raw("SELECT id,name FROM users Where id =?",3).scan(&result)
db.Exec("Drop Table users")
db,EXEC("UPDATE orders SET shipped_at=? where id In ?",time>Now(),[]int64{1,2,3})

##############################关联
#BelongsTO
type User struct{
    gorm.Model
    Name string
    CompanyID int
    Company Commany
}
type Commany struct{
    ID int
    Name string
}
#HasOne
type User struct{
    gorm.Model
    CreaditCard CreditCard
}
type CreaditCard struct{
    gorm.Model
    Number string
    UerId uint
}
#hasMany
type User struct{
    gorm.Model
    CreaditCards []CreaditCard
    ID int64    `gorm:"column:id"`
    UUID string `gorm:"primaryKey"`
}
type CreaditCard struct{
    gorm.Model
    Number string
    UserID uint
}
#ManyTOMany
type User struct{
    gorm.Model
    Languages []Lanaguage `gorm:"many2many:user_languages;"`
}
type Lanaguage struct{
    gorm.Model
    Name string `gorm:"index"`
}
#实体关联
db.Model(&user).Association("Languages").Find(&Languages)
db.Model(&user).Association("Languages").Append(&Lanaguage{Name:"DE"})
db.Model.Association("Languages").Repalce([]Lanaguage{L1,L2})
db.Model.Association("Languages").Delete(L1,L2)
db.Model(&user).Association("Languages").Clear()
db.Model(&user).Association("Languages").Count()
db.Select("Account").Delete(&user)
#关联标签foreignKey/references/polymorpic/polymorohicValue/many2many/joinForeignKey/joinReferences/constraint
#教程
tx:=db.WithContext(ctx)
tx.First(&user,1)
#链式调用
#钩子:BeforeSave/BeforeCreate/AfterCreate/AfterSave/BeforeUpdate/AterUpdate
#事务
db.Transaction(
    func(tx *gorm.DB)error{
        return nil
    }
)
tx:=db.Begin()
tx.Create()
tx.Rollback()
tx.Commit()
#AutoMigrate
db.AutoMigrate(&User{},&product{},&Order{})
db.Migrator().CreateTable(&User{]})
db.Migrator().HasTable("users")
db.Migrator().DropTable("users")
db.Migrator().RenameTable("users","user_infos")
db.Migrator().AddColumn(&user{},"name")
db.Migrator().DropColumn(&user{},"name")
db.Migrator().AlterColumn(&user{},"name")
db.Migrator().HasColumn(&user{},"name")
db.Migrator().RenameColumn(&user{},"name","new_name")
db.Migrator().CreateIndex(&user{},"index_name")
db.Migrator().DropIndex(&user{},"index_name")
db.Migrator().HasIndex(&user{},"index_name")
db.Migrator().RenameIndex(&user{},"index_name")
#
type User struct{
    ID string `gorm:"primaryKey;autoIncrement:false"`
    Name1 string `gorm:"uniquerIndex"`
    Name2 string `gorm:"index:index_number"`
    OID int64 `gorm:"index:idx_id;index:idx_oid,unique"`
    name3 string `gorm:"check:,name <> 'jinzhu'"`
    Commany Commany `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
}