diff --git a/.circleci/config.yml b/.circleci/config.yml
index 7f681029..c7a8d6a9 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -49,8 +49,8 @@ jobs:
 
       - run: go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -coverprofile=coverage2-1.txt -covermode=atomic
       - run: go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -cache=true -coverprofile=coverage2-2.txt -covermode=atomic
-      - run: go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -map_type=same -coverprofile=coverage2-1.txt -covermode=atomic
-      - run: go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -map_type=same -cache=true -coverprofile=coverage2-2.txt -covermode=atomic
+      - run: go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -map_type=same -coverprofile=coverage2-3.txt -covermode=atomic
+      - run: go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -map_type=same -cache=true -coverprofile=coverage2-4.txt -covermode=atomic
 
       - run: go test -v -race -db="mymysql" -conn_str="xorm_test/root/" -coverprofile=coverage3-1.txt -covermode=atomic
       - run: go test -v -race -db="mymysql" -conn_str="xorm_test/root/" -cache=true -coverprofile=coverage3-2.txt -covermode=atomic
@@ -62,6 +62,6 @@ jobs:
       - run: go test -v -race -db="mssql" -conn_str="server=localhost;user id=sa;password=yourStrong(!)Password;database=xorm_test" -cache=true -coverprofile=coverage6-2.txt -covermode=atomic
       - run: go test -v -race -db="mysql" -conn_str="root:@tcp(localhost:4000)/xorm_test" -ignore_select_update=true -coverprofile=coverage7-1.txt -covermode=atomic
       - run: go test -v -race -db="mysql" -conn_str="root:@tcp(localhost:4000)/xorm_test" -ignore_select_update=true -cache=true -coverprofile=coverage7-2.txt -covermode=atomic
-      - run: gocovmerge coverage1-1.txt coverage1-2.txt coverage2-1.txt coverage2-2.txt coverage3-1.txt coverage3-2.txt coverage4-1.txt coverage4-2.txt coverage5-1.txt coverage5-2.txt coverage6-1.txt coverage6-2.txt coverage7-1.txt coverage7-2.txt > coverage.txt
+      - run: gocovmerge coverage1-1.txt coverage1-2.txt coverage1-3.txt coverage1-4.txt coverage2-1.txt coverage2-2.txt  coverage2-3.txt coverage2-4.txt coverage3-1.txt coverage3-2.txt coverage4-1.txt coverage4-2.txt coverage5-1.txt coverage5-2.txt coverage6-1.txt coverage6-2.txt coverage7-1.txt coverage7-2.txt > coverage.txt
 
       - run: bash <(curl -s https://codecov.io/bash)
\ No newline at end of file
diff --git a/cache_test.go b/cache_test.go
index 26d7ac68..dbfa28e2 100644
--- a/cache_test.go
+++ b/cache_test.go
@@ -59,8 +59,10 @@ func TestCacheFind(t *testing.T) {
 		assert.Equal(t, inserts[i].Password, box.Password)
 	}
 
+	idName := mapper.Obj2Table("Id")
+
 	boxes = make([]MailBox, 0, 2)
-	assert.NoError(t, testEngine.Alias("a").Where("a.id > -1").Asc("a.id").Find(&boxes))
+	assert.NoError(t, testEngine.Alias("a").Where("a."+idName+" > -1").Asc("a."+idName).Find(&boxes))
 	assert.EqualValues(t, 2, len(boxes))
 	for i, box := range boxes {
 		assert.Equal(t, inserts[i].Id, box.Id)
@@ -74,8 +76,10 @@ func TestCacheFind(t *testing.T) {
 		Password string
 	}
 
+	tableName := mapper.Obj2Table("MailBox")
+
 	boxes2 := make([]MailBox4, 0, 2)
-	assert.NoError(t, testEngine.Table("mail_box").Where("mail_box.id > -1").Asc("mail_box.id").Find(&boxes2))
+	assert.NoError(t, testEngine.Table(tableName).Where(tableName+"."+idName+" > -1").Asc(tableName+"."+idName).Find(&boxes2))
 	assert.EqualValues(t, 2, len(boxes2))
 	for i, box := range boxes2 {
 		assert.Equal(t, inserts[i].Id, box.Id)
diff --git a/session_cond_test.go b/session_cond_test.go
index 10650484..6fd83293 100644
--- a/session_cond_test.go
+++ b/session_cond_test.go
@@ -36,25 +36,27 @@ func TestBuilder(t *testing.T) {
 	_, err = testEngine.Insert(&Condition{TableName: "table1", ColName: "col1", Op: OpEqual, Value: "1"})
 	assert.NoError(t, err)
 
+	colNameName := mapper.Obj2Table("ColName")
+
 	var cond Condition
-	has, err := testEngine.Where(builder.Eq{"col_name": "col1"}).Get(&cond)
+	has, err := testEngine.Where(builder.Eq{colNameName: "col1"}).Get(&cond)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has, "records should exist")
 
-	has, err = testEngine.Where(builder.Eq{"col_name": "col1"}.
+	has, err = testEngine.Where(builder.Eq{colNameName: "col1"}.
 		And(builder.Eq{"op": OpEqual})).
 		NoAutoCondition().
 		Get(&cond)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has, "records should exist")
 
-	has, err = testEngine.Where(builder.Eq{"col_name": "col1", "op": OpEqual, "value": "1"}).
+	has, err = testEngine.Where(builder.Eq{colNameName: "col1", "op": OpEqual, "value": "1"}).
 		NoAutoCondition().
 		Get(&cond)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has, "records should exist")
 
-	has, err = testEngine.Where(builder.Eq{"col_name": "col1"}.
+	has, err = testEngine.Where(builder.Eq{colNameName: "col1"}.
 		And(builder.Neq{"op": OpEqual})).
 		NoAutoCondition().
 		Get(&cond)
@@ -62,37 +64,37 @@ func TestBuilder(t *testing.T) {
 	assert.Equal(t, false, has, "records should not exist")
 
 	var conds []Condition
-	err = testEngine.Where(builder.Eq{"col_name": "col1"}.
+	err = testEngine.Where(builder.Eq{colNameName: "col1"}.
 		And(builder.Eq{"op": OpEqual})).
 		Find(&conds)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(conds), "records should exist")
 
 	conds = make([]Condition, 0)
-	err = testEngine.Where(builder.Like{"col_name", "col"}).Find(&conds)
+	err = testEngine.Where(builder.Like{colNameName, "col"}).Find(&conds)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(conds), "records should exist")
 
 	conds = make([]Condition, 0)
-	err = testEngine.Where(builder.Expr("col_name = ?", "col1")).Find(&conds)
+	err = testEngine.Where(builder.Expr(colNameName+" = ?", "col1")).Find(&conds)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(conds), "records should exist")
 
 	conds = make([]Condition, 0)
-	err = testEngine.Where(builder.In("col_name", "col1", "col2")).Find(&conds)
+	err = testEngine.Where(builder.In(colNameName, "col1", "col2")).Find(&conds)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(conds), "records should exist")
 
 	conds = make([]Condition, 0)
-	err = testEngine.NotIn("col_name", "col1", "col2").Find(&conds)
+	err = testEngine.NotIn(colNameName, "col1", "col2").Find(&conds)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 0, len(conds), "records should not exist")
 
 	// complex condtions
 	var where = builder.NewCond()
 	if true {
-		where = where.And(builder.Eq{"col_name": "col1"})
-		where = where.Or(builder.And(builder.In("col_name", "col1", "col2"), builder.Expr("col_name = ?", "col1")))
+		where = where.And(builder.Eq{colNameName: "col1"})
+		where = where.Or(builder.And(builder.In(colNameName, "col1", "col2"), builder.Expr(colNameName+" = ?", "col1")))
 	}
 
 	conds = make([]Condition, 0)
diff --git a/session_exist_test.go b/session_exist_test.go
index 9d985771..3bc15b3a 100644
--- a/session_exist_test.go
+++ b/session_exist_test.go
@@ -54,23 +54,25 @@ func TestExistStruct(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, has)
 
-	has, err = testEngine.SQL("select * from "+testEngine.TableName("record_exist", true)+" where name = ?", "test1").Exist()
+	tableName := mapper.Obj2Table("RecordExist")
+
+	has, err = testEngine.SQL("select * from "+testEngine.TableName(tableName, true)+" where name = ?", "test1").Exist()
 	assert.NoError(t, err)
 	assert.True(t, has)
 
-	has, err = testEngine.SQL("select * from "+testEngine.TableName("record_exist", true)+" where name = ?", "test2").Exist()
+	has, err = testEngine.SQL("select * from "+testEngine.TableName(tableName, true)+" where name = ?", "test2").Exist()
 	assert.NoError(t, err)
 	assert.False(t, has)
 
-	has, err = testEngine.Table("record_exist").Exist()
+	has, err = testEngine.Table(tableName).Exist()
 	assert.NoError(t, err)
 	assert.True(t, has)
 
-	has, err = testEngine.Table("record_exist").Where("name = ?", "test1").Exist()
+	has, err = testEngine.Table(tableName).Where("name = ?", "test1").Exist()
 	assert.NoError(t, err)
 	assert.True(t, has)
 
-	has, err = testEngine.Table("record_exist").Where("name = ?", "test2").Exist()
+	has, err = testEngine.Table(tableName).Where("name = ?", "test2").Exist()
 	assert.NoError(t, err)
 	assert.False(t, has)
 }
diff --git a/session_find_test.go b/session_find_test.go
index f805f06e..2f89ad9b 100644
--- a/session_find_test.go
+++ b/session_find_test.go
@@ -53,10 +53,12 @@ func TestJoinLimit(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
+	tableName := mapper.Obj2Table("CheckList")
+
 	var salaries []Salary
 	err = testEngine.Table("salary").
-		Join("INNER", "check_list", "check_list.id = salary.lid").
-		Join("LEFT", "empsetting", "empsetting.id = check_list.eid").
+		Join("INNER", tableName, tableName+".id = salary.lid").
+		Join("LEFT", "empsetting", "empsetting.id = "+tableName+".eid").
 		Limit(10, 0).
 		Find(&salaries)
 	assert.NoError(t, err)
@@ -133,7 +135,7 @@ type TeamUser struct {
 }
 
 func (TeamUser) TableName() string {
-	return "team_user"
+	return mapper.Obj2Table("TeamUser")
 }
 
 func TestFind3(t *testing.T) {
@@ -142,51 +144,58 @@ func TestFind3(t *testing.T) {
 	err := testEngine.Sync2(new(Team), teamUser)
 	assert.NoError(t, err)
 
+	tableName := mapper.Obj2Table("TeamUser")
+	teamTableName := mapper.Obj2Table("Team")
+	idName := mapper.Obj2Table("Id")
+	orgIDName := mapper.Obj2Table("OrgId")
+	uidName := mapper.Obj2Table("Uid")
+	teamIDName := mapper.Obj2Table("TeamId")
+
 	var teams []Team
-	err = testEngine.Cols("`team`.id").
-		Where("`team_user`.org_id=?", 1).
-		And("`team_user`.uid=?", 2).
-		Join("INNER", "`team_user`", "`team_user`.team_id=`team`.id").
+	err = testEngine.Cols("`"+teamTableName+"`."+idName).
+		Where("`"+tableName+"`."+orgIDName+"=?", 1).
+		And("`"+tableName+"`."+uidName+"=?", 2).
+		Join("INNER", "`"+tableName+"`", "`"+tableName+"`."+teamIDName+"=`"+teamTableName+"`."+idName).
 		Find(&teams)
 	assert.NoError(t, err)
 
 	teams = make([]Team, 0)
-	err = testEngine.Cols("`team`.id").
-		Where("`team_user`.org_id=?", 1).
-		And("`team_user`.uid=?", 2).
-		Join("INNER", teamUser, "`team_user`.team_id=`team`.id").
+	err = testEngine.Cols("`"+teamTableName+"`."+idName).
+		Where("`"+tableName+"`."+orgIDName+"=?", 1).
+		And("`"+tableName+"`."+uidName+"=?", 2).
+		Join("INNER", teamUser, "`"+tableName+"`."+teamIDName+"=`"+teamTableName+"`."+idName).
 		Find(&teams)
 	assert.NoError(t, err)
 
 	teams = make([]Team, 0)
-	err = testEngine.Cols("`team`.id").
-		Where("`team_user`.org_id=?", 1).
-		And("`team_user`.uid=?", 2).
-		Join("INNER", []interface{}{teamUser}, "`team_user`.team_id=`team`.id").
+	err = testEngine.Cols("`"+teamTableName+"`."+idName).
+		Where("`"+tableName+"`."+orgIDName+"=?", 1).
+		And("`"+tableName+"`."+uidName+"=?", 2).
+		Join("INNER", []interface{}{teamUser}, "`"+tableName+"`."+teamIDName+"=`"+teamTableName+"`."+idName).
 		Find(&teams)
 	assert.NoError(t, err)
 
 	teams = make([]Team, 0)
-	err = testEngine.Cols("`team`.id").
-		Where("`tu`.org_id=?", 1).
-		And("`tu`.uid=?", 2).
-		Join("INNER", []string{"team_user", "tu"}, "`tu`.team_id=`team`.id").
+	err = testEngine.Cols("`"+teamTableName+"`.id").
+		Where("`tu`."+orgIDName+"=?", 1).
+		And("`tu`."+uidName+"=?", 2).
+		Join("INNER", []string{tableName, "tu"}, "`tu`."+teamIDName+"=`"+teamTableName+"`."+idName).
 		Find(&teams)
 	assert.NoError(t, err)
 
 	teams = make([]Team, 0)
-	err = testEngine.Cols("`team`.id").
-		Where("`tu`.org_id=?", 1).
-		And("`tu`.uid=?", 2).
-		Join("INNER", []interface{}{"team_user", "tu"}, "`tu`.team_id=`team`.id").
+	err = testEngine.Cols("`"+teamTableName+"`."+idName).
+		Where("`tu`."+orgIDName+"=?", 1).
+		And("`tu`."+uidName+"=?", 2).
+		Join("INNER", []interface{}{tableName, "tu"}, "`tu`."+teamIDName+"=`"+teamTableName+"`."+idName).
 		Find(&teams)
 	assert.NoError(t, err)
 
 	teams = make([]Team, 0)
-	err = testEngine.Cols("`team`.id").
-		Where("`tu`.org_id=?", 1).
-		And("`tu`.uid=?", 2).
-		Join("INNER", []interface{}{teamUser, "tu"}, "`tu`.team_id=`team`.id").
+	err = testEngine.Cols("`"+teamTableName+"`."+idName).
+		Where("`tu`."+orgIDName+"=?", 1).
+		And("`tu`."+uidName+"=?", 2).
+		Join("INNER", []interface{}{teamUser, "tu"}, "`tu`."+teamIDName+"=`"+teamTableName+"`."+idName).
 		Find(&teams)
 	assert.NoError(t, err)
 }
@@ -197,10 +206,8 @@ func TestFindMap(t *testing.T) {
 
 	users := make(map[int64]Userinfo)
 	err := testEngine.Find(&users)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
+
 	for _, user := range users {
 		fmt.Println(user)
 	}
@@ -212,10 +219,8 @@ func TestFindMap2(t *testing.T) {
 
 	users := make(map[int64]*Userinfo)
 	err := testEngine.Find(&users)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
+
 	for id, user := range users {
 		fmt.Println(id, user)
 	}
@@ -791,13 +796,20 @@ func TestFindJoin(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(SceneItem), new(DeviceUserPrivrels))
 
+	tableName1 := mapper.Obj2Table("SceneItem")
+	tableName2 := mapper.Obj2Table("DeviceUserPrivrels")
+
+	deviceIDName := mapper.Obj2Table("DeviceId")
+	userIDName := mapper.Obj2Table("UserId")
+	typeName := mapper.Obj2Table("Type")
+
 	var scenes []SceneItem
-	err := testEngine.Join("LEFT OUTER", "device_user_privrels", "device_user_privrels.device_id=scene_item.device_id").
-		Where("scene_item.type=?", 3).Or("device_user_privrels.user_id=?", 339).Find(&scenes)
+	err := testEngine.Join("LEFT OUTER", tableName2, tableName1+"."+deviceIDName+"="+tableName2+"."+deviceIDName).
+		Where(tableName1+"."+typeName+"=?", 3).Or(tableName2+"."+userIDName+"=?", 339).Find(&scenes)
 	assert.NoError(t, err)
 
 	scenes = make([]SceneItem, 0)
-	err = testEngine.Join("LEFT OUTER", new(DeviceUserPrivrels), "device_user_privrels.device_id=scene_item.device_id").
-		Where("scene_item.type=?", 3).Or("device_user_privrels.user_id=?", 339).Find(&scenes)
+	err = testEngine.Join("LEFT OUTER", new(DeviceUserPrivrels), tableName1+"."+deviceIDName+"="+tableName2+"."+deviceIDName).
+		Where(tableName1+"."+typeName+"=?", 3).Or(tableName2+"."+userIDName+"=?", 339).Find(&scenes)
 	assert.NoError(t, err)
 }
diff --git a/session_get_test.go b/session_get_test.go
index f93068c8..e7e40b8a 100644
--- a/session_get_test.go
+++ b/session_get_test.go
@@ -35,14 +35,16 @@ func TestGetVar(t *testing.T) {
 	_, err := testEngine.InsertOne(&data)
 	assert.NoError(t, err)
 
+	tableName := mapper.Obj2Table("GetVar")
+
 	var msg string
-	has, err := testEngine.Table("get_var").Cols("msg").Get(&msg)
+	has, err := testEngine.Table(tableName).Cols("msg").Get(&msg)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, "hi", msg)
 
 	var age int
-	has, err = testEngine.Table("get_var").Cols("age").Get(&age)
+	has, err = testEngine.Table(tableName).Cols("age").Get(&age)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, 28, age)
@@ -54,7 +56,7 @@ func TestGetVar(t *testing.T) {
 	assert.Equal(t, 28, ageMax)
 
 	var age2 int64
-	has, err = testEngine.Table("get_var").Cols("age").
+	has, err = testEngine.Table(tableName).Cols("age").
 		Where("age > ?", 20).
 		And("age < ?", 30).
 		Get(&age2)
@@ -126,72 +128,77 @@ func TestGetVar(t *testing.T) {
 	assert.EqualValues(t, 28, age10)
 
 	var id sql.NullInt64
-	has, err = testEngine.Table("get_var").Cols("id").Get(&id)
+	has, err = testEngine.Table(tableName).Cols("id").Get(&id)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, true, id.Valid)
 	assert.EqualValues(t, data.Id, id.Int64)
 
 	var msgNull sql.NullString
-	has, err = testEngine.Table("get_var").Cols("msg").Get(&msgNull)
+	has, err = testEngine.Table(tableName).Cols("msg").Get(&msgNull)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, true, msgNull.Valid)
 	assert.EqualValues(t, data.Msg, msgNull.String)
 
 	var nullMoney sql.NullFloat64
-	has, err = testEngine.Table("get_var").Cols("money").Get(&nullMoney)
+	has, err = testEngine.Table(tableName).Cols("money").Get(&nullMoney)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, true, nullMoney.Valid)
 	assert.EqualValues(t, data.Money, nullMoney.Float64)
 
 	var money float64
-	has, err = testEngine.Table("get_var").Cols("money").Get(&money)
+	has, err = testEngine.Table(tableName).Cols("money").Get(&money)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, "1.5", fmt.Sprintf("%.1f", money))
 
 	var money2 float64
 	if testEngine.Dialect().DBType() == core.MSSQL {
-		has, err = testEngine.SQL("SELECT TOP 1 money FROM " + testEngine.TableName("get_var", true)).Get(&money2)
+		has, err = testEngine.SQL("SELECT TOP 1 money FROM " + testEngine.TableName(tableName, true)).Get(&money2)
 	} else {
-		has, err = testEngine.SQL("SELECT money FROM " + testEngine.TableName("get_var", true) + " LIMIT 1").Get(&money2)
+		has, err = testEngine.SQL("SELECT money FROM " + testEngine.TableName(tableName, true) + " LIMIT 1").Get(&money2)
 	}
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, "1.5", fmt.Sprintf("%.1f", money2))
 
 	var money3 float64
-	has, err = testEngine.SQL("SELECT money FROM " + testEngine.TableName("get_var", true) + " WHERE money > 20").Get(&money3)
+	has, err = testEngine.SQL("SELECT money FROM " + testEngine.TableName(tableName, true) + " WHERE money > 20").Get(&money3)
 	assert.NoError(t, err)
 	assert.Equal(t, false, has)
 
+	idName := mapper.Obj2Table("Id")
+	ageName := mapper.Obj2Table("Age")
+	msgName := mapper.Obj2Table("Msg")
+	moneyName := mapper.Obj2Table("Money")
+
 	var valuesString = make(map[string]string)
-	has, err = testEngine.Table("get_var").Get(&valuesString)
+	has, err = testEngine.Table(tableName).Get(&valuesString)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, 5, len(valuesString))
-	assert.Equal(t, "1", valuesString["id"])
-	assert.Equal(t, "hi", valuesString["msg"])
-	assert.Equal(t, "28", valuesString["age"])
-	assert.Equal(t, "1.5", valuesString["money"])
+	assert.Equal(t, "1", valuesString[idName])
+	assert.Equal(t, "hi", valuesString[msgName])
+	assert.Equal(t, "28", valuesString[ageName])
+	assert.Equal(t, "1.5", valuesString[moneyName])
 
 	// for mymysql driver, interface{} will be []byte, so ignore it currently
 	if testEngine.Dialect().DriverName() != "mymysql" {
 		var valuesInter = make(map[string]interface{})
-		has, err = testEngine.Table("get_var").Where("id = ?", 1).Select("*").Get(&valuesInter)
+		has, err = testEngine.Table(tableName).Where(idName+" = ?", 1).Select("*").Get(&valuesInter)
 		assert.NoError(t, err)
 		assert.Equal(t, true, has)
 		assert.Equal(t, 5, len(valuesInter))
-		assert.EqualValues(t, 1, valuesInter["id"])
-		assert.Equal(t, "hi", fmt.Sprintf("%s", valuesInter["msg"]))
-		assert.EqualValues(t, 28, valuesInter["age"])
-		assert.Equal(t, "1.5", fmt.Sprintf("%v", valuesInter["money"]))
+		assert.EqualValues(t, 1, valuesInter[idName])
+		assert.Equal(t, "hi", fmt.Sprintf("%s", valuesInter[msgName]))
+		assert.EqualValues(t, 28, valuesInter[ageName])
+		assert.Equal(t, "1.5", fmt.Sprintf("%v", valuesInter[moneyName]))
 	}
 
 	var valuesSliceString = make([]string, 5)
-	has, err = testEngine.Table("get_var").Get(&valuesSliceString)
+	has, err = testEngine.Table(tableName).Get(&valuesSliceString)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, "1", valuesSliceString[0])
@@ -200,7 +207,7 @@ func TestGetVar(t *testing.T) {
 	assert.Equal(t, "1.5", valuesSliceString[3])
 
 	var valuesSliceInter = make([]interface{}, 5)
-	has, err = testEngine.Table("get_var").Get(&valuesSliceInter)
+	has, err = testEngine.Table(tableName).Get(&valuesSliceInter)
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 
@@ -329,15 +336,17 @@ func TestJSONString(t *testing.T) {
 	})
 	assert.NoError(t, err)
 
+	tableName := mapper.Obj2Table("JsonJson")
+
 	var js JsonString
-	has, err := testEngine.Table("json_json").Get(&js)
+	has, err := testEngine.Table(tableName).Get(&js)
 	assert.NoError(t, err)
 	assert.True(t, has)
 	assert.EqualValues(t, 1, js.Id)
 	assert.EqualValues(t, `["1","2"]`, js.Content)
 
 	var jss []JsonString
-	err = testEngine.Table("json_json").Find(&jss)
+	err = testEngine.Table(tableName).Find(&jss)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(jss))
 	assert.EqualValues(t, `["1","2"]`, jss[0].Content)
@@ -366,9 +375,12 @@ func TestGetActionMapping(t *testing.T) {
 	})
 	assert.NoError(t, err)
 
+	scriptIdName := mapper.Obj2Table("ScriptId")
+	rollbackIdName := mapper.Obj2Table("RollbackId")
+
 	var valuesSlice = make([]string, 2)
 	has, err := testEngine.Table(new(ActionMapping)).
-		Cols("script_id", "rollback_id").
+		Cols(scriptIdName, rollbackIdName).
 		ID("1").Get(&valuesSlice)
 	assert.NoError(t, err)
 	assert.True(t, has)
@@ -393,9 +405,10 @@ func TestGetStructId(t *testing.T) {
 		Id int64
 	}
 
+	idName := mapper.Obj2Table("Id")
 	//var id int64
 	var maxid maxidst
-	sql := "select max(id) as id from " + testEngine.TableName(&TestGetStruct{}, true)
+	sql := "select max(" + idName + ") as id from " + testEngine.TableName(&TestGetStruct{}, true)
 	has, err := testEngine.SQL(sql).Get(&maxid)
 	assert.NoError(t, err)
 	assert.True(t, has)
diff --git a/session_insert_test.go b/session_insert_test.go
index 2785401d..262badf3 100644
--- a/session_insert_test.go
+++ b/session_insert_test.go
@@ -783,7 +783,9 @@ func TestInsertMap(t *testing.T) {
 	assert.EqualValues(t, 10, im.Height)
 	assert.EqualValues(t, "lunny", im.Name)
 
-	cnt, err = testEngine.Table("insert_map").Insert(map[string]interface{}{
+	tableName := mapper.Obj2Table("InsertMap")
+
+	cnt, err = testEngine.Table(tableName).Insert(map[string]interface{}{
 		"width":  30,
 		"height": 10,
 		"name":   "lunny",
@@ -802,7 +804,7 @@ func TestInsertMap(t *testing.T) {
 	assert.EqualValues(t, 10, ims[1].Height)
 	assert.EqualValues(t, "lunny", ims[1].Name)
 
-	cnt, err = testEngine.Table("insert_map").Insert([]map[string]interface{}{
+	cnt, err = testEngine.Table(tableName).Insert([]map[string]interface{}{
 		{
 			"width":  40,
 			"height": 10,
diff --git a/session_query_test.go b/session_query_test.go
index 772206a8..da4b6465 100644
--- a/session_query_test.go
+++ b/session_query_test.go
@@ -37,14 +37,22 @@ func TestQueryString(t *testing.T) {
 	_, err := testEngine.InsertOne(data)
 	assert.NoError(t, err)
 
-	records, err := testEngine.QueryString("select * from " + testEngine.TableName("get_var2", true))
+	tableName := mapper.Obj2Table("GetVar2")
+
+	records, err := testEngine.QueryString("select * from " + testEngine.TableName(tableName, true))
 	assert.NoError(t, err)
 	assert.Equal(t, 1, len(records))
 	assert.Equal(t, 5, len(records[0]))
-	assert.Equal(t, "1", records[0]["id"])
-	assert.Equal(t, "hi", records[0]["msg"])
-	assert.Equal(t, "28", records[0]["age"])
-	assert.Equal(t, "1.5", records[0]["money"])
+
+	idName := mapper.Obj2Table("Id")
+	ageName := mapper.Obj2Table("Age")
+	msgName := mapper.Obj2Table("Msg")
+	moneyName := mapper.Obj2Table("Money")
+
+	assert.Equal(t, "1", records[0][idName])
+	assert.Equal(t, "hi", records[0][msgName])
+	assert.Equal(t, "28", records[0][ageName])
+	assert.Equal(t, "1.5", records[0][moneyName])
 }
 
 func TestQueryString2(t *testing.T) {
@@ -63,12 +71,17 @@ func TestQueryString2(t *testing.T) {
 	_, err := testEngine.Insert(data)
 	assert.NoError(t, err)
 
-	records, err := testEngine.QueryString("select * from " + testEngine.TableName("get_var3", true))
+	tableName := mapper.Obj2Table("GetVar3")
+
+	idName := mapper.Obj2Table("Id")
+	msgName := mapper.Obj2Table("Msg")
+
+	records, err := testEngine.QueryString("select * from " + testEngine.TableName(tableName, true))
 	assert.NoError(t, err)
 	assert.Equal(t, 1, len(records))
 	assert.Equal(t, 2, len(records[0]))
-	assert.Equal(t, "1", records[0]["id"])
-	assert.True(t, "0" == records[0]["msg"] || "false" == records[0]["msg"])
+	assert.Equal(t, "1", records[0][idName])
+	assert.True(t, "0" == records[0][msgName] || "false" == records[0][msgName])
 }
 
 func toString(i interface{}) string {
@@ -128,14 +141,20 @@ func TestQueryInterface(t *testing.T) {
 	_, err := testEngine.InsertOne(data)
 	assert.NoError(t, err)
 
-	records, err := testEngine.QueryInterface("select * from " + testEngine.TableName("get_var_interface", true))
+	tableName := mapper.Obj2Table("GetVarInterface")
+	idName := mapper.Obj2Table("Id")
+	msgName := mapper.Obj2Table("Msg")
+	ageName := mapper.Obj2Table("Age")
+	moneyName := mapper.Obj2Table("Money")
+
+	records, err := testEngine.QueryInterface("select * from " + testEngine.TableName(tableName, true))
 	assert.NoError(t, err)
 	assert.Equal(t, 1, len(records))
 	assert.Equal(t, 5, len(records[0]))
-	assert.EqualValues(t, 1, toInt64(records[0]["id"]))
-	assert.Equal(t, "hi", toString(records[0]["msg"]))
-	assert.EqualValues(t, 28, toInt64(records[0]["age"]))
-	assert.EqualValues(t, 1.5, toFloat64(records[0]["money"]))
+	assert.EqualValues(t, 1, toInt64(records[0][idName]))
+	assert.Equal(t, "hi", toString(records[0][msgName]))
+	assert.EqualValues(t, 28, toInt64(records[0][ageName]))
+	assert.EqualValues(t, 1.5, toFloat64(records[0][moneyName]))
 }
 
 func TestQueryNoParams(t *testing.T) {
@@ -162,27 +181,33 @@ func TestQueryNoParams(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
+	idName := mapper.Obj2Table("Id")
+	msgName := mapper.Obj2Table("Msg")
+	ageName := mapper.Obj2Table("Age")
+	moneyName := mapper.Obj2Table("Money")
+
 	assertResult := func(t *testing.T, results []map[string][]byte) {
 		assert.EqualValues(t, 1, len(results))
-		id, err := strconv.ParseInt(string(results[0]["id"]), 10, 64)
+		id, err := strconv.ParseInt(string(results[0][idName]), 10, 64)
 		assert.NoError(t, err)
 		assert.EqualValues(t, 1, id)
-		assert.Equal(t, "message", string(results[0]["msg"]))
+		assert.Equal(t, "message", string(results[0][msgName]))
 
-		age, err := strconv.Atoi(string(results[0]["age"]))
+		age, err := strconv.Atoi(string(results[0][ageName]))
 		assert.NoError(t, err)
 		assert.EqualValues(t, 20, age)
 
-		money, err := strconv.ParseFloat(string(results[0]["money"]), 32)
+		money, err := strconv.ParseFloat(string(results[0][moneyName]), 32)
 		assert.NoError(t, err)
 		assert.EqualValues(t, 3000, money)
 	}
 
-	results, err := testEngine.Table("query_no_params").Limit(10).Query()
+	tableName := mapper.Obj2Table("QueryNoParams")
+	results, err := testEngine.Table(tableName).Limit(10).Query()
 	assert.NoError(t, err)
 	assertResult(t, results)
 
-	results, err = testEngine.SQL("select * from " + testEngine.TableName("query_no_params", true)).Query()
+	results, err = testEngine.SQL("select * from " + testEngine.TableName(tableName, true)).Query()
 	assert.NoError(t, err)
 	assertResult(t, results)
 }
@@ -203,24 +228,29 @@ func TestQueryStringNoParam(t *testing.T) {
 	_, err := testEngine.Insert(data)
 	assert.NoError(t, err)
 
-	records, err := testEngine.Table("get_var4").Limit(1).QueryString()
+	tableName := mapper.Obj2Table("GetVar4")
+
+	idName := mapper.Obj2Table("Id")
+	msgName := mapper.Obj2Table("Msg")
+
+	records, err := testEngine.Table(tableName).Limit(1).QueryString()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
-	assert.EqualValues(t, "1", records[0]["id"])
+	assert.EqualValues(t, "1", records[0][idName])
 	if testEngine.Dialect().DBType() == core.POSTGRES || testEngine.Dialect().DBType() == core.MSSQL {
-		assert.EqualValues(t, "false", records[0]["msg"])
+		assert.EqualValues(t, "false", records[0][msgName])
 	} else {
-		assert.EqualValues(t, "0", records[0]["msg"])
+		assert.EqualValues(t, "0", records[0][msgName])
 	}
 
-	records, err = testEngine.Table("get_var4").Where(builder.Eq{"id": 1}).QueryString()
+	records, err = testEngine.Table(tableName).Where(builder.Eq{idName: 1}).QueryString()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
-	assert.EqualValues(t, "1", records[0]["id"])
+	assert.EqualValues(t, "1", records[0][idName])
 	if testEngine.Dialect().DBType() == core.POSTGRES || testEngine.Dialect().DBType() == core.MSSQL {
-		assert.EqualValues(t, "false", records[0]["msg"])
+		assert.EqualValues(t, "false", records[0][msgName])
 	} else {
-		assert.EqualValues(t, "0", records[0]["msg"])
+		assert.EqualValues(t, "0", records[0][msgName])
 	}
 }
 
@@ -240,7 +270,9 @@ func TestQuerySliceStringNoParam(t *testing.T) {
 	_, err := testEngine.Insert(data)
 	assert.NoError(t, err)
 
-	records, err := testEngine.Table("get_var6").Limit(1).QuerySliceString()
+	tableName := mapper.Obj2Table("GetVar6")
+
+	records, err := testEngine.Table(tableName).Limit(1).QuerySliceString()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
 	assert.EqualValues(t, "1", records[0][0])
@@ -250,7 +282,8 @@ func TestQuerySliceStringNoParam(t *testing.T) {
 		assert.EqualValues(t, "0", records[0][1])
 	}
 
-	records, err = testEngine.Table("get_var6").Where(builder.Eq{"id": 1}).QuerySliceString()
+	idName := mapper.Obj2Table("Id")
+	records, err = testEngine.Table(tableName).Where(builder.Eq{idName: 1}).QuerySliceString()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
 	assert.EqualValues(t, "1", records[0][0])
@@ -277,17 +310,21 @@ func TestQueryInterfaceNoParam(t *testing.T) {
 	_, err := testEngine.Insert(data)
 	assert.NoError(t, err)
 
-	records, err := testEngine.Table("get_var5").Limit(1).QueryInterface()
-	assert.NoError(t, err)
-	assert.EqualValues(t, 1, len(records))
-	assert.EqualValues(t, 1, toInt64(records[0]["id"]))
-	assert.EqualValues(t, 0, toInt64(records[0]["msg"]))
+	tableName := mapper.Obj2Table("GetVar5")
+	idName := mapper.Obj2Table("Id")
+	msgName := mapper.Obj2Table("Msg")
 
-	records, err = testEngine.Table("get_var5").Where(builder.Eq{"id": 1}).QueryInterface()
+	records, err := testEngine.Table(tableName).Limit(1).QueryInterface()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
-	assert.EqualValues(t, 1, toInt64(records[0]["id"]))
-	assert.EqualValues(t, 0, toInt64(records[0]["msg"]))
+	assert.EqualValues(t, 1, toInt64(records[0][idName]))
+	assert.EqualValues(t, 0, toInt64(records[0][msgName]))
+
+	records, err = testEngine.Table(tableName).Where(builder.Eq{idName: 1}).QueryInterface()
+	assert.NoError(t, err)
+	assert.EqualValues(t, 1, len(records))
+	assert.EqualValues(t, 1, toInt64(records[0][idName]))
+	assert.EqualValues(t, 0, toInt64(records[0][msgName]))
 }
 
 func TestQueryWithBuilder(t *testing.T) {
@@ -314,23 +351,29 @@ func TestQueryWithBuilder(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
+	idName := mapper.Obj2Table("Id")
+	msgName := mapper.Obj2Table("Msg")
+	ageName := mapper.Obj2Table("Age")
+	moneyName := mapper.Obj2Table("Money")
+
 	assertResult := func(t *testing.T, results []map[string][]byte) {
 		assert.EqualValues(t, 1, len(results))
-		id, err := strconv.ParseInt(string(results[0]["id"]), 10, 64)
+		id, err := strconv.ParseInt(string(results[0][idName]), 10, 64)
 		assert.NoError(t, err)
 		assert.EqualValues(t, 1, id)
-		assert.Equal(t, "message", string(results[0]["msg"]))
+		assert.Equal(t, "message", string(results[0][msgName]))
 
-		age, err := strconv.Atoi(string(results[0]["age"]))
+		age, err := strconv.Atoi(string(results[0][ageName]))
 		assert.NoError(t, err)
 		assert.EqualValues(t, 20, age)
 
-		money, err := strconv.ParseFloat(string(results[0]["money"]), 32)
+		money, err := strconv.ParseFloat(string(results[0][moneyName]), 32)
 		assert.NoError(t, err)
 		assert.EqualValues(t, 3000, money)
 	}
 
-	results, err := testEngine.Query(builder.Select("*").From(testEngine.TableName("query_with_builder", true)))
+	tableName := mapper.Obj2Table("QueryWithBuilder")
+	results, err := testEngine.Query(builder.Select("*").From(testEngine.TableName(tableName, true)))
 	assert.NoError(t, err)
 	assertResult(t, results)
 }
@@ -371,9 +414,15 @@ func TestJoinWithSubQuery(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
+	tableName := mapper.Obj2Table("JoinWithSubQueryDepart")
+	tableName1 := mapper.Obj2Table("JoinWithSubQuery1")
+
+	departID := mapper.Obj2Table("DepartId")
+	idName := mapper.Obj2Table("Id")
+
 	var querys []JoinWithSubQuery1
-	err = testEngine.Join("INNER", builder.Select("id").From(testEngine.Quote(testEngine.TableName("join_with_sub_query_depart", true))),
-		"join_with_sub_query_depart.id = join_with_sub_query1.depart_id").Find(&querys)
+	err = testEngine.Join("INNER", builder.Select(idName).From(testEngine.Quote(testEngine.TableName(tableName, true))),
+		tableName+"."+idName+" = "+tableName1+"."+departID).Find(&querys)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(querys))
 	assert.EqualValues(t, q, querys[0])
diff --git a/session_raw_test.go b/session_raw_test.go
index 766206a4..8bfabb4d 100644
--- a/session_raw_test.go
+++ b/session_raw_test.go
@@ -21,17 +21,21 @@ func TestExecAndQuery(t *testing.T) {
 
 	assert.NoError(t, testEngine.Sync2(new(UserinfoQuery)))
 
-	res, err := testEngine.Exec("INSERT INTO "+testEngine.TableName("`userinfo_query`", true)+" (uid, name) VALUES (?, ?)", 1, "user")
+	tableName := mapper.Obj2Table("UserinfoQuery")
+	uidName := mapper.Obj2Table("Uid")
+	nameName := mapper.Obj2Table("Name")
+
+	res, err := testEngine.Exec("INSERT INTO "+testEngine.TableName(tableName, true)+" ("+uidName+", "+nameName+") VALUES (?, ?)", 1, "user")
 	assert.NoError(t, err)
 	cnt, err := res.RowsAffected()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
-	results, err := testEngine.Query("select * from " + testEngine.TableName("userinfo_query", true))
+	results, err := testEngine.Query("select * from " + testEngine.TableName(tableName, true))
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(results))
-	id, err := strconv.Atoi(string(results[0]["uid"]))
+	id, err := strconv.Atoi(string(results[0][uidName]))
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, id)
-	assert.Equal(t, "user", string(results[0]["name"]))
+	assert.Equal(t, "user", string(results[0][nameName]))
 }
diff --git a/session_schema_test.go b/session_schema_test.go
index 5a0fca2e..f655a225 100644
--- a/session_schema_test.go
+++ b/session_schema_test.go
@@ -79,7 +79,7 @@ type SyncTable2 struct {
 }
 
 func (SyncTable2) TableName() string {
-	return "sync_table1"
+	return mapper.Obj2Table("SyncTable1")
 }
 
 type SyncTable3 struct {
@@ -91,7 +91,7 @@ type SyncTable3 struct {
 }
 
 func (s *SyncTable3) TableName() string {
-	return "sync_table1"
+	return mapper.Obj2Table("SyncTable1")
 }
 
 func TestSyncTable(t *testing.T) {
@@ -99,24 +99,26 @@ func TestSyncTable(t *testing.T) {
 
 	assert.NoError(t, testEngine.Sync2(new(SyncTable1)))
 
+	tableName := mapper.Obj2Table("SyncTable1")
+
 	tables, err := testEngine.DBMetas()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(tables))
-	assert.EqualValues(t, "sync_table1", tables[0].Name)
+	assert.EqualValues(t, tableName, tables[0].Name)
 
 	assert.NoError(t, testEngine.Sync2(new(SyncTable2)))
 
 	tables, err = testEngine.DBMetas()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(tables))
-	assert.EqualValues(t, "sync_table1", tables[0].Name)
+	assert.EqualValues(t, tableName, tables[0].Name)
 
 	assert.NoError(t, testEngine.Sync2(new(SyncTable3)))
 
 	tables, err = testEngine.DBMetas()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(tables))
-	assert.EqualValues(t, "sync_table1", tables[0].Name)
+	assert.EqualValues(t, tableName, tables[0].Name)
 }
 
 func TestIsTableExist(t *testing.T) {
@@ -227,8 +229,10 @@ func TestMetaInfo(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, len(tables))
 	tableNames := []string{tables[0].Name, tables[1].Name}
+
+	tableName2 := mapper.Obj2Table("IndexOrUnique")
 	assert.Contains(t, tableNames, "customtablename")
-	assert.Contains(t, tableNames, "index_or_unique")
+	assert.Contains(t, tableNames, tableName2)
 }
 
 func TestCharst(t *testing.T) {
@@ -273,10 +277,12 @@ func TestUnique_1(t *testing.T) {
 
 	assert.NoError(t, prepareEngine())
 
-	assert.NoError(t, testEngine.DropTables("user_unique"))
+	tableName := mapper.Obj2Table("UserUnique")
+
+	assert.NoError(t, testEngine.DropTables(tableName))
 	assert.NoError(t, testEngine.Sync2(new(UserUnique)))
 
-	assert.NoError(t, testEngine.DropTables("user_unique"))
+	assert.NoError(t, testEngine.DropTables(tableName))
 	assert.NoError(t, testEngine.CreateTables(new(UserUnique)))
 	assert.NoError(t, testEngine.CreateUniques(new(UserUnique)))
 }
diff --git a/session_stats_test.go b/session_stats_test.go
index 01c76ba5..08a554ca 100644
--- a/session_stats_test.go
+++ b/session_stats_test.go
@@ -186,11 +186,12 @@ func TestCount(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, total)
 
-	total, err = testEngine.Where(cond).Table("userinfo_count").Count()
+	tableName := mapper.Obj2Table("UserinfoCount")
+	total, err = testEngine.Where(cond).Table(tableName).Count()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, total)
 
-	total, err = testEngine.Table("userinfo_count").Count()
+	total, err = testEngine.Table(tableName).Count()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, total)
 }
@@ -211,7 +212,9 @@ func TestSQLCount(t *testing.T) {
 
 	assertSync(t, new(UserinfoCount2), new(UserinfoBooks))
 
-	total, err := testEngine.SQL("SELECT count(id) FROM " + testEngine.TableName("userinfo_count2", true)).
+	tableName := mapper.Obj2Table("UserinfoCount2")
+	idName := mapper.Obj2Table("Id")
+	total, err := testEngine.SQL("SELECT count(" + idName + ") FROM " + testEngine.TableName(tableName, true)).
 		Count()
 	assert.NoError(t, err)
 	assert.EqualValues(t, 0, total)
@@ -237,7 +240,8 @@ func TestCountWithOthers(t *testing.T) {
 	})
 	assert.NoError(t, err)
 
-	total, err := testEngine.OrderBy("id desc").Limit(1).Count(new(CountWithOthers))
+	idName := mapper.Obj2Table("Id")
+	total, err := testEngine.OrderBy(idName + " desc").Limit(1).Count(new(CountWithOthers))
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, total)
 }
@@ -266,11 +270,13 @@ func TestWithTableName(t *testing.T) {
 	})
 	assert.NoError(t, err)
 
-	total, err := testEngine.OrderBy("id desc").Count(new(CountWithTableName))
+	idName := mapper.Obj2Table("Id")
+
+	total, err := testEngine.OrderBy(idName + " desc").Count(new(CountWithTableName))
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, total)
 
-	total, err = testEngine.OrderBy("id desc").Count(CountWithTableName{})
+	total, err = testEngine.OrderBy(idName + " desc").Count(CountWithTableName{})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 2, total)
 }
diff --git a/session_update_test.go b/session_update_test.go
index a0a98469..79b938d7 100644
--- a/session_update_test.go
+++ b/session_update_test.go
@@ -32,9 +32,13 @@ func TestUpdateMap(t *testing.T) {
 	_, err := testEngine.Insert(&tb)
 	assert.NoError(t, err)
 
-	cnt, err := testEngine.Table("update_table").Where("id = ?", tb.Id).Update(map[string]interface{}{
-		"name": "test2",
-		"age":  36,
+	tableName := mapper.Obj2Table("UpdateTable")
+	nameName := mapper.Obj2Table("Name")
+	ageName := mapper.Obj2Table("age")
+
+	cnt, err := testEngine.Table(tableName).Where("id = ?", tb.Id).Update(map[string]interface{}{
+		nameName: "test2",
+		ageName:  36,
 	})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
@@ -64,7 +68,9 @@ func TestUpdateLimit(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
-	cnt, err = testEngine.OrderBy("name desc").Limit(1).Update(&UpdateTable2{
+	nameName := mapper.Obj2Table("Name")
+
+	cnt, err = testEngine.OrderBy(nameName + " desc").Limit(1).Update(&UpdateTable2{
 		Age: 30,
 	})
 	assert.NoError(t, err)
@@ -268,7 +274,8 @@ func TestUpdateMap2(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 	assertSync(t, new(UpdateMustCols))
 
-	_, err := testEngine.Table("update_must_cols").Where("id =?", 1).Update(map[string]interface{}{
+	tableName := mapper.Obj2Table("UpdateMustCols")
+	_, err := testEngine.Table(tableName).Where("id =?", 1).Update(map[string]interface{}{
 		"bool": true,
 	})
 	assert.NoError(t, err)
@@ -305,6 +312,13 @@ func TestUpdate1(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, total, cnt)
 
+	userName := mapper.Obj2Table("Username")
+	heightName := mapper.Obj2Table("Height")
+	departName := mapper.Obj2Table("Departname")
+	detailIDName := "detail_id"
+	isMan := mapper.Obj2Table("IsMan")
+	createdName := mapper.Obj2Table("Created")
+
 	// nullable update
 	{
 		user := &Userinfo{Username: "not null data", Height: 180.5}
@@ -313,29 +327,29 @@ func TestUpdate1(t *testing.T) {
 
 		userID := user.Uid
 		has, err := testEngine.ID(userID).
-			And("username = ?", user.Username).
-			And("height = ?", user.Height).
-			And("departname = ?", "").
-			And("detail_id = ?", 0).
-			And("is_man = ?", 0).
+			And(userName+" = ?", user.Username).
+			And(heightName+" = ?", user.Height).
+			And(departName+" = ?", "").
+			And(detailIDName+" = ?", 0).
+			And(isMan+" = ?", 0).
 			Get(&Userinfo{})
 		assert.NoError(t, err)
 		assert.True(t, has)
 
 		updatedUser := &Userinfo{Username: "null data"}
 		cnt, err = testEngine.ID(userID).
-			Nullable("height", "departname", "is_man", "created").
+			Nullable(heightName, departName, isMan, createdName).
 			Update(updatedUser)
 		assert.NoError(t, err)
 		assert.EqualValues(t, 1, cnt)
 
 		has, err = testEngine.ID(userID).
-			And("username = ?", updatedUser.Username).
-			And("height IS NULL").
-			And("departname IS NULL").
-			And("is_man IS NULL").
-			And("created IS NULL").
-			And("detail_id = ?", 0).
+			And(userName+" = ?", updatedUser.Username).
+			And(heightName+" IS NULL").
+			And(departName+" IS NULL").
+			And(isMan+" IS NULL").
+			And(createdName+" IS NULL").
+			And(detailIDName+" = ?", 0).
 			Get(&Userinfo{})
 		assert.NoError(t, err)
 		assert.True(t, has)
@@ -1024,8 +1038,9 @@ func TestDeletedUpdate(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
+	deletedAtName := mapper.Obj2Table("DeletedAt")
 	s.DeletedAt = time.Time{}
-	cnt, err = testEngine.Unscoped().Nullable("deleted_at").Update(&s)
+	cnt, err = testEngine.Unscoped().Nullable(deletedAtName).Update(&s)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
@@ -1037,11 +1052,11 @@ func TestDeletedUpdate(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
-	cnt, err = testEngine.ID(s.Id).Cols("deleted_at").Update(&DeletedUpdatedStruct{})
+	cnt, err = testEngine.ID(s.Id).Cols(deletedAtName).Update(&DeletedUpdatedStruct{})
 	assert.EqualValues(t, "No content found to be updated", err.Error())
 	assert.EqualValues(t, 0, cnt)
 
-	cnt, err = testEngine.ID(s.Id).Unscoped().Cols("deleted_at").Update(&DeletedUpdatedStruct{})
+	cnt, err = testEngine.ID(s.Id).Unscoped().Cols(deletedAtName).Update(&DeletedUpdatedStruct{})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
@@ -1066,10 +1081,12 @@ func TestUpdateMapCondition(t *testing.T) {
 	_, err := testEngine.Insert(&c)
 	assert.NoError(t, err)
 
+	idName := mapper.Obj2Table("Id")
+
 	cnt, err := testEngine.Update(&UpdateMapCondition{
 		String: "string1",
 	}, map[string]interface{}{
-		"id": c.Id,
+		idName: c.Id,
 	})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
@@ -1104,7 +1121,11 @@ func TestUpdateMapContent(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 18, c.Age)
 
-	cnt, err := testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{"age": 0})
+	ageName := mapper.Obj2Table("Age")
+	isManName := mapper.Obj2Table("IsMan")
+	genderName := mapper.Obj2Table("Gender")
+
+	cnt, err := testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{ageName: 0})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
@@ -1115,9 +1136,9 @@ func TestUpdateMapContent(t *testing.T) {
 	assert.EqualValues(t, 0, c1.Age)
 
 	cnt, err = testEngine.Table(new(UpdateMapContent)).ID(c.Id).Update(map[string]interface{}{
-		"age":    16,
-		"is_man": false,
-		"gender": 2,
+		ageName:    16,
+		isManName:  false,
+		genderName: 2,
 	})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
@@ -1131,9 +1152,9 @@ func TestUpdateMapContent(t *testing.T) {
 	assert.EqualValues(t, 2, c2.Gender)
 
 	cnt, err = testEngine.Table(testEngine.TableName(new(UpdateMapContent))).ID(c.Id).Update(map[string]interface{}{
-		"age":    15,
-		"is_man": true,
-		"gender": 1,
+		ageName:    15,
+		isManName:  true,
+		genderName: 1,
 	})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
diff --git a/statement_test.go b/statement_test.go
index acc542ab..ff84eba4 100644
--- a/statement_test.go
+++ b/statement_test.go
@@ -197,8 +197,10 @@ func TestDistinctAndCols(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
+	tableName := mapper.Obj2Table("DistinctAndCols")
+
 	var names []string
-	err = testEngine.Table("distinct_and_cols").Cols("name").Distinct("name").Find(&names)
+	err = testEngine.Table(tableName).Cols("name").Distinct("name").Find(&names)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(names))
 	assert.EqualValues(t, "test", names[0])
diff --git a/tag_test.go b/tag_test.go
index 891c6ffc..6e55f1f0 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -159,12 +159,14 @@ func TestAutoIncrTag(t *testing.T) {
 		Id int64
 	}
 
+	idName := mapper.Obj2Table("Id")
+
 	tb := testEngine.TableInfo(new(TestAutoIncr1))
 	cols := tb.Columns()
 	assert.EqualValues(t, 1, len(cols))
 	assert.True(t, cols[0].IsAutoIncrement)
 	assert.True(t, cols[0].IsPrimaryKey)
-	assert.Equal(t, "id", cols[0].Name)
+	assert.Equal(t, idName, cols[0].Name)
 
 	type TestAutoIncr2 struct {
 		Id int64 `xorm:"id"`
@@ -197,7 +199,7 @@ func TestAutoIncrTag(t *testing.T) {
 	assert.EqualValues(t, 1, len(cols))
 	assert.False(t, cols[0].IsAutoIncrement)
 	assert.True(t, cols[0].IsPrimaryKey)
-	assert.Equal(t, "id", cols[0].Name)
+	assert.Equal(t, idName, cols[0].Name)
 }
 
 func TestTagComment(t *testing.T) {
@@ -524,7 +526,7 @@ func TestTagTime(t *testing.T) {
 	assert.EqualValues(t, s.Created.Format("2006-01-02 15:04:05"), u.Created.Format("2006-01-02 15:04:05"))
 
 	var tm string
-	has, err = testEngine.Table("tag_u_t_c_struct").Cols("created").Get(&tm)
+	has, err = testEngine.Table(&s).Cols("created").Get(&tm)
 	assert.NoError(t, err)
 	assert.True(t, has)
 	assert.EqualValues(t, s.Created.UTC().Format("2006-01-02 15:04:05"),
diff --git a/xorm_test.go b/xorm_test.go
index c0302df3..654533b1 100644
--- a/xorm_test.go
+++ b/xorm_test.go
@@ -35,6 +35,8 @@ var (
 	splitter           = flag.String("splitter", ";", "the splitter on connstr for cluster")
 	schema             = flag.String("schema", "", "specify the schema")
 	ignoreSelectUpdate = flag.Bool("ignore_select_update", false, "ignore select update if implementation difference, only for tidb")
+
+	mapper core.IMapper
 )
 
 func createEngine(dbType, connStr string) error {
@@ -113,11 +115,14 @@ func createEngine(dbType, connStr string) error {
 		if len(*mapType) > 0 {
 			switch *mapType {
 			case "snake":
-				testEngine.SetMapper(core.SnakeMapper{})
+				mapper = core.SnakeMapper{}
 			case "same":
-				testEngine.SetMapper(core.SameMapper{})
+				mapper = core.SameMapper{}
 			case "gonic":
-				testEngine.SetMapper(core.LintGonicMapper)
+				mapper = core.LintGonicMapper
+			}
+			if mapper != nil {
+				testEngine.SetMapper(mapper)
 			}
 		}
 	}