merge

base_test.go

@@ -655,7 +655,7 @@ func transaction(engine *Engine, t *testing.T) {
 		t.Error(err)
 		panic(err)
 	}
-	panic(err)
+	// panic(err) !nashtsai! should remove this
 }
 
 func combineTransaction(engine *Engine, t *testing.T) {

engine.go

@@ -1,10 +1,13 @@
 package xorm
 
 import (
+	"bufio"
+	"bytes"
 	"database/sql"
 	"errors"
 	"fmt"
 	"io"
+	"os"
 	"reflect"
 	"strconv"
 	"strings"
@@ -277,14 +280,14 @@ func (engine *Engine) Before(closures func(interface{})) *Session {
 	session := engine.NewSession()
 	session.IsAutoClose = true
 	return session.Before(closures)
-} 
+}
 
 // Apply after insert Processor, affected bean is passed to closure arg
 func (engine *Engine) After(closures func(interface{})) *Session {
 	session := engine.NewSession()
 	session.IsAutoClose = true
 	return session.After(closures)
-} 
+}
 
 // set charset when create table, only support mysql now
 func (engine *Engine) Charset(charset string) *Session {
@@ -924,3 +927,50 @@ func (engine *Engine) Count(bean interface{}) (int64, error) {
 	defer session.Close()
 	return session.Count(bean)
 }
+
+// Import SQL DDL file
+func (engine *Engine) Import(ddlPath string) ([]sql.Result, error) {
+
+	file, err := os.Open(ddlPath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	var results []sql.Result
+	var lastError error
+	scanner := bufio.NewScanner(file)
+
+	semiColSpliter := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+		if atEOF && len(data) == 0 {
+			return 0, nil, nil
+		}
+		if i := bytes.IndexByte(data, ';'); i >= 0 {
+			return i + 1, data[0:i], nil
+		}
+		// If we're at EOF, we have a final, non-terminated line. Return it.
+		if atEOF {
+			return len(data), data, nil
+		}
+		// Request more data.
+		return 0, nil, nil
+	}
+
+	scanner.Split(semiColSpliter)
+
+	session := engine.NewSession()
+	session.IsAutoClose = false
+	for scanner.Scan() {
+		query := scanner.Text()
+		query = strings.Trim(query, " \t")
+		if len(query) > 0 {
+			result, err := session.Exec(query)
+			results = append(results, result)
+			if err != nil {
+				lastError = err
+			}
+		}
+	}
+	session.Close()
+	return results, lastError
+}

mymysql_test.go

@@ -13,6 +13,11 @@ utf8 COLLATE utf8_general_ci;
 var showTestSql bool = true
 
 func TestMyMysql(t *testing.T) {
+	err := mysqlDdlImport()
+	if err != nil {
+		t.Error(err)
+		return
+	}
 	engine, err := NewEngine("mymysql", "xorm_test/root/")
 	defer engine.Close()
 	if err != nil {
@@ -24,11 +29,19 @@ 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)
 }
 
 func TestMyMysqlWithCache(t *testing.T) {
+	err := mysqlDdlImport()
+	if err != nil {
+		t.Error(err)
+		return
+	}
 	engine, err := NewEngine("mymysql", "xorm_test2/root/")
 	defer engine.Close()
 	if err != nil {
@@ -41,6 +54,9 @@ 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)
 }
@@ -49,45 +65,65 @@ func newMyMysqlEngine() (*Engine, error) {
 	return NewEngine("mymysql", "xorm_test2/root/")
 }
 
+func mysqlDdlImport() error {
+	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
+}
+
 func BenchmarkMyMysqlNoCacheInsert(t *testing.B) {
 	engine, err := newMyMysqlEngine()
-	defer engine.Close()
 	if err != nil {
 		t.Error(err)
 		return
 	}
+	defer engine.Close()
+
 	doBenchInsert(engine, t)
 }
 
 func BenchmarkMyMysqlNoCacheFind(t *testing.B) {
 	engine, err := newMyMysqlEngine()
-	defer engine.Close()
 	if err != nil {
 		t.Error(err)
 		return
 	}
+	defer engine.Close()
+
 	//engine.ShowSQL = true
 	doBenchFind(engine, t)
 }
 
 func BenchmarkMyMysqlNoCacheFindPtr(t *testing.B) {
 	engine, err := newMyMysqlEngine()
-	defer engine.Close()
 	if err != nil {
 		t.Error(err)
 		return
 	}
+	defer engine.Close()
+
 	//engine.ShowSQL = true
 	doBenchFindPtr(engine, t)
 }
 
 func BenchmarkMyMysqlCacheInsert(t *testing.B) {
 	engine, err := newMyMysqlEngine()
-	defer engine.Close()
 	if err != nil {
 		t.Error(err)
 		return
 	}
+
+	defer engine.Close()
 	engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
 
 	doBenchInsert(engine, t)
@@ -95,11 +131,12 @@ func BenchmarkMyMysqlCacheInsert(t *testing.B) {
 
 func BenchmarkMyMysqlCacheFind(t *testing.B) {
 	engine, err := newMyMysqlEngine()
-	defer engine.Close()
 	if err != nil {
 		t.Error(err)
 		return
 	}
+
+	defer engine.Close()
 	engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
 
 	doBenchFind(engine, t)
@@ -107,11 +144,12 @@ func BenchmarkMyMysqlCacheFind(t *testing.B) {
 
 func BenchmarkMyMysqlCacheFindPtr(t *testing.B) {
 	engine, err := newMyMysqlEngine()
-	defer engine.Close()
 	if err != nil {
 		t.Error(err)
 		return
 	}
+
+	defer engine.Close()
 	engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
 
 	doBenchFindPtr(engine, t)

tests/mysql_ddl.sql

@@ -0,0 +1,4 @@
+--DROP DATABASE xorm_test;
+--DROP DATABASE xorm_test2;
+CREATE DATABASE IF NOT EXISTS xorm_test CHARACTER SET utf8 COLLATE utf8_general_ci;
+CREATE DATABASE IF NOT EXISTS xorm_test2 CHARACTER SET utf8 COLLATE utf8_general_ci;