模型（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/astaxie/beego/orm

ORM 使用方法

比较规范的，现在models的文件夹下创建model的对象，所有的关于数据库的操作都是在models中进行的，controller调用models中的方法即可。

models.go:

package mainimport (    "github.com/astaxie/beego/orm" //导入包)//定义 struct和数据表进行映射的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 mainimport (    "fmt"
    "github.com/astaxie/beego/orm"
    _ "github.com/go-sql-driver/mysql" // 只是调用init方法)func init() {
    orm.RegisterDriver("mysql", orm.DRMySQL)

    orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8")
}func main() {
    o := orm.NewOrm()
    o.Using("default") // 默认使用 default，你可以指定为其他数据库

    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

三种默认数据库类型

// For version 1.6orm.DRMySQL
orm.DRSqlite
orm.DRPostgres// < 1.6orm.DR_MySQL
orm.DR_Sqlite
orm.DR_Postgres

// 参数1   driverName// 参数2   数据库类型// 这个用来设置 driverName 对应的数据库类型// mysql / sqlite3 / postgres 这三种是默认已经注册过的，所以可以无需设置orm.RegisterDriver("mysql", orm.DRMySQL)

RegisterDataBase

ORM 必须注册一个别名为 default 的数据库，作为默认使用。

ORM 使用 golang 自己的连接池

// RegisterDataBase Setting the database connect params. Use the database driver self dataSource args.func RegisterDataBase(aliasName, driverName, dataSource string, params ...int) error {    var (
        err error
        db  *sql.DB
        al  *alias
    )

    db, err = sql.Open(driverName, dataSource)    if err != nil {
        err = fmt.Errorf("register db `%s`, %s", aliasName, err.Error())        goto end
    }

    al, err = addAliasWthDB(aliasName, driverName, db)    if err != nil {        goto end
    }

    al.DataSource = dataSource

    detectTZ(al)    for i, v := range params {        switch i {        case 0:
            SetMaxIdleConns(al.Name, v)        case 1:
            SetMaxOpenConns(al.Name, v)
        }
    }

end:    if err != nil {        if db != nil {
            db.Close()
        }
        DebugLog.Println(err.Error())
    }    return err
}

// 参数1        数据库的别名，用来在 ORM 中切换数据库使用// 参数2        driverName// 参数3        对应的链接字符串orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8")// 参数4(可选)  设置最大空闲连接// 参数5(可选)  设置最大数据库连接 (go >= 1.2)maxIdle := 30maxConn := 30orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8", maxIdle, 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 mainimport "github.com/astaxie/beego/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 Ormer
o = orm.NewOrm() // 创建一个 Ormer// NewOrm 的同时会执行 orm.BootStrap (整个 app 只执行一次)，用以验证模型之间的定义并缓存。

切换数据库，或者，进行事务处理，都会作用于这个 Ormer 对象，以及其进行的任何查询。

所以：需要 切换数据库 和 事务处理 的话，不要使用全局保存的 Ormer 对象。

// Ormer define the orm interfacetype Ormer interface {    // read data to model
    // for example:
    //  this will find User by Id field
    //  u = &User{Id: user.Id}
    //  err = Ormer.Read(u)
    //  this will find User by UserName field
    //  u = &User{UserName: "astaxie", Password: "pass"}
    //  err = Ormer.Read(u, "UserName")
    Read(md interface{}, cols ...string) error    // Like Read(), but with "FOR UPDATE" clause, useful in transaction.
    // Some databases are not support this feature.
    ReadForUpdate(md interface{}, cols ...string) error    // Try to read a row from the database, or insert one if it doesn't exist
    ReadOrCreate(md interface{}, col1 string, cols ...string) (bool, int64, error)    // insert model data to database
    // for example:
    //  user := new(User)
    //  id, err = Ormer.Insert(user)
    //  user must a pointer and Insert will set user's pk field
    Insert(interface{}) (int64, error)    // mysql:InsertOrUpdate(model) or InsertOrUpdate(model,"colu=colu+value")
    // if colu type is integer : can use(+-*/), string : convert(colu,"value")
    // postgres: InsertOrUpdate(model,"conflictColumnName") or InsertOrUpdate(model,"conflictColumnName","colu=colu+value")
    // if colu type is integer : can use(+-*/), string : colu || "value"
    InsertOrUpdate(md interface{}, colConflitAndArgs ...string) (int64, error)    // insert some models to database
    InsertMulti(bulk int, mds interface{}) (int64, error)    // update model to database.
    // cols set the columns those want to update.
    // find model by Id(pk) field and update columns specified by fields, if cols is null then update all columns
    // for example:
    // user := User{Id: 2}
    //  user.Langs = append(user.Langs, "zh-CN", "en-US")
    //  user.Extra.Name = "beego"
    //  user.Extra.Data = "orm"
    //  num, err = Ormer.Update(&user, "Langs", "Extra")
    Update(md interface{}, cols ...string) (int64, error)    // delete model in database
    Delete(md interface{}, cols ...string) (int64, error)    // load related models to md model.
    // args are limit, offset int and order string.
    //
    // example:
    //  Ormer.LoadRelated(post,"Tags")
    //  for _,tag := range post.Tags{...}
    //args[0] bool true useDefaultRelsDepth ; false  depth 0
    //args[0] int  loadRelationDepth
    //args[1] int limit default limit 1000
    //args[2] int offset default offset 0
    //args[3] string order  for example : "-Id"
    // make sure the relation is defined in model struct tags.
    LoadRelated(md interface{}, name string, args ...interface{}) (int64, error)    // create a models to models queryer
    // for example:
    //  post := Post{Id: 4}
    //  m2m := Ormer.QueryM2M(&post, "Tags")
    QueryM2M(md interface{}, name string) QueryM2Mer    // return a QuerySeter for table operations.
    // table name can be string or struct.
    // e.g. QueryTable("user"), QueryTable(&user{}) or QueryTable((*User)(nil)),
    QueryTable(ptrStructOrTableName interface{}) QuerySeter    // switch to another registered database driver by given name.
    Using(name string) error    // begin transaction
    // for example:
    //  o := NewOrm()
    //  err := o.Begin()
    //  ...
    //  err = o.Rollback()
    Begin() error    // commit transaction
    Commit() error    // rollback transaction
    Rollback() error    // return a raw query seter for raw sql string.
    // for example:
    //   ormer.Raw("UPDATE `user` SET `user_name` = ? WHERE `user_name` = ?", "slene", "testing").Exec()
    //  // update user testing's name to slene
    Raw(query string, args ...interface{}) RawSeter
    Driver() Driver
}

QueryTable

传入表名，或者 Model 对象，返回一个 QuerySeter

o := orm.NewOrm()var qs QuerySeter
qs = o.QueryTable("user")// 如果表没有定义过，会立刻 panic

Using

切换为其他数据库

orm.RegisterDataBase("db1", "mysql", "root:root@/orm_db2?charset=utf8")
orm.RegisterDataBase("db2", "sqlite3", "data.db")

o1 := orm.NewOrm()
o1.Using("db1")

o2 := orm.NewOrm()
o2.Using("db2")// 切换为其他数据库以后// 这个 Ormer 对象的其下的 api 调用都将使用这个数据库

默认使用 default 数据库，无需调用 Using

Raw

使用 sql 语句直接进行操作

Raw 函数，返回一个 RawSeter 用以对设置的 sql 语句和参数进行操作

o := NewOrm()var r 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.NewOrm()
o1.Using("db1")
dr := o1.Driver()
fmt.Println(dr.Name() == "db1") // truefmt.Println(dr.Type() == orm.DRMySQL) // trueo2 := orm.NewOrm()
o2.Using("db2")
dr = o2.Driver()
fmt.Println(dr.Name() == "db2") // truefmt.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)

作者：若与
链接：https://www.jianshu.com/p/77e5ba832dcb