gorm/main_test.go

570 lines
16 KiB
Go
Raw Normal View History

2014-01-28 12:21:02 +04:00
package gorm_test
2013-10-25 18:31:56 +04:00
2013-10-26 20:36:56 +04:00
import (
2014-07-29 08:32:58 +04:00
"database/sql"
"database/sql/driver"
2013-10-29 03:39:26 +04:00
"fmt"
2014-07-29 08:32:58 +04:00
testdb "github.com/erikstmartin/go-testdb"
2013-11-04 16:32:46 +04:00
_ "github.com/go-sql-driver/mysql"
2014-04-29 12:02:18 +04:00
"github.com/jinzhu/gorm"
2014-07-29 08:32:58 +04:00
"github.com/jinzhu/now"
2013-10-28 16:27:25 +04:00
_ "github.com/lib/pq"
2013-11-04 16:47:45 +04:00
_ "github.com/mattn/go-sqlite3"
2014-07-29 08:32:58 +04:00
"strconv"
2013-12-17 14:54:30 +04:00
2013-12-04 08:06:50 +04:00
"os"
2014-07-29 08:32:58 +04:00
"testing"
2013-10-26 20:36:56 +04:00
"time"
)
2013-10-25 18:31:56 +04:00
2013-10-27 03:38:08 +04:00
var (
2014-08-28 11:33:43 +04:00
DB gorm.DB
2013-10-27 03:38:08 +04:00
t1, t2, t3, t4, t5 time.Time
)
2013-10-26 17:05:54 +04:00
func init() {
2013-10-29 03:39:26 +04:00
var err error
2013-12-04 08:06:50 +04:00
switch os.Getenv("GORM_DIALECT") {
case "mysql":
// CREATE USER 'gorm'@'localhost' IDENTIFIED BY 'gorm';
2013-12-30 08:46:37 +04:00
// CREATE DATABASE gorm;
2013-12-04 08:06:50 +04:00
// GRANT ALL ON gorm.* TO 'gorm'@'localhost';
fmt.Println("testing mysql...")
2014-08-28 11:33:43 +04:00
DB, err = gorm.Open("mysql", "gorm:gorm@/gorm?charset=utf8&parseTime=True")
2014-04-29 12:02:18 +04:00
case "postgres":
2013-12-04 08:06:50 +04:00
fmt.Println("testing postgres...")
2014-08-28 11:33:43 +04:00
DB, err = gorm.Open("postgres", "user=gorm DB.ame=gorm sslmode=disable")
2014-04-29 12:02:18 +04:00
default:
fmt.Println("testing sqlite3...")
2014-08-28 11:33:43 +04:00
DB, err = gorm.Open("sqlite3", "/tmp/gorm.db")
2013-12-04 08:06:50 +04:00
}
2014-01-03 15:23:41 +04:00
2014-08-28 11:33:43 +04:00
// DB.SetLogger(Logger{log.New(os.Stdout, "\r\n", 0)})
// DB.SetLogger(log.New(os.Stdout, "\r\n", 0))
DB.LogMode(true)
DB.LogMode(false)
2014-01-03 15:23:41 +04:00
2013-10-29 03:39:26 +04:00
if err != nil {
panic(fmt.Sprintf("No error should happen when connect database, but got %+v", err))
}
2013-11-04 16:32:46 +04:00
2014-08-28 11:33:43 +04:00
DB.DB().SetMaxIdleConns(10)
2013-10-28 06:09:44 +04:00
2014-07-29 06:59:13 +04:00
runMigration()
}
2014-07-29 08:32:58 +04:00
func TestExceptionsWithInvalidSql(t *testing.T) {
var columns []string
2014-08-28 11:33:43 +04:00
if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Should got error with invalid SQL")
}
2014-08-28 11:33:43 +04:00
if DB.Model(&User{}).Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Should got error with invalid SQL")
}
2014-08-28 11:33:43 +04:00
if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Find(&User{}).Error == nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Should got error with invalid SQL")
}
var count1, count2 int64
2014-08-28 11:33:43 +04:00
DB.Model(&User{}).Count(&count1)
2014-07-29 08:32:58 +04:00
if count1 <= 0 {
t.Errorf("Should find some users")
}
2014-08-28 11:33:43 +04:00
if DB.Where("name = ?", "jinzhu; delete * from users").First(&User{}).Error == nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Should got error with invalid SQL")
}
2014-08-28 11:33:43 +04:00
DB.Model(&User{}).Count(&count2)
2014-07-29 08:32:58 +04:00
if count1 != count2 {
t.Errorf("No user should not be deleted by invalid SQL")
}
}
func TestSetTable(t *testing.T) {
2014-08-28 11:33:43 +04:00
if DB.Table("users").Pluck("age", &[]int{}).Error != nil {
2014-07-29 08:32:58 +04:00
t.Errorf("No errors should happen if set table for pluck")
}
var users []User
2014-08-28 11:33:43 +04:00
if DB.Table("users").Find(&[]User{}).Error != nil {
2014-07-29 08:32:58 +04:00
t.Errorf("No errors should happen if set table for find")
}
2014-08-28 11:33:43 +04:00
if DB.Table("invalid_table").Find(&users).Error == nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Should got error when table is set to an invalid table")
}
2014-08-28 11:33:43 +04:00
DB.Exec("drop table deleted_users;")
if DB.Table("deleted_users").CreateTable(&User{}).Error != nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Create table with specified table")
}
2014-08-28 11:33:43 +04:00
DB.Table("deleted_users").Save(&User{Name: "DeletedUser"})
2014-07-29 08:32:58 +04:00
var deletedUsers []User
2014-08-28 11:33:43 +04:00
DB.Table("deleted_users").Find(&deletedUsers)
2014-07-29 08:32:58 +04:00
if len(deletedUsers) != 1 {
t.Errorf("Query from specified table")
}
var user1, user2, user3 User
2014-08-28 11:33:43 +04:00
DB.First(&user1).Table("deleted_users").First(&user2).Table("").First(&user3)
2014-07-29 08:32:58 +04:00
if (user1.Name == user2.Name) || (user1.Name != user3.Name) {
t.Errorf("unset specified table with blank string")
}
}
2014-07-29 12:25:38 +04:00
type Order struct {
}
type Cart struct {
}
func (c Cart) TableName() string {
return "shopping_cart"
}
2014-07-29 08:32:58 +04:00
func TestTableName(t *testing.T) {
2014-08-28 11:33:43 +04:00
DB := DB.Model("")
if DB.NewScope(Order{}).TableName() != "orders" {
2014-07-29 08:32:58 +04:00
t.Errorf("Order's table name should be orders")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope(&Order{}).TableName() != "orders" {
2014-07-29 08:32:58 +04:00
t.Errorf("&Order's table name should be orders")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope([]Order{}).TableName() != "orders" {
2014-07-29 08:32:58 +04:00
t.Errorf("[]Order's table name should be orders")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope(&[]Order{}).TableName() != "orders" {
2014-07-29 08:32:58 +04:00
t.Errorf("&[]Order's table name should be orders")
}
2014-08-28 11:33:43 +04:00
DB.SingularTable(true)
if DB.NewScope(Order{}).TableName() != "order" {
2014-07-29 08:32:58 +04:00
t.Errorf("Order's singular table name should be order")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope(&Order{}).TableName() != "order" {
2014-07-29 08:32:58 +04:00
t.Errorf("&Order's singular table name should be order")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope([]Order{}).TableName() != "order" {
2014-07-29 08:32:58 +04:00
t.Errorf("[]Order's singular table name should be order")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope(&[]Order{}).TableName() != "order" {
2014-07-29 08:32:58 +04:00
t.Errorf("&[]Order's singular table name should be order")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope(&Cart{}).TableName() != "shopping_cart" {
2014-07-29 08:32:58 +04:00
t.Errorf("&Cart's singular table name should be shopping_cart")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope(Cart{}).TableName() != "shopping_cart" {
2014-07-29 08:32:58 +04:00
t.Errorf("Cart's singular table name should be shopping_cart")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope(&[]Cart{}).TableName() != "shopping_cart" {
2014-07-29 08:32:58 +04:00
t.Errorf("&[]Cart's singular table name should be shopping_cart")
}
2014-08-28 11:33:43 +04:00
if DB.NewScope([]Cart{}).TableName() != "shopping_cart" {
2014-07-29 08:32:58 +04:00
t.Errorf("[]Cart's singular table name should be shopping_cart")
}
2014-08-28 11:33:43 +04:00
DB.SingularTable(false)
2014-07-29 08:32:58 +04:00
}
func TestSqlNullValue(t *testing.T) {
2014-08-28 11:33:43 +04:00
DB.DropTable(&NullValue{})
DB.AutoMigrate(&NullValue{})
2014-07-29 08:32:58 +04:00
2014-08-28 11:33:43 +04:00
if err := DB.Save(&NullValue{Name: sql.NullString{String: "hello", Valid: true},
2014-07-29 08:32:58 +04:00
Age: sql.NullInt64{Int64: 18, Valid: true},
Male: sql.NullBool{Bool: true, Valid: true},
Height: sql.NullFloat64{Float64: 100.11, Valid: true},
AddedAt: NullTime{Time: time.Now(), Valid: true},
}).Error; err != nil {
t.Errorf("Not error should raise when test null value")
}
var nv NullValue
2014-08-28 11:33:43 +04:00
DB.First(&nv, "name = ?", "hello")
2014-07-29 08:32:58 +04:00
if nv.Name.String != "hello" || nv.Age.Int64 != 18 || nv.Male.Bool != true || nv.Height.Float64 != 100.11 || nv.AddedAt.Valid != true {
t.Errorf("Should be able to fetch null value")
}
2014-08-28 11:33:43 +04:00
if err := DB.Save(&NullValue{Name: sql.NullString{String: "hello-2", Valid: true},
2014-07-29 08:32:58 +04:00
Age: sql.NullInt64{Int64: 18, Valid: false},
Male: sql.NullBool{Bool: true, Valid: true},
Height: sql.NullFloat64{Float64: 100.11, Valid: true},
AddedAt: NullTime{Time: time.Now(), Valid: false},
}).Error; err != nil {
t.Errorf("Not error should raise when test null value")
}
var nv2 NullValue
2014-08-28 11:33:43 +04:00
DB.First(&nv2, "name = ?", "hello-2")
2014-07-29 08:32:58 +04:00
if nv2.Name.String != "hello-2" || nv2.Age.Int64 != 0 || nv2.Male.Bool != true || nv2.Height.Float64 != 100.11 || nv2.AddedAt.Valid != false {
t.Errorf("Should be able to fetch null value")
}
2014-08-28 11:33:43 +04:00
if err := DB.Save(&NullValue{Name: sql.NullString{String: "hello-3", Valid: false},
2014-07-29 08:32:58 +04:00
Age: sql.NullInt64{Int64: 18, Valid: false},
Male: sql.NullBool{Bool: true, Valid: true},
Height: sql.NullFloat64{Float64: 100.11, Valid: true},
AddedAt: NullTime{Time: time.Now(), Valid: false},
}).Error; err == nil {
t.Errorf("Can't save because of name can't be null")
}
}
func TestTransaction(t *testing.T) {
2014-08-28 11:33:43 +04:00
tx := DB.Begin()
2014-07-29 08:32:58 +04:00
u := User{Name: "transcation"}
if err := tx.Save(&u).Error; err != nil {
t.Errorf("No error should raise")
}
if err := tx.First(&User{}, "name = ?", "transcation").Error; err != nil {
t.Errorf("Should find saved record")
}
if sqlTx, ok := tx.CommonDB().(*sql.Tx); !ok || sqlTx == nil {
t.Errorf("Should return the underlying sql.Tx")
}
tx.Rollback()
if err := tx.First(&User{}, "name = ?", "transcation").Error; err == nil {
t.Errorf("Should not find record after rollback")
}
2014-08-28 11:33:43 +04:00
tx2 := DB.Begin()
2014-07-29 08:32:58 +04:00
u2 := User{Name: "transcation-2"}
if err := tx2.Save(&u2).Error; err != nil {
t.Errorf("No error should raise")
}
if err := tx2.First(&User{}, "name = ?", "transcation-2").Error; err != nil {
t.Errorf("Should find saved record")
}
tx2.Commit()
2014-08-28 11:33:43 +04:00
if err := DB.First(&User{}, "name = ?", "transcation-2").Error; err != nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Should be able to find committed record")
}
}
func TestRow(t *testing.T) {
user1 := User{Name: "RowUser1", Age: 1, Birthday: now.MustParse("2000-1-1")}
user2 := User{Name: "RowUser2", Age: 10, Birthday: now.MustParse("2010-1-1")}
user3 := User{Name: "RowUser3", Age: 20, Birthday: now.MustParse("2020-1-1")}
2014-08-28 11:33:43 +04:00
DB.Save(&user1).Save(&user2).Save(&user3)
2014-07-29 08:32:58 +04:00
2014-08-28 11:33:43 +04:00
row := DB.Table("users").Where("name = ?", user2.Name).Select("age").Row()
2014-07-29 08:32:58 +04:00
var age int64
row.Scan(&age)
if age != 10 {
t.Errorf("Scan with Row")
}
}
func TestRows(t *testing.T) {
user1 := User{Name: "RowsUser1", Age: 1, Birthday: now.MustParse("2000-1-1")}
user2 := User{Name: "RowsUser2", Age: 10, Birthday: now.MustParse("2010-1-1")}
user3 := User{Name: "RowsUser3", Age: 20, Birthday: now.MustParse("2020-1-1")}
2014-08-28 11:33:43 +04:00
DB.Save(&user1).Save(&user2).Save(&user3)
2014-07-29 08:32:58 +04:00
2014-08-28 11:33:43 +04:00
rows, err := DB.Table("users").Where("name = ? or name = ?", user2.Name, user3.Name).Select("name, age").Rows()
2014-07-29 08:32:58 +04:00
if err != nil {
t.Errorf("Not error should happen, but got")
}
count := 0
for rows.Next() {
var name string
var age int64
rows.Scan(&name, &age)
count++
}
if count != 2 {
t.Errorf("Should found two records with name 3")
}
}
func TestScan(t *testing.T) {
user1 := User{Name: "ScanUser1", Age: 1, Birthday: now.MustParse("2000-1-1")}
user2 := User{Name: "ScanUser2", Age: 10, Birthday: now.MustParse("2010-1-1")}
user3 := User{Name: "ScanUser3", Age: 20, Birthday: now.MustParse("2020-1-1")}
2014-08-28 11:33:43 +04:00
DB.Save(&user1).Save(&user2).Save(&user3)
2014-07-29 08:32:58 +04:00
type result struct {
Name string
Age int
}
var res result
2014-08-28 11:33:43 +04:00
DB.Table("users").Select("name, age").Where("name = ?", user3.Name).Scan(&res)
2014-07-29 08:32:58 +04:00
if res.Name != user3.Name {
t.Errorf("Scan into struct should work")
}
var doubleAgeRes result
2014-08-28 11:33:43 +04:00
DB.Table("users").Select("age + age as age").Where("name = ?", user3.Name).Scan(&doubleAgeRes)
2014-07-29 08:32:58 +04:00
if doubleAgeRes.Age != res.Age*2 {
t.Errorf("Scan double age as age")
}
var ress []result
2014-08-28 11:33:43 +04:00
DB.Table("users").Select("name, age").Where("name in (?)", []string{user2.Name, user3.Name}).Scan(&ress)
2014-07-29 08:32:58 +04:00
if len(ress) != 2 || ress[0].Name != user2.Name || ress[1].Name != user3.Name {
t.Errorf("Scan into struct map")
}
}
func TestRaw(t *testing.T) {
user1 := User{Name: "ExecRawSqlUser1", Age: 1, Birthday: now.MustParse("2000-1-1")}
user2 := User{Name: "ExecRawSqlUser2", Age: 10, Birthday: now.MustParse("2010-1-1")}
user3 := User{Name: "ExecRawSqlUser3", Age: 20, Birthday: now.MustParse("2020-1-1")}
2014-08-28 11:33:43 +04:00
DB.Save(&user1).Save(&user2).Save(&user3)
2014-07-29 08:32:58 +04:00
type result struct {
Name string
Email string
}
var ress []result
2014-08-28 11:33:43 +04:00
DB.Raw("SELECT name, age FROM users WHERE name = ? or name = ?", user2.Name, user3.Name).Scan(&ress)
2014-07-29 08:32:58 +04:00
if len(ress) != 2 || ress[0].Name != user2.Name || ress[1].Name != user3.Name {
t.Errorf("Raw with scan")
}
2014-08-28 11:33:43 +04:00
rows, _ := DB.Raw("select name, age from users where name = ?", user3.Name).Rows()
2014-07-29 08:32:58 +04:00
count := 0
for rows.Next() {
count++
}
if count != 1 {
t.Errorf("Raw with Rows should find one record with name 3")
}
2014-08-28 11:33:43 +04:00
DB.Exec("update users set name=? where name in (?)", "jinzhu", []string{user1.Name, user2.Name, user3.Name})
if DB.Where("name in (?)", []string{user1.Name, user2.Name, user3.Name}).First(&User{}).Error != gorm.RecordNotFound {
2014-07-29 08:32:58 +04:00
t.Error("Raw sql to update records")
}
}
func TestGroup(t *testing.T) {
2014-08-28 11:33:43 +04:00
rows, err := DB.Select("name").Table("users").Group("name").Rows()
2014-07-29 08:32:58 +04:00
if err == nil {
defer rows.Close()
for rows.Next() {
var name string
rows.Scan(&name)
}
} else {
t.Errorf("Should not raise any error")
}
}
func TestJoins(t *testing.T) {
type result struct {
Name string
Email string
}
user := User{
Name: "joins",
Emails: []Email{{Email: "join1@example.com"}, {Email: "join2@example.com"}},
}
2014-08-28 11:33:43 +04:00
DB.Save(&user)
2014-07-29 08:32:58 +04:00
var results []result
2014-08-28 11:33:43 +04:00
DB.Table("users").Select("name, email").Joins("left join emails on emails.user_id = users.id").Where("name = ?", "joins").Scan(&results)
2014-07-29 08:32:58 +04:00
if len(results) != 2 || results[0].Email != "join1@example.com" || results[1].Email != "join2@example.com" {
t.Errorf("Should find all two emails with Join")
}
}
func TestHaving(t *testing.T) {
2014-08-28 11:33:43 +04:00
rows, err := DB.Select("name, count(*) as total").Table("users").Group("name").Having("name IN (?)", []string{"2", "3"}).Rows()
2014-07-29 08:32:58 +04:00
if err == nil {
defer rows.Close()
for rows.Next() {
var name string
var total int64
rows.Scan(&name, &total)
if name == "2" && total != 1 {
t.Errorf("Should have one user having name 2")
}
if name == "3" && total != 2 {
t.Errorf("Should have two users having name 3")
}
}
} else {
t.Errorf("Should not raise any error")
}
}
func TestTimeWithZone(t *testing.T) {
var format = "2006-01-02 15:04:05 -0700"
var times []time.Time
GMT8, _ := time.LoadLocation("Asia/Shanghai")
times = append(times, time.Date(2013, 02, 19, 1, 51, 49, 123456789, GMT8))
times = append(times, time.Date(2013, 02, 18, 17, 51, 49, 123456789, time.UTC))
for index, vtime := range times {
name := "time_with_zone_" + strconv.Itoa(index)
user := User{Name: name, Birthday: vtime}
2014-08-28 11:33:43 +04:00
DB.Save(&user)
2014-07-29 08:32:58 +04:00
if user.Birthday.UTC().Format(format) != "2013-02-18 17:51:49 +0000" {
t.Errorf("User's birthday should not be changed after save")
}
var findUser, findUser2, findUser3 User
2014-08-28 11:33:43 +04:00
DB.First(&findUser, "name = ?", name)
2014-07-29 08:32:58 +04:00
if findUser.Birthday.UTC().Format(format) != "2013-02-18 17:51:49 +0000" {
t.Errorf("User's birthday should not be changed after find")
}
2014-08-28 11:33:43 +04:00
if DB.Where("id = ? AND birthday >= ?", findUser.Id, vtime.Add(-time.Minute)).First(&findUser2).RecordNotFound() {
2014-07-29 08:32:58 +04:00
t.Errorf("User should be found")
}
2014-08-28 11:33:43 +04:00
if !DB.Where("id = ? AND birthday >= ?", findUser.Id, vtime.Add(time.Minute)).First(&findUser3).RecordNotFound() {
2014-07-29 08:32:58 +04:00
t.Errorf("User should not be found")
}
}
}
func TestHstore(t *testing.T) {
2014-07-29 12:25:38 +04:00
type Details struct {
Id int64
Bulk gorm.Hstore
}
2014-07-29 08:32:58 +04:00
if dialect := os.Getenv("GORM_DIALECT"); dialect != "postgres" {
t.Skip()
}
2014-08-28 11:33:43 +04:00
if err := DB.Exec("CREATE EXTENSION IF NOT EXISTS hstore").Error; err != nil {
2014-07-29 08:32:58 +04:00
fmt.Println("\033[31mHINT: Must be superuser to create hstore extension (ALTER USER gorm WITH SUPERUSER;)\033[0m")
panic(fmt.Sprintf("No error should happen when create hstore extension, but got %+v", err))
}
2014-08-28 11:33:43 +04:00
DB.Exec("drop table details")
2014-07-29 08:32:58 +04:00
2014-08-28 11:33:43 +04:00
if err := DB.CreateTable(&Details{}).Error; err != nil {
2014-07-29 08:32:58 +04:00
panic(fmt.Sprintf("No error should happen when create table, but got %+v", err))
}
bankAccountId, phoneNumber, opinion := "123456", "14151321232", "sharkbait"
bulk := map[string]*string{
"bankAccountId": &bankAccountId,
"phoneNumber": &phoneNumber,
"opinion": &opinion,
}
d := Details{Bulk: bulk}
2014-08-28 11:33:43 +04:00
DB.Save(&d)
2014-07-29 08:32:58 +04:00
var d2 Details
2014-08-28 11:33:43 +04:00
if err := DB.First(&d2).Error; err != nil {
2014-07-29 08:32:58 +04:00
t.Errorf("Got error when tried to fetch details: %+v", err)
}
for k := range bulk {
if r, ok := d2.Bulk[k]; ok {
if res, _ := bulk[k]; *res != *r {
t.Errorf("Details should be equal")
}
} else {
t.Errorf("Details should be existed")
}
}
}
func TestSetAndGet(t *testing.T) {
2014-08-28 11:33:43 +04:00
if value, ok := DB.Set("hello", "world").Get("hello"); !ok {
t.Errorf("Should be able to get setting after set")
} else {
if value.(string) != "world" {
t.Errorf("Setted value should not be changed")
}
}
2014-08-28 11:33:43 +04:00
if _, ok := DB.Get("non_existing"); ok {
t.Errorf("Get non existing key should return error")
}
}
2014-07-29 08:32:58 +04:00
func TestCompatibilityMode(t *testing.T) {
2014-08-28 11:33:43 +04:00
DB, _ := gorm.Open("testdb", "")
2014-07-29 08:32:58 +04:00
testdb.SetQueryFunc(func(query string) (driver.Rows, error) {
columns := []string{"id", "name", "age"}
result := `
1,Tim,20
2,Joe,25
3,Bob,30
`
return testdb.RowsFromCSVString(columns, result), nil
})
var users []User
2014-08-28 11:33:43 +04:00
DB.Find(&users)
2014-07-29 08:32:58 +04:00
if (users[0].Name != "Tim") || len(users) != 3 {
t.Errorf("Unexcepted result returned")
}
}
func BenchmarkGorm(b *testing.B) {
b.N = 2000
for x := 0; x < b.N; x++ {
e := strconv.Itoa(x) + "benchmark@example.org"
email := BigEmail{Email: e, UserAgent: "pc", RegisteredAt: time.Now()}
// Insert
2014-08-28 11:33:43 +04:00
DB.Save(&email)
2014-07-29 08:32:58 +04:00
// Query
2014-08-28 11:33:43 +04:00
DB.First(&BigEmail{}, "email = ?", e)
2014-07-29 08:32:58 +04:00
// Update
2014-08-28 11:33:43 +04:00
DB.Model(&email).UpdateColumn("email", "new-"+e)
2014-07-29 08:32:58 +04:00
// Delete
2014-08-28 11:33:43 +04:00
DB.Delete(&email)
2014-07-29 08:32:58 +04:00
}
}
func BenchmarkRawSql(b *testing.B) {
2014-08-28 11:33:43 +04:00
DB, _ := sql.Open("postgres", "user=gorm DB.ame=gorm sslmode=disable")
DB.SetMaxIdleConns(10)
2014-07-29 08:32:58 +04:00
insert_sql := "INSERT INTO emails (user_id,email,user_agent,registered_at,created_at,updated_at) VALUES ($1,$2,$3,$4,$5,$6) RETURNING id"
query_sql := "SELECT * FROM emails WHERE email = $1 ORDER BY id LIMIT 1"
update_sql := "UPDATE emails SET email = $1, updated_at = $2 WHERE id = $3"
delete_sql := "DELETE FROM orders WHERE id = $1"
b.N = 2000
for x := 0; x < b.N; x++ {
var id int64
e := strconv.Itoa(x) + "benchmark@example.org"
email := BigEmail{Email: e, UserAgent: "pc", RegisteredAt: time.Now()}
// Insert
2014-08-28 11:33:43 +04:00
DB.QueryRow(insert_sql, email.UserId, email.Email, email.UserAgent, email.RegisteredAt, time.Now(), time.Now()).Scan(&id)
2014-07-29 08:32:58 +04:00
// Query
2014-08-28 11:33:43 +04:00
rows, _ := DB.Query(query_sql, email.Email)
2014-07-29 08:32:58 +04:00
rows.Close()
// Update
2014-08-28 11:33:43 +04:00
DB.Exec(update_sql, "new-"+e, time.Now(), id)
2014-07-29 08:32:58 +04:00
// Delete
2014-08-28 11:33:43 +04:00
DB.Exec(delete_sql, id)
2014-07-29 08:32:58 +04:00
}
}