add benchmark tests

benchmark.sh

@@ -0,0 +1 @@
+go test -v -bench=. -run=XXX

benchmark_base_test.go

@@ -14,24 +14,7 @@ type BigStruct struct {
 	NickName string
 }
 
-func doBenchDriverInsert(engine *Engine, db *sql.DB, b *testing.B) {
+func doBenchDriverInsert(db *sql.DB, b *testing.B) {
-    b.StopTimer()
-    err := engine.CreateTables(&BigStruct{})
-    if err != nil {
-        b.Error(err)
-        return
-    }
-
-    doBenchDriverInsertS(db, b)
-
-    err = engine.DropTables(&BigStruct{})
-    if err != nil {
-        b.Error(err)
-        return
-    }
-}
-
-func doBenchDriverInsertS(db *sql.DB, b *testing.B) {
 	b.StartTimer()
 	for i := 0; i < b.N; i++ {
 		_, err := db.Exec(`insert into big_struct (name, title, age, alias, nick_name) 
@@ -44,26 +27,9 @@ func doBenchDriverInsertS(db *sql.DB, b *testing.B) {
 	b.StopTimer()
 }
 
-func doBenchDriverFind(engine *Engine, db *sql.DB, b *testing.B) {
+func doBenchDriverFind(db *sql.DB, b *testing.B) {
 	b.StopTimer()
-    err := engine.CreateTables(&BigStruct{})
+	for i := 0; i < 50; i++ {
-    if err != nil {
-        b.Error(err)
-        return
-    }
-
-    doBenchDriverFindS(db, b)
-
-    err = engine.DropTables(&BigStruct{})
-    if err != nil {
-        b.Error(err)
-        return
-    }
-}
-
-func doBenchDriverFindS(db *sql.DB, b *testing.B) {
-    b.StopTimer()
-    for i := 0; i < 100; i++ {
 		_, err := db.Exec(`insert into big_struct (name, title, age, alias, nick_name) 
             values ('fafdasf', 'fadfa', 'afadfsaf', 'fadfafdsafd', 'fadfafdsaf')`)
 		if err != nil {
@@ -73,16 +39,44 @@ func doBenchDriverFindS(db *sql.DB, b *testing.B) {
 	}
 
 	b.StartTimer()
-    for i := 0; i < b.N; i++ {
+	for i := 0; i < b.N/50; i++ {
-        _, err := db.Query("select * from big_struct limit 50")
+		rows, err := db.Query("select * from big_struct limit 50")
 		if err != nil {
 			b.Error(err)
 			return
 		}
+		for rows.Next() {
+			s := &BigStruct{}
+			rows.Scan(&s.Id, &s.Name, &s.Title, &s.Age, &s.Alias, &s.NickName)
+		}
 	}
 	b.StopTimer()
 }
 
+func doBenchDriver(newdriver func() (*sql.DB, error), createTableSql,
+	dropTableSql string, opFunc func(*sql.DB, *testing.B), t *testing.B) {
+	db, err := newdriver()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer db.Close()
+
+	_, err = db.Exec(createTableSql)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	opFunc(db, t)
+
+	_, err = db.Exec(dropTableSql)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+}
+
 func doBenchInsert(engine *Engine, b *testing.B) {
 	b.StopTimer()
 	bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"}
@@ -128,7 +122,7 @@ func doBenchFind(engine *Engine, b *testing.B) {
 	}
 
 	b.StartTimer()
-    for i := 0; i < b.N; i++ {
+	for i := 0; i < b.N/50; i++ {
 		bss := new([]BigStruct)
 		err = engine.Limit(50).Find(bss)
 		if err != nil {
@@ -163,7 +157,7 @@ func doBenchFindPtr(engine *Engine, b *testing.B) {
 	}
 
 	b.StartTimer()
-    for i := 0; i < b.N; i++ {
+	for i := 0; i < b.N/50; i++ {
 		bss := new([]*BigStruct)
 		err = engine.Limit(50).Find(bss)
 		if err != nil {

mymysql_test.go

@@ -1,8 +1,10 @@
 package xorm
 
 import (
-    _ "github.com/ziutek/mymysql/godrv"
+	"database/sql"
 	"testing"
+
+	_ "github.com/ziutek/mymysql/godrv"
 )
 
 /*
@@ -29,9 +31,6 @@ func TestMyMysql(t *testing.T) {
 	engine.ShowWarn = showTestSql
 	engine.ShowDebug = showTestSql
 
-    sqlResults, _ := engine.Import("tests/mysql_ddl.sql")
-    engine.LogDebug("sql results: %v", sqlResults)
-
 	testAll(engine, t)
 	testAll2(engine, t)
 	testAll3(engine, t)
@@ -55,9 +54,6 @@ func TestMyMysqlWithCache(t *testing.T) {
 	engine.ShowWarn = showTestSql
 	engine.ShowDebug = showTestSql
 
-    sqlResults, _ := engine.Import("tests/mysql_ddl.sql")
-    engine.LogDebug("sql results: %v", sqlResults)
-
 	testAll(engine, t)
 	testAll2(engine, t)
 }
@@ -66,6 +62,20 @@ func newMyMysqlEngine() (*Engine, error) {
 	return NewEngine("mymysql", "xorm_test2/root/")
 }
 
+func newMyMysqlDriverDB() (*sql.DB, error) {
+	return sql.Open("mymysql", "xorm_test2/root/")
+}
+
+func BenchmarkMyMysqlDriverInsert(t *testing.B) {
+	doBenchDriver(newMyMysqlDriverDB, createTableMySql, dropTableMySql,
+		doBenchDriverInsert, t)
+}
+
+func BenchmarkMyMysqlDriverFind(t *testing.B) {
+	doBenchDriver(newMyMysqlDriverDB, createTableMySql, dropTableMySql,
+		doBenchDriverFind, t)
+}
+
 func mymysqlDdlImport() error {
 	engine, err := NewEngine("mymysql", "/root/")
 	if err != nil {

mysql_test.go

@@ -1,8 +1,10 @@
 package xorm
 
 import (
-    _ "github.com/go-sql-driver/mysql"
+	"database/sql"
 	"testing"
+
+	_ "github.com/go-sql-driver/mysql"
 )
 
 /*
@@ -78,6 +80,25 @@ func mysqlDdlImport() error {
 	return nil
 }
 
+func newMysqlDriverDB() (*sql.DB, error) {
+	return sql.Open("mysql", "root:@/xorm_test?charset=utf8")
+}
+
+const (
+	createTableMySql = "CREATE TABLE IF NOT EXISTS `big_struct` (`id` BIGINT PRIMARY KEY AUTO_INCREMENT NOT NULL, `name` VARCHAR(255) NULL, `title` VARCHAR(255) NULL, `age` VARCHAR(255) NULL, `alias` VARCHAR(255) NULL, `nick_name` VARCHAR(255) NULL);"
+	dropTableMySql   = "DROP TABLE IF EXISTS `big_struct`;"
+)
+
+func BenchmarkMysqlDriverInsert(t *testing.B) {
+	doBenchDriver(newMysqlDriverDB, createTableMySql, dropTableMySql,
+		doBenchDriverInsert, t)
+}
+
+func BenchmarkMysqlDriverFind(t *testing.B) {
+	doBenchDriver(newMysqlDriverDB, createTableMySql, dropTableMySql,
+		doBenchDriverFind, t)
+}
+
 func BenchmarkMysqlNoCacheInsert(t *testing.B) {
 	engine, err := newMysqlEngine()
 	defer engine.Close()

postgres_test.go

@@ -1,16 +1,20 @@
 package xorm
 
 import (
-    //"fmt"
+	"database/sql"
-    //_ "github.com/bylevel/pq"
-    _ "github.com/lib/pq"
 	"testing"
+
+	_ "github.com/lib/pq"
 )
 
 func newPostgresEngine() (*Engine, error) {
 	return NewEngine("postgres", "dbname=xorm_test sslmode=disable")
 }
 
+func newPostgresDriverDB() (*sql.DB, error) {
+	return sql.Open("postgres", "dbname=xorm_test sslmode=disable")
+}
+
 func TestPostgres(t *testing.T) {
 	engine, err := newPostgresEngine()
 	if err != nil {
@@ -142,46 +146,20 @@ func TestPostgres2(t *testing.T) {
     transaction(engine, t)
 }*/
 
-/*
+const (
+	createTablePostgres = `CREATE TABLE IF NOT EXISTS "big_struct" ("id" SERIAL PRIMARY KEY  NOT NULL, "name" VARCHAR(255) NULL, "title" VARCHAR(255) NULL, "age" VARCHAR(255) NULL, "alias" VARCHAR(255) NULL, "nick_name" VARCHAR(255) NULL);`
+	dropTablePostgres   = `DROP TABLE IF EXISTS "big_struct";`
+)
+
 func BenchmarkPostgresDriverInsert(t *testing.B) {
-    t.StopTimer()
+	doBenchDriver(newPostgresDriverDB, createTablePostgres, dropTablePostgres,
-    engine, err := newPostgresEngine()
+		doBenchDriverInsert, t)
-
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    defer engine.Close()
-
-    db, err := engine.OpenDB()
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    defer db.Close()
-
-    doBenchDriverInsert(engine, db, t)
 }
 
 func BenchmarkPostgresDriverFind(t *testing.B) {
-    t.StopTimer()
+	doBenchDriver(newPostgresDriverDB, createTablePostgres, dropTablePostgres,
-    engine, err := newPostgresEngine()
+		doBenchDriverFind, t)
-
+}
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    defer engine.Close()
-
-    db, err := engine.OpenDB()
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    //defer db.Close()
-
-    doBenchDriverFind(engine, db, t)
-}*/
 
 func BenchmarkPostgresNoCacheInsert(t *testing.B) {
 	engine, err := newPostgresEngine()

sqlite3_test.go

@@ -1,10 +1,11 @@
 package xorm
 
 import (
-    //"database/sql"
+	"database/sql"
-    _ "github.com/mattn/go-sqlite3"
 	"os"
 	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
 )
 
 func newSqlite3Engine() (*Engine, error) {
@@ -12,6 +13,11 @@ func newSqlite3Engine() (*Engine, error) {
 	return NewEngine("sqlite3", "./test.db")
 }
 
+func newSqlite3DriverDB() (*sql.DB, error) {
+	os.Remove("./test.db")
+	return sql.Open("sqlite3", "./test.db")
+}
+
 func TestSqlite3(t *testing.T) {
 	engine, err := newSqlite3Engine()
 	defer engine.Close()
@@ -46,85 +52,20 @@ func TestSqlite3WithCache(t *testing.T) {
 	testAll2(engine, t)
 }
 
-/*func BenchmarkSqlite3DriverInsert(t *testing.B) {
+const (
-    t.StopTimer()
+	createTableSqlite3 = "CREATE TABLE IF NOT EXISTS `big_struct` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NULL, `title` TEXT NULL, `age` TEXT NULL, `alias` TEXT NULL, `nick_name` TEXT NULL);"
-    engine, err := newSqlite3Engine()
+	dropTableSqlite3   = "DROP TABLE IF EXISTS `big_struct`;"
-    if err != nil {
+)
-        t.Error(err)
-        return
-    }
 
-    err = engine.CreateTables(&BigStruct{})
+func BenchmarkSqlite3DriverInsert(t *testing.B) {
-    if err != nil {
+	doBenchDriver(newSqlite3DriverDB, createTableSqlite3, dropTableSqlite3,
-        t.Error(err)
+		doBenchDriverInsert, t)
-        return
-    }
-    engine.Close()
-
-    db, err := sql.Open("sqlite3", "./test.db")
-    if err != nil {
-        t.Error(err)
-        return
-    }
-
-    doBenchDriverInsertS(db, t)
-
-    db.Close()
-
-    engine, err = newSqlite3Engine()
-    if err != nil {
-        t.Error(err)
-        return
-    }
-
-    err = engine.DropTables(&BigStruct{})
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    defer engine.Close()
 }
 
 func BenchmarkSqlite3DriverFind(t *testing.B) {
-    t.StopTimer()
+	doBenchDriver(newSqlite3DriverDB, createTableSqlite3, dropTableSqlite3,
-    engine, err := newSqlite3Engine()
+		doBenchDriverFind, t)
-    defer engine.Close()
+}
-    if err != nil {
-        t.Error(err)
-        return
-    }
-
-    err = engine.CreateTables(&BigStruct{})
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    engine.Close()
-
-    db, err := sql.Open("sqlite3", "./test.db")
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    defer db.Close()
-
-    doBenchDriverFindS(db, t)
-
-    db.Close()
-
-    engine, err = newSqlite3Engine()
-    if err != nil {
-        t.Error(err)
-        return
-    }
-
-    err = engine.DropTables(&BigStruct{})
-    if err != nil {
-        t.Error(err)
-        return
-    }
-    defer engine.Close()
-}*/
 
 func BenchmarkSqlite3NoCacheInsert(t *testing.B) {
 	t.StopTimer()