HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add benchmark tests

This commit is contained in:
Lunny Xiao 2013-12-16 23:42:31 +08:00
parent f0ae4ff860
commit 81a4c102b9
6 changed files with 576 additions and 631 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
benchmark.sh Executable file
View File

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

76
benchmark_base_test.go
View File

@ -14,24 +14,7 @@ type BigStruct struct {
NickName string
}
func doBenchDriverInsert(engine *Engine, 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) {
func doBenchDriverInsert(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{})
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++ {
for i := 0; i < 50; 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++ {
_, err := db.Query("select * from big_struct limit 50")
for i := 0; i < b.N/50; i++ {
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 {

24
mymysql_test.go
View File

@ -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 {

23
mysql_test.go
View File

@ -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()

56
postgres_test.go
View File

@ -1,16 +1,20 @@
package xorm
import (
//"fmt"
//_ "github.com/bylevel/pq"
_ "github.com/lib/pq"
"database/sql"
"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()
engine, err := newPostgresEngine()
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)
doBenchDriver(newPostgresDriverDB, createTablePostgres, dropTablePostgres,
doBenchDriverInsert, t)
}
func BenchmarkPostgresDriverFind(t *testing.B) {
t.StopTimer()
engine, err := newPostgresEngine()
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)
}*/
doBenchDriver(newPostgresDriverDB, createTablePostgres, dropTablePostgres,
doBenchDriverFind, t)
}
func BenchmarkPostgresNoCacheInsert(t *testing.B) {
engine, err := newPostgresEngine()

95
sqlite3_test.go
View File

@ -1,10 +1,11 @@
package xorm
import (
//"database/sql"
_ "github.com/mattn/go-sqlite3"
"database/sql"
"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) {
t.StopTimer()
engine, err := newSqlite3Engine()
if err != nil {
t.Error(err)
return
}
const (
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);"
dropTableSqlite3 = "DROP TABLE IF EXISTS `big_struct`;"
)
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
}
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 BenchmarkSqlite3DriverInsert(t *testing.B) {
doBenchDriver(newSqlite3DriverDB, createTableSqlite3, dropTableSqlite3,
doBenchDriverInsert, t)
}
func BenchmarkSqlite3DriverFind(t *testing.B) {
t.StopTimer()
engine, err := newSqlite3Engine()
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()
}*/
doBenchDriver(newSqlite3DriverDB, createTableSqlite3, dropTableSqlite3,
doBenchDriverFind, t)
}
func BenchmarkSqlite3NoCacheInsert(t *testing.B) {
t.StopTimer()