name: Overview

sort: 1

Models － Beego ORM

Build Status Go Walker

Beego ORM is a powerful ORM framework written in Go. It is inspired by Django ORM and SQLAlchemy.

This framework is still under development so compatibility is not guaranteed.

Supported Database:

All of the database drivers have passed the tests, but we still need your feedback and bug reports.

ORM Features:

  • Supports all the types in Go.
  • CRUD is easy to use.
  • Auto join connection tables.
  • Compatible with crossing database queries.
  • Supports raw SQL query and mapping.
  • Strict and well-covered test cases ensure the ORM’s stability.

You can learn more in this documentation.

Install ORM:

  1. go get github.com/astaxie/beego/orm

Change log

Quickstart

Demo

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/astaxie/beego/orm"
  6.     _ "github.com/go-sql-driver/mysql" // import your required driver
  7. )
  9. // Model Struct
  10. type User struct {
  11.     Id   int
  12.     Name string `orm:"size(100)"`
  13. }
  15. func init() {
  16.     // register model
  17.     orm.RegisterModel(new(User))
  19.     // set default database
  20.     orm.RegisterDataBase("default", "mysql", "root:root@/my_db?charset=utf8")
  21. }
  23. func main() {
  24.     o := orm.NewOrm()
  26.     user := User{Name: "slene"}
  28.     // insert
  29.     id, err := o.Insert(&user)
  30.     fmt.Printf("ID: %d, ERR: %v\n", id, err)
  32.     // update
  33.     user.Name = "astaxie"
  34.     num, err := o.Update(&user)
  35.     fmt.Printf("NUM: %d, ERR: %v\n", num, err)
  37.     // read one
  38.     u := User{Id: user.Id}
  39.     err = o.Read(&u)
  40.     fmt.Printf("ERR: %v\n", err)
  42.     // delete
  43.     num, err = o.Delete(&u)
  44.     fmt.Printf("NUM: %d, ERR: %v\n", num, err)
  45. }

Relation Query

  1. type Post struct {
  2.     Id    int    `orm:"auto"`
  3.     Title string `orm:"size(100)"`
  4.     User  *User  `orm:"rel(fk)"`
  5. }
  7. var posts []*Post
  8. qs := o.QueryTable("post")
  9. num, err := qs.Filter("User__Name", "slene").All(&posts)

Raw SQL query

You can always use raw SQL to query and mapping.

  1. var maps []Params
  2. num, err := o.Raw("SELECT id FROM user WHERE name = ?", "slene").Values(&maps)
  3. if num > 0 {
  4.     fmt.Println(maps[0]["id"])
  5. }

Transactions

  1. o.Begin()
  2. ...
  3. user := User{Name: "slene"}
  4. id, err := o.Insert(&user)
  5. if err == nil {
  6.     o.Commit()
  7. } else {
  8.     o.Rollback()
  9. }

Debugging query log

In development environment, you can enable debug mode by:

  1. func main() {
  2.     orm.Debug = true
  3. ...

It will output every query statement including execution, preparation and transactions.

For example:

  1. [ORM] - 2013-08-09 13:18:16 - [Queries/default] - [    db.Exec /     0.4ms] -     [INSERT INTO `user` (`name`) VALUES (?)] - `slene`
  2. ...

Notes: It is not recommended to enable debug mode in a production environment.

Index

  1. Orm Usage
  2. CRUD of Object
  3. Advanced Queries
  4. Use Raw SQL
  5. Transactions
  6. Model Definition
  7. Command Line
  8. Test ORM
  9. Custom Fields
  10. FAQ