diff --git a/.drone.yml b/.drone.yml
index e9dae788..60abd422 100644
--- a/.drone.yml
+++ b/.drone.yml
@@ -24,6 +24,8 @@ steps:
   commands:
   - "go test -v -race -db=\"sqlite3\" -conn_str=\"./test.db\" -coverprofile=coverage1-1.txt -covermode=atomic"
   - "go test -v -race -db=\"sqlite3\" -conn_str=\"./test.db\" -cache=true -coverprofile=coverage1-2.txt -covermode=atomic"
+  - "go test -v -race -db=\"sqlite3\" -conn_str=\"./test.db\" -col_quote=reserved -coverprofile=coverage1-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"sqlite3\" -conn_str=\"./test.db\" -col_quote=reserved -cache=true -coverprofile=coverage1-4.txt -covermode=atomic"
   when:
     event:
     - push
@@ -38,7 +40,9 @@ steps:
   commands:
   - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test\" -coverprofile=coverage2-1.txt -covermode=atomic"
   - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test\" -cache=true -coverprofile=coverage2-2.txt -covermode=atomic"
-  when:
+  - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test\" -col_quote=reserved -coverprofile=coverage2-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test\" -col_quote=reserved -cache=true -coverprofile=coverage2-4.txt -covermode=atomic"
+   when:
     event:
     - push
     - pull_request
@@ -54,6 +58,8 @@ steps:
   commands:
   - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test?charset=utf8mb4\" -coverprofile=coverage2.1-1.txt -covermode=atomic"
   - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test?charset=utf8mb4\" -cache=true -coverprofile=coverage2.1-2.txt -covermode=atomic"
+  - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test?charset=utf8mb4\" -col_quote=reserved -coverprofile=coverage2.1-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(mysql)/xorm_test?charset=utf8mb4\" -col_quote=reserved -cache=true -coverprofile=coverage2.1-4.txt -covermode=atomic"
   when:
     event:
     - push
@@ -70,6 +76,8 @@ steps:
   commands:
   - "go test -v -race -db=\"mymysql\" -conn_str=\"tcp:mysql:3306*xorm_test/root/\" -coverprofile=coverage3-1.txt -covermode=atomic"
   - "go test -v -race -db=\"mymysql\" -conn_str=\"tcp:mysql:3306*xorm_test/root/\" -cache=true -coverprofile=coverage3-2.txt -covermode=atomic"
+  - "go test -v -race -db=\"mymysql\" -conn_str=\"tcp:mysql:3306*xorm_test/root/\" -col_quote=reserved -coverprofile=coverage3-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"mymysql\" -conn_str=\"tcp:mysql:3306*xorm_test/root/\" -col_quote=reserved -cache=true -coverprofile=coverage3-4.txt -covermode=atomic"
   when:
     event:
     - push
@@ -84,6 +92,8 @@ steps:
   commands:
   - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -coverprofile=coverage4-1.txt -covermode=atomic"
   - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -cache=true -coverprofile=coverage4-2.txt -covermode=atomic"
+  - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -col_quote=reserved -coverprofile=coverage4-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -col_quote=reserved -cache=true -coverprofile=coverage4-4.txt -covermode=atomic"
   when:
     event:
     - push
@@ -98,6 +108,8 @@ steps:
   commands:
   - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -schema=xorm -coverprofile=coverage5-1.txt -covermode=atomic"
   - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -schema=xorm -cache=true -coverprofile=coverage5-2.txt -covermode=atomic"
+  - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -col_quote=reserved -schema=xorm -coverprofile=coverage5-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"postgres\" -conn_str=\"postgres://postgres:@pgsql/xorm_test?sslmode=disable\" -col_quote=reserved -schema=xorm -cache=true -coverprofile=coverage5-4.txt -covermode=atomic"
   when:
     event:
     - push
@@ -112,6 +124,8 @@ steps:
   commands:
   - "go test -v -race -db=\"mssql\" -conn_str=\"server=mssql;user id=sa;password=yourStrong(!)Password;database=xorm_test\" -coverprofile=coverage6-1.txt -covermode=atomic"
   - "go test -v -race -db=\"mssql\" -conn_str=\"server=mssql;user id=sa;password=yourStrong(!)Password;database=xorm_test\" -cache=true -coverprofile=coverage6-2.txt -covermode=atomic"
+  - "go test -v -race -db=\"mssql\" -conn_str=\"server=mssql;user id=sa;password=yourStrong(!)Password;database=xorm_test\" -col_quote=reserved -coverprofile=coverage6-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"mssql\" -conn_str=\"server=mssql;user id=sa;password=yourStrong(!)Password;database=xorm_test\" -col_quote=reserved -cache=true -coverprofile=coverage6-4.txt -covermode=atomic"
   when:
     event:
     - push
@@ -126,6 +140,8 @@ steps:
   commands:
   - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(tidb:4000)/xorm_test\" -ignore_select_update=true -coverprofile=coverage7-1.txt -covermode=atomic"
   - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(tidb:4000)/xorm_test\" -ignore_select_update=true -cache=true -coverprofile=coverage7-2.txt -covermode=atomic"
+  - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(tidb:4000)/xorm_test\" -col_quote=reserved -ignore_select_update=true -coverprofile=coverage7-3.txt -covermode=atomic"
+  - "go test -v -race -db=\"mysql\" -conn_str=\"root:@tcp(tidb:4000)/xorm_test\" -col_quote=reserved -ignore_select_update=true -cache=true -coverprofile=coverage7-4.txt -covermode=atomic"
   when:
     event:
     - push
@@ -149,7 +165,15 @@ steps:
   - test-tidb
   commands:
   - go get github.com/wadey/gocovmerge
-  - gocovmerge coverage1-1.txt coverage1-2.txt coverage2-1.txt coverage2-2.txt coverage2.1-1.txt coverage2.1-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
+  - >
+    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
+    coverage2.1-1.txt coverage2.1-2.txt coverage2.1-3.txt coverage2.1-4.txt
+    coverage3-1.txt coverage3-2.txt coverage3-3.txt coverage3-4.txt
+    coverage4-1.txt coverage4-2.txt coverage4-3.txt coverage4-4.txt
+    coverage5-1.txt coverage5-2.txt coverage5-3.txt coverage5-4.txt
+    coverage6-1.txt coverage6-2.txt coverage6-3.txt coverage6-4.txt
+    coverage7-1.txt coverage7-2.txt coverage7-3.txt coverage7-4.txt > coverage.txt
   when:
     event:
     - push
diff --git a/dialect_mssql.go b/dialect_mssql.go
index 430811ff..60bdbbbc 100644
--- a/dialect_mssql.go
+++ b/dialect_mssql.go
@@ -533,7 +533,7 @@ func (db *mssql) ForUpdateSql(query string) string {
 }
 
 func (db *mssql) Filters() []core.Filter {
-	return []core.Filter{&core.IdFilter{}, &core.QuoteFilter{}}
+	return []core.Filter{&core.QuoteFilter{}}
 }
 
 type odbcDriver struct {
diff --git a/dialect_mysql.go b/dialect_mysql.go
index 2e393439..56f00897 100644
--- a/dialect_mysql.go
+++ b/dialect_mysql.go
@@ -560,7 +560,7 @@ func (db *mysql) CreateTableSql(table *core.Table, tableName, storeEngine, chars
 }
 
 func (db *mysql) Filters() []core.Filter {
-	return []core.Filter{&core.IdFilter{}}
+	return []core.Filter{}
 }
 
 type mymysqlDriver struct {
diff --git a/dialect_oracle.go b/dialect_oracle.go
index 537ee50b..848f81bf 100644
--- a/dialect_oracle.go
+++ b/dialect_oracle.go
@@ -847,7 +847,7 @@ func (db *oracle) GetIndexes(tableName string) (map[string]*core.Index, error) {
 }
 
 func (db *oracle) Filters() []core.Filter {
-	return []core.Filter{&core.QuoteFilter{}, &core.SeqFilter{Prefix: ":", Start: 1}, &core.IdFilter{}}
+	return []core.Filter{&core.QuoteFilter{}, &core.SeqFilter{Prefix: ":", Start: 1}}
 }
 
 type goracleDriver struct {
diff --git a/dialect_postgres.go b/dialect_postgres.go
index c12fad40..1c07c4de 100644
--- a/dialect_postgres.go
+++ b/dialect_postgres.go
@@ -1160,7 +1160,7 @@ func (db *postgres) GetIndexes(tableName string) (map[string]*core.Index, error)
 }
 
 func (db *postgres) Filters() []core.Filter {
-	return []core.Filter{&core.IdFilter{}, &core.QuoteFilter{}, &core.SeqFilter{Prefix: "$", Start: 1}}
+	return []core.Filter{&core.QuoteFilter{}, &core.SeqFilter{Prefix: "$", Start: 1}}
 }
 
 type pqDriver struct {
diff --git a/dialect_sqlite3.go b/dialect_sqlite3.go
index 181fad29..265f14fd 100644
--- a/dialect_sqlite3.go
+++ b/dialect_sqlite3.go
@@ -477,7 +477,7 @@ func (db *sqlite3) GetIndexes(tableName string) (map[string]*core.Index, error)
 }
 
 func (db *sqlite3) Filters() []core.Filter {
-	return []core.Filter{&core.IdFilter{}}
+	return []core.Filter{}
 }
 
 type sqlite3Driver struct {
diff --git a/engine_quote.go b/engine_quote.go
index 30b15f4b..299e20d7 100644
--- a/engine_quote.go
+++ b/engine_quote.go
@@ -17,9 +17,9 @@ type QuotePolicy int
 
 // All QuotePolicies
 const (
-	QuoteAddAlways QuotePolicy = iota
-	QuoteNoAdd
-	QuoteAddReserved
+	QuotePolicyAlways QuotePolicy = iota
+	QuotePolicyNone
+	QuotePolicyReserved
 )
 
 // Quoter represents an object has Quote method
@@ -56,7 +56,7 @@ func (q *quoter) IsReserved(value string) bool {
 }
 
 func (q *quoter) needQuote(value string) bool {
-	return q.quotePolicy == QuoteAddAlways || (q.quotePolicy == QuoteAddReserved && q.IsReserved(value))
+	return q.quotePolicy == QuotePolicyAlways || (q.quotePolicy == QuotePolicyReserved && q.IsReserved(value))
 }
 
 func (q *quoter) WriteTo(w *builder.BytesWriter, name string) error {
@@ -134,8 +134,8 @@ func (engine *Engine) SetColumnQuotePolicy(policy QuotePolicy) {
 // quoteTo quotes string and writes into the buffer
 func quoteTo(quoter Quoter, buf *strings.Builder, value string) {
 	left, right := quoter.Quotes()
-	if (quoter.QuotePolicy() == QuoteAddAlways) ||
-		(quoter.QuotePolicy() == QuoteAddReserved && quoter.IsReserved(value)) {
+	if (quoter.QuotePolicy() == QuotePolicyAlways) ||
+		(quoter.QuotePolicy() == QuotePolicyReserved && quoter.IsReserved(value)) {
 		realQuoteTo(left, right, buf, value)
 		return
 	}
diff --git a/engine_quote_test.go b/engine_quote_test.go
index 85a498eb..3318acd4 100644
--- a/engine_quote_test.go
+++ b/engine_quote_test.go
@@ -27,7 +27,11 @@ func TestChangeQuotePolicy(t *testing.T) {
 		Name string
 	}
 
-	testEngine.SetColumnQuotePolicy(QuoteNoAdd)
+	testEngine.SetColumnQuotePolicy(QuotePolicyNone)
+	defer func() {
+		testEngine.SetColumnQuotePolicy(colQuotePolicy)
+	}()
+
 	assertSync(t, new(ChangeQuotePolicy))
 
 	var obj1 = ChangeQuotePolicy{
@@ -63,7 +67,11 @@ func TestChangeQuotePolicy2(t *testing.T) {
 		Index int
 	}
 
-	testEngine.SetColumnQuotePolicy(QuoteAddReserved)
+	testEngine.SetColumnQuotePolicy(QuotePolicyReserved)
+	defer func() {
+		testEngine.SetColumnQuotePolicy(colQuotePolicy)
+	}()
+
 	assertSync(t, new(ChangeQuotePolicy2))
 
 	var obj1 = ChangeQuotePolicy2{
diff --git a/session_cond_test.go b/session_cond_test.go
index 10650484..d6c3417f 100644
--- a/session_cond_test.go
+++ b/session_cond_test.go
@@ -9,8 +9,8 @@ import (
 	"fmt"
 	"testing"
 
-	"xorm.io/builder"
 	"github.com/stretchr/testify/assert"
+	"xorm.io/builder"
 )
 
 func TestBuilder(t *testing.T) {
@@ -122,7 +122,8 @@ func TestIn(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 3, cnt)
 
-	department := "`" + testEngine.GetColumnMapper().Obj2Table("Departname") + "`"
+	department := testEngine.Quote(colMapper.Obj2Table("Departname"), true)
+	idStr := testEngine.Quote(colMapper.Obj2Table("Id"), true)
 	var usrs []Userinfo
 	err = testEngine.Where(department+" = ?", "dev").Limit(3).Find(&usrs)
 	assert.NoError(t, err)
@@ -137,13 +138,13 @@ func TestIn(t *testing.T) {
 	idsStr = idsStr[:len(idsStr)-1]
 
 	users := make([]Userinfo, 0)
-	err = testEngine.In("(id)", ids[0], ids[1], ids[2]).Find(&users)
+	err = testEngine.In(idStr, ids[0], ids[1], ids[2]).Find(&users)
 	assert.NoError(t, err)
 	fmt.Println(users)
 	assert.EqualValues(t, 3, len(users))
 
 	users = make([]Userinfo, 0)
-	err = testEngine.In("(id)", ids).Find(&users)
+	err = testEngine.In(idStr, ids).Find(&users)
 	assert.NoError(t, err)
 	fmt.Println(users)
 	assert.EqualValues(t, 3, len(users))
@@ -161,7 +162,7 @@ func TestIn(t *testing.T) {
 		idsInterface = append(idsInterface, id)
 	}
 
-	err = testEngine.Where(department+" = ?", "dev").In("(id)", idsInterface...).Find(&users)
+	err = testEngine.Where(department+" = ?", "dev").In(idStr, idsInterface...).Find(&users)
 	assert.NoError(t, err)
 	fmt.Println(users)
 	assert.EqualValues(t, 3, len(users))
@@ -175,11 +176,11 @@ func TestIn(t *testing.T) {
 
 	dev := testEngine.GetColumnMapper().Obj2Table("Dev")
 
-	err = testEngine.In("(id)", 1).In("(id)", 2).In(department, dev).Find(&users)
+	err = testEngine.In(idStr, 1).In(idStr, 2).In(department, dev).Find(&users)
 	assert.NoError(t, err)
 	fmt.Println(users)
 
-	cnt, err = testEngine.In("(id)", ids[0]).Update(&Userinfo{Departname: "dev-"})
+	cnt, err = testEngine.In(idStr, ids[0]).Update(&Userinfo{Departname: "dev-"})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
@@ -189,11 +190,11 @@ func TestIn(t *testing.T) {
 	assert.True(t, has)
 	assert.EqualValues(t, "dev-", user.Departname)
 
-	cnt, err = testEngine.In("(id)", ids[0]).Update(&Userinfo{Departname: "dev"})
+	cnt, err = testEngine.In(idStr, ids[0]).Update(&Userinfo{Departname: "dev"})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
-	cnt, err = testEngine.In("(id)", ids[1]).Delete(&Userinfo{})
+	cnt, err = testEngine.In(idStr, ids[1]).Delete(&Userinfo{})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 }
diff --git a/session_find_test.go b/session_find_test.go
index 0f8ebd14..4396a763 100644
--- a/session_find_test.go
+++ b/session_find_test.go
@@ -309,13 +309,14 @@ func TestOrderSameMapper(t *testing.T) {
 
 	assertSync(t, new(Userinfo))
 
+	idStr := testEngine.Quote("id", true)
 	users := make([]Userinfo, 0)
-	err := testEngine.OrderBy("(id) desc").Find(&users)
+	err := testEngine.OrderBy(idStr + " desc").Find(&users)
 	assert.NoError(t, err)
 	fmt.Println(users)
 
 	users2 := make([]Userinfo, 0)
-	err = testEngine.Asc("(id)", "Username").Desc("Height").Find(&users2)
+	err = testEngine.Asc(idStr, "Username").Desc("Height").Find(&users2)
 	assert.NoError(t, err)
 	fmt.Println(users2)
 }
diff --git a/session_insert.go b/session_insert.go
index 1620db70..02c9a2d9 100644
--- a/session_insert.go
+++ b/session_insert.go
@@ -260,6 +260,8 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 			quoteJoin(session.engine.colQuoter, colNames),
 			strings.Join(colMultiPlaces, "),("))
 	}
+
+	fmt.Println("====", sql)
 	res, err := session.exec(sql, args...)
 	if err != nil {
 		return 0, err
diff --git a/session_insert_test.go b/session_insert_test.go
index e6100fdc..8a0f0a60 100644
--- a/session_insert_test.go
+++ b/session_insert_test.go
@@ -201,28 +201,13 @@ func TestInsertDefault(t *testing.T) {
 	_, err = testEngine.Omit(testEngine.GetColumnMapper().Obj2Table("Status")).Insert(&di2)
 	assert.NoError(t, err)
 
-	has, err := testEngine.Desc("(id)").Get(di)
+	idStr := colMapper.Obj2Table("Id")
+	has, err := testEngine.Desc(idStr).Get(di)
 	assert.NoError(t, err)
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
-	if di.Status != -1 {
-		err = errors.New("inserted error data")
-		t.Error(err)
-		panic(err)
-	}
-	if di2.Updated.Unix() != di.Updated.Unix() {
-		err = errors.New("updated should equal")
-		t.Error(err, di.Updated, di2.Updated)
-		panic(err)
-	}
-	if di2.Created.Unix() != di.Created.Unix() {
-		err = errors.New("created should equal")
-		t.Error(err, di.Created, di2.Created)
-		panic(err)
-	}
+	assert.True(t, has, "error with no data")
+	assert.EqualValues(t, -1, di.Status, "inserted error data")
+	assert.EqualValues(t, di.Updated.Unix(), di2.Updated.Unix(), "updated should equal")
+	assert.EqualValues(t, di.Created.Unix(), di2.Created.Unix())
 }
 
 type DefaultInsert2 struct {
@@ -237,53 +222,21 @@ func TestInsertDefault2(t *testing.T) {
 
 	di := new(DefaultInsert2)
 	err := testEngine.Sync2(di)
-	if err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, err)
 
 	var di2 = DefaultInsert2{Name: "test"}
 	_, err = testEngine.Omit(testEngine.GetColumnMapper().Obj2Table("CheckTime")).Insert(&di2)
-	if err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, err)
 
-	has, err := testEngine.Desc("(id)").Get(di)
-	if err != nil {
-		t.Error(err)
-	}
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
+	idStr := testEngine.Quote(testEngine.GetColumnMapper().Obj2Table("Id"), true)
+	has, err := testEngine.Desc(idStr).Get(di)
+	assert.NoError(t, err)
+	assert.True(t, has, "error with no data")
 
-	has, err = testEngine.NoAutoCondition().Desc("(id)").Get(&di2)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if !has {
-		err = errors.New("error with no data")
-		t.Error(err)
-		panic(err)
-	}
-
-	if *di != di2 {
-		err = fmt.Errorf("%v is not equal to %v", di, di2)
-		t.Error(err)
-		panic(err)
-	}
-
-	/*if di2.Updated.Unix() != di.Updated.Unix() {
-		err = errors.New("updated should equal")
-		t.Error(err, di.Updated, di2.Updated)
-		panic(err)
-	}
-	if di2.Created.Unix() != di.Created.Unix() {
-		err = errors.New("created should equal")
-		t.Error(err, di.Created, di2.Created)
-		panic(err)
-	}*/
+	has, err = testEngine.NoAutoCondition().Desc(idStr).Get(&di2)
+	assert.NoError(t, err)
+	assert.True(t, has, "error with no data")
+	assert.EqualValues(t, *di, di2, fmt.Errorf("%v is not equal to %v", di, di2))
 }
 
 type CreatedInsert struct {
@@ -321,19 +274,15 @@ func TestInsertCreated(t *testing.T) {
 
 	di := new(CreatedInsert)
 	err := testEngine.Sync2(di)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
 	ci := &CreatedInsert{}
 	_, err = testEngine.Insert(ci)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
 
-	has, err := testEngine.Desc("(id)").Get(di)
-	if err != nil {
-		t.Fatal(err)
-	}
+	idStr := testEngine.Quote("Id", true)
+	has, err := testEngine.Desc(idStr).Get(di)
+	assert.NoError(t, err)
 	if !has {
 		t.Fatal(ErrNotExist)
 	}
@@ -344,18 +293,14 @@ func TestInsertCreated(t *testing.T) {
 
 	di2 := new(CreatedInsert2)
 	err = testEngine.Sync2(di2)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
 	ci2 := &CreatedInsert2{}
 	_, err = testEngine.Insert(ci2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di2)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
+	has, err = testEngine.Desc(idStr).Get(di2)
+	assert.NoError(t, err)
 	if !has {
 		t.Fatal(ErrNotExist)
 	}
@@ -366,18 +311,14 @@ func TestInsertCreated(t *testing.T) {
 
 	di3 := new(CreatedInsert3)
 	err = testEngine.Sync2(di3)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
 	ci3 := &CreatedInsert3{}
 	_, err = testEngine.Insert(ci3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di3)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
+	has, err = testEngine.Desc(idStr).Get(di3)
+	assert.NoError(t, err)
 	if !has {
 		t.Fatal(ErrNotExist)
 	}
@@ -388,18 +329,14 @@ func TestInsertCreated(t *testing.T) {
 
 	di4 := new(CreatedInsert4)
 	err = testEngine.Sync2(di4)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
 	ci4 := &CreatedInsert4{}
 	_, err = testEngine.Insert(ci4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di4)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
+	has, err = testEngine.Desc(idStr).Get(di4)
+	assert.NoError(t, err)
 	if !has {
 		t.Fatal(ErrNotExist)
 	}
@@ -410,18 +347,14 @@ func TestInsertCreated(t *testing.T) {
 
 	di5 := new(CreatedInsert5)
 	err = testEngine.Sync2(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
 	ci5 := &CreatedInsert5{}
 	_, err = testEngine.Insert(ci5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err = testEngine.Desc("(id)").Get(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
+	has, err = testEngine.Desc(idStr).Get(di5)
+	assert.NoError(t, err)
 	if !has {
 		t.Fatal(ErrNotExist)
 	}
@@ -432,20 +365,15 @@ func TestInsertCreated(t *testing.T) {
 
 	di6 := new(CreatedInsert6)
 	err = testEngine.Sync2(di6)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
 	oldTime := time.Now().Add(-time.Hour)
 	ci6 := &CreatedInsert6{Created: oldTime}
 	_, err = testEngine.Insert(ci6)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
 
-	has, err = testEngine.Desc("(id)").Get(di6)
-	if err != nil {
-		t.Fatal(err)
-	}
+	has, err = testEngine.Desc(idStr).Get(di6)
+	assert.NoError(t, err)
 	if !has {
 		t.Fatal(ErrNotExist)
 	}
@@ -476,8 +404,7 @@ func (j JsonTime) MarshalJSON() ([]byte, error) {
 
 func TestDefaultTime3(t *testing.T) {
 	type PrepareTask struct {
-		Id int `xorm:"not null pk autoincr INT(11)" json:"id"`
-		// ...
+		Id        int      `xorm:"not null pk autoincr INT(11)" json:"id"`
 		StartTime JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP index" json:"start_time"`
 		EndTime   JsonTime `xorm:"not null default '2006-01-02 15:04:05' TIMESTAMP" json:"end_time"`
 		Cuser     string   `xorm:"not null default '' VARCHAR(64) index" json:"cuser"`
@@ -509,25 +436,18 @@ func TestCreatedJsonTime(t *testing.T) {
 
 	di5 := new(MyJsonTime)
 	err := testEngine.Sync2(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
+	assert.NoError(t, err)
+
 	ci5 := &MyJsonTime{}
 	_, err = testEngine.Insert(ci5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	has, err := testEngine.Desc("(id)").Get(di5)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !has {
-		t.Fatal(ErrNotExist)
-	}
-	if time.Time(ci5.Created).Unix() != time.Time(di5.Created).Unix() {
-		t.Fatal("should equal:", time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix())
-	}
-	fmt.Println("ci5:", ci5, "di5:", di5)
+	assert.NoError(t, err)
+
+	idStr := testEngine.Quote(colMapper.Obj2Table("Id"), true)
+	has, err := testEngine.Desc(idStr).Get(di5)
+	assert.NoError(t, err)
+	assert.True(t, has, ErrNotExist.Error())
+	assert.EqualValues(t, time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix(),
+		fmt.Sprintf("should equal: %v %v", time.Time(ci5.Created).Unix(), time.Time(di5.Created).Unix()))
 
 	var dis = make([]MyJsonTime, 0)
 	err = testEngine.Find(&dis)
@@ -546,10 +466,7 @@ func TestInsertMulti2(t *testing.T) {
 		{Username: "xlw22", Departname: "dev", Alias: "lunny3", Created: time.Now()},
 	}
 	cnt, err := testEngine.Insert(&users)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 	assert.EqualValues(t, len(users), cnt)
 
 	users2 := []*Userinfo{
@@ -573,10 +490,7 @@ func TestInsertTwoTable(t *testing.T) {
 	userinfo := Userinfo{Username: "xlw3", Departname: "dev", Alias: "lunny4", Created: time.Now(), Detail: userdetail}
 
 	cnt, err := testEngine.Insert(&userinfo, &userdetail)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	if userinfo.Uid <= 0 {
 		err = errors.New("not return id error")
diff --git a/statement_test.go b/statement_test.go
index 03d73ff7..b287d96d 100644
--- a/statement_test.go
+++ b/statement_test.go
@@ -18,12 +18,12 @@ var colStrTests = []struct {
 	onlyToDBColumnNdx int
 	expected          string
 }{
-	{"", -1, "`ID`, `IsDeleted`, `Caption`, `Code1`, `Code2`, `Code3`, `ParentID`, `Latitude`, `Longitude`"},
-	{"Code2", -1, "`ID`, `IsDeleted`, `Caption`, `Code1`, `Code3`, `ParentID`, `Latitude`, `Longitude`"},
-	{"", 1, "`ID`, `Caption`, `Code1`, `Code2`, `Code3`, `ParentID`, `Latitude`, `Longitude`"},
-	{"Code3", 1, "`ID`, `Caption`, `Code1`, `Code2`, `ParentID`, `Latitude`, `Longitude`"},
-	{"Longitude", 1, "`ID`, `Caption`, `Code1`, `Code2`, `Code3`, `ParentID`, `Latitude`"},
-	{"", 8, "`ID`, `IsDeleted`, `Caption`, `Code1`, `Code2`, `Code3`, `ParentID`, `Latitude`"},
+	{"", -1, "ID, IsDeleted, Caption, Code1, Code2, Code3, ParentID, Latitude, Longitude"},
+	{"Code2", -1, "ID, IsDeleted, Caption, Code1, Code3, ParentID, Latitude, Longitude"},
+	{"", 1, "ID, Caption, Code1, Code2, Code3, ParentID, Latitude, Longitude"},
+	{"Code3", 1, "ID, Caption, Code1, Code2, ParentID, Latitude, Longitude"},
+	{"Longitude", 1, "ID, Caption, Code1, Code2, Code3, ParentID, Latitude"},
+	{"", 8, "ID, IsDeleted, Caption, Code1, Code2, Code3, ParentID, Latitude"},
 }
 
 func TestColumnsStringGeneration(t *testing.T) {
@@ -31,6 +31,11 @@ func TestColumnsStringGeneration(t *testing.T) {
 		return
 	}
 
+	testEngine.SetColumnQuotePolicy(QuotePolicyNone)
+	defer func() {
+		testEngine.SetColumnQuotePolicy(colQuotePolicy)
+	}()
+
 	var statement *Statement
 
 	for ndx, testCase := range colStrTests {
diff --git a/tag_test.go b/tag_test.go
index 979ba929..bff7742b 100644
--- a/tag_test.go
+++ b/tag_test.go
@@ -250,7 +250,7 @@ func TestTagDefault(t *testing.T) {
 
 	var defaultVal string
 	var isDefaultExist bool
-	tableName := testEngine.GetColumnMapper().Obj2Table("DefaultStruct")
+	tableName := tableMapper.Obj2Table("DefaultStruct")
 	for _, table := range tables {
 		if table.Name == tableName {
 			col := table.GetColumn("age")
@@ -293,7 +293,7 @@ func TestTagDefault2(t *testing.T) {
 
 	var defaultVal string
 	var isDefaultExist bool
-	tableName := testEngine.GetColumnMapper().Obj2Table("DefaultStruct2")
+	tableName := tableMapper.Obj2Table("DefaultStruct2")
 	for _, table := range tables {
 		if table.Name == tableName {
 			col := table.GetColumn("name")
@@ -322,7 +322,7 @@ func TestTagDefault3(t *testing.T) {
 
 	var defaultVal string
 	var isDefaultExist bool
-	tableName := testEngine.GetColumnMapper().Obj2Table("DefaultStruct3")
+	tableName := tableMapper.Obj2Table("DefaultStruct3")
 	for _, table := range tables {
 		if table.Name == tableName {
 			col := table.GetColumn("name")
@@ -351,7 +351,7 @@ func TestTagDefault4(t *testing.T) {
 
 	var defaultVal string
 	var isDefaultExist bool
-	tableName := testEngine.GetColumnMapper().Obj2Table("DefaultStruct4")
+	tableName := tableMapper.Obj2Table("DefaultStruct4")
 	for _, table := range tables {
 		if table.Name == tableName {
 			col := table.GetColumn("created")
@@ -387,7 +387,7 @@ func TestTagDefault5(t *testing.T) {
 
 	var defaultVal string
 	var isDefaultExist bool
-	tableName := testEngine.GetColumnMapper().Obj2Table("DefaultStruct5")
+	tableName := colMapper.Obj2Table("DefaultStruct5")
 	for _, table := range tables {
 		if table.Name == tableName {
 			col := table.GetColumn("created")
diff --git a/xorm.go b/xorm.go
index f6cfcc2b..f3b83c3a 100644
--- a/xorm.go
+++ b/xorm.go
@@ -95,8 +95,8 @@ func NewEngine(driverName string, dataSourceName string) (*Engine, error) {
 		tagHandlers:    defaultTagHandlers,
 		cachers:        make(map[string]core.Cacher),
 		defaultContext: context.Background(),
-		colQuoter:      newQuoter(dialect, QuoteAddAlways),
-		tableQuoter:    newQuoter(dialect, QuoteAddAlways),
+		colQuoter:      newQuoter(dialect, QuotePolicyAlways),
+		tableQuoter:    newQuoter(dialect, QuotePolicyAlways),
 	}
 
 	if uri.DbType == core.SQLITE {
diff --git a/xorm_test.go b/xorm_test.go
index 21715256..e82cfbe9 100644
--- a/xorm_test.go
+++ b/xorm_test.go
@@ -35,9 +35,11 @@ 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")
+	colQuotePolicyStr  = flag.String("col_quote", "always", "quote could be always, none, reversed")
 
-	tableMapper core.IMapper
-	colMapper   core.IMapper
+	tableMapper    core.IMapper
+	colMapper      core.IMapper
+	colQuotePolicy QuotePolicy
 )
 
 func createEngine(dbType, connStr string) error {
@@ -123,6 +125,15 @@ func createEngine(dbType, connStr string) error {
 				testEngine.SetMapper(core.LintGonicMapper)
 			}
 		}
+
+		if *colQuotePolicyStr == "none" {
+			colQuotePolicy = QuotePolicyNone
+		} else if *colQuotePolicyStr == "reserved" {
+			colQuotePolicy = QuotePolicyReserved
+		} else {
+			colQuotePolicy = QuotePolicyAlways
+		}
+		testEngine.SetColumnQuotePolicy(colQuotePolicy)
 	}
 
 	tableMapper = testEngine.GetTableMapper()