DB接口

First：

// 按照主键顺序的第一条记录，（主键升序）

var user model.User
result := db.First(&user)
fmt.Println(user)

result.RowsAffected // 返回找到的记录数
result.Error // returns error

// sql语句：SELECT * FROM users ORDER BY id LIMIT 1;

FirstOrCreate

// 未找到 user，则根据给定条件创建一条新纪录
var user model.User
db.FirstOrCreate(&user, User{Name: "hallen"})

// 找到了 `name` = `hallen` 的 user
db.Where(User{Name: "hallen"}).FirstOrCreate(&user)

Last

// 获取最后一条记录（主键降序）
var user model.User
// 按照主键顺序的最后一条记录
db.Last(&user)
fmt.Println(user)

// sql语句：SELECT * FROM users ORDER BY id DESC LIMIT 1;

Take

// 获取一条记录，没有指定排序字段
var user model.User
db.Take(&user)

// sql语句：SELECT * FROM users LIMIT 1;

Find

var user model.User

// 所有记录
db.Find(&users, []int{1,2,3})
// sql语句：// SELECT * FROM users WHERE id IN (1,2,3);

result := db.Find(&users)
// sql语句：SELECT * FROM users;

// 根据指定条件查询
db.Find(&user, "name = ?", "hallen")

//或者结合where
db.Where("name = ?", "hallen").Find(&users)
// sql语句：SELECT * FROM users WHERE name = 'hallen';

db.Where("name LIKE ?", "%ha%").Find(&users)
// sql语句：SELECT * FROM users WHERE name LIKE '%hal%';

Where

var user model.User


// 根据条件查询得到满足条件的第一条记录
db.Where("role_id = ?", "2").First(&user)
fmt.Println(user)

var users []model.User

// 根据条件查询得到满足条件的所有记录
db.Where("user_id = ?", "1").Find(&users)
fmt.Println(users)

// like模糊查询
db.Where("role_id like ?", "%2").Find(&users)
fmt.Println(users)

db.Where("updated_at > ?", "2019-02-08 18:08:27").Find(&users)
fmt.Println(users)

// struct结构查询条件
db.Where(&DqmUserRole{RoleId: "1,2", UserId: "1"}).First(&user)
fmt.Println(user)


条件：
=
LIKE
IN：Where("name IN ?", []string{"hallen", "hallen2"})
AND：Where("name = ? AND age >= ?", "jinzhu", "22")
Time：Where("updated_at > ?", lastWeek)
BETWEEN：Where("created_at BETWEEN ? AND ?", lastWeek, today)

Select

指定要从数据库检索的字段，默认情况下，将选择所有字段;

db.Select("name, age").Find(&users)
//// SELECT name, age FROM users;

db.Select([]string{"name", "age"}).Find(&users)
//// SELECT name, age FROM users;

db.Table("users").Select("COALESCE(age,?)", 42).Rows() // COALESCE:聚合
//// SELECT COALESCE(age,'42') FROM users;

Create

1.插入单条

user := models.User{Name:"李四",Age:18,Addr:"xxx",Pic:"/static/upload/pic111.jpg",Phone:"13411232312"}
result := db.Create(&user)

user.ID // 返回插入数据的主键
result.Error // 返回 error
result.RowsAffected // 返回插入记录的条数

2.批量插入：暂不支持

user4 := []relate_tables.User{
{
Name:"hallen8",
Age:18,
Addr:"xxx",
},
{
Name:"hallen9",
Age:18,
Addr:"xxx",
},
}

db.Create(&user4) // 这种方式不支持

save

var user model.User

db.First(&user)

user.Name = "jinzhu 2"
user.Age = 100
db.Save(&user)

update

var users []model.User
db.Where("active = ?", true).find(&users).Update("name", "hello")


db.Where("active = ?", true).find(&users).Updates(User{Name: "hello", Age: 18})


// update也可以使用map：map[string]interface{}{"name": "hello", "age": 18}

// 也可以使用save更新

delete

db.Delete(&user,1)

// 批量删除
db.Where("age = ?", 20).Delete(&User{})

Unscoped:软删除

// 也就是逻辑删除
// gorm.Model 将DeletedAt 字段设置为当前时间
// 需要再模型中指定

type User struct {
ID int
Deleted `gorm:"DeletedAt"` // 如果设置了所有的删除都将是逻辑删除
Name string
}

// 在查询时会忽略被软删除的记录
db.Where("age = 20").Find(&user)
// SELECT * FROM users WHERE age = 20 AND deleted_at IS NULL;


// 查询逻辑删除的数据
db.Unscoped().Where("age = 20").Find(&users)
// SELECT * FROM users WHERE age = 20;

// 想要物理删除的办法
db.Unscoped().Delete(&user)

Not

var user model.User

db.Not(User{Name: "hallen", Age: 18}).First(&user)

// SELECT * FROM `users` WHERE (`users`.`name` <> 'hallen6') AND (`users`.`age` <> 19);

Or

var users []model.User


db.Where("name = 'hallen'").Or(User{Name: "hallen2", Age: 18}).Find(&users)
// SELECT * FROM users WHERE name = 'hallen' OR (name = 'jinzhu 2' AND age = 18);

Order

var users []model.User
db.Order("age desc").Find(&users) // 注意这里的order要在find前面，否则不生效
fmt.Println(users)

// SELECT * FROM users ORDER BY age desc;

默认为asc

Limit和Offset

Limit 指定获取记录的最大数量 Offset 指定在开始返回记录之前要跳过的记录数量

var users []model.User


db.Limit(3).Find(&users) // 三条
// SELECT * FROM users LIMIT 3;

db.Limit(10).Offset(5).Find(&users) // 从5开始的10条数据
// SELECT * FROM users OFFSET 5 LIMIT 10;

Scan

将结果扫描到另一个结构中。

type Result struct {
Id int64
}
var results []Result
db.Select("id").Where("user_id in (?)", []string{"1", "2"}).Find(&dqmUserRole20).Scan(&results)
fmt.Println(results)

Count

获取模型的记录数

db.Where("name = ?", "hallen").Find(&users).Count(&count)
// SELECT count(*) FROM users WHERE name = 'jinzhu'

db.Model(&User{}).Where("name = ?", "jinzhu").Count(&count)
// SELECT count(*) FROM users WHERE name = 'jinzhu'; (count)

db.Table("deleted_users").Count(&count)
// SELECT count(*) FROM deleted_users;

Group & Having

GROUP BY语句用来与聚合函数(aggregate functions such as COUNT, SUM, AVG, MIN, or MAX.)联合使用，只返回一个单个值

HAVING语句通常与GROUP BY语句联合使用，用来过滤由GROUP BY语句返回的记录集。

HAVING语句的存在弥补了WHERE关键字不能与聚合函数联合使用的不足

type result struct {
Date time.Time
Total int
}

db.Select("name, count(*)").Group("name").Find(&result)

// select name,count(*) FROM users GROUP BY `age`

db.Select("name, count(*)").Group("name").Having("add = ?","xxx").Find(&result)


// select name,count(*) FROM users GROUP BY `age` 后面不能用where限制条件，只能使用having

// select name,count(age) FROM users GROUP BY `age` HAVING addr='xxx'

Distinct：暂无 {#Distinct}

db.Distinct("name", "age").Order("name, age desc").Find(&results)

Join

left join … on …

right join … on …

db.Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&result{})

高级查询

FirstOrInit和Attrs

FirstOrInit：获取第一个匹配的记录，或者使用给定的条件初始化一个新的记录（仅适用于struct，map条件）

Attrs：如果没有找到记录，则使用Attrs中的数据来初始化一条记录：

var user model.User

// 查不到该条记录，则使用attrs值替换,// 查到记录，则使用数据库中的值
db.Where(User{Name:"hallen"}).Attrs(User{Name:"hallen",Age:18}).FirstOrInit(&user)

FirstOrInit和Assign

Assign:不管是否找的到，最终返回结构中都将带上Assign指定的参数，有则代替，没有则添加

var user model.User

// 不管是否找到对应记录，使用Assign值替代查询到的值
db.Where("id = ?", "1").Assign(model.User{Id: "15"}).FirstOrInit(&user)

Pluck

Pluck 用于从数据库查询单个列，并将结果扫描到切片。如果您想要查询多列，您应该使用 Select 和 Scan

var ages []int64
db.Find(&users).Pluck("age", &ages)

var names []string
db.Model(&User{}).Pluck("name", &names)


// 超过一列的查询，应该使用 `Scan` 或者 `Find`，例如：
db.Select("name", "age").Scan(&users)
db.Select("name", "age").Find(&users)

Scopes

Scopes 允许你指定常用的查询，可以在调用方法时引用这些查询

func AmountGreaterThan1000(db *gorm.DB) *gorm.DB {
return db.Where("amount > ?", 1000)
}

func PaidWithCreditCard(db *gorm.DB) *gorm.DB {
return db.Where("pay_mode_sign = ?", "C")
}

func PaidWithCod(db *gorm.DB) *gorm.DB {
return db.Where("pay_mode_sign = ?", "C")
}

func OrderStatus(status []string) func (db *gorm.DB) *gorm.DB {
return func (db *gorm.DB) *gorm.DB {
return db.Where("status IN (?)", status)
}
}

db.Scopes(AmountGreaterThan1000, PaidWithCreditCard).Find(&orders)
// 查找所有金额大于 1000 的信用卡订单

db.Scopes(AmountGreaterThan1000, PaidWithCod).Find(&orders)
// 查找所有金额大于 1000 的货到付款订单

db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)
// 查找所有金额大于 1000 且已付款或已发货的订单

LogMode

Gorm有内置的日志记录器支持，默认情况下，它会打印发生的错误。

// 启用Logger，显示详细日志

db.LogMode(true)

// 也可以查看单语句的信息

db.Debug().Where("name = ?", "hallen").First(&User{})