diff --git a/benchmark.sh b/benchmark.sh new file mode 100755 index 00000000..d35fe044 --- /dev/null +++ b/benchmark.sh @@ -0,0 +1 @@ +go test -v -bench=. -run=XXX \ No newline at end of file diff --git a/benchmark_base_test.go b/benchmark_base_test.go index ee04bae3..d263da06 100644 --- a/benchmark_base_test.go +++ b/benchmark_base_test.go @@ -1,180 +1,174 @@ package xorm import ( - "database/sql" - "testing" + "database/sql" + "testing" ) type BigStruct struct { - Id int64 - Name string - Title string - Age string - Alias string - NickName string + Id int64 + Name string + Title string + Age string + Alias string + 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) { - b.StartTimer() - for i := 0; i < b.N; i++ { - _, err := db.Exec(`insert into big_struct (name, title, age, alias, nick_name) +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) values ('fafdasf', 'fadfa', 'afadfsaf', 'fadfafdsafd', 'fadfafdsaf')`) - if err != nil { - b.Error(err) - return - } - } - b.StopTimer() + if err != nil { + b.Error(err) + return + } + } + b.StopTimer() } -func doBenchDriverFind(engine *Engine, 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++ { - _, err := db.Exec(`insert into big_struct (name, title, age, alias, nick_name) +func doBenchDriverFind(db *sql.DB, b *testing.B) { + b.StopTimer() + 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 { - b.Error(err) - return - } - } + if err != nil { + b.Error(err) + return + } + } - b.StartTimer() - for i := 0; i < b.N; i++ { - _, err := db.Query("select * from big_struct limit 50") - if err != nil { - b.Error(err) - return - } - } - b.StopTimer() + b.StartTimer() + 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"} - err := engine.CreateTables(bs) - if err != nil { - b.Error(err) - return - } + b.StopTimer() + bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} + err := engine.CreateTables(bs) + if err != nil { + b.Error(err) + return + } - b.StartTimer() - for i := 0; i < b.N; i++ { - bs.Id = 0 - _, err = engine.Insert(bs) - if err != nil { - b.Error(err) - return - } - } - b.StopTimer() - err = engine.DropTables(bs) - if err != nil { - b.Error(err) - return - } + b.StartTimer() + for i := 0; i < b.N; i++ { + bs.Id = 0 + _, err = engine.Insert(bs) + if err != nil { + b.Error(err) + return + } + } + b.StopTimer() + err = engine.DropTables(bs) + if err != nil { + b.Error(err) + return + } } func doBenchFind(engine *Engine, b *testing.B) { - b.StopTimer() - bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} - err := engine.CreateTables(bs) - if err != nil { - b.Error(err) - return - } + b.StopTimer() + bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} + err := engine.CreateTables(bs) + if err != nil { + b.Error(err) + return + } - for i := 0; i < 100; i++ { - bs.Id = 0 - _, err = engine.Insert(bs) - if err != nil { - b.Error(err) - return - } - } + for i := 0; i < 100; i++ { + bs.Id = 0 + _, err = engine.Insert(bs) + if err != nil { + b.Error(err) + return + } + } - b.StartTimer() - for i := 0; i < b.N; i++ { - bss := new([]BigStruct) - err = engine.Limit(50).Find(bss) - if err != nil { - b.Error(err) - return - } - } - b.StopTimer() - err = engine.DropTables(bs) - if err != nil { - b.Error(err) - return - } + b.StartTimer() + for i := 0; i < b.N/50; i++ { + bss := new([]BigStruct) + err = engine.Limit(50).Find(bss) + if err != nil { + b.Error(err) + return + } + } + b.StopTimer() + err = engine.DropTables(bs) + if err != nil { + b.Error(err) + return + } } func doBenchFindPtr(engine *Engine, b *testing.B) { - b.StopTimer() - bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} - err := engine.CreateTables(bs) - if err != nil { - b.Error(err) - return - } + b.StopTimer() + bs := &BigStruct{0, "fafdasf", "fadfa", "afadfsaf", "fadfafdsafd", "fadfafdsaf"} + err := engine.CreateTables(bs) + if err != nil { + b.Error(err) + return + } - for i := 0; i < 100; i++ { - bs.Id = 0 - _, err = engine.Insert(bs) - if err != nil { - b.Error(err) - return - } - } + for i := 0; i < 100; i++ { + bs.Id = 0 + _, err = engine.Insert(bs) + if err != nil { + b.Error(err) + return + } + } - b.StartTimer() - for i := 0; i < b.N; i++ { - bss := new([]*BigStruct) - err = engine.Limit(50).Find(bss) - if err != nil { - b.Error(err) - return - } - } - b.StopTimer() - err = engine.DropTables(bs) - if err != nil { - b.Error(err) - return - } + b.StartTimer() + for i := 0; i < b.N/50; i++ { + bss := new([]*BigStruct) + err = engine.Limit(50).Find(bss) + if err != nil { + b.Error(err) + return + } + } + b.StopTimer() + err = engine.DropTables(bs) + if err != nil { + b.Error(err) + return + } } diff --git a/mymysql_test.go b/mymysql_test.go index 3c4d6700..0ad8aace 100644 --- a/mymysql_test.go +++ b/mymysql_test.go @@ -1,8 +1,10 @@ package xorm import ( - _ "github.com/ziutek/mymysql/godrv" - "testing" + "database/sql" + "testing" + + _ "github.com/ziutek/mymysql/godrv" ) /* @@ -13,145 +15,153 @@ utf8 COLLATE utf8_general_ci; var showTestSql bool = true func TestMyMysql(t *testing.T) { - err := mymysqlDdlImport() - if err != nil { - t.Error(err) - return - } - engine, err := NewEngine("mymysql", "xorm_test/root/") - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.ShowSQL = showTestSql - engine.ShowErr = showTestSql - engine.ShowWarn = showTestSql - engine.ShowDebug = showTestSql + err := mymysqlDdlImport() + if err != nil { + t.Error(err) + return + } + engine, err := NewEngine("mymysql", "xorm_test/root/") + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + 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) + testAll(engine, t) + testAll2(engine, t) + testAll3(engine, t) } func TestMyMysqlWithCache(t *testing.T) { - err := mymysqlDdlImport() - if err != nil { - t.Error(err) - return - } - engine, err := NewEngine("mymysql", "xorm_test2/root/") - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - engine.ShowSQL = showTestSql - engine.ShowErr = showTestSql - engine.ShowWarn = showTestSql - engine.ShowDebug = showTestSql + err := mymysqlDdlImport() + if err != nil { + t.Error(err) + return + } + engine, err := NewEngine("mymysql", "xorm_test2/root/") + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + 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) + testAll(engine, t) + testAll2(engine, t) } func newMyMysqlEngine() (*Engine, error) { - return NewEngine("mymysql", "xorm_test2/root/") + 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 { - return err - } - engine.ShowSQL = showTestSql - engine.ShowErr = showTestSql - engine.ShowWarn = showTestSql - engine.ShowDebug = showTestSql + engine, err := NewEngine("mymysql", "/root/") + if err != nil { + return err + } + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql - sqlResults, _ := engine.Import("tests/mysql_ddl.sql") - engine.LogDebug("sql results: %v", sqlResults) - engine.Close() - return nil + sqlResults, _ := engine.Import("tests/mysql_ddl.sql") + engine.LogDebug("sql results: %v", sqlResults) + engine.Close() + return nil } func BenchmarkMyMysqlNoCacheInsert(t *testing.B) { - engine, err := newMyMysqlEngine() - if err != nil { - t.Error(err) - return - } - defer engine.Close() + engine, err := newMyMysqlEngine() + if err != nil { + t.Error(err) + return + } + defer engine.Close() - doBenchInsert(engine, t) + doBenchInsert(engine, t) } func BenchmarkMyMysqlNoCacheFind(t *testing.B) { - engine, err := newMyMysqlEngine() - if err != nil { - t.Error(err) - return - } - defer engine.Close() + engine, err := newMyMysqlEngine() + if err != nil { + t.Error(err) + return + } + defer engine.Close() - //engine.ShowSQL = true - doBenchFind(engine, t) + //engine.ShowSQL = true + doBenchFind(engine, t) } func BenchmarkMyMysqlNoCacheFindPtr(t *testing.B) { - engine, err := newMyMysqlEngine() - if err != nil { - t.Error(err) - return - } - defer engine.Close() + engine, err := newMyMysqlEngine() + if err != nil { + t.Error(err) + return + } + defer engine.Close() - //engine.ShowSQL = true - doBenchFindPtr(engine, t) + //engine.ShowSQL = true + doBenchFindPtr(engine, t) } func BenchmarkMyMysqlCacheInsert(t *testing.B) { - engine, err := newMyMysqlEngine() - if err != nil { - t.Error(err) - return - } + engine, err := newMyMysqlEngine() + if err != nil { + t.Error(err) + return + } - defer engine.Close() - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + defer engine.Close() + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchInsert(engine, t) + doBenchInsert(engine, t) } func BenchmarkMyMysqlCacheFind(t *testing.B) { - engine, err := newMyMysqlEngine() - if err != nil { - t.Error(err) - return - } + engine, err := newMyMysqlEngine() + if err != nil { + t.Error(err) + return + } - defer engine.Close() - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + defer engine.Close() + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFind(engine, t) + doBenchFind(engine, t) } func BenchmarkMyMysqlCacheFindPtr(t *testing.B) { - engine, err := newMyMysqlEngine() - if err != nil { - t.Error(err) - return - } + engine, err := newMyMysqlEngine() + if err != nil { + t.Error(err) + return + } - defer engine.Close() - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + defer engine.Close() + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFindPtr(engine, t) + doBenchFindPtr(engine, t) } diff --git a/mysql_test.go b/mysql_test.go index de1f7595..2e106231 100644 --- a/mysql_test.go +++ b/mysql_test.go @@ -1,8 +1,10 @@ package xorm import ( - _ "github.com/go-sql-driver/mysql" - "testing" + "database/sql" + "testing" + + _ "github.com/go-sql-driver/mysql" ) /* @@ -13,136 +15,155 @@ utf8 COLLATE utf8_general_ci; var mysqlShowTestSql bool = true func TestMysql(t *testing.T) { - err := mysqlDdlImport() - if err != nil { - t.Error(err) - return - } + err := mysqlDdlImport() + if err != nil { + t.Error(err) + return + } - engine, err := NewEngine("mysql", "root:@/xorm_test?charset=utf8") - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.ShowSQL = mysqlShowTestSql - engine.ShowErr = mysqlShowTestSql - engine.ShowWarn = mysqlShowTestSql - engine.ShowDebug = mysqlShowTestSql + engine, err := NewEngine("mysql", "root:@/xorm_test?charset=utf8") + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.ShowSQL = mysqlShowTestSql + engine.ShowErr = mysqlShowTestSql + engine.ShowWarn = mysqlShowTestSql + engine.ShowDebug = mysqlShowTestSql - testAll(engine, t) - testAll2(engine, t) - testAll3(engine, t) + testAll(engine, t) + testAll2(engine, t) + testAll3(engine, t) } func TestMysqlWithCache(t *testing.T) { - err := mysqlDdlImport() - if err != nil { - t.Error(err) - return - } + err := mysqlDdlImport() + if err != nil { + t.Error(err) + return + } - engine, err := NewEngine("mysql", "root:@/xorm_test?charset=utf8") - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - engine.ShowSQL = mysqlShowTestSql - engine.ShowErr = mysqlShowTestSql - engine.ShowWarn = mysqlShowTestSql - engine.ShowDebug = mysqlShowTestSql + engine, err := NewEngine("mysql", "root:@/xorm_test?charset=utf8") + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + engine.ShowSQL = mysqlShowTestSql + engine.ShowErr = mysqlShowTestSql + engine.ShowWarn = mysqlShowTestSql + engine.ShowDebug = mysqlShowTestSql - testAll(engine, t) - testAll2(engine, t) + testAll(engine, t) + testAll2(engine, t) } func newMysqlEngine() (*Engine, error) { - return NewEngine("mysql", "root:@/xorm_test?charset=utf8") + return NewEngine("mysql", "root:@/xorm_test?charset=utf8") } func mysqlDdlImport() error { - engine, err := NewEngine("mysql", "root:@/?charset=utf8") - if err != nil { - return err - } - engine.ShowSQL = mysqlShowTestSql - engine.ShowErr = mysqlShowTestSql - engine.ShowWarn = mysqlShowTestSql - engine.ShowDebug = mysqlShowTestSql + engine, err := NewEngine("mysql", "root:@/?charset=utf8") + if err != nil { + return err + } + engine.ShowSQL = mysqlShowTestSql + engine.ShowErr = mysqlShowTestSql + engine.ShowWarn = mysqlShowTestSql + engine.ShowDebug = mysqlShowTestSql - sqlResults, _ := engine.Import("tests/mysql_ddl.sql") - engine.LogDebug("sql results: %v", sqlResults) - engine.Close() - return nil + sqlResults, _ := engine.Import("tests/mysql_ddl.sql") + engine.LogDebug("sql results: %v", sqlResults) + engine.Close() + 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() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchInsert(engine, t) + engine, err := newMysqlEngine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchInsert(engine, t) } func BenchmarkMysqlNoCacheFind(t *testing.B) { - engine, err := newMysqlEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchFind(engine, t) + engine, err := newMysqlEngine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchFind(engine, t) } func BenchmarkMysqlNoCacheFindPtr(t *testing.B) { - engine, err := newMysqlEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchFindPtr(engine, t) + engine, err := newMysqlEngine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchFindPtr(engine, t) } func BenchmarkMysqlCacheInsert(t *testing.B) { - engine, err := newMysqlEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + engine, err := newMysqlEngine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchInsert(engine, t) + doBenchInsert(engine, t) } func BenchmarkMysqlCacheFind(t *testing.B) { - engine, err := newMysqlEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + engine, err := newMysqlEngine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFind(engine, t) + doBenchFind(engine, t) } func BenchmarkMysqlCacheFindPtr(t *testing.B) { - engine, err := newMysqlEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + engine, err := newMysqlEngine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFindPtr(engine, t) + doBenchFindPtr(engine, t) } diff --git a/postgres_test.go b/postgres_test.go index 364aa784..e7cc363f 100644 --- a/postgres_test.go +++ b/postgres_test.go @@ -1,48 +1,52 @@ package xorm import ( - //"fmt" - //_ "github.com/bylevel/pq" - _ "github.com/lib/pq" - "testing" + "database/sql" + "testing" + + _ "github.com/lib/pq" ) func newPostgresEngine() (*Engine, error) { - return NewEngine("postgres", "dbname=xorm_test sslmode=disable") + 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 { - t.Error(err) - return - } - defer engine.Close() - engine.ShowSQL = showTestSql - engine.ShowErr = showTestSql - engine.ShowWarn = showTestSql - engine.ShowDebug = showTestSql + engine, err := newPostgresEngine() + if err != nil { + t.Error(err) + return + } + defer engine.Close() + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql - testAll(engine, t) - testAll2(engine, t) - testAll3(engine, t) + testAll(engine, t) + testAll2(engine, t) + testAll3(engine, t) } func TestPostgresWithCache(t *testing.T) { - engine, err := newPostgresEngine() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - defer engine.Close() - engine.ShowSQL = showTestSql - engine.ShowErr = showTestSql - engine.ShowWarn = showTestSql - engine.ShowDebug = showTestSql + engine, err := newPostgresEngine() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + defer engine.Close() + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql - testAll(engine, t) - testAll2(engine, t) + testAll(engine, t) + testAll2(engine, t) } /* @@ -142,118 +146,92 @@ 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() + engine, err := newPostgresEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchInsert(engine, t) + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchInsert(engine, t) } func BenchmarkPostgresNoCacheFind(t *testing.B) { - engine, err := newPostgresEngine() + engine, err := newPostgresEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchFind(engine, t) + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchFind(engine, t) } func BenchmarkPostgresNoCacheFindPtr(t *testing.B) { - engine, err := newPostgresEngine() + engine, err := newPostgresEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchFindPtr(engine, t) + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchFindPtr(engine, t) } func BenchmarkPostgresCacheInsert(t *testing.B) { - engine, err := newPostgresEngine() + engine, err := newPostgresEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchInsert(engine, t) + doBenchInsert(engine, t) } func BenchmarkPostgresCacheFind(t *testing.B) { - engine, err := newPostgresEngine() + engine, err := newPostgresEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFind(engine, t) + doBenchFind(engine, t) } func BenchmarkPostgresCacheFindPtr(t *testing.B) { - engine, err := newPostgresEngine() + engine, err := newPostgresEngine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFindPtr(engine, t) + doBenchFindPtr(engine, t) } diff --git a/sqlite3_test.go b/sqlite3_test.go index a84dda50..b55702b0 100644 --- a/sqlite3_test.go +++ b/sqlite3_test.go @@ -1,199 +1,140 @@ package xorm import ( - //"database/sql" - _ "github.com/mattn/go-sqlite3" - "os" - "testing" + "database/sql" + "os" + "testing" + + _ "github.com/mattn/go-sqlite3" ) func newSqlite3Engine() (*Engine, error) { - os.Remove("./test.db") - return NewEngine("sqlite3", "./test.db") + os.Remove("./test.db") + 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() - if err != nil { - t.Error(err) - return - } - engine.ShowSQL = showTestSql - engine.ShowErr = showTestSql - engine.ShowWarn = showTestSql - engine.ShowDebug = showTestSql + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql - testAll(engine, t) - testAll2(engine, t) - testAll3(engine, t) + testAll(engine, t) + testAll2(engine, t) + testAll3(engine, t) } func TestSqlite3WithCache(t *testing.T) { - engine, err := newSqlite3Engine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - engine.ShowSQL = showTestSql - engine.ShowErr = showTestSql - engine.ShowWarn = showTestSql - engine.ShowDebug = showTestSql + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + engine.ShowSQL = showTestSql + engine.ShowErr = showTestSql + engine.ShowWarn = showTestSql + engine.ShowDebug = showTestSql - testAll(engine, t) - testAll2(engine, t) + testAll(engine, 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() - engine, err := newSqlite3Engine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchInsert(engine, t) + t.StopTimer() + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchInsert(engine, t) } func BenchmarkSqlite3NoCacheFind(t *testing.B) { - t.StopTimer() - engine, err := newSqlite3Engine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchFind(engine, t) + t.StopTimer() + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchFind(engine, t) } func BenchmarkSqlite3NoCacheFindPtr(t *testing.B) { - t.StopTimer() - engine, err := newSqlite3Engine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - //engine.ShowSQL = true - doBenchFindPtr(engine, t) + t.StopTimer() + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + //engine.ShowSQL = true + doBenchFindPtr(engine, t) } func BenchmarkSqlite3CacheInsert(t *testing.B) { - t.StopTimer() - engine, err := newSqlite3Engine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchInsert(engine, t) + t.StopTimer() + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + doBenchInsert(engine, t) } func BenchmarkSqlite3CacheFind(t *testing.B) { - t.StopTimer() - engine, err := newSqlite3Engine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFind(engine, t) + t.StopTimer() + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + doBenchFind(engine, t) } func BenchmarkSqlite3CacheFindPtr(t *testing.B) { - t.StopTimer() - engine, err := newSqlite3Engine() - defer engine.Close() - if err != nil { - t.Error(err) - return - } - engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) - doBenchFindPtr(engine, t) + t.StopTimer() + engine, err := newSqlite3Engine() + defer engine.Close() + if err != nil { + t.Error(err) + return + } + engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000)) + doBenchFindPtr(engine, t) }