## 鏈接數據
```go
package main
import (
"github.com/gohouse/gorose"
_ "github.com/gohouse/gorose/driver/mysql"
"fmt"
)
type users struct {
Name string `orm:"name"`
Age int `orm:"age"`
Job string `orm:"job"`
}
// DB Config.(Recommend to use configuration file to import)
var DbConfig = &gorose.DbConfigSingle {
Driver: "mysql", // 驅動: mysql/sqlite/oracle/mssql/postgres
EnableQueryLog: false, // 是否開啟sql日志
SetMaxOpenConns: 0, // (連接池)最大打開的連接數，默認值為0表示不限制
SetMaxIdleConns: 0, // (連接池)閑置的連接數
Prefix: "", // 表前綴
Dsn: "root:root@tcp(localhost:3306)/test?charset=utf8", // 數據庫鏈接
}
func main() {
connection, err := gorose.Open(DbConfig)
if err != nil {
fmt.Println(err)
return
}
db := connection.NewSession()
}
```
## 構建用戶表struct
```go
type User struct {
Name string `orm:"name"`
Age int `orm:"age"`
Job string `rom:"job"`
}
func (u User) TableName() string {
return "users"
}
var user User
var users []User
```
## 原生sql
```go
connection.Query()
// or
db.Query("select * from users limit 1")
db.Query("select * from users where id<?", 10)
db.Execute("update users set job='it' where id=?", 1)
```
## 查詢一條
```go
// select * from users limit 1 // 這的*對應的值根據傳入類型確定, 如果是struct, 則對應struct字段,否則就是*(所有字段, 下同)
db.Table(&user).Select()
// or
db.Table("users").First()
```
## 查詢多條
```go
// select * from users limit 10
db.Table(&users).Limit(10).Select()
// or
db.Table("users").Limit(10).Get()
// 等同于
db.Table("users").Limit(10).Select()
```
## Fields() 指定查詢字段 / AddFields()
```go
// select name,job from users limit 1
user := db.Table(&user)
user.Fields("name,job").Select()
// select name,job,age from users limit 1
user.AddFields("age")
user.Fields("name,job").Select()
```
可以手動指定要查詢的字段, 那么, 這里查詢的結果會優先從Fields api傳入的獲取, 如果沒有, 才會使用struct對應的字段
## Distinct
```go
// select distinct name,age,job from users limit 1
db.Table(&user).Distinct().Select()
```
## Where
```go
// select * from users where id=1
db.Table(&user).Where("id", 1).Select()
// select * from users where id>1
db.Table(&user).Where("id", ">", 1).Select()
// select * from users where id>1 and name like "%fizz%"
db.Table(&user).Where("id", ">", 1).Where("name","like","%fizz%").Select()
```
- OrWhere
```go
// select * from users where id>1 or name like "%fizz%"
db.Table(&user).Where("id", ">", 1).OrWhere("name","like","%fizz%").Select()
```
- WhereNull / WhereNotNull
```go
// select * from users where job is null
db.Table(&users).WhereNull("job").Select()
// select * from users where job is not null
db.Table(&users).WhereNotNull("job").Select()
```
- WhereIn / WhereNotIn / OrWhereIn / OrWhereNotIn
```go
// select * from users where age in (17,18)
db.Table(&users).WhereIn("age",[]interface{}{17, 18}).Select()
...
```
- WhereBetween / WhereBetwee / OrWhereBetween / OrWhereNotBetween
```go
// select * from users where age between 17 and 20
db.Table(&users).WhereBetween("age",[]interface{}{17, 18}).Select()
...
```
## 嵌套where
```go
// SELECT * FROM users
// WHERE id > 1
// and ( name = 'fizz'
// or ( name = 'fizz2'
// and ( name = 'fizz3' or website like 'fizzday%')
// )
// )
// and job = 'it' LIMIT 1
User := db.Table("users")
User.Where("id", ">", 1).Where(func() {
User.Where("name", "fizz").OrWhere(func() {
User.Where("name", "fizz2").Where(func() {
User.Where("name", "fizz3").OrWhere("website", "like", "fizzday%")
})
})
}).Where("job", "it").First()
```
## Join / LeftJoin / RightJoin / CrossJoin / UnionJoin
```go
// 普通示例
// select * from user inner join card on user.id=card.user_id limit 10
db.Table("user")
.Join("card","user.id","=","card.user_id")
.Limit(10)
.Get()
// 左鏈接
// select * from user a left join card b on a.id=b.user_id limit 1
db.Table("user a")
.LeftJoin("card b on a.id = b.user_id")
.First()
// RightJoin => right join
// CrossJoin => cross join
// UnionJoin => union join
```
默認 `join` 是 `inner join`
## Order / OrderBy
```go
// select * from users order by id desc, job asc
db.Table(&user).Order("id desc, job asc").Select()
```
Order 等同于 orderby
## Group / GroupBy
```go
// select * from users group by job
db.Table(&user).Group("job").Select()
```
Group 等同于 GroupBy
## Limit 和 Offset
```go
// select * from users limit 10 offset 10
db.Table(&user).Limit(10).Offset(10).Select()
```
## Having
```go
// select * from users group by job having age>17
db.Table(&user).Group("job").Having("age>17").Select()
```
## Value 獲取一個字段的單一值
```go
// 獲取id=1的job
db.Table(&user).Value("job") // it
```
## Pluck 獲取表的一列值
```go
// 獲取id=1的job
db.Table(&user).Pluck("job") // ["id", "drawer"]
// 可以指定第二個參數, 第二個參數的值, 做為第一個字段值得key, 這兩個參數都必須為表的字段
db.Table(&user).Pluck("job", "name") // {"fizz":id", "fizz2":"drawer"}
```
## Sum / Count / Avg / Max / Min 聚合查詢
```go
// select sum(age) from users
db.Table(&user).Sum("age")
db.Table(&user).Count()
db.Table(&user).Count("*")
db.Table(&user).Avg("age")
db.Table(&user).Max("age")
db.Table(&user).Min("age")
```
## Chunk 數據分片 大量數據批量處理 (累積處理)
```go
` 當需要操作大量數據的時候, 一次性取出再操作, 不太合理, 就可以使用chunk方法
chunk的第一個參數是指定一次操作的數據量, 根據業務量, 取100條或者1000條都可以
chunk的第二個參數是一個回調方法, 用于書寫正常的數據處理邏輯
目的是做到, 無感知處理大量數據
實現原理是, 每一次操作, 自動記錄當前的操作位置, 下一次重復取數據的時候, 從當前位置開始取
`
User := db.Table("users")
User.Fields("id, name").Where("id",">",2).Chunk(2, func(data []map[string]interface{}) {
// for _,item := range data {
// fmt.Println(item)
// }
fmt.Println(data)
})
// 打印結果:
// map[id:3 name:gorose]
// map[id:4 name:fizzday]
// map[id:5 name:fizz3]
// map[id:6 name:gohouse]
[map[id:3 name:gorose] map[name:fizzday id:4]]
[map[id:5 name:fizz3] map[id:6 name:gohouse]]
```
##Loop 數據分片 大量數據批量處理 (從頭處理)
```go
` 類似 chunk 方法, 實現原理是, 每一次操作, 都是從頭開始取數據
原因: 當我們更改數據時, 更改的結果可能作為where條件會影響我們取數據的結果,所以, 可以使用Loop`
User := db.Table("users")
User.Fields("id, name").Where("id",">",2).Loop(2, func(data []map[string]interface{}) {
// for _,item := range data {
// fmt.Println(item)
// }
// 這里執行update / delete 等操作
})
```
## 獲取sql記錄
- 直接構建sql而不執行
```go
// select 語句
db.Table().BuildSql() // 或者 xxx.BuildSql("select")
// insert
db.Table().Data().BuildSql("insert")
// update, delete
// xxx.BuildSql("update")
// xxx.BuildSql("delete")
```
- 執行過程中獲取sql
```go
// 要先新建會話
db := connection.NewSession()
db.Table().xxx()
// 獲取最后一條sql
fmt.Println(db.LastSql)
// 獲取所有sql
fmt.Println(db.SqlLogs)
```
---
溫馨提示, 不要忘了導入對應的驅動, 如 MySQL驅動:
```go
import _ "github.com/gohouse/gorose/driver/mysql"
// or
import _ "github.com/go-sql-driver/mysql"
```
