samemapper support

base_test.go

@@ -150,7 +150,7 @@ func exec(engine *Engine, t *testing.T) {
 	fmt.Println(res)
 }
 
-func querySameMapper(engine *Engine, t *testing.T) {
+func testQuerySameMapper(engine *Engine, t *testing.T) {
 	sql := "select * from `Userinfo`"
 	results, err := engine.Query(sql)
 	if err != nil {
@@ -274,7 +274,7 @@ type Condi map[string]interface{}
 func update(engine *Engine, t *testing.T) {
 	// update by id
 	user := Userinfo{Username: "xxx", Height: 1.2}
-	cnt, err := engine.Id(1).Update(&user)
+	cnt, err := engine.Id(4).Update(&user)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -286,8 +286,8 @@ func update(engine *Engine, t *testing.T) {
 		return
 	}
 
-	condi := Condi{"username": "zzz", "height": 0.0, "departname": ""}
+	condi := Condi{"username": "zzz", "departname": ""}
-	cnt, err = engine.Table(&user).Id(1).Update(&condi)
+	cnt, err = engine.Table(&user).Id(4).Update(&condi)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -321,7 +321,7 @@ func update(engine *Engine, t *testing.T) {
 func updateSameMapper(engine *Engine, t *testing.T) {
 	// update by id
 	user := Userinfo{Username: "xxx", Height: 1.2}
-	cnt, err := engine.Id(1).Update(&user)
+	cnt, err := engine.Id(4).Update(&user)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -333,15 +333,15 @@ func updateSameMapper(engine *Engine, t *testing.T) {
 		return
 	}
 
-	condi := Condi{"Username": "zzz", "Height": 0.0, "Departname": ""}
+	condi := Condi{"Username": "zzz", "Departname": ""}
-	cnt, err = engine.Table(&user).Id(1).Update(&condi)
+	cnt, err = engine.Table(&user).Id(4).Update(&condi)
 	if err != nil {
 		t.Error(err)
 		panic(err)
 	}
 
 	if cnt != 1 {
-		err = errors.New("insert not returned 1")
+		err = errors.New("update not returned 1")
 		t.Error(err)
 		panic(err)
 		return
@@ -354,7 +354,7 @@ func updateSameMapper(engine *Engine, t *testing.T) {
 	}
 
 	if cnt != 1 {
-		err = errors.New("insert not returned 1")
+		err = errors.New("update not returned 1")
 		t.Error(err)
 		panic(err)
 		return
@@ -376,6 +376,7 @@ func testDelete(engine *Engine, t *testing.T) {
 	}
 
 	user.Uid = 0
+	user.IsMan = true
 	has, err := engine.Id(3).Get(&user)
 	if err != nil {
 		t.Error(err)
@@ -423,7 +424,9 @@ func get(engine *Engine, t *testing.T) {
 		panic(err)
 	}
 
-	_, err = engine.Where("`user` = ?", "xlw").Delete(&NoIdUser{})
+	userCol := engine.columnMapper.Obj2Table("User")
+
+	_, err = engine.Where("`"+userCol+"` = ?", "xlw").Delete(&NoIdUser{})
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -442,7 +445,7 @@ func get(engine *Engine, t *testing.T) {
 	}
 
 	noIdUser := new(NoIdUser)
-	has, err = engine.Where("`user` = ?", "xlw").Get(noIdUser)
+	has, err = engine.Where("`"+userCol+"` = ?", "xlw").Get(noIdUser)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -484,7 +487,8 @@ func find(engine *Engine, t *testing.T) {
 	}
 
 	users2 := make([]Userinfo, 0)
-	err = engine.Sql("select * from userinfo").Find(&users2)
+	userinfo := engine.tableMapper.Obj2Table("Userinfo")
+	err = engine.Sql("select * from " + engine.Quote(userinfo)).Find(&users2)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -574,7 +578,10 @@ func in(engine *Engine, t *testing.T) {
 	}
 	fmt.Println(users)
 
-	err = engine.In("(id)", 1).In("(id)", 2).In("departname", "dev").Find(&users)
+	department := engine.columnMapper.Obj2Table("Departname")
+	dev := engine.columnMapper.Obj2Table("Dev")
+
+	err = engine.In("(id)", 1).In("(id)", 2).In(department, dev).Find(&users)
 	if err != nil {
 		t.Error(err)
 		panic(err)
@@ -3782,18 +3789,12 @@ func testAll(engine *Engine, t *testing.T) {
 	directCreateTable(engine, t)
 	fmt.Println("-------------- insert --------------")
 	insert(engine, t)
-	fmt.Println("-------------- query --------------")
-	testQuery(engine, t)
-	fmt.Println("-------------- exec --------------")
-	exec(engine, t)
 	fmt.Println("-------------- insertAutoIncr --------------")
 	insertAutoIncr(engine, t)
 	fmt.Println("-------------- insertMulti --------------")
 	insertMulti(engine, t)
 	fmt.Println("-------------- insertTwoTable --------------")
 	insertTwoTable(engine, t)
-	fmt.Println("-------------- update --------------")
-	update(engine, t)
 	fmt.Println("-------------- testDelete --------------")
 	testDelete(engine, t)
 	fmt.Println("-------------- get --------------")
@@ -3816,12 +3817,6 @@ func testAll(engine *Engine, t *testing.T) {
 	in(engine, t)
 	fmt.Println("-------------- limit --------------")
 	limit(engine, t)
-	fmt.Println("-------------- order --------------")
-	order(engine, t)
-	fmt.Println("-------------- join --------------")
-	join(engine, t)
-	fmt.Println("-------------- having --------------")
-	having(engine, t)
 }
 
 func testAll2(engine *Engine, t *testing.T) {
@@ -3904,9 +3899,31 @@ func testAll3(engine *Engine, t *testing.T) {
 }
 
 func testAllSnakeMapper(engine *Engine, t *testing.T) {
-
+	fmt.Println("-------------- query --------------")
+	testQuery(engine, t)
+	fmt.Println("-------------- exec --------------")
+	exec(engine, t)
+	fmt.Println("-------------- update --------------")
+	update(engine, t)
+	fmt.Println("-------------- order --------------")
+	order(engine, t)
+	fmt.Println("-------------- join --------------")
+	join(engine, t)
+	fmt.Println("-------------- having --------------")
+	having(engine, t)
 }
 
 func testAllSameMapper(engine *Engine, t *testing.T) {
-
+	fmt.Println("-------------- query --------------")
+	testQuerySameMapper(engine, t)
+	fmt.Println("-------------- exec --------------")
+	execSameMapper(engine, t)
+	fmt.Println("-------------- update --------------")
+	updateSameMapper(engine, t)
+	fmt.Println("-------------- order --------------")
+	orderSameMapper(engine, t)
+	fmt.Println("-------------- join --------------")
+	joinSameMapper(engine, t)
+	fmt.Println("-------------- having --------------")
+	havingSameMapper(engine, t)
 }

mysql_test.go

@@ -42,7 +42,7 @@ func TestMysqlSameMapper(t *testing.T) {
 		return
 	}
 
-	engine, err := NewEngine("mysql", "root:@/xorm_test3?charset=utf8")
+	engine, err := NewEngine("mysql", "root:@/xorm_test1?charset=utf8")
 	defer engine.Close()
 	if err != nil {
 		t.Error(err)
@@ -66,7 +66,7 @@ func TestMysqlWithCache(t *testing.T) {
 		return
 	}
 
-	engine, err := NewEngine("mysql", "root:@/xorm_test?charset=utf8")
+	engine, err := NewEngine("mysql", "root:@/xorm_test2?charset=utf8")
 	defer engine.Close()
 	if err != nil {
 		t.Error(err)
@@ -82,6 +82,30 @@ func TestMysqlWithCache(t *testing.T) {
 	testAll2(engine, t)
 }
 
+func TestMysqlWithCacheSameMapper(t *testing.T) {
+	err := mysqlDdlImport()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	engine, err := NewEngine("mysql", "root:@/xorm_test3?charset=utf8")
+	defer engine.Close()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	engine.SetMapper(SameMapper{})
+	engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
+	engine.ShowSQL = showTestSql
+	engine.ShowErr = showTestSql
+	engine.ShowWarn = showTestSql
+	engine.ShowDebug = showTestSql
+
+	testAll(engine, t)
+	testAll2(engine, t)
+}
+
 func newMysqlEngine() (*Engine, error) {
 	return NewEngine("mysql", "root:@/xorm_test?charset=utf8")
 }

postgres_test.go

@@ -12,7 +12,22 @@ import (
 var connStr string = "dbname=xorm_test sslmode=disable"
 
 func newPostgresEngine() (*Engine, error) {
-	return NewEngine("postgres", connStr)
+	orm, err := NewEngine("postgres", connStr)
+	if err != nil {
+		return nil, err
+	}
+	tables, err := orm.DBMetas()
+	if err != nil {
+		return nil, err
+	}
+	for _, table := range tables {
+		_, err = orm.Exec("drop table \"" + table.Name + "\"")
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return orm, err
 }
 
 func newPostgresDriverDB() (*sql.DB, error) {
@@ -32,6 +47,7 @@ func TestPostgres(t *testing.T) {
 	engine.ShowDebug = showTestSql
 
 	testAll(engine, t)
+	testAllSnakeMapper(engine, t)
 	testAll2(engine, t)
 	testAll3(engine, t)
 }
@@ -50,105 +66,47 @@ func TestPostgresWithCache(t *testing.T) {
 	engine.ShowDebug = showTestSql
 
 	testAll(engine, t)
+	testAllSnakeMapper(engine, t)
 	testAll2(engine, t)
 }
 
-/*
+func TestPostgresSameMapper(t *testing.T) {
-func TestPostgres2(t *testing.T) {
+	engine, err := newPostgresEngine()
-    engine, err := NewEngine("postgres", "dbname=xorm_test sslmode=disable")
 	if err != nil {
 		t.Error(err)
 		return
 	}
 	defer engine.Close()
+	engine.SetMapper(SameMapper{})
 	engine.ShowSQL = showTestSql
-    engine.Mapper = SameMapper{}
+	engine.ShowErr = showTestSql
+	engine.ShowWarn = showTestSql
+	engine.ShowDebug = showTestSql
 
-    fmt.Println("-------------- directCreateTable --------------")
+	testAll(engine, t)
-    directCreateTable(engine, t)
+	testAllSameMapper(engine, t)
-    fmt.Println("-------------- mapper --------------")
+	testAll2(engine, t)
-    mapper(engine, t)
+	testAll3(engine, t)
-    fmt.Println("-------------- insert --------------")
+}
-    insert(engine, t)
+
-    fmt.Println("-------------- querySameMapper --------------")
+func TestPostgresWithCacheSameMapper(t *testing.T) {
-    querySameMapper(engine, t)
+	engine, err := newPostgresEngine()
-    fmt.Println("-------------- execSameMapper --------------")
+	if err != nil {
-    execSameMapper(engine, t)
+		t.Error(err)
-    fmt.Println("-------------- insertAutoIncr --------------")
+		return
-    insertAutoIncr(engine, t)
+	}
-    fmt.Println("-------------- insertMulti --------------")
+	engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
-    insertMulti(engine, t)
+	defer engine.Close()
-    fmt.Println("-------------- insertTwoTable --------------")
+	engine.SetMapper(SameMapper{})
-    insertTwoTable(engine, t)
+	engine.ShowSQL = showTestSql
-    fmt.Println("-------------- updateSameMapper --------------")
+	engine.ShowErr = showTestSql
-    updateSameMapper(engine, t)
+	engine.ShowWarn = showTestSql
-    fmt.Println("-------------- testdelete --------------")
+	engine.ShowDebug = showTestSql
-    testdelete(engine, t)
+
-    fmt.Println("-------------- get --------------")
+	testAll(engine, t)
-    get(engine, t)
+	testAllSameMapper(engine, t)
-    fmt.Println("-------------- cascadeGet --------------")
+	testAll2(engine, t)
-    cascadeGet(engine, t)
+}
-    fmt.Println("-------------- find --------------")
-    find(engine, t)
-    fmt.Println("-------------- find2 --------------")
-    find2(engine, t)
-    fmt.Println("-------------- findMap --------------")
-    findMap(engine, t)
-    fmt.Println("-------------- findMap2 --------------")
-    findMap2(engine, t)
-    fmt.Println("-------------- count --------------")
-    count(engine, t)
-    fmt.Println("-------------- where --------------")
-    where(engine, t)
-    fmt.Println("-------------- in --------------")
-    in(engine, t)
-    fmt.Println("-------------- limit --------------")
-    limit(engine, t)
-    fmt.Println("-------------- orderSameMapper --------------")
-    orderSameMapper(engine, t)
-    fmt.Println("-------------- joinSameMapper --------------")
-    joinSameMapper(engine, t)
-    fmt.Println("-------------- havingSameMapper --------------")
-    havingSameMapper(engine, t)
-    fmt.Println("-------------- combineTransactionSameMapper --------------")
-    combineTransactionSameMapper(engine, t)
-    fmt.Println("-------------- table --------------")
-    table(engine, t)
-    fmt.Println("-------------- createMultiTables --------------")
-    createMultiTables(engine, t)
-    fmt.Println("-------------- tableOp --------------")
-    tableOp(engine, t)
-    fmt.Println("-------------- testColsSameMapper --------------")
-    testColsSameMapper(engine, t)
-    fmt.Println("-------------- testCharst --------------")
-    testCharst(engine, t)
-    fmt.Println("-------------- testStoreEngine --------------")
-    testStoreEngine(engine, t)
-    fmt.Println("-------------- testExtends --------------")
-    testExtends(engine, t)
-    fmt.Println("-------------- testColTypes --------------")
-    testColTypes(engine, t)
-    fmt.Println("-------------- testCustomType --------------")
-    testCustomType(engine, t)
-    fmt.Println("-------------- testCreatedAndUpdated --------------")
-    testCreatedAndUpdated(engine, t)
-    fmt.Println("-------------- testIndexAndUnique --------------")
-    testIndexAndUnique(engine, t)
-    fmt.Println("-------------- testMetaInfo --------------")
-    testMetaInfo(engine, t)
-    fmt.Println("-------------- testIterate --------------")
-    testIterate(engine, t)
-    fmt.Println("-------------- testStrangeName --------------")
-    testStrangeName(engine, t)
-    fmt.Println("-------------- testVersion --------------")
-    testVersion(engine, t)
-    fmt.Println("-------------- testDistinct --------------")
-    testDistinct(engine, t)
-    fmt.Println("-------------- testUseBool --------------")
-    testUseBool(engine, t)
-    fmt.Println("-------------- transaction --------------")
-    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);`

sqlite3_test.go

@@ -52,6 +52,42 @@ func TestSqlite3WithCache(t *testing.T) {
 	testAll2(engine, t)
 }
 
+func TestSqlite3SameMapper(t *testing.T) {
+	engine, err := newSqlite3Engine()
+	defer engine.Close()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	engine.SetMapper(SameMapper{})
+	engine.ShowSQL = showTestSql
+	engine.ShowErr = showTestSql
+	engine.ShowWarn = showTestSql
+	engine.ShowDebug = showTestSql
+
+	testAll(engine, t)
+	testAll2(engine, t)
+	testAll3(engine, t)
+}
+
+func TestSqlite3WithCacheSameMapper(t *testing.T) {
+	engine, err := newSqlite3Engine()
+	defer engine.Close()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	engine.SetMapper(SameMapper{})
+	engine.SetDefaultCacher(NewLRUCacher(NewMemoryStore(), 1000))
+	engine.ShowSQL = showTestSql
+	engine.ShowErr = showTestSql
+	engine.ShowWarn = showTestSql
+	engine.ShowDebug = showTestSql
+
+	testAll(engine, t)
+	testAll2(engine, t)
+}
+
 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`;"

statement.go

@@ -12,6 +12,11 @@ import (
 	"github.com/lunny/xorm/core"
 )
 
+type inParam struct {
+	colName string
+	args    []interface{}
+}
+
 // statement save all the sql info for executing SQL
 type Statement struct {
 	RefTable      *core.Table
@@ -43,7 +48,7 @@ type Statement struct {
 	allUseBool    bool
 	checkVersion  bool
 	boolColumnMap map[string]bool
-	inColumns     map[string][]interface{}
+	inColumns     map[string]*inParam
 }
 
 // init
@@ -72,7 +77,7 @@ func (statement *Statement) Init() {
 	statement.allUseBool = false
 	statement.boolColumnMap = make(map[string]bool)
 	statement.checkVersion = true
-	statement.inColumns = make(map[string][]interface{})
+	statement.inColumns = make(map[string]*inParam)
 }
 
 // add the raw sql statement
@@ -456,10 +461,10 @@ func (statement *Statement) Id(id interface{}) *Statement {
 // Generate "Where column IN (?) " statment
 func (statement *Statement) In(column string, args ...interface{}) *Statement {
 	k := strings.ToLower(column)
-	if params, ok := statement.inColumns[k]; ok {
+	if _, ok := statement.inColumns[k]; ok {
-		statement.inColumns[k] = append(params, args...)
+		statement.inColumns[k].args = append(statement.inColumns[k].args, args...)
 	} else {
-		statement.inColumns[k] = args
+		statement.inColumns[k] = &inParam{column, args}
 	}
 	return statement
 }
@@ -471,10 +476,11 @@ func (statement *Statement) genInSql() (string, []interface{}) {
 
 	inStrs := make([]string, 0, len(statement.inColumns))
 	args := make([]interface{}, 0)
-	for column, params := range statement.inColumns {
+	for _, params := range statement.inColumns {
-		inStrs = append(inStrs, fmt.Sprintf("(%v IN (%v))", statement.Engine.Quote(column),
+		inStrs = append(inStrs, fmt.Sprintf("(%v IN (%v))",
-			strings.Join(makeArray("?", len(params)), ",")))
+			statement.Engine.Quote(params.colName),
-		args = append(args, params...)
+			strings.Join(makeArray("?", len(params.args)), ",")))
+		args = append(args, params.args...)
 	}
 
 	if len(statement.inColumns) == 1 {