How to access Gorm in Revel Controller?

let me start by saying these are my first couple days of toying around in Go.

I'm trying to use the Revel framework with Gorm like this:

app/controllers/gorm.go

package controllers

import (
	"fmt"
	"go-testapp/app/models"

	_ "github.com/go-sql-driver/mysql"
	"github.com/jinzhu/gorm"
	"github.com/revel/revel"
)

var DB gorm.DB

func InitDB() {
	var err error
	DB, err = gorm.Open("mysql", "root:@/go-testapp?charset=utf8&parseTime=True")
	if err != nil {
		panic(err)
	}
	DB.LogMode(true)
	DB.AutoMigrate(models.User{})
}

type GormController struct {
	*revel.Controller
	DB *gorm.DB
}

app/controller/app.go

package controllers

import (
	"fmt"
	"go-bingo/app/models"

	_ "github.com/go-sql-driver/mysql"
	"github.com/revel/revel"
)

type App struct {
	GormController
}

func (c App) Index() revel.Result {
	user := models.User{Name: "Jinzhu", Age: 18}

	fmt.Println(c.DB)
	c.DB.NewRecord(user)

	c.DB.Create(&user)

	return c.RenderJson(user)
}

After running it results in:

runtime error: invalid memory address or nil pointer dereference on line 19 c.DB.NewRecord(user)

It successfully creates the datatables with automigrate, but I have no idea how I should use Gorm in my controller.

Any hints in the right direction?

Important note

it's just replacement for GORP of original example of the Revel. And it comes with some pitfalls of the origin. This answer can be used as drop-in replacement for the original one. But it doesn't solve the pitfalls.

Please, take a look comments of this unswer and @MaxGabriel's answer that solves the pitfalls.

I'd recommend to use @MaxGabriel's solution to protect you application against some kinds of slow-* DDoS attacks. And to reduce (in some cases) DB pressure.

Original answer

@rauyran rights, you have to invoke InitDB inside init function (into controllers package).

Full example here (too much):

Tree

<!-- language: lang-none -->

/app
    /controllers
      app.go
      gorm.go
      init.go
    /models
      user.go
[...]

user.go

<!-- language: java -->

// models/user.go
package models

import  "time" // if you need/want

type User struct {          // example user fields
    Id                    int64
    Name                  string
    EncryptedPassword     []byte
    Password              string      `sql:"-"`
    CreatedAt             time.Time
    UpdatedAt             time.Time
    DeletedAt             time.Time 	// for soft delete
}

gorm.go

<!-- language: java -->

//controllers/gorm.go
package controllers

import (
	"github.com/jinzhu/gorm"
    _ "github.com/lib/pq" // my example for postgres
    // short name for revel
    r "github.com/revel/revel"
    // YOUR APP NAME
    "yourappname/app/models"
    "database/sql"
)

// type: revel controller with `*gorm.DB`
// c.Txn will keep `Gdb *gorm.DB`
type GormController struct {
	*r.Controller
	Txn *gorm.DB
}

// it can be used for jobs
var Gdb *gorm.DB

// init db
func InitDB() {
	var err error
	// open db
	Gdb, err = gorm.Open("postgres", "user=uname dbname=udbname sslmode=disable password=supersecret")
	if err != nil {
		r.ERROR.Println("FATAL", err)
		panic( err )
	}
	Gdb.AutoMigrate(&models.User{})
    // unique index if need
	//Gdb.Model(&models.User{}).AddUniqueIndex("idx_user_name", "name")
}


// transactions

// This method fills the c.Txn before each transaction
func (c *GormController) Begin() r.Result {
	txn := Gdb.Begin()
	if txn.Error != nil {
		panic(txn.Error)
	}
	c.Txn = txn
	return nil
}

// This method clears the c.Txn after each transaction
func (c *GormController) Commit() r.Result {
	if c.Txn == nil {
		return nil
	}
	c.Txn.Commit()
	if err := c.Txn.Error; err != nil && err != sql.ErrTxDone {
		panic(err)
	}
	c.Txn = nil
	return nil
}

// This method clears the c.Txn after each transaction, too
func (c *GormController) Rollback() r.Result {
	if c.Txn == nil {
		return nil
	}
	c.Txn.Rollback()
	if err := c.Txn.Error; err != nil && err != sql.ErrTxDone {
		panic(err)
	}
	c.Txn = nil
	return nil
}

app.go

<!-- language: java -->

package controllers

import(
	"github.com/revel/revel"
	"yourappname/app/models"
)

type App struct {
	GormController
}

func (c App) Index() revel.Result {
	user := models.User{Name: "Jinzhup"}
	c.Txn.NewRecord(user)
	c.Txn.Create(&user)
    return c.RenderJSON(user)
}

init.go

<!-- language: java -->

package controllers
import "github.com/revel/revel"

func init() {
	revel.OnAppStart(InitDB) // invoke InitDB function before
	revel.InterceptMethod((*GormController).Begin, revel.BEFORE)
	revel.InterceptMethod((*GormController).Commit, revel.AFTER)
	revel.InterceptMethod((*GormController).Rollback, revel.FINALLY)
}

As you can see, it's like Revel's Booking modified for GORM.

Works fine for me. Result:

<!-- language: lang-json -->

{
  "Id": 5,
  "Name": "Jinzhup",
  "EncryptedPassword": null,
  "Password": "",
  "CreatedAt": "2014-09-22T17:55:14.828661062+04:00",
  "UpdatedAt": "2014-09-22T17:55:14.828661062+04:00",
  "DeletedAt": "0001-01-01T00:00:00Z"
}

This answer is derived from @IvanBlack's answer, at his suggestion. His version is a direct translation of the Revel example code, but we identified some problems with the original code that this answer fixes. The main changes it makes are:

1. The entire HTTP request is no longer wrapped by a database transaction. Wrapping the entire HTTP request keeps open the transaction far longer than necessary, which could cause a number of problems:

   • Your transactions will hold locks on the database, and many transactions holding locks could lead to deadlocks
   • More database resources are used
   • These problems are magnified if your HTTP requests aren't mostly limited by your SQL database access. E.g. if your HTTP request blocks for 30 seconds on making an external HTTP request or accessing another database, the slowdown on those services could affect your SQL database.

2. Because the transaction is no longer automatically being checked for errors at the end of the HTTP request, errors are checked as soon as the database insert is made. This is more correct as well: Imagine that after inserting the User struct into a database, you then stored the User.Id in another database like Redis. This would be fine if the database insert worked, but if it failed and you didn't immediately check the error, you would insert the default int64 value of 0 into Redis (before later rolling back only the SQL transaction).

Tree

<!-- language: lang-none -->

/app
    /controllers
      app.go
      gorm.go
      init.go
    /models
      user.go
[...]

user.go

<!-- language: java -->

// models/user.go
package models

import  "time" // if you need/want

type User struct {          // example user fields
    Id                    int64
    Name                  string
    EncryptedPassword     []byte
    Password              string      `sql:"-"`
    CreatedAt             time.Time
    UpdatedAt             time.Time
    DeletedAt             time.Time 	// for soft delete
}

gorm.go

<!-- language: java -->

//controllers/gorm.go
package controllers

import (
    "github.com/jinzhu/gorm"
    _ "github.com/lib/pq" // my example for postgres
    // short name for revel
    r "github.com/revel/revel"
)

// type: revel controller with `*gorm.DB`
type GormController struct {
    *r.Controller
    DB *gorm.DB
}

// it can be used for jobs
var Gdb *gorm.DB

// init db
func InitDB() {
    var err error
    // open db
    Gdb, err = gorm.Open("postgres", "user=USERNAME dbname=DBNAME sslmode=disable")
    Gdb.LogMode(true) // Print SQL statements
    if err != nil {
        r.ERROR.Println("FATAL", err)
        panic(err)
    }
}

func (c *GormController) SetDB() r.Result {
    c.DB = Gdb
    return nil
}

init.go

<!-- language: java -->

package controllers
import "github.com/revel/revel"

func init() {
    revel.OnAppStart(InitDB) // invoke InitDB function before
    revel.InterceptMethod((*GormController).SetDB, revel.BEFORE)
}

app.go

<!-- language: java -->

package controllers

import(
	"github.com/revel/revel"
	"yourappname/app/models"
)

type App struct {
	GormController
}

func (c App) Index() revel.Result {
	user := models.User{Name: "Jinzhup"} // Note: In practice you should initialize all struct fields
	if err := c.DB.Create(&user).Error; err != nil {
        panic(err)
    }
    return c.RenderJSON(user)
}

Result:

<!-- language: lang-json -->

{
  "Id": 5,
  "Name": "Jinzhup",
  "EncryptedPassword": null,
  "Password": "",
  "CreatedAt": "2014-09-22T17:55:14.828661062+04:00",
  "UpdatedAt": "2014-09-22T17:55:14.828661062+04:00",
  "DeletedAt": "0001-01-01T00:00:00Z"
}

Your error is caused because you haven't initialised your c.DB database variable, it's still nil.

In your controllers/init.go file make sure you are calling revel.OnAppStart(InitDB). It should look something like this:

package controllers

import "github.com/revel/revel"

func init() {
    revel.OnAppStart(InitDB)
    // maybe some other init things
}

OR you need to pass in a pointer to AutoMigrate?

 DB.AutoMigrate(&models.User{})