模型(Models)- beego ORM
beego ORM 是一个强大的 Go 语言 ORM 框架。她的灵感主要来自 Django ORM 和 SQLAlchemy。
目前该框架仍处于开发阶段,可能发生任何导致不兼容的改动。
已支持数据库驱动:
- MySQL:github.com/go-sql-driver/mysql
- PostgreSQL:github.com/lib/pq
- Sqlite3:github.com/mattn/go-sqlite3
以上数据库驱动均通过基本测试,但我们仍需要您的反馈。
ORM 特性:
- 支持 Go 的所有类型存储
- 轻松上手,采用简单的 CRUD 风格
- 自动 Join 关联表
- 跨数据库兼容查询
- 允许直接使用 SQL 查询/映射
- 严格完整的测试保证 ORM 的稳定与健壮
更多特性请在文档中自行品读。
安装 ORM:
go get github.com/beego/beego/v2/client/orm
快速入门
简单示例
package main
import (
"fmt"
"github.com/beego/beego/v2/client/orm"
_ "github.com/go-sql-driver/mysql" // import your used driver
)
// Model Struct
type User struct {
Id int
Name string `orm:"size(100)"`
}
func init() {
// set default database
orm.RegisterDataBase("default", "mysql", "username:password@tcp(127.0.0.1:3306)/db_name?charset=utf8&loc=Local")
// register model
orm.RegisterModel(new(User))
// create table
orm.RunSyncdb("default", false, true)
}
func main() {
o := orm.NewOrm()
user := User{Name: "slene"}
// insert
id, err := o.Insert(&user)
fmt.Printf("ID: %d, ERR: %v\n", id, err)
// update
user.Name = "astaxie"
num, err := o.Update(&user)
fmt.Printf("NUM: %d, ERR: %v\n", num, err)
// read one
u := User{Id: user.Id}
err = o.Read(&u)
fmt.Printf("ERR: %v\n", err)
// delete
num, err = o.Delete(&u)
fmt.Printf("NUM: %d, ERR: %v\n", num, err)
}
关联查询
type Post struct {
Id int `orm:"auto"`
Title string `orm:"size(100)"`
User *User `orm:"rel(fk)"`
}
var posts []*Post
qs := o.QueryTable("post")
num, err := qs.Filter("User__Name", "slene").All(&posts)
SQL 查询
当您无法使用 ORM 来达到您的需求时,也可以直接使用 SQL 来完成查询/映射操作。
var maps []orm.Params
num, err := o.Raw("SELECT * FROM user").Values(&maps)
for _,term := range maps{
fmt.Println(term["id"],":",term["name"])
}
事务处理
o.Begin()
...
user := User{Name: "slene"}
id, err := o.Insert(&user)
if err == nil {
o.Commit()
} else {
o.Rollback()
}
调试查询日志
在开发环境下,您可以使用以下指令来开启查询调试模式:
func main() {
orm.Debug = true
...
开启后将会输出所有查询语句,包括执行、准备、事务等。
例如:
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Exec / 0.4ms] - [INSERT INTO `user` (`name`) VALUES (?)] - `slene`
...
注意:我们不建议您在部署产品后这样做。
ORM 使用方法
beego/orm 的使用例子
后文例子如无特殊说明都以这个为基础。
注意的是,v2.x和v1.x在 ORM 上有一个极大的不同,即v2.x的ORM
对象被设计为无状态的,因而天然是线程安全的。
也因此,我们建议在使用过程中,一个数据库应该只存在一个ORM
对象。
models.go:
package main
import (
"github.com/beego/beego/v2/client/orm"
)
type User struct {
Id int
Name string
Profile *Profile `orm:"rel(one)"` // OneToOne relation
Post []*Post `orm:"reverse(many)"` // 设置一对多的反向关系
}
type Profile struct {
Id int
Age int16
User *User `orm:"reverse(one)"` // 设置一对一反向关系(可选)
}
type Post struct {
Id int
Title string
User *User `orm:"rel(fk)"` //设置一对多关系
Tags []*Tag `orm:"rel(m2m)"`
}
type Tag struct {
Id int
Name string
Posts []*Post `orm:"reverse(many)"` //设置多对多反向关系
}
func init() {
// 需要在init中注册定义的model
orm.RegisterModel(new(User), new(Post), new(Profile), new(Tag))
}
main.go
package main
import (
"fmt"
"github.com/beego/beego/v2/client/orm"
_ "github.com/go-sql-driver/mysql"
)
func init() {
orm.RegisterDriver("mysql", orm.DRMySQL)
orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8")
}
func main() {
// 默认使用 default,你可以指定为其他数据库
o := orm.NewOrm()
profile := new(Profile)
profile.Age = 30
user := new(User)
user.Profile = profile
user.Name = "slene"
fmt.Println(o.Insert(profile))
fmt.Println(o.Insert(user))
}
数据库的设置
目前 ORM 支持多种数据库,以下为测试过的 driver
将你需要使用的 driver 加入 import 中
import (
_ "github.com/go-sql-driver/mysql"
_ "github.com/lib/pq"
_ "github.com/mattn/go-sqlite3"
)
RegisterDriver
默认数据库类型
orm.DRMySQL
orm.DRSqlite
orm.DRPostgres
orm.DRTiDB
// < 1.6
orm.DR_MySQL
orm.DR_Sqlite
orm.DR_Postgres
// 参数1 driverName
// 参数2 数据库类型
// 这个用来设置 driverName 对应的数据库类型
// mysql / sqlite3 / postgres / tidb 这几种是默认已经注册过的,所以可以无需设置
orm.RegisterDriver("mysql", orm.DRMySQL)
RegisterDataBase
ORM 必须注册一个别名为 default
的数据库,作为默认使用。
ORM 使用 golang 自己的连接池
// 参数1 数据库的别名,用来在 ORM 中切换数据库使用
// 参数2 driverName
// 参数3 对应的链接字符串
orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8")
// 参数4(可选) 设置最大空闲连接
// 参数5(可选) 设置最大数据库连接 (go >= 1.2)
maxIdle := 30
maxConn := 30
orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8", orm.MaxIdleConnections(maxIdle), orm.MaxOpenConnections(maxConn))
SetMaxIdleConns
根据数据库的别名,设置数据库的最大空闲连接
orm.SetMaxIdleConns("default", 30)
SetMaxOpenConns
根据数据库的别名,设置数据库的最大数据库连接 (go >= 1.2)
orm.SetMaxOpenConns("default", 30)
时区设置
ORM 默认使用 time.Local 本地时区
- 作用于 ORM 自动创建的时间
- 从数据库中取回的时间转换成 ORM 本地时间
如果需要的话,你也可以进行更改
// 设置为 UTC 时间
orm.DefaultTimeLoc = time.UTC
ORM 在进行 RegisterDataBase 的同时,会获取数据库使用的时区,然后在 time.Time 类型存取时做相应转换,以匹配时间系统,从而保证时间不会出错。
注意:
- 鉴于 Sqlite3 的设计,存取默认都为 UTC 时间
- 使用 go-sql-driver 驱动时,请注意参数设置
从某一版本开始,驱动默认使用 UTC 时间,而非本地时间,所以请指定时区参数或者全部以 UTC 时间存取
例如:root:root@/orm_test?charset=utf8&loc=Asia%2FShanghai
参见 loc / parseTime
注册模型
如果使用 orm.QuerySeter 进行高级查询的话,这个是必须的。
反之,如果只使用 Raw 查询和 map struct,是无需这一步的。您可以去查看 Raw SQL 查询
RegisterModel
将你定义的 Model 进行注册,最佳设计是有单独的 models.go 文件,在他的 init 函数中进行注册。
迷你版 models.go
package main
import "github.com/beego/beego/v2/client/orm"
type User struct {
Id int
Name string
}
func init(){
orm.RegisterModel(new(User))
}
RegisterModel 也可以同时注册多个 model
orm.RegisterModel(new(User), new(Profile), new(Post))
详细的 struct 定义请查看文档 模型定义
RegisterModelWithPrefix
使用表名前缀
orm.RegisterModelWithPrefix("prefix_", new(User))
创建后的表名为 prefix_user
NewOrmWithDB
有时候需要自行管理连接池与数据库链接(比如:go 的链接池无法让两次查询使用同一个链接的)
但又想使用 ORM 的查询功能
var driverName, aliasName string
// driverName 是驱动的名称
// aliasName 是当前 db 的自定义别名
var db *sql.DB
...
o := orm.NewOrmWithDB(driverName, aliasName, db)
GetDB
从已注册的数据库返回 *sql.DB 对象,默认返回别名为 default 的数据库。
db, err := orm.GetDB()
if err != nil {
fmt.Println("get default DataBase")
}
db, err := orm.GetDB("alias")
if err != nil {
fmt.Println("get alias DataBase")
}
ResetModelCache
重置已经注册的模型 struct,一般用于编写测试用例
orm.ResetModelCache()
ORM 接口使用
使用 ORM 必然接触的 Ormer 接口,我们来熟悉一下
var o orm.Ormer
o = orm.NewOrm() // 创建一个 Ormer
// NewOrm 的同时会执行 orm.BootStrap (整个 app 只执行一次),用以验证模型之间的定义并缓存。
大多数情况下,你可以直接使用这个。
但是在使用事务的时候,我们会返回TxOrm
的实例。请参考orm 事务
和 v1.x 比起来,我们在事务上重新设计了一番,以规避相当多用户都会犯的错——即复用全局的 orm 对象来操作事务。
这体现了我们的一个新的认知——即,我们认为 orm 对象应该是一种无状态的对象。
在实际应用中,我们现在推荐大家保存全局的 orm 对象。而事务orm 对象,即 TxOrm 的实例,则应该每次使用完毕就丢弃。
QueryTable
o := orm.NewOrm()
var qs orm.QuerySeter
qs = o.QueryTable("user")
// 如果表没有定义过,会立刻 panic
Using
我们的 v2.x 移除了这个方法。因为 v1.x 的一些用户反馈,该方法容易被程序员误用。
在不恰当的切换数据库的时候,会导致使用相同 orm 实例的其余代码崩溃。
想象一下,你有一段代码本来只是想用 A 数据库的,结果另外一段代码切换到了 B 数据库。
我们推荐使用另外一个方法:
go o := orm.NewOrmUsingDB("db_name")
正如前面提及的,我们希望大家能够尽量复用 orm 实例。
Raw
使用 sql 语句直接进行操作
Raw 函数,返回一个 RawSeter 用以对设置的 sql 语句和参数进行操作
o := orm.NewOrm()
var r orm.RawSeter
r = o.Raw("UPDATE user SET name = ? WHERE name = ?", "testing", "slene")
Driver
返回当前 ORM 使用的 db 信息
type Driver interface {
Name() string
Type() DriverType
}
orm.RegisterDataBase("db1", "mysql", "root:root@/orm_db2?charset=utf8")
orm.RegisterDataBase("db2", "sqlite3", "data.db")
o1 := orm.NewOrmUsingDB("db1")
dr := o1.Driver()
fmt.Println(dr.Name() == "db1") // true
fmt.Println(dr.Type() == orm.DRMySQL) // true
o2 := orm.NewOrmUsingDB("db2")
dr = o2.Driver()
fmt.Println(dr.Name() == "db2") // true
fmt.Println(dr.Type() == orm.DRSqlite) // true
调试模式打印查询语句
简单的设置 Debug 为 true 打印查询的语句
可能存在性能问题,不建议使用在生产模式
func main() {
orm.Debug = true
...
默认使用 os.Stderr 输出日志信息
改变输出到你自己的 io.Writer
var w io.Writer
...
// 设置为你的 io.Writer
...
orm.DebugLog = orm.NewLog(w)
日志格式
[ORM] - 时间 - [Queries/数据库名] - [执行操作/执行时间] - [SQL语句] - 使用标点 `,` 分隔的参数列表 - 打印遇到的错误
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Exec / 0.4ms] - [INSERT INTO `user` (`name`) VALUES (?)] - `slene`
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Exec / 0.5ms] - [UPDATE `user` SET `name` = ? WHERE `id` = ?] - `astaxie`, `14`
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [db.QueryRow / 0.4ms] - [SELECT `id`, `name` FROM `user` WHERE `id` = ?] - `14`
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Exec / 0.4ms] - [INSERT INTO `post` (`user_id`,`title`,`content`) VALUES (?, ?, ?)] - `14`, `beego orm`, `powerful amazing`
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Query / 0.4ms] - [SELECT T1.`name` `User__Name`, T0.`user_id` `User`, T1.`id` `User__Id` FROM `post` T0 INNER JOIN `user` T1 ON T1.`id` = T0.`user_id` WHERE T0.`id` = ? LIMIT 1000] - `68`
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Exec / 0.4ms] - [DELETE FROM `user` WHERE `id` = ?] - `14`
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Query / 0.3ms] - [SELECT T0.`id` FROM `post` T0 WHERE T0.`user_id` IN (?) ] - `14`
[ORM] - 2013-08-09 13:18:16 - [Queries/default] - [ db.Exec / 0.4ms] - [DELETE FROM `post` WHERE `id` IN (?)] - `68`
日志内容包括 所有的数据库操作,事务,Prepare,等
对象的 CRUD 操作
如果已知主键的值,那么可以使用这些方法进行 CRUD 操作
对 object 操作的四个方法 Read / Insert / Update / Delete
o := orm.NewOrm()
user := new(User)
user.Name = "slene"
fmt.Println(o.Insert(user))
user.Name = "Your"
fmt.Println(o.Update(user))
fmt.Println(o.Read(user))
fmt.Println(o.Delete(user))
如果需要通过条件查询获取对象,请参见高级查询
Read
o := orm.NewOrm()
user := User{Id: 1}
err := o.Read(&user)
if err == orm.ErrNoRows {
fmt.Println("查询不到")
} else if err == orm.ErrMissPK {
fmt.Println("找不到主键")
} else {
fmt.Println(user.Id, user.Name)
}
Read 默认通过查询主键赋值,可以使用指定的字段进行查询:
user := User{Name: "slene"}
err = o.Read(&user, "Name")
...
复杂的单个对象查询参见 One
ReadOrCreate
尝试从数据库读取,不存在的话就创建一个。
它的实现机制,和具体的数据库有关。例如在 MYSQL 中,是使用
默认必须传入一个参数作为条件字段,同时也支持多个参数多个条件字段
o := orm.NewOrm()
user := User{Name: "slene"}
// 三个返回参数依次为:是否新创建的,对象 Id 值,错误
if created, id, err := o.ReadOrCreate(&user, "Name"); err == nil {
if created {
fmt.Println("New Insert an object. Id:", id)
} else {
fmt.Println("Get an object. Id:", id)
}
}
Insert
第一个返回值为自增健 Id 的值
o := orm.NewOrm()
var user User
user.Name = "slene"
user.IsActive = true
id, err := o.Insert(&user)
if err == nil {
fmt.Println(id)
}
创建后会自动对 auto 的 field 赋值
InsertMulti
同时插入多个对象
类似sql语句
insert into table (name, age) values("slene", 28),("astaxie", 30),("unknown", 20)
第一个参数 bulk 为并列插入的数量,第二个为对象的slice
返回值为成功插入的数量
users := []User{
{Name: "slene"},
{Name: "astaxie"},
{Name: "unknown"},
...
}
successNums, err := o.InsertMulti(100, users)
bulk 为 1 时,将会顺序插入 slice 中的数据
Update
第一个返回值为影响的行数
o := orm.NewOrm()
user := User{Id: 1}
if o.Read(&user) == nil {
user.Name = "MyName"
if num, err := o.Update(&user); err == nil {
fmt.Println(num)
}
}
Update 默认更新所有的字段,可以更新指定的字段:
// 只更新 Name
o.Update(&user, "Name")
// 指定多个字段
// o.Update(&user, "Field1", "Field2", ...)
...
根据复杂条件更新字段值参见 Update
Delete
第一个返回值为影响的行数
o := orm.NewOrm()
if num, err := o.Delete(&User{Id: 1}); err == nil {
fmt.Println(num)
}
Delete 操作会对反向关系进行操作,此例中 Post 拥有一个到 User 的外键。删除 User 的时候。如果 on_delete 设置为默认的级联操作,将删除对应的 Post
Changed in 1.0.3 删除以后不会删除 auto field 的值