diff --git a/engine.go b/engine.go
index 84e9206d..5f09450f 100644
--- a/engine.go
+++ b/engine.go
@@ -205,14 +205,14 @@ func (engine *Engine) SetDefaultCacher(cacher core.Cacher) {
 // you can use NoCache()
 func (engine *Engine) NoCache() *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.NoCache()
 }
 
 // NoCascade If you do not want to auto cascade load object
 func (engine *Engine) NoCascade() *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.NoCascade()
 }
 
@@ -245,7 +245,7 @@ func (engine *Engine) Dialect() core.Dialect {
 
 // NewSession New a session
 func (engine *Engine) NewSession() *Session {
-	session := &Session{Engine: engine}
+	session := &Session{engine: engine}
 	session.Init()
 	return session
 }
@@ -320,7 +320,7 @@ func (engine *Engine) Sql(querystring string, args ...interface{}) *Session {
 // This    code will execute "select * from user" and set the records to users
 func (engine *Engine) SQL(query interface{}, args ...interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.SQL(query, args...)
 }
 
@@ -329,14 +329,14 @@ func (engine *Engine) SQL(query interface{}, args ...interface{}) *Session {
 // invoked. Call NoAutoTime if you dont' want to fill automatically.
 func (engine *Engine) NoAutoTime() *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.NoAutoTime()
 }
 
 // NoAutoCondition disable auto generate Where condition from bean or not
 func (engine *Engine) NoAutoCondition(no ...bool) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.NoAutoCondition(no...)
 }
 
@@ -570,56 +570,56 @@ func (engine *Engine) tbName(v reflect.Value) string {
 // Cascade use cascade or not
 func (engine *Engine) Cascade(trueOrFalse ...bool) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Cascade(trueOrFalse...)
 }
 
 // Where method provide a condition query
 func (engine *Engine) Where(query interface{}, args ...interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Where(query, args...)
 }
 
 // Id will be depracated, please use ID instead
 func (engine *Engine) Id(id interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Id(id)
 }
 
 // ID method provoide a condition as (id) = ?
 func (engine *Engine) ID(id interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.ID(id)
 }
 
 // Before apply before Processor, affected bean is passed to closure arg
 func (engine *Engine) Before(closures func(interface{})) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Before(closures)
 }
 
 // After apply after insert Processor, affected bean is passed to closure arg
 func (engine *Engine) After(closures func(interface{})) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.After(closures)
 }
 
 // Charset set charset when create table, only support mysql now
 func (engine *Engine) Charset(charset string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Charset(charset)
 }
 
 // StoreEngine set store engine when create table, only support mysql now
 func (engine *Engine) StoreEngine(storeEngine string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.StoreEngine(storeEngine)
 }
 
@@ -628,35 +628,35 @@ func (engine *Engine) StoreEngine(storeEngine string) *Session {
 // but distinct will not provide id
 func (engine *Engine) Distinct(columns ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Distinct(columns...)
 }
 
 // Select customerize your select columns or contents
 func (engine *Engine) Select(str string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Select(str)
 }
 
 // Cols only use the parameters as select or update columns
 func (engine *Engine) Cols(columns ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Cols(columns...)
 }
 
 // AllCols indicates that all columns should be use
 func (engine *Engine) AllCols() *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.AllCols()
 }
 
 // MustCols specify some columns must use even if they are empty
 func (engine *Engine) MustCols(columns ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.MustCols(columns...)
 }
 
@@ -667,77 +667,77 @@ func (engine *Engine) MustCols(columns ...string) *Session {
 // it will use parameters's columns
 func (engine *Engine) UseBool(columns ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.UseBool(columns...)
 }
 
 // Omit only not use the parameters as select or update columns
 func (engine *Engine) Omit(columns ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Omit(columns...)
 }
 
 // Nullable set null when column is zero-value and nullable for update
 func (engine *Engine) Nullable(columns ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Nullable(columns...)
 }
 
 // In will generate "column IN (?, ?)"
 func (engine *Engine) In(column string, args ...interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.In(column, args...)
 }
 
 // Incr provides a update string like "column = column + ?"
 func (engine *Engine) Incr(column string, arg ...interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Incr(column, arg...)
 }
 
 // Decr provides a update string like "column = column - ?"
 func (engine *Engine) Decr(column string, arg ...interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Decr(column, arg...)
 }
 
 // SetExpr provides a update string like "column = {expression}"
 func (engine *Engine) SetExpr(column string, expression string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.SetExpr(column, expression)
 }
 
 // Table temporarily change the Get, Find, Update's table
 func (engine *Engine) Table(tableNameOrBean interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Table(tableNameOrBean)
 }
 
 // Alias set the table alias
 func (engine *Engine) Alias(alias string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Alias(alias)
 }
 
 // Limit will generate "LIMIT start, limit"
 func (engine *Engine) Limit(limit int, start ...int) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Limit(limit, start...)
 }
 
 // Desc will generate "ORDER BY column1 DESC, column2 DESC"
 func (engine *Engine) Desc(colNames ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Desc(colNames...)
 }
 
@@ -749,35 +749,35 @@ func (engine *Engine) Desc(colNames ...string) *Session {
 //
 func (engine *Engine) Asc(colNames ...string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Asc(colNames...)
 }
 
 // OrderBy will generate "ORDER BY order"
 func (engine *Engine) OrderBy(order string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.OrderBy(order)
 }
 
 // Join the join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
 func (engine *Engine) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Join(joinOperator, tablename, condition, args...)
 }
 
 // GroupBy generate group by statement
 func (engine *Engine) GroupBy(keys string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.GroupBy(keys)
 }
 
 // Having generate having statement
 func (engine *Engine) Having(conditions string) *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Having(conditions)
 }
 
@@ -1251,7 +1251,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 				if !isExist {
 					session := engine.NewSession()
 					defer session.Close()
-					if err := session.Statement.setRefValue(v); err != nil {
+					if err := session.statement.setRefValue(v); err != nil {
 						return err
 					}
 					err = session.addColumn(col.Name)
@@ -1264,7 +1264,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 			for name, index := range table.Indexes {
 				session := engine.NewSession()
 				defer session.Close()
-				if err := session.Statement.setRefValue(v); err != nil {
+				if err := session.statement.setRefValue(v); err != nil {
 					return err
 				}
 				if index.Type == core.UniqueType {
@@ -1275,7 +1275,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 					if !isExist {
 						session := engine.NewSession()
 						defer session.Close()
-						if err := session.Statement.setRefValue(v); err != nil {
+						if err := session.statement.setRefValue(v); err != nil {
 							return err
 						}
 
@@ -1292,7 +1292,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 					if !isExist {
 						session := engine.NewSession()
 						defer session.Close()
-						if err := session.Statement.setRefValue(v); err != nil {
+						if err := session.statement.setRefValue(v); err != nil {
 							return err
 						}
 
@@ -1587,7 +1587,7 @@ func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}
 // Unscoped always disable struct tag "deleted"
 func (engine *Engine) Unscoped() *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Unscoped()
 }
 
diff --git a/helpers.go b/helpers.go
index 8c0f7574..5a0fe7c8 100644
--- a/helpers.go
+++ b/helpers.go
@@ -358,7 +358,7 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
 
 	for _, col := range table.Columns() {
 		if useCol && !col.IsVersion && !col.IsCreated && !col.IsUpdated {
-			if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+			if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
 				continue
 			}
 		}
@@ -397,32 +397,32 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
 			continue
 		}
 
-		if session.Statement.ColumnStr != "" {
-			if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+		if session.statement.ColumnStr != "" {
+			if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
 				continue
-			} else if _, ok := session.Statement.incrColumns[col.Name]; ok {
+			} else if _, ok := session.statement.incrColumns[col.Name]; ok {
 				continue
-			} else if _, ok := session.Statement.decrColumns[col.Name]; ok {
+			} else if _, ok := session.statement.decrColumns[col.Name]; ok {
 				continue
 			}
 		}
-		if session.Statement.OmitStr != "" {
-			if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+		if session.statement.OmitStr != "" {
+			if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
 				continue
 			}
 		}
 
 		// !evalphobia! set fieldValue as nil when column is nullable and zero-value
-		if _, ok := getFlagForColumn(session.Statement.nullableMap, col); ok {
+		if _, ok := getFlagForColumn(session.statement.nullableMap, col); ok {
 			if col.Nullable && isZero(fieldValue.Interface()) {
 				var nilValue *int
 				fieldValue = reflect.ValueOf(nilValue)
 			}
 		}
 
-		if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ {
+		if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ {
 			// if time is non-empty, then set to auto time
-			val, t := session.Engine.NowTime2(col.SQLType.Name)
+			val, t := session.engine.NowTime2(col.SQLType.Name)
 			args = append(args, val)
 
 			var colName = col.Name
@@ -430,7 +430,7 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
 				col := table.GetColumn(colName)
 				setColumnTime(bean, col, t)
 			})
-		} else if col.IsVersion && session.Statement.checkVersion {
+		} else if col.IsVersion && session.statement.checkVersion {
 			args = append(args, 1)
 		} else {
 			arg, err := session.value2Interface(col, fieldValue)
@@ -441,7 +441,7 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
 		}
 
 		if includeQuote {
-			colNames = append(colNames, session.Engine.Quote(col.Name)+" = ?")
+			colNames = append(colNames, session.engine.Quote(col.Name)+" = ?")
 		} else {
 			colNames = append(colNames, col.Name)
 		}
diff --git a/rows.go b/rows.go
index bb9738cb..444e3d43 100644
--- a/rows.go
+++ b/rows.go
@@ -35,26 +35,26 @@ func newRows(session *Session, bean interface{}) (*Rows, error) {
 	var args []interface{}
 	var err error
 
-	if err = rows.session.Statement.setRefValue(rValue(bean)); err != nil {
+	if err = rows.session.statement.setRefValue(rValue(bean)); err != nil {
 		return nil, err
 	}
 
-	if len(session.Statement.TableName()) <= 0 {
+	if len(session.statement.TableName()) <= 0 {
 		return nil, ErrTableNotFound
 	}
 
-	if rows.session.Statement.RawSQL == "" {
-		sqlStr, args, err = rows.session.Statement.genGetSQL(bean)
+	if rows.session.statement.RawSQL == "" {
+		sqlStr, args, err = rows.session.statement.genGetSQL(bean)
 		if err != nil {
 			return nil, err
 		}
 	} else {
-		sqlStr = rows.session.Statement.RawSQL
-		args = rows.session.Statement.RawParams
+		sqlStr = rows.session.statement.RawSQL
+		args = rows.session.statement.RawParams
 	}
 
-	for _, filter := range rows.session.Engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, rows.session.Statement.RefTable)
+	for _, filter := range rows.session.engine.dialect.Filters() {
+		sqlStr = filter.Do(sqlStr, session.engine.dialect, rows.session.statement.RefTable)
 	}
 
 	rows.session.saveLastSQL(sqlStr, args...)
@@ -119,7 +119,7 @@ func (rows *Rows) Scan(bean interface{}) error {
 	}
 
 	dataStruct := rValue(bean)
-	if err := rows.session.Statement.setRefValue(dataStruct); err != nil {
+	if err := rows.session.statement.setRefValue(dataStruct); err != nil {
 		return err
 	}
 
@@ -128,13 +128,13 @@ func (rows *Rows) Scan(bean interface{}) error {
 		return err
 	}
 
-	_, err = rows.session.slice2Bean(scanResults, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.Statement.RefTable)
+	_, err = rows.session.slice2Bean(scanResults, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.statement.RefTable)
 	return err
 }
 
 // Close session if session.IsAutoClose is true, and claimed any opened resources
 func (rows *Rows) Close() error {
-	if rows.session.IsAutoClose {
+	if rows.session.isAutoClose {
 		defer rows.session.Close()
 	}
 
diff --git a/session.go b/session.go
index 0bef19a0..9d041402 100644
--- a/session.go
+++ b/session.go
@@ -21,16 +21,16 @@ import (
 // kind of database operations.
 type Session struct {
 	db                     *core.DB
-	Engine                 *Engine
-	Tx                     *core.Tx
-	Statement              Statement
-	IsAutoCommit           bool
-	IsCommitedOrRollbacked bool
-	IsAutoClose            bool
+	engine                 *Engine
+	tx                     *core.Tx
+	statement              Statement
+	isAutoCommit           bool
+	isCommitedOrRollbacked bool
+	isAutoClose            bool
 
 	// Automatically reset the statement after operations that execute a SQL
 	// query such as Count(), Find(), Get(), ...
-	AutoResetStatement bool
+	autoResetStatement bool
 
 	// !nashtsai! storing these beans due to yet committed tx
 	afterInsertBeans map[interface{}]*[]func(interface{})
@@ -60,12 +60,12 @@ func (session *Session) Clone() *Session {
 
 // Init reset the session as the init status.
 func (session *Session) Init() {
-	session.Statement.Init()
-	session.Statement.Engine = session.Engine
-	session.IsAutoCommit = true
-	session.IsCommitedOrRollbacked = false
-	session.IsAutoClose = false
-	session.AutoResetStatement = true
+	session.statement.Init()
+	session.statement.Engine = session.engine
+	session.isAutoCommit = true
+	session.isCommitedOrRollbacked = false
+	session.isAutoClose = false
+	session.autoResetStatement = true
 	session.prepareStmt = false
 
 	// !nashtsai! is lazy init better?
@@ -88,10 +88,10 @@ func (session *Session) Close() {
 	if session.db != nil {
 		// When Close be called, if session is a transaction and do not call
 		// Commit or Rollback, then call Rollback.
-		if session.Tx != nil && !session.IsCommitedOrRollbacked {
+		if session.tx != nil && !session.isCommitedOrRollbacked {
 			session.Rollback()
 		}
-		session.Tx = nil
+		session.tx = nil
 		session.stmtCache = nil
 		session.db = nil
 	}
@@ -103,8 +103,8 @@ func (session *Session) IsClosed() bool {
 }
 
 func (session *Session) resetStatement() {
-	if session.AutoResetStatement {
-		session.Statement.Init()
+	if session.autoResetStatement {
+		session.statement.Init()
 	}
 }
 
@@ -132,75 +132,75 @@ func (session *Session) After(closures func(interface{})) *Session {
 
 // Table can input a string or pointer to struct for special a table to operate.
 func (session *Session) Table(tableNameOrBean interface{}) *Session {
-	session.Statement.Table(tableNameOrBean)
+	session.statement.Table(tableNameOrBean)
 	return session
 }
 
 // Alias set the table alias
 func (session *Session) Alias(alias string) *Session {
-	session.Statement.Alias(alias)
+	session.statement.Alias(alias)
 	return session
 }
 
 // NoCascade indicate that no cascade load child object
 func (session *Session) NoCascade() *Session {
-	session.Statement.UseCascade = false
+	session.statement.UseCascade = false
 	return session
 }
 
 // ForUpdate Set Read/Write locking for UPDATE
 func (session *Session) ForUpdate() *Session {
-	session.Statement.IsForUpdate = true
+	session.statement.IsForUpdate = true
 	return session
 }
 
 // NoAutoCondition disable generate SQL condition from beans
 func (session *Session) NoAutoCondition(no ...bool) *Session {
-	session.Statement.NoAutoCondition(no...)
+	session.statement.NoAutoCondition(no...)
 	return session
 }
 
 // Limit provide limit and offset query condition
 func (session *Session) Limit(limit int, start ...int) *Session {
-	session.Statement.Limit(limit, start...)
+	session.statement.Limit(limit, start...)
 	return session
 }
 
 // OrderBy provide order by query condition, the input parameter is the content
 // after order by on a sql statement.
 func (session *Session) OrderBy(order string) *Session {
-	session.Statement.OrderBy(order)
+	session.statement.OrderBy(order)
 	return session
 }
 
 // Desc provide desc order by query condition, the input parameters are columns.
 func (session *Session) Desc(colNames ...string) *Session {
-	session.Statement.Desc(colNames...)
+	session.statement.Desc(colNames...)
 	return session
 }
 
 // Asc provide asc order by query condition, the input parameters are columns.
 func (session *Session) Asc(colNames ...string) *Session {
-	session.Statement.Asc(colNames...)
+	session.statement.Asc(colNames...)
 	return session
 }
 
 // StoreEngine is only avialble mysql dialect currently
 func (session *Session) StoreEngine(storeEngine string) *Session {
-	session.Statement.StoreEngine = storeEngine
+	session.statement.StoreEngine = storeEngine
 	return session
 }
 
 // Charset is only avialble mysql dialect currently
 func (session *Session) Charset(charset string) *Session {
-	session.Statement.Charset = charset
+	session.statement.Charset = charset
 	return session
 }
 
 // Cascade indicates if loading sub Struct
 func (session *Session) Cascade(trueOrFalse ...bool) *Session {
 	if len(trueOrFalse) >= 1 {
-		session.Statement.UseCascade = trueOrFalse[0]
+		session.statement.UseCascade = trueOrFalse[0]
 	}
 	return session
 }
@@ -208,32 +208,32 @@ func (session *Session) Cascade(trueOrFalse ...bool) *Session {
 // NoCache ask this session do not retrieve data from cache system and
 // get data from database directly.
 func (session *Session) NoCache() *Session {
-	session.Statement.UseCache = false
+	session.statement.UseCache = false
 	return session
 }
 
 // Join join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
 func (session *Session) Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *Session {
-	session.Statement.Join(joinOperator, tablename, condition, args...)
+	session.statement.Join(joinOperator, tablename, condition, args...)
 	return session
 }
 
 // GroupBy Generate Group By statement
 func (session *Session) GroupBy(keys string) *Session {
-	session.Statement.GroupBy(keys)
+	session.statement.GroupBy(keys)
 	return session
 }
 
 // Having Generate Having statement
 func (session *Session) Having(conditions string) *Session {
-	session.Statement.Having(conditions)
+	session.statement.Having(conditions)
 	return session
 }
 
 // DB db return the wrapper of sql.DB
 func (session *Session) DB() *core.DB {
 	if session.db == nil {
-		session.db = session.Engine.db
+		session.db = session.engine.db
 		session.stmtCache = make(map[uint32]*core.Stmt, 0)
 	}
 	return session.db
@@ -246,13 +246,13 @@ func cleanupProcessorsClosures(slices *[]func(interface{})) {
 }
 
 func (session *Session) canCache() bool {
-	if session.Statement.RefTable == nil ||
-		session.Statement.JoinStr != "" ||
-		session.Statement.RawSQL != "" ||
-		!session.Statement.UseCache ||
-		session.Statement.IsForUpdate ||
-		session.Tx != nil ||
-		len(session.Statement.selectStr) > 0 {
+	if session.statement.RefTable == nil ||
+		session.statement.JoinStr != "" ||
+		session.statement.RawSQL != "" ||
+		!session.statement.UseCache ||
+		session.statement.IsForUpdate ||
+		session.tx != nil ||
+		len(session.statement.selectStr) > 0 {
 		return false
 	}
 	return true
@@ -276,18 +276,18 @@ func (session *Session) doPrepare(sqlStr string) (stmt *core.Stmt, err error) {
 func (session *Session) getField(dataStruct *reflect.Value, key string, table *core.Table, idx int) *reflect.Value {
 	var col *core.Column
 	if col = table.GetColumnIdx(key, idx); col == nil {
-		//session.Engine.logger.Warnf("table %v has no column %v. %v", table.Name, key, table.ColumnsSeq())
+		//session.engine.logger.Warnf("table %v has no column %v. %v", table.Name, key, table.ColumnsSeq())
 		return nil
 	}
 
 	fieldValue, err := col.ValueOfV(dataStruct)
 	if err != nil {
-		session.Engine.logger.Error(err)
+		session.engine.logger.Error(err)
 		return nil
 	}
 
 	if !fieldValue.IsValid() || !fieldValue.CanSet() {
-		session.Engine.logger.Warnf("table %v's column %v is not valid or cannot set", table.Name, key)
+		session.engine.logger.Warnf("table %v's column %v is not valid or cannot set", table.Name, key)
 		return nil
 	}
 	return fieldValue
@@ -532,7 +532,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
 				}
 			case reflect.Struct:
 				if fieldType.ConvertibleTo(core.TimeType) {
-					dbTZ := session.Engine.DatabaseTZ
+					dbTZ := session.engine.DatabaseTZ
 					if col.TimeZone != nil {
 						dbTZ = col.TimeZone
 					}
@@ -545,25 +545,25 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
 						z, _ := t.Zone()
 						// set new location if database don't save timezone or give an incorrect timezone
 						if len(z) == 0 || t.Year() == 0 || t.Location().String() != dbTZ.String() { // !nashtsai! HACK tmp work around for lib/pq doesn't properly time with location
-							session.Engine.logger.Debugf("empty zone key[%v] : %v | zone: %v | location: %+v\n", key, t, z, *t.Location())
+							session.engine.logger.Debugf("empty zone key[%v] : %v | zone: %v | location: %+v\n", key, t, z, *t.Location())
 							t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(),
 								t.Minute(), t.Second(), t.Nanosecond(), dbTZ)
 						}
 
-						t = t.In(session.Engine.TZLocation)
+						t = t.In(session.engine.TZLocation)
 						fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
 					} else if rawValueType == core.IntType || rawValueType == core.Int64Type ||
 						rawValueType == core.Int32Type {
 						hasAssigned = true
 
-						t := time.Unix(vv.Int(), 0).In(session.Engine.TZLocation)
+						t := time.Unix(vv.Int(), 0).In(session.engine.TZLocation)
 						fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
 					} else {
 						if d, ok := vv.Interface().([]uint8); ok {
 							hasAssigned = true
 							t, err := session.byte2Time(col, d)
 							if err != nil {
-								session.Engine.logger.Error("byte2Time error:", err.Error())
+								session.engine.logger.Error("byte2Time error:", err.Error())
 								hasAssigned = false
 							} else {
 								fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
@@ -572,7 +572,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
 							hasAssigned = true
 							t, err := session.str2Time(col, d)
 							if err != nil {
-								session.Engine.logger.Error("byte2Time error:", err.Error())
+								session.engine.logger.Error("byte2Time error:", err.Error())
 								hasAssigned = false
 							} else {
 								fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
@@ -585,7 +585,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
 					// !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString
 					hasAssigned = true
 					if err := nulVal.Scan(vv.Interface()); err != nil {
-						session.Engine.logger.Error("sql.Sanner error:", err.Error())
+						session.engine.logger.Error("sql.Sanner error:", err.Error())
 						hasAssigned = false
 					}
 				} else if col.SQLType.IsJson() {
@@ -610,8 +610,8 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
 							fieldValue.Set(x.Elem())
 						}
 					}
-				} else if session.Statement.UseCascade {
-					table, err := session.Engine.autoMapType(*fieldValue)
+				} else if session.statement.UseCascade {
+					table, err := session.engine.autoMapType(*fieldValue)
 					if err != nil {
 						return nil, err
 					}
@@ -631,7 +631,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
 						// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
 						// property to be fetched lazily
 						structInter := reflect.New(fieldValue.Type())
-						newsession := session.Engine.NewSession()
+						newsession := session.engine.NewSession()
 						defer newsession.Close()
 						has, err := newsession.ID(pk).NoCascade().Get(structInter.Interface())
 						if err != nil {
@@ -778,8 +778,8 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, f
 }
 
 func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) {
-	for _, filter := range session.Engine.dialect.Filters() {
-		*sqlStr = filter.Do(*sqlStr, session.Engine.dialect, session.Statement.RefTable)
+	for _, filter := range session.engine.dialect.Filters() {
+		*sqlStr = filter.Do(*sqlStr, session.engine.dialect, session.statement.RefTable)
 	}
 
 	session.saveLastSQL(*sqlStr, paramStr...)
@@ -789,7 +789,7 @@ func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{})
 func (session *Session) saveLastSQL(sql string, args ...interface{}) {
 	session.lastSQL = sql
 	session.lastSQLArgs = args
-	session.Engine.logSQL(sql, args...)
+	session.engine.logSQL(sql, args...)
 }
 
 // LastSQL returns last query information
@@ -799,8 +799,8 @@ func (session *Session) LastSQL() (string, []interface{}) {
 
 // tbName get some table's table name
 func (session *Session) tbNameNoSchema(table *core.Table) string {
-	if len(session.Statement.AltTableName) > 0 {
-		return session.Statement.AltTableName
+	if len(session.statement.AltTableName) > 0 {
+		return session.statement.AltTableName
 	}
 
 	return table.Name
@@ -808,6 +808,6 @@ func (session *Session) tbNameNoSchema(table *core.Table) string {
 
 // Unscoped always disable struct tag "deleted"
 func (session *Session) Unscoped() *Session {
-	session.Statement.Unscoped()
+	session.statement.Unscoped()
 	return session
 }
diff --git a/session_cols.go b/session_cols.go
index 91185def..9972cb0a 100644
--- a/session_cols.go
+++ b/session_cols.go
@@ -6,43 +6,43 @@ package xorm
 
 // Incr provides a query string like "count = count + 1"
 func (session *Session) Incr(column string, arg ...interface{}) *Session {
-	session.Statement.Incr(column, arg...)
+	session.statement.Incr(column, arg...)
 	return session
 }
 
 // Decr provides a query string like "count = count - 1"
 func (session *Session) Decr(column string, arg ...interface{}) *Session {
-	session.Statement.Decr(column, arg...)
+	session.statement.Decr(column, arg...)
 	return session
 }
 
 // SetExpr provides a query string like "column = {expression}"
 func (session *Session) SetExpr(column string, expression string) *Session {
-	session.Statement.SetExpr(column, expression)
+	session.statement.SetExpr(column, expression)
 	return session
 }
 
 // Select provides some columns to special
 func (session *Session) Select(str string) *Session {
-	session.Statement.Select(str)
+	session.statement.Select(str)
 	return session
 }
 
 // Cols provides some columns to special
 func (session *Session) Cols(columns ...string) *Session {
-	session.Statement.Cols(columns...)
+	session.statement.Cols(columns...)
 	return session
 }
 
 // AllCols ask all columns
 func (session *Session) AllCols() *Session {
-	session.Statement.AllCols()
+	session.statement.AllCols()
 	return session
 }
 
 // MustCols specify some columns must use even if they are empty
 func (session *Session) MustCols(columns ...string) *Session {
-	session.Statement.MustCols(columns...)
+	session.statement.MustCols(columns...)
 	return session
 }
 
@@ -52,7 +52,7 @@ func (session *Session) MustCols(columns ...string) *Session {
 // If no parameters, it will use all the bool field of struct, or
 // it will use parameters's columns
 func (session *Session) UseBool(columns ...string) *Session {
-	session.Statement.UseBool(columns...)
+	session.statement.UseBool(columns...)
 	return session
 }
 
@@ -60,25 +60,25 @@ func (session *Session) UseBool(columns ...string) *Session {
 // distinct will not be cached because cache system need id,
 // but distinct will not provide id
 func (session *Session) Distinct(columns ...string) *Session {
-	session.Statement.Distinct(columns...)
+	session.statement.Distinct(columns...)
 	return session
 }
 
 // Omit Only not use the parameters as select or update columns
 func (session *Session) Omit(columns ...string) *Session {
-	session.Statement.Omit(columns...)
+	session.statement.Omit(columns...)
 	return session
 }
 
 // Nullable Set null when column is zero-value and nullable for update
 func (session *Session) Nullable(columns ...string) *Session {
-	session.Statement.Nullable(columns...)
+	session.statement.Nullable(columns...)
 	return session
 }
 
 // NoAutoTime means do not automatically give created field and updated field
 // the current time on the current session temporarily
 func (session *Session) NoAutoTime() *Session {
-	session.Statement.UseAutoTime = false
+	session.statement.UseAutoTime = false
 	return session
 }
diff --git a/session_cond.go b/session_cond.go
index 69775187..e1d528f2 100644
--- a/session_cond.go
+++ b/session_cond.go
@@ -17,25 +17,25 @@ func (session *Session) Sql(query string, args ...interface{}) *Session {
 // SQL provides raw sql input parameter. When you have a complex SQL statement
 // and cannot use Where, Id, In and etc. Methods to describe, you can use SQL.
 func (session *Session) SQL(query interface{}, args ...interface{}) *Session {
-	session.Statement.SQL(query, args...)
+	session.statement.SQL(query, args...)
 	return session
 }
 
 // Where provides custom query condition.
 func (session *Session) Where(query interface{}, args ...interface{}) *Session {
-	session.Statement.Where(query, args...)
+	session.statement.Where(query, args...)
 	return session
 }
 
 // And provides custom query condition.
 func (session *Session) And(query interface{}, args ...interface{}) *Session {
-	session.Statement.And(query, args...)
+	session.statement.And(query, args...)
 	return session
 }
 
 // Or provides custom query condition.
 func (session *Session) Or(query interface{}, args ...interface{}) *Session {
-	session.Statement.Or(query, args...)
+	session.statement.Or(query, args...)
 	return session
 }
 
@@ -48,23 +48,23 @@ func (session *Session) Id(id interface{}) *Session {
 
 // ID provides converting id as a query condition
 func (session *Session) ID(id interface{}) *Session {
-	session.Statement.ID(id)
+	session.statement.ID(id)
 	return session
 }
 
 // In provides a query string like "id in (1, 2, 3)"
 func (session *Session) In(column string, args ...interface{}) *Session {
-	session.Statement.In(column, args...)
+	session.statement.In(column, args...)
 	return session
 }
 
 // NotIn provides a query string like "id in (1, 2, 3)"
 func (session *Session) NotIn(column string, args ...interface{}) *Session {
-	session.Statement.NotIn(column, args...)
+	session.statement.NotIn(column, args...)
 	return session
 }
 
 // Conds returns session query conditions except auto bean conditions
 func (session *Session) Conds() builder.Cond {
-	return session.Statement.cond
+	return session.statement.cond
 }
diff --git a/session_convert.go b/session_convert.go
index 931d1dc0..85002d27 100644
--- a/session_convert.go
+++ b/session_convert.go
@@ -23,7 +23,7 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
 	var x time.Time
 	var err error
 
-	var parseLoc = session.Engine.DatabaseTZ
+	var parseLoc = session.engine.DatabaseTZ
 	if col.TimeZone != nil {
 		parseLoc = col.TimeZone
 	}
@@ -34,27 +34,27 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
 		sd, err := strconv.ParseInt(sdata, 10, 64)
 		if err == nil {
 			x = time.Unix(sd, 0)
-			session.Engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+			session.engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 		} else {
-			session.Engine.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+			session.engine.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 		}
 	} else if len(sdata) > 19 && strings.Contains(sdata, "-") {
 		x, err = time.ParseInLocation(time.RFC3339Nano, sdata, parseLoc)
-		session.Engine.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+		session.engine.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 		if err != nil {
 			x, err = time.ParseInLocation("2006-01-02 15:04:05.999999999", sdata, parseLoc)
-			session.Engine.logger.Debugf("time(2) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+			session.engine.logger.Debugf("time(2) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 		}
 		if err != nil {
 			x, err = time.ParseInLocation("2006-01-02 15:04:05.9999999 Z07:00", sdata, parseLoc)
-			session.Engine.logger.Debugf("time(3) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+			session.engine.logger.Debugf("time(3) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 		}
 	} else if len(sdata) == 19 && strings.Contains(sdata, "-") {
 		x, err = time.ParseInLocation("2006-01-02 15:04:05", sdata, parseLoc)
-		session.Engine.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+		session.engine.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 	} else if len(sdata) == 10 && sdata[4] == '-' && sdata[7] == '-' {
 		x, err = time.ParseInLocation("2006-01-02", sdata, parseLoc)
-		session.Engine.logger.Debugf("time(5) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+		session.engine.logger.Debugf("time(5) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 	} else if col.SQLType.Name == core.Time {
 		if strings.Contains(sdata, " ") {
 			ssd := strings.Split(sdata, " ")
@@ -62,13 +62,13 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
 		}
 
 		sdata = strings.TrimSpace(sdata)
-		if session.Engine.dialect.DBType() == core.MYSQL && len(sdata) > 8 {
+		if session.engine.dialect.DBType() == core.MYSQL && len(sdata) > 8 {
 			sdata = sdata[len(sdata)-8:]
 		}
 
 		st := fmt.Sprintf("2006-01-02 %v", sdata)
 		x, err = time.ParseInLocation("2006-01-02 15:04:05", st, parseLoc)
-		session.Engine.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+		session.engine.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
 	} else {
 		outErr = fmt.Errorf("unsupported time format %v", sdata)
 		return
@@ -77,7 +77,7 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
 		outErr = fmt.Errorf("unsupported time format %v: %v", sdata, err)
 		return
 	}
-	outTime = x.In(session.Engine.TZLocation)
+	outTime = x.In(session.engine.TZLocation)
 	return
 }
 
@@ -105,7 +105,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 		if len(data) > 0 {
 			err := json.Unmarshal(data, x.Interface())
 			if err != nil {
-				session.Engine.logger.Error(err)
+				session.engine.logger.Error(err)
 				return err
 			}
 			fieldValue.Set(x.Elem())
@@ -119,7 +119,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			if len(data) > 0 {
 				err := json.Unmarshal(data, x.Interface())
 				if err != nil {
-					session.Engine.logger.Error(err)
+					session.engine.logger.Error(err)
 					return err
 				}
 				fieldValue.Set(x.Elem())
@@ -132,7 +132,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 				if len(data) > 0 {
 					err := json.Unmarshal(data, x.Interface())
 					if err != nil {
-						session.Engine.logger.Error(err)
+						session.engine.logger.Error(err)
 						return err
 					}
 					fieldValue.Set(x.Elem())
@@ -156,7 +156,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 		var err error
 		// for mysql, when use bit, it returned \x01
 		if col.SQLType.Name == core.Bit &&
-			session.Engine.dialect.DBType() == core.MYSQL { // !nashtsai! TODO dialect needs to provide conversion interface API
+			session.engine.dialect.DBType() == core.MYSQL { // !nashtsai! TODO dialect needs to provide conversion interface API
 			if len(data) == 1 {
 				x = int64(data[0])
 			} else {
@@ -204,8 +204,8 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 				}
 				v = x
 				fieldValue.Set(reflect.ValueOf(v).Convert(fieldType))
-			} else if session.Statement.UseCascade {
-				table, err := session.Engine.autoMapType(*fieldValue)
+			} else if session.statement.UseCascade {
+				table, err := session.engine.autoMapType(*fieldValue)
 				if err != nil {
 					return err
 				}
@@ -227,7 +227,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 					// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
 					// property to be fetched lazily
 					structInter := reflect.New(fieldValue.Type())
-					newsession := session.Engine.NewSession()
+					newsession := session.engine.NewSession()
 					defer newsession.Close()
 					has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface())
 					if err != nil {
@@ -264,7 +264,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			if len(data) > 0 {
 				err := json.Unmarshal(data, &x)
 				if err != nil {
-					session.Engine.logger.Error(err)
+					session.engine.logger.Error(err)
 					return err
 				}
 				fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
@@ -275,7 +275,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			if len(data) > 0 {
 				err := json.Unmarshal(data, &x)
 				if err != nil {
-					session.Engine.logger.Error(err)
+					session.engine.logger.Error(err)
 					return err
 				}
 				fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
@@ -347,7 +347,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			var err error
 			// for mysql, when use bit, it returned \x01
 			if col.SQLType.Name == core.Bit &&
-				strings.Contains(session.Engine.DriverName(), "mysql") {
+				strings.Contains(session.engine.DriverName(), "mysql") {
 				if len(data) == 1 {
 					x = int64(data[0])
 				} else {
@@ -372,7 +372,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			var err error
 			// for mysql, when use bit, it returned \x01
 			if col.SQLType.Name == core.Bit &&
-				strings.Contains(session.Engine.DriverName(), "mysql") {
+				strings.Contains(session.engine.DriverName(), "mysql") {
 				if len(data) == 1 {
 					x = int(data[0])
 				} else {
@@ -400,7 +400,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			var err error
 			// for mysql, when use bit, it returned \x01
 			if col.SQLType.Name == core.Bit &&
-				session.Engine.dialect.DBType() == core.MYSQL {
+				session.engine.dialect.DBType() == core.MYSQL {
 				if len(data) == 1 {
 					x = int32(data[0])
 				} else {
@@ -428,7 +428,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			var err error
 			// for mysql, when use bit, it returned \x01
 			if col.SQLType.Name == core.Bit &&
-				strings.Contains(session.Engine.DriverName(), "mysql") {
+				strings.Contains(session.engine.DriverName(), "mysql") {
 				if len(data) == 1 {
 					x = int8(data[0])
 				} else {
@@ -456,7 +456,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 			var err error
 			// for mysql, when use bit, it returned \x01
 			if col.SQLType.Name == core.Bit &&
-				strings.Contains(session.Engine.DriverName(), "mysql") {
+				strings.Contains(session.engine.DriverName(), "mysql") {
 				if len(data) == 1 {
 					x = int16(data[0])
 				} else {
@@ -488,9 +488,9 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 				v = x
 				fieldValue.Set(reflect.ValueOf(&x))
 			default:
-				if session.Statement.UseCascade {
+				if session.statement.UseCascade {
 					structInter := reflect.New(fieldType.Elem())
-					table, err := session.Engine.autoMapType(structInter.Elem())
+					table, err := session.engine.autoMapType(structInter.Elem())
 					if err != nil {
 						return err
 					}
@@ -510,7 +510,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 						// !nashtsai! TODO for hasOne relationship, it's preferred to use join query for eager fetch
 						// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
 						// property to be fetched lazily
-						newsession := session.Engine.NewSession()
+						newsession := session.engine.NewSession()
 						defer newsession.Close()
 						has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface())
 						if err != nil {
@@ -569,7 +569,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 		if fieldValue.IsNil() {
 			return nil, nil
 		} else if !fieldValue.IsValid() {
-			session.Engine.logger.Warn("the field[", col.FieldName, "] is invalid")
+			session.engine.logger.Warn("the field[", col.FieldName, "] is invalid")
 			return nil, nil
 		} else {
 			// !nashtsai! deference pointer type to instance type
@@ -587,7 +587,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 	case reflect.Struct:
 		if fieldType.ConvertibleTo(core.TimeType) {
 			t := fieldValue.Convert(core.TimeType).Interface().(time.Time)
-			tf := session.Engine.formatColTime(col, t)
+			tf := session.engine.formatColTime(col, t)
 			return tf, nil
 		}
 
@@ -597,7 +597,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 				return v.Value()
 			}
 
-			fieldTable, err := session.Engine.autoMapType(fieldValue)
+			fieldTable, err := session.engine.autoMapType(fieldValue)
 			if err != nil {
 				return nil, err
 			}
@@ -611,14 +611,14 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 		if col.SQLType.IsText() {
 			bytes, err := json.Marshal(fieldValue.Interface())
 			if err != nil {
-				session.Engine.logger.Error(err)
+				session.engine.logger.Error(err)
 				return 0, err
 			}
 			return string(bytes), nil
 		} else if col.SQLType.IsBlob() {
 			bytes, err := json.Marshal(fieldValue.Interface())
 			if err != nil {
-				session.Engine.logger.Error(err)
+				session.engine.logger.Error(err)
 				return 0, err
 			}
 			return bytes, nil
@@ -627,7 +627,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 	case reflect.Complex64, reflect.Complex128:
 		bytes, err := json.Marshal(fieldValue.Interface())
 		if err != nil {
-			session.Engine.logger.Error(err)
+			session.engine.logger.Error(err)
 			return 0, err
 		}
 		return string(bytes), nil
@@ -639,7 +639,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 		if col.SQLType.IsText() {
 			bytes, err := json.Marshal(fieldValue.Interface())
 			if err != nil {
-				session.Engine.logger.Error(err)
+				session.engine.logger.Error(err)
 				return 0, err
 			}
 			return string(bytes), nil
@@ -652,7 +652,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 			} else {
 				bytes, err = json.Marshal(fieldValue.Interface())
 				if err != nil {
-					session.Engine.logger.Error(err)
+					session.engine.logger.Error(err)
 					return 0, err
 				}
 			}
diff --git a/session_delete.go b/session_delete.go
index 044e9d61..9fd7b8af 100644
--- a/session_delete.go
+++ b/session_delete.go
@@ -13,22 +13,22 @@ import (
 )
 
 func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
-	if session.Statement.RefTable == nil ||
-		session.Tx != nil {
+	if session.statement.RefTable == nil ||
+		session.tx != nil {
 		return ErrCacheFailed
 	}
 
-	for _, filter := range session.Engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+	for _, filter := range session.engine.dialect.Filters() {
+		sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
 	}
 
-	newsql := session.Statement.convertIDSQL(sqlStr)
+	newsql := session.statement.convertIDSQL(sqlStr)
 	if newsql == "" {
 		return ErrCacheFailed
 	}
 
-	cacher := session.Engine.getCacher2(session.Statement.RefTable)
-	tableName := session.Statement.TableName()
+	cacher := session.engine.getCacher2(session.statement.RefTable)
+	tableName := session.statement.TableName()
 	ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
 	if err != nil {
 		resultsSlice, err := session.query(newsql, args...)
@@ -40,7 +40,7 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
 			for _, data := range resultsSlice {
 				var id int64
 				var pk core.PK = make([]interface{}, 0)
-				for _, col := range session.Statement.RefTable.PKColumns() {
+				for _, col := range session.statement.RefTable.PKColumns() {
 					if v, ok := data[col.Name]; !ok {
 						return errors.New("no id")
 					} else if col.SQLType.IsText() {
@@ -59,19 +59,19 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
 			}
 		}
 	} /*else {
-	    session.Engine.LogDebug("delete cache sql %v", newsql)
+	    session.engine.LogDebug("delete cache sql %v", newsql)
 	    cacher.DelIds(tableName, genSqlKey(newsql, args))
 	}*/
 
 	for _, id := range ids {
-		session.Engine.logger.Debug("[cacheDelete] delete cache obj", tableName, id)
+		session.engine.logger.Debug("[cacheDelete] delete cache obj", tableName, id)
 		sid, err := id.ToString()
 		if err != nil {
 			return err
 		}
 		cacher.DelBean(tableName, sid)
 	}
-	session.Engine.logger.Debug("[cacheDelete] clear cache sql", tableName)
+	session.engine.logger.Debug("[cacheDelete] clear cache sql", tableName)
 	cacher.ClearIds(tableName)
 	return nil
 }
@@ -79,14 +79,14 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
 // Delete records, bean's non-empty fields are conditions
 func (session *Session) Delete(bean interface{}) (int64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
-	if err := session.Statement.setRefValue(rValue(bean)); err != nil {
+	if err := session.statement.setRefValue(rValue(bean)); err != nil {
 		return 0, err
 	}
-	var table = session.Statement.RefTable
+	var table = session.statement.RefTable
 
 	// handle before delete processors
 	for _, closure := range session.beforeClosures {
@@ -98,15 +98,15 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 		processor.BeforeDelete()
 	}
 
-	condSQL, condArgs, err := session.Statement.genConds(bean)
+	condSQL, condArgs, err := session.statement.genConds(bean)
 	if err != nil {
 		return 0, err
 	}
-	if len(condSQL) == 0 && session.Statement.LimitN == 0 {
+	if len(condSQL) == 0 && session.statement.LimitN == 0 {
 		return 0, ErrNeedDeletedCond
 	}
 
-	var tableName = session.Engine.Quote(session.Statement.TableName())
+	var tableName = session.engine.Quote(session.statement.TableName())
 	var deleteSQL string
 	if len(condSQL) > 0 {
 		deleteSQL = fmt.Sprintf("DELETE FROM %v WHERE %v", tableName, condSQL)
@@ -115,15 +115,15 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 	}
 
 	var orderSQL string
-	if len(session.Statement.OrderStr) > 0 {
-		orderSQL += fmt.Sprintf(" ORDER BY %s", session.Statement.OrderStr)
+	if len(session.statement.OrderStr) > 0 {
+		orderSQL += fmt.Sprintf(" ORDER BY %s", session.statement.OrderStr)
 	}
-	if session.Statement.LimitN > 0 {
-		orderSQL += fmt.Sprintf(" LIMIT %d", session.Statement.LimitN)
+	if session.statement.LimitN > 0 {
+		orderSQL += fmt.Sprintf(" LIMIT %d", session.statement.LimitN)
 	}
 
 	if len(orderSQL) > 0 {
-		switch session.Engine.dialect.DBType() {
+		switch session.engine.dialect.DBType() {
 		case core.POSTGRES:
 			inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
 			if len(condSQL) > 0 {
@@ -148,7 +148,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 
 	var realSQL string
 	argsForCache := make([]interface{}, 0, len(condArgs)*2)
-	if session.Statement.unscoped || table.DeletedColumn() == nil { // tag "deleted" is disabled
+	if session.statement.unscoped || table.DeletedColumn() == nil { // tag "deleted" is disabled
 		realSQL = deleteSQL
 		copy(argsForCache, condArgs)
 		argsForCache = append(condArgs, argsForCache...)
@@ -159,12 +159,12 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 
 		deletedColumn := table.DeletedColumn()
 		realSQL = fmt.Sprintf("UPDATE %v SET %v = ? WHERE %v",
-			session.Engine.Quote(session.Statement.TableName()),
-			session.Engine.Quote(deletedColumn.Name),
+			session.engine.Quote(session.statement.TableName()),
+			session.engine.Quote(deletedColumn.Name),
 			condSQL)
 
 		if len(orderSQL) > 0 {
-			switch session.Engine.dialect.DBType() {
+			switch session.engine.dialect.DBType() {
 			case core.POSTGRES:
 				inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
 				if len(condSQL) > 0 {
@@ -187,12 +187,12 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 			}
 		}
 
-		// !oinume! Insert NowTime to the head of session.Statement.Params
+		// !oinume! Insert NowTime to the head of session.statement.Params
 		condArgs = append(condArgs, "")
 		paramsLen := len(condArgs)
 		copy(condArgs[1:paramsLen], condArgs[0:paramsLen-1])
 
-		val, t := session.Engine.NowTime2(deletedColumn.SQLType.Name)
+		val, t := session.engine.NowTime2(deletedColumn.SQLType.Name)
 		condArgs[0] = val
 
 		var colName = deletedColumn.Name
@@ -202,7 +202,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 		})
 	}
 
-	if cacher := session.Engine.getCacher2(session.Statement.RefTable); cacher != nil && session.Statement.UseCache {
+	if cacher := session.engine.getCacher2(session.statement.RefTable); cacher != nil && session.statement.UseCache {
 		session.cacheDelete(deleteSQL, argsForCache...)
 	}
 
@@ -212,7 +212,7 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 	}
 
 	// handle after delete processors
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		for _, closure := range session.afterClosures {
 			closure(bean)
 		}
diff --git a/session_exist.go b/session_exist.go
index 6f895c1e..91d1cd60 100644
--- a/session_exist.go
+++ b/session_exist.go
@@ -16,7 +16,7 @@ import (
 // Exist returns true if the record exist otherwise return false
 func (session *Session) Exist(bean ...interface{}) (bool, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -24,15 +24,15 @@ func (session *Session) Exist(bean ...interface{}) (bool, error) {
 	var args []interface{}
 	var err error
 
-	if session.Statement.RawSQL == "" {
+	if session.statement.RawSQL == "" {
 		if len(bean) == 0 {
-			tableName := session.Statement.TableName()
+			tableName := session.statement.TableName()
 			if len(tableName) <= 0 {
 				return false, ErrTableNotFound
 			}
 
-			if session.Statement.cond.IsValid() {
-				condSQL, condArgs, err := builder.ToSQL(session.Statement.cond)
+			if session.statement.cond.IsValid() {
+				condSQL, condArgs, err := builder.ToSQL(session.statement.cond)
 				if err != nil {
 					return false, err
 				}
@@ -50,32 +50,32 @@ func (session *Session) Exist(bean ...interface{}) (bool, error) {
 			}
 
 			if beanValue.Elem().Kind() == reflect.Struct {
-				if err := session.Statement.setRefValue(beanValue.Elem()); err != nil {
+				if err := session.statement.setRefValue(beanValue.Elem()); err != nil {
 					return false, err
 				}
 			}
 
-			if len(session.Statement.TableName()) <= 0 {
+			if len(session.statement.TableName()) <= 0 {
 				return false, ErrTableNotFound
 			}
-			session.Statement.Limit(1)
-			sqlStr, args, err = session.Statement.genGetSQL(bean[0])
+			session.statement.Limit(1)
+			sqlStr, args, err = session.statement.genGetSQL(bean[0])
 			if err != nil {
 				return false, err
 			}
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	session.queryPreprocess(&sqlStr, args...)
 
 	var rawRows *core.Rows
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		_, rawRows, err = session.innerQuery(sqlStr, args...)
 	} else {
-		rawRows, err = session.Tx.Query(sqlStr, args...)
+		rawRows, err = session.tx.Query(sqlStr, args...)
 	}
 	if err != nil {
 		return false, err
diff --git a/session_find.go b/session_find.go
index 2518af42..42b3506e 100644
--- a/session_find.go
+++ b/session_find.go
@@ -24,7 +24,7 @@ const (
 // map[int64]*Struct
 func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{}) error {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -36,11 +36,11 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 	sliceElementType := sliceValue.Type().Elem()
 
 	var tp = tpStruct
-	if session.Statement.RefTable == nil {
+	if session.statement.RefTable == nil {
 		if sliceElementType.Kind() == reflect.Ptr {
 			if sliceElementType.Elem().Kind() == reflect.Struct {
 				pv := reflect.New(sliceElementType.Elem())
-				if err := session.Statement.setRefValue(pv.Elem()); err != nil {
+				if err := session.statement.setRefValue(pv.Elem()); err != nil {
 					return err
 				}
 			} else {
@@ -48,7 +48,7 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 			}
 		} else if sliceElementType.Kind() == reflect.Struct {
 			pv := reflect.New(sliceElementType)
-			if err := session.Statement.setRefValue(pv.Elem()); err != nil {
+			if err := session.statement.setRefValue(pv.Elem()); err != nil {
 				return err
 			}
 		} else {
@@ -56,31 +56,31 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 		}
 	}
 
-	var table = session.Statement.RefTable
+	var table = session.statement.RefTable
 
-	var addedTableName = (len(session.Statement.JoinStr) > 0)
+	var addedTableName = (len(session.statement.JoinStr) > 0)
 	var autoCond builder.Cond
 	if tp == tpStruct {
-		if !session.Statement.noAutoCondition && len(condiBean) > 0 {
+		if !session.statement.noAutoCondition && len(condiBean) > 0 {
 			var err error
-			autoCond, err = session.Statement.buildConds(table, condiBean[0], true, true, false, true, addedTableName)
+			autoCond, err = session.statement.buildConds(table, condiBean[0], true, true, false, true, addedTableName)
 			if err != nil {
 				return err
 			}
 		} else {
 			// !oinume! Add "<col> IS NULL" to WHERE whatever condiBean is given.
 			// See https://github.com/go-xorm/xorm/issues/179
-			if col := table.DeletedColumn(); col != nil && !session.Statement.unscoped { // tag "deleted" is enabled
-				var colName = session.Engine.Quote(col.Name)
+			if col := table.DeletedColumn(); col != nil && !session.statement.unscoped { // tag "deleted" is enabled
+				var colName = session.engine.Quote(col.Name)
 				if addedTableName {
-					var nm = session.Statement.TableName()
-					if len(session.Statement.TableAlias) > 0 {
-						nm = session.Statement.TableAlias
+					var nm = session.statement.TableName()
+					if len(session.statement.TableAlias) > 0 {
+						nm = session.statement.TableAlias
 					}
-					colName = session.Engine.Quote(nm) + "." + colName
+					colName = session.engine.Quote(nm) + "." + colName
 				}
 
-				autoCond = session.Engine.CondDeleted(colName)
+				autoCond = session.engine.CondDeleted(colName)
 			}
 		}
 	}
@@ -88,27 +88,27 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 	var sqlStr string
 	var args []interface{}
 	var err error
-	if session.Statement.RawSQL == "" {
-		if len(session.Statement.TableName()) <= 0 {
+	if session.statement.RawSQL == "" {
+		if len(session.statement.TableName()) <= 0 {
 			return ErrTableNotFound
 		}
 
-		var columnStr = session.Statement.ColumnStr
-		if len(session.Statement.selectStr) > 0 {
-			columnStr = session.Statement.selectStr
+		var columnStr = session.statement.ColumnStr
+		if len(session.statement.selectStr) > 0 {
+			columnStr = session.statement.selectStr
 		} else {
-			if session.Statement.JoinStr == "" {
+			if session.statement.JoinStr == "" {
 				if columnStr == "" {
-					if session.Statement.GroupByStr != "" {
-						columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1))
+					if session.statement.GroupByStr != "" {
+						columnStr = session.statement.Engine.Quote(strings.Replace(session.statement.GroupByStr, ",", session.engine.Quote(","), -1))
 					} else {
-						columnStr = session.Statement.genColumnStr()
+						columnStr = session.statement.genColumnStr()
 					}
 				}
 			} else {
 				if columnStr == "" {
-					if session.Statement.GroupByStr != "" {
-						columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1))
+					if session.statement.GroupByStr != "" {
+						columnStr = session.statement.Engine.Quote(strings.Replace(session.statement.GroupByStr, ",", session.engine.Quote(","), -1))
 					} else {
 						columnStr = "*"
 					}
@@ -119,14 +119,14 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 			}
 		}
 
-		session.Statement.cond = session.Statement.cond.And(autoCond)
-		condSQL, condArgs, err := builder.ToSQL(session.Statement.cond)
+		session.statement.cond = session.statement.cond.And(autoCond)
+		condSQL, condArgs, err := builder.ToSQL(session.statement.cond)
 		if err != nil {
 			return err
 		}
 
-		args = append(session.Statement.joinArgs, condArgs...)
-		sqlStr, err = session.Statement.genSelectSQL(columnStr, condSQL)
+		args = append(session.statement.joinArgs, condArgs...)
+		sqlStr, err = session.statement.genSelectSQL(columnStr, condSQL)
 		if err != nil {
 			return err
 		}
@@ -136,20 +136,20 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 			args = append(args, args...)
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	if session.canCache() {
-		if cacher := session.Engine.getCacher2(table); cacher != nil &&
-			!session.Statement.IsDistinct &&
-			!session.Statement.unscoped {
+		if cacher := session.engine.getCacher2(table); cacher != nil &&
+			!session.statement.IsDistinct &&
+			!session.statement.unscoped {
 			err = session.cacheFind(sliceElementType, sqlStr, rowsSlicePtr, args...)
 			if err != ErrCacheFailed {
 				return err
 			}
 			err = nil // !nashtsai! reset err to nil for ErrCacheFailed
-			session.Engine.logger.Warn("Cache Find Failed")
+			session.engine.logger.Warn("Cache Find Failed")
 		}
 	}
 
@@ -161,10 +161,10 @@ func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Va
 	var err error
 
 	session.queryPreprocess(&sqlStr, args...)
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		_, rawRows, err = session.innerQuery(sqlStr, args...)
 	} else {
-		rawRows, err = session.Tx.Query(sqlStr, args...)
+		rawRows, err = session.tx.Query(sqlStr, args...)
 	}
 	if err != nil {
 		return err
@@ -241,7 +241,7 @@ func (session *Session) noCacheFind(table *core.Table, containerValue reflect.Va
 	if elemType.Kind() == reflect.Struct {
 		var newValue = newElemFunc(fields)
 		dataStruct := rValue(newValue.Interface())
-		tb, err := session.Engine.autoMapType(dataStruct)
+		tb, err := session.engine.autoMapType(dataStruct)
 		if err != nil {
 			return err
 		}
@@ -289,19 +289,19 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 		return ErrCacheFailed
 	}
 
-	for _, filter := range session.Engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+	for _, filter := range session.engine.dialect.Filters() {
+		sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
 	}
 
-	newsql := session.Statement.convertIDSQL(sqlStr)
+	newsql := session.statement.convertIDSQL(sqlStr)
 	if newsql == "" {
 		return ErrCacheFailed
 	}
 
-	tableName := session.Statement.TableName()
+	tableName := session.statement.TableName()
 
-	table := session.Statement.RefTable
-	cacher := session.Engine.getCacher2(table)
+	table := session.statement.RefTable
+	cacher := session.engine.getCacher2(table)
 	ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
 	if err != nil {
 		rows, err := session.DB().Query(newsql, args...)
@@ -315,7 +315,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 		for rows.Next() {
 			i++
 			if i > 500 {
-				session.Engine.logger.Debug("[cacheFind] ids length > 500, no cache")
+				session.engine.logger.Debug("[cacheFind] ids length > 500, no cache")
 				return ErrCacheFailed
 			}
 			var res = make([]string, len(table.PrimaryKeys))
@@ -325,7 +325,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 			}
 			var pk core.PK = make([]interface{}, len(table.PrimaryKeys))
 			for i, col := range table.PKColumns() {
-				pk[i], err = session.Engine.idTypeAssertion(col, res[i])
+				pk[i], err = session.engine.idTypeAssertion(col, res[i])
 				if err != nil {
 					return err
 				}
@@ -334,13 +334,13 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 			ids = append(ids, pk)
 		}
 
-		session.Engine.logger.Debug("[cacheFind] cache sql:", ids, tableName, newsql, args)
+		session.engine.logger.Debug("[cacheFind] cache sql:", ids, tableName, newsql, args)
 		err = core.PutCacheSql(cacher, ids, tableName, newsql, args)
 		if err != nil {
 			return err
 		}
 	} else {
-		session.Engine.logger.Debug("[cacheFind] cache hit sql:", newsql, args)
+		session.engine.logger.Debug("[cacheFind] cache hit sql:", newsql, args)
 	}
 
 	sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
@@ -359,16 +359,16 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 			ides = append(ides, id)
 			ididxes[sid] = idx
 		} else {
-			session.Engine.logger.Debug("[cacheFind] cache hit bean:", tableName, id, bean)
+			session.engine.logger.Debug("[cacheFind] cache hit bean:", tableName, id, bean)
 
-			pk := session.Engine.IdOf(bean)
+			pk := session.engine.IdOf(bean)
 			xid, err := pk.ToString()
 			if err != nil {
 				return err
 			}
 
 			if sid != xid {
-				session.Engine.logger.Error("[cacheFind] error cache", xid, sid, bean)
+				session.engine.logger.Error("[cacheFind] error cache", xid, sid, bean)
 				return ErrCacheFailed
 			}
 			temps[idx] = bean
@@ -376,7 +376,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 	}
 
 	if len(ides) > 0 {
-		newSession := session.Engine.NewSession()
+		newSession := session.engine.NewSession()
 		defer newSession.Close()
 
 		slices := reflect.New(reflect.SliceOf(t))
@@ -410,7 +410,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 			if rv.Kind() != reflect.Ptr {
 				rv = rv.Addr()
 			}
-			id, err := session.Engine.idOfV(rv)
+			id, err := session.engine.idOfV(rv)
 			if err != nil {
 				return err
 			}
@@ -421,7 +421,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 
 			bean := rv.Interface()
 			temps[ididxes[sid]] = bean
-			session.Engine.logger.Debug("[cacheFind] cache bean:", tableName, id, bean, temps)
+			session.engine.logger.Debug("[cacheFind] cache bean:", tableName, id, bean, temps)
 			cacher.PutBean(tableName, sid, bean)
 		}
 	}
@@ -429,7 +429,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 	for j := 0; j < len(temps); j++ {
 		bean := temps[j]
 		if bean == nil {
-			session.Engine.logger.Warn("[cacheFind] cache no hit:", tableName, ids[j], temps)
+			session.engine.logger.Warn("[cacheFind] cache no hit:", tableName, ids[j], temps)
 			// return errors.New("cache error") // !nashtsai! no need to return error, but continue instead
 			continue
 		}
diff --git a/session_get.go b/session_get.go
index 70bc9676..ac147756 100644
--- a/session_get.go
+++ b/session_get.go
@@ -16,7 +16,7 @@ import (
 // will be as conditions
 func (session *Session) Get(bean interface{}) (bool, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -26,7 +26,7 @@ func (session *Session) Get(bean interface{}) (bool, error) {
 	}
 
 	if beanValue.Elem().Kind() == reflect.Struct {
-		if err := session.Statement.setRefValue(beanValue.Elem()); err != nil {
+		if err := session.statement.setRefValue(beanValue.Elem()); err != nil {
 			return false, err
 		}
 	}
@@ -35,23 +35,23 @@ func (session *Session) Get(bean interface{}) (bool, error) {
 	var args []interface{}
 	var err error
 
-	if session.Statement.RawSQL == "" {
-		if len(session.Statement.TableName()) <= 0 {
+	if session.statement.RawSQL == "" {
+		if len(session.statement.TableName()) <= 0 {
 			return false, ErrTableNotFound
 		}
-		session.Statement.Limit(1)
-		sqlStr, args, err = session.Statement.genGetSQL(bean)
+		session.statement.Limit(1)
+		sqlStr, args, err = session.statement.genGetSQL(bean)
 		if err != nil {
 			return false, err
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	if session.canCache() && beanValue.Elem().Kind() == reflect.Struct {
-		if cacher := session.Engine.getCacher2(session.Statement.RefTable); cacher != nil &&
-			!session.Statement.unscoped {
+		if cacher := session.engine.getCacher2(session.statement.RefTable); cacher != nil &&
+			!session.statement.unscoped {
 			has, err := session.cacheGet(bean, sqlStr, args...)
 			if err != ErrCacheFailed {
 				return has, err
@@ -67,10 +67,10 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
 
 	var rawRows *core.Rows
 	var err error
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		_, rawRows, err = session.innerQuery(sqlStr, args...)
 	} else {
-		rawRows, err = session.Tx.Query(sqlStr, args...)
+		rawRows, err = session.tx.Query(sqlStr, args...)
 	}
 	if err != nil {
 		return false, err
@@ -90,7 +90,7 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
 			return true, err
 		}
 		dataStruct := rValue(bean)
-		if err := session.Statement.setRefValue(dataStruct); err != nil {
+		if err := session.statement.setRefValue(dataStruct); err != nil {
 			return false, err
 		}
 
@@ -100,7 +100,7 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
 		}
 		rawRows.Close()
 
-		_, err = session.slice2Bean(scanResults, fields, len(fields), bean, &dataStruct, session.Statement.RefTable)
+		_, err = session.slice2Bean(scanResults, fields, len(fields), bean, &dataStruct, session.statement.RefTable)
 	case reflect.Slice:
 		err = rawRows.ScanSlice(bean)
 	case reflect.Map:
@@ -118,19 +118,19 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
 		return false, ErrCacheFailed
 	}
 
-	for _, filter := range session.Engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+	for _, filter := range session.engine.dialect.Filters() {
+		sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
 	}
-	newsql := session.Statement.convertIDSQL(sqlStr)
+	newsql := session.statement.convertIDSQL(sqlStr)
 	if newsql == "" {
 		return false, ErrCacheFailed
 	}
 
-	cacher := session.Engine.getCacher2(session.Statement.RefTable)
-	tableName := session.Statement.TableName()
-	session.Engine.logger.Debug("[cacheGet] find sql:", newsql, args)
+	cacher := session.engine.getCacher2(session.statement.RefTable)
+	tableName := session.statement.TableName()
+	session.engine.logger.Debug("[cacheGet] find sql:", newsql, args)
 	ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
-	table := session.Statement.RefTable
+	table := session.statement.RefTable
 	if err != nil {
 		var res = make([]string, len(table.PrimaryKeys))
 		rows, err := session.DB().Query(newsql, args...)
@@ -164,19 +164,19 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
 		}
 
 		ids = []core.PK{pk}
-		session.Engine.logger.Debug("[cacheGet] cache ids:", newsql, ids)
+		session.engine.logger.Debug("[cacheGet] cache ids:", newsql, ids)
 		err = core.PutCacheSql(cacher, ids, tableName, newsql, args)
 		if err != nil {
 			return false, err
 		}
 	} else {
-		session.Engine.logger.Debug("[cacheGet] cache hit sql:", newsql)
+		session.engine.logger.Debug("[cacheGet] cache hit sql:", newsql)
 	}
 
 	if len(ids) > 0 {
 		structValue := reflect.Indirect(reflect.ValueOf(bean))
 		id := ids[0]
-		session.Engine.logger.Debug("[cacheGet] get bean:", tableName, id)
+		session.engine.logger.Debug("[cacheGet] get bean:", tableName, id)
 		sid, err := id.ToString()
 		if err != nil {
 			return false, err
@@ -189,10 +189,10 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
 				return has, err
 			}
 
-			session.Engine.logger.Debug("[cacheGet] cache bean:", tableName, id, cacheBean)
+			session.engine.logger.Debug("[cacheGet] cache bean:", tableName, id, cacheBean)
 			cacher.PutBean(tableName, sid, cacheBean)
 		} else {
-			session.Engine.logger.Debug("[cacheGet] cache hit bean:", tableName, id, cacheBean)
+			session.engine.logger.Debug("[cacheGet] cache hit bean:", tableName, id, cacheBean)
 			has = true
 		}
 		structValue.Set(reflect.Indirect(reflect.ValueOf(cacheBean)))
diff --git a/session_insert.go b/session_insert.go
index c3648171..02edf574 100644
--- a/session_insert.go
+++ b/session_insert.go
@@ -19,7 +19,7 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
 	var affected int64
 	var err error
 
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 	defer session.resetStatement()
@@ -29,7 +29,7 @@ func (session *Session) Insert(beans ...interface{}) (int64, error) {
 		if sliceValue.Kind() == reflect.Slice {
 			size := sliceValue.Len()
 			if size > 0 {
-				if session.Engine.SupportInsertMany() {
+				if session.engine.SupportInsertMany() {
 					cnt, err := session.innerInsertMulti(bean)
 					if err != nil {
 						return affected, err
@@ -67,15 +67,15 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 		return 0, errors.New("could not insert a empty slice")
 	}
 
-	if err := session.Statement.setRefValue(reflect.ValueOf(sliceValue.Index(0).Interface())); err != nil {
+	if err := session.statement.setRefValue(reflect.ValueOf(sliceValue.Index(0).Interface())); err != nil {
 		return 0, err
 	}
 
-	if len(session.Statement.TableName()) <= 0 {
+	if len(session.statement.TableName()) <= 0 {
 		return 0, ErrTableNotFound
 	}
 
-	table := session.Statement.RefTable
+	table := session.statement.RefTable
 	size := sliceValue.Len()
 
 	var colNames []string
@@ -116,18 +116,18 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 				if col.IsDeleted {
 					continue
 				}
-				if session.Statement.ColumnStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+				if session.statement.ColumnStr != "" {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
 						continue
 					}
 				}
-				if session.Statement.OmitStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+				if session.statement.OmitStr != "" {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
 						continue
 					}
 				}
-				if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime {
-					val, t := session.Engine.NowTime2(col.SQLType.Name)
+				if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
+					val, t := session.engine.NowTime2(col.SQLType.Name)
 					args = append(args, val)
 
 					var colName = col.Name
@@ -135,7 +135,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 						col := table.GetColumn(colName)
 						setColumnTime(bean, col, t)
 					})
-				} else if col.IsVersion && session.Statement.checkVersion {
+				} else if col.IsVersion && session.statement.checkVersion {
 					args = append(args, 1)
 					var colName = col.Name
 					session.afterClosures = append(session.afterClosures, func(bean interface{}) {
@@ -171,18 +171,18 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 				if col.IsDeleted {
 					continue
 				}
-				if session.Statement.ColumnStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+				if session.statement.ColumnStr != "" {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
 						continue
 					}
 				}
-				if session.Statement.OmitStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+				if session.statement.OmitStr != "" {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
 						continue
 					}
 				}
-				if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime {
-					val, t := session.Engine.NowTime2(col.SQLType.Name)
+				if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
+					val, t := session.engine.NowTime2(col.SQLType.Name)
 					args = append(args, val)
 
 					var colName = col.Name
@@ -190,7 +190,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 						col := table.GetColumn(colName)
 						setColumnTime(bean, col, t)
 					})
-				} else if col.IsVersion && session.Statement.checkVersion {
+				} else if col.IsVersion && session.statement.checkVersion {
 					args = append(args, 1)
 					var colName = col.Name
 					session.afterClosures = append(session.afterClosures, func(bean interface{}) {
@@ -214,25 +214,25 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 
 	var sql = "INSERT INTO %s (%v%v%v) VALUES (%v)"
 	var statement string
-	if session.Engine.dialect.DBType() == core.ORACLE {
+	if session.engine.dialect.DBType() == core.ORACLE {
 		sql = "INSERT ALL INTO %s (%v%v%v) VALUES (%v) SELECT 1 FROM DUAL"
 		temp := fmt.Sprintf(") INTO %s (%v%v%v) VALUES (",
-			session.Engine.Quote(session.Statement.TableName()),
-			session.Engine.QuoteStr(),
-			strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
-			session.Engine.QuoteStr())
+			session.engine.Quote(session.statement.TableName()),
+			session.engine.QuoteStr(),
+			strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
+			session.engine.QuoteStr())
 		statement = fmt.Sprintf(sql,
-			session.Engine.Quote(session.Statement.TableName()),
-			session.Engine.QuoteStr(),
-			strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
-			session.Engine.QuoteStr(),
+			session.engine.Quote(session.statement.TableName()),
+			session.engine.QuoteStr(),
+			strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
+			session.engine.QuoteStr(),
 			strings.Join(colMultiPlaces, temp))
 	} else {
 		statement = fmt.Sprintf(sql,
-			session.Engine.Quote(session.Statement.TableName()),
-			session.Engine.QuoteStr(),
-			strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
-			session.Engine.QuoteStr(),
+			session.engine.Quote(session.statement.TableName()),
+			session.engine.QuoteStr(),
+			strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
+			session.engine.QuoteStr(),
 			strings.Join(colMultiPlaces, "),("))
 	}
 	res, err := session.exec(statement, args...)
@@ -240,8 +240,8 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 		return 0, err
 	}
 
-	if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
-		session.cacheInsert(session.Statement.TableName())
+	if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+		session.cacheInsert(session.statement.TableName())
 	}
 
 	lenAfterClosures := len(session.afterClosures)
@@ -249,7 +249,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 		elemValue := reflect.Indirect(sliceValue.Index(i)).Addr().Interface()
 
 		// handle AfterInsertProcessor
-		if session.IsAutoCommit {
+		if session.isAutoCommit {
 			// !nashtsai! does user expect it's same slice to passed closure when using Before()/After() when insert multi??
 			for _, closure := range session.afterClosures {
 				closure(elemValue)
@@ -281,7 +281,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
 // InsertMulti insert multiple records
 func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -299,14 +299,14 @@ func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
 }
 
 func (session *Session) innerInsert(bean interface{}) (int64, error) {
-	if err := session.Statement.setRefValue(rValue(bean)); err != nil {
+	if err := session.statement.setRefValue(rValue(bean)); err != nil {
 		return 0, err
 	}
-	if len(session.Statement.TableName()) <= 0 {
+	if len(session.statement.TableName()) <= 0 {
 		return 0, ErrTableNotFound
 	}
 
-	table := session.Statement.RefTable
+	table := session.statement.RefTable
 
 	// handle BeforeInsertProcessor
 	for _, closure := range session.beforeClosures {
@@ -318,12 +318,12 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		processor.BeforeInsert()
 	}
 	// --
-	colNames, args, err := genCols(session.Statement.RefTable, session, bean, false, false)
+	colNames, args, err := genCols(session.statement.RefTable, session, bean, false, false)
 	if err != nil {
 		return 0, err
 	}
 	// insert expr columns, override if exists
-	exprColumns := session.Statement.getExpr()
+	exprColumns := session.statement.getExpr()
 	exprColVals := make([]string, 0, len(exprColumns))
 	for _, v := range exprColumns {
 		// remove the expr columns
@@ -351,21 +351,21 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 	var sqlStr string
 	if len(colPlaces) > 0 {
 		sqlStr = fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)",
-			session.Engine.Quote(session.Statement.TableName()),
-			session.Engine.QuoteStr(),
-			strings.Join(colNames, session.Engine.Quote(", ")),
-			session.Engine.QuoteStr(),
+			session.engine.Quote(session.statement.TableName()),
+			session.engine.QuoteStr(),
+			strings.Join(colNames, session.engine.Quote(", ")),
+			session.engine.QuoteStr(),
 			colPlaces)
 	} else {
-		if session.Engine.dialect.DBType() == core.MYSQL {
-			sqlStr = fmt.Sprintf("INSERT INTO %s VALUES ()", session.Engine.Quote(session.Statement.TableName()))
+		if session.engine.dialect.DBType() == core.MYSQL {
+			sqlStr = fmt.Sprintf("INSERT INTO %s VALUES ()", session.engine.Quote(session.statement.TableName()))
 		} else {
-			sqlStr = fmt.Sprintf("INSERT INTO %s DEFAULT VALUES", session.Engine.Quote(session.Statement.TableName()))
+			sqlStr = fmt.Sprintf("INSERT INTO %s DEFAULT VALUES", session.engine.Quote(session.statement.TableName()))
 		}
 	}
 
 	handleAfterInsertProcessorFunc := func(bean interface{}) {
-		if session.IsAutoCommit {
+		if session.isAutoCommit {
 			for _, closure := range session.afterClosures {
 				closure(bean)
 			}
@@ -394,7 +394,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 	// for postgres, many of them didn't implement lastInsertId, so we should
 	// implemented it ourself.
-	if session.Engine.dialect.DBType() == core.ORACLE && len(table.AutoIncrement) > 0 {
+	if session.engine.dialect.DBType() == core.ORACLE && len(table.AutoIncrement) > 0 {
 		res, err := session.query("select seq_atable.currval from dual", args...)
 		if err != nil {
 			return 0, err
@@ -402,14 +402,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 		handleAfterInsertProcessorFunc(bean)
 
-		if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
-			session.cacheInsert(session.Statement.TableName())
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+			session.cacheInsert(session.statement.TableName())
 		}
 
-		if table.Version != "" && session.Statement.checkVersion {
+		if table.Version != "" && session.statement.checkVersion {
 			verValue, err := table.VersionColumn().ValueOf(bean)
 			if err != nil {
-				session.Engine.logger.Error(err)
+				session.engine.logger.Error(err)
 			} else if verValue.IsValid() && verValue.CanSet() {
 				verValue.SetInt(1)
 			}
@@ -427,7 +427,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 		aiValue, err := table.AutoIncrColumn().ValueOf(bean)
 		if err != nil {
-			session.Engine.logger.Error(err)
+			session.engine.logger.Error(err)
 		}
 
 		if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@@ -437,9 +437,9 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		aiValue.Set(int64ToIntValue(id, aiValue.Type()))
 
 		return 1, nil
-	} else if session.Engine.dialect.DBType() == core.POSTGRES && len(table.AutoIncrement) > 0 {
+	} else if session.engine.dialect.DBType() == core.POSTGRES && len(table.AutoIncrement) > 0 {
 		//assert table.AutoIncrement != ""
-		sqlStr = sqlStr + " RETURNING " + session.Engine.Quote(table.AutoIncrement)
+		sqlStr = sqlStr + " RETURNING " + session.engine.Quote(table.AutoIncrement)
 		res, err := session.query(sqlStr, args...)
 
 		if err != nil {
@@ -447,14 +447,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		}
 		handleAfterInsertProcessorFunc(bean)
 
-		if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
-			session.cacheInsert(session.Statement.TableName())
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+			session.cacheInsert(session.statement.TableName())
 		}
 
-		if table.Version != "" && session.Statement.checkVersion {
+		if table.Version != "" && session.statement.checkVersion {
 			verValue, err := table.VersionColumn().ValueOf(bean)
 			if err != nil {
-				session.Engine.logger.Error(err)
+				session.engine.logger.Error(err)
 			} else if verValue.IsValid() && verValue.CanSet() {
 				verValue.SetInt(1)
 			}
@@ -472,7 +472,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 		aiValue, err := table.AutoIncrColumn().ValueOf(bean)
 		if err != nil {
-			session.Engine.logger.Error(err)
+			session.engine.logger.Error(err)
 		}
 
 		if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@@ -490,14 +490,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 		defer handleAfterInsertProcessorFunc(bean)
 
-		if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
-			session.cacheInsert(session.Statement.TableName())
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+			session.cacheInsert(session.statement.TableName())
 		}
 
-		if table.Version != "" && session.Statement.checkVersion {
+		if table.Version != "" && session.statement.checkVersion {
 			verValue, err := table.VersionColumn().ValueOf(bean)
 			if err != nil {
-				session.Engine.logger.Error(err)
+				session.engine.logger.Error(err)
 			} else if verValue.IsValid() && verValue.CanSet() {
 				verValue.SetInt(1)
 			}
@@ -515,7 +515,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 		aiValue, err := table.AutoIncrColumn().ValueOf(bean)
 		if err != nil {
-			session.Engine.logger.Error(err)
+			session.engine.logger.Error(err)
 		}
 
 		if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@@ -533,7 +533,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 // parameter is inserted and error
 func (session *Session) InsertOne(bean interface{}) (int64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -541,15 +541,15 @@ func (session *Session) InsertOne(bean interface{}) (int64, error) {
 }
 
 func (session *Session) cacheInsert(tables ...string) error {
-	if session.Statement.RefTable == nil {
+	if session.statement.RefTable == nil {
 		return ErrCacheFailed
 	}
 
-	table := session.Statement.RefTable
-	cacher := session.Engine.getCacher2(table)
+	table := session.statement.RefTable
+	cacher := session.engine.getCacher2(table)
 
 	for _, t := range tables {
-		session.Engine.logger.Debug("[cache] clear sql:", t)
+		session.engine.logger.Debug("[cache] clear sql:", t)
 		cacher.ClearIds(t)
 	}
 
diff --git a/session_raw.go b/session_raw.go
index b44b1cd5..05223c46 100644
--- a/session_raw.go
+++ b/session_raw.go
@@ -17,10 +17,10 @@ import (
 func (session *Session) query(sqlStr string, paramStr ...interface{}) ([]map[string][]byte, error) {
 	session.queryPreprocess(&sqlStr, paramStr...)
 
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		return session.innerQuery2(sqlStr, paramStr...)
 	}
-	return session.txQuery(session.Tx, sqlStr, paramStr...)
+	return session.txQuery(session.tx, sqlStr, paramStr...)
 }
 
 func (session *Session) txQuery(tx *core.Tx, sqlStr string, params ...interface{}) ([]map[string][]byte, error) {
@@ -56,7 +56,7 @@ func (session *Session) innerQuery(sqlStr string, params ...interface{}) (*core.
 			return nil, rows, err
 		}
 	}
-	stmt, rows, err := session.Engine.logSQLQueryTime(sqlStr, params, callback)
+	stmt, rows, err := session.engine.logSQLQueryTime(sqlStr, params, callback)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -131,7 +131,7 @@ func (session *Session) innerQuery2(sqlStr string, params ...interface{}) ([]map
 // Query runs a raw sql and return records as []map[string][]byte
 func (session *Session) Query(sqlStr string, paramStr ...interface{}) ([]map[string][]byte, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -256,16 +256,16 @@ func query2(db *core.DB, sqlStr string, params ...interface{}) ([]map[string]str
 // QueryString runs a raw sql and return records as []map[string]string
 func (session *Session) QueryString(sqlStr string, args ...interface{}) ([]map[string]string, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
 	session.queryPreprocess(&sqlStr, args...)
 
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		return query2(session.DB(), sqlStr, args...)
 	}
-	return txQuery2(session.Tx, sqlStr, args...)
+	return txQuery2(session.tx, sqlStr, args...)
 }
 
 // Execute sql
@@ -287,32 +287,32 @@ func (session *Session) innerExec(sqlStr string, args ...interface{}) (sql.Resul
 }
 
 func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, error) {
-	for _, filter := range session.Engine.dialect.Filters() {
+	for _, filter := range session.engine.dialect.Filters() {
 		// TODO: for table name, it's no need to RefTable
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+		sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
 	}
 
 	session.saveLastSQL(sqlStr, args...)
 
-	return session.Engine.logSQLExecutionTime(sqlStr, args, func() (sql.Result, error) {
-		if session.IsAutoCommit {
+	return session.engine.logSQLExecutionTime(sqlStr, args, func() (sql.Result, error) {
+		if session.isAutoCommit {
 			// FIXME: oci8 can not auto commit (github.com/mattn/go-oci8)
-			if session.Engine.dialect.DBType() == core.ORACLE {
+			if session.engine.dialect.DBType() == core.ORACLE {
 				session.Begin()
-				r, err := session.Tx.Exec(sqlStr, args...)
+				r, err := session.tx.Exec(sqlStr, args...)
 				session.Commit()
 				return r, err
 			}
 			return session.innerExec(sqlStr, args...)
 		}
-		return session.Tx.Exec(sqlStr, args...)
+		return session.tx.Exec(sqlStr, args...)
 	})
 }
 
 // Exec raw sql
 func (session *Session) Exec(sqlStr string, args ...interface{}) (sql.Result, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
diff --git a/session_schema.go b/session_schema.go
index 215efb85..a6a72a40 100644
--- a/session_schema.go
+++ b/session_schema.go
@@ -17,7 +17,7 @@ import (
 // Ping test if database is ok
 func (session *Session) Ping() error {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -27,12 +27,12 @@ func (session *Session) Ping() error {
 // CreateTable create a table according a bean
 func (session *Session) CreateTable(bean interface{}) error {
 	v := rValue(bean)
-	if err := session.Statement.setRefValue(v); err != nil {
+	if err := session.statement.setRefValue(v); err != nil {
 		return err
 	}
 
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -42,16 +42,16 @@ func (session *Session) CreateTable(bean interface{}) error {
 // CreateIndexes create indexes
 func (session *Session) CreateIndexes(bean interface{}) error {
 	v := rValue(bean)
-	if err := session.Statement.setRefValue(v); err != nil {
+	if err := session.statement.setRefValue(v); err != nil {
 		return err
 	}
 
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
-	sqls := session.Statement.genIndexSQL()
+	sqls := session.statement.genIndexSQL()
 	for _, sqlStr := range sqls {
 		_, err := session.exec(sqlStr)
 		if err != nil {
@@ -64,16 +64,16 @@ func (session *Session) CreateIndexes(bean interface{}) error {
 // CreateUniques create uniques
 func (session *Session) CreateUniques(bean interface{}) error {
 	v := rValue(bean)
-	if err := session.Statement.setRefValue(v); err != nil {
+	if err := session.statement.setRefValue(v); err != nil {
 		return err
 	}
 
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
-	sqls := session.Statement.genUniqueSQL()
+	sqls := session.statement.genUniqueSQL()
 	for _, sqlStr := range sqls {
 		_, err := session.exec(sqlStr)
 		if err != nil {
@@ -84,7 +84,7 @@ func (session *Session) CreateUniques(bean interface{}) error {
 }
 
 func (session *Session) createOneTable() error {
-	sqlStr := session.Statement.genCreateTableSQL()
+	sqlStr := session.statement.genCreateTableSQL()
 	_, err := session.exec(sqlStr)
 	return err
 }
@@ -92,16 +92,16 @@ func (session *Session) createOneTable() error {
 // DropIndexes drop indexes
 func (session *Session) DropIndexes(bean interface{}) error {
 	v := rValue(bean)
-	if err := session.Statement.setRefValue(v); err != nil {
+	if err := session.statement.setRefValue(v); err != nil {
 		return err
 	}
 
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
-	sqls := session.Statement.genDelIndexSQL()
+	sqls := session.statement.genDelIndexSQL()
 	for _, sqlStr := range sqls {
 		_, err := session.exec(sqlStr)
 		if err != nil {
@@ -113,14 +113,14 @@ func (session *Session) DropIndexes(bean interface{}) error {
 
 // DropTable drop table will drop table if exist, if drop failed, it will return error
 func (session *Session) DropTable(beanOrTableName interface{}) error {
-	tableName, err := session.Engine.tableName(beanOrTableName)
+	tableName, err := session.engine.tableName(beanOrTableName)
 	if err != nil {
 		return err
 	}
 
 	var needDrop = true
-	if !session.Engine.dialect.SupportDropIfExists() {
-		sqlStr, args := session.Engine.dialect.TableCheckSql(tableName)
+	if !session.engine.dialect.SupportDropIfExists() {
+		sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
 		results, err := session.query(sqlStr, args...)
 		if err != nil {
 			return err
@@ -129,7 +129,7 @@ func (session *Session) DropTable(beanOrTableName interface{}) error {
 	}
 
 	if needDrop {
-		sqlStr := session.Engine.Dialect().DropTableSql(tableName)
+		sqlStr := session.engine.Dialect().DropTableSql(tableName)
 		_, err = session.exec(sqlStr)
 		return err
 	}
@@ -138,7 +138,7 @@ func (session *Session) DropTable(beanOrTableName interface{}) error {
 
 // IsTableExist if a table is exist
 func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error) {
-	tableName, err := session.Engine.tableName(beanOrTableName)
+	tableName, err := session.engine.tableName(beanOrTableName)
 	if err != nil {
 		return false, err
 	}
@@ -148,10 +148,10 @@ func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error)
 
 func (session *Session) isTableExist(tableName string) (bool, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
-	sqlStr, args := session.Engine.dialect.TableCheckSql(tableName)
+	sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
 	results, err := session.query(sqlStr, args...)
 	return len(results) > 0, err
 }
@@ -172,12 +172,12 @@ func (session *Session) IsTableEmpty(bean interface{}) (bool, error) {
 
 func (session *Session) isTableEmpty(tableName string) (bool, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
 	var total int64
-	sqlStr := fmt.Sprintf("select count(*) from %s", session.Engine.Quote(tableName))
+	sqlStr := fmt.Sprintf("select count(*) from %s", session.engine.Quote(tableName))
 	err := session.DB().QueryRow(sqlStr).Scan(&total)
 	session.saveLastSQL(sqlStr)
 	if err != nil {
@@ -193,11 +193,11 @@ func (session *Session) isTableEmpty(tableName string) (bool, error) {
 // find if index is exist according cols
 func (session *Session) isIndexExist2(tableName string, cols []string, unique bool) (bool, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
-	indexes, err := session.Engine.dialect.GetIndexes(tableName)
+	indexes, err := session.engine.dialect.GetIndexes(tableName)
 	if err != nil {
 		return false, err
 	}
@@ -215,23 +215,23 @@ func (session *Session) isIndexExist2(tableName string, cols []string, unique bo
 
 func (session *Session) addColumn(colName string) error {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
-	col := session.Statement.RefTable.GetColumn(colName)
-	sql, args := session.Statement.genAddColumnStr(col)
+	col := session.statement.RefTable.GetColumn(colName)
+	sql, args := session.statement.genAddColumnStr(col)
 	_, err := session.exec(sql, args...)
 	return err
 }
 
 func (session *Session) addIndex(tableName, idxName string) error {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
-	index := session.Statement.RefTable.Indexes[idxName]
-	sqlStr := session.Engine.dialect.CreateIndexSql(tableName, index)
+	index := session.statement.RefTable.Indexes[idxName]
+	sqlStr := session.engine.dialect.CreateIndexSql(tableName, index)
 
 	_, err := session.exec(sqlStr)
 	return err
@@ -239,18 +239,18 @@ func (session *Session) addIndex(tableName, idxName string) error {
 
 func (session *Session) addUnique(tableName, uqeName string) error {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
-	index := session.Statement.RefTable.Indexes[uqeName]
-	sqlStr := session.Engine.dialect.CreateIndexSql(tableName, index)
+	index := session.statement.RefTable.Indexes[uqeName]
+	sqlStr := session.engine.dialect.CreateIndexSql(tableName, index)
 	_, err := session.exec(sqlStr)
 	return err
 }
 
 // Sync2 synchronize structs to database tables
 func (session *Session) Sync2(beans ...interface{}) error {
-	engine := session.Engine
+	engine := session.engine
 
 	tables, err := engine.DBMetas()
 	if err != nil {
@@ -277,7 +277,7 @@ func (session *Session) Sync2(beans ...interface{}) error {
 		}
 
 		if oriTable == nil {
-			err = session.StoreEngine(session.Statement.StoreEngine).CreateTable(bean)
+			err = session.StoreEngine(session.statement.StoreEngine).CreateTable(bean)
 			if err != nil {
 				return err
 			}
@@ -350,8 +350,8 @@ func (session *Session) Sync2(beans ...interface{}) error {
 					}
 				} else {
 					session := engine.NewSession()
-					session.Statement.RefTable = table
-					session.Statement.tableName = tbName
+					session.statement.RefTable = table
+					session.statement.tableName = tbName
 					defer session.Close()
 					err = session.addColumn(col.Name)
 				}
@@ -402,14 +402,14 @@ func (session *Session) Sync2(beans ...interface{}) error {
 			for name, index := range addedNames {
 				if index.Type == core.UniqueType {
 					session := engine.NewSession()
-					session.Statement.RefTable = table
-					session.Statement.tableName = tbName
+					session.statement.RefTable = table
+					session.statement.tableName = tbName
 					defer session.Close()
 					err = session.addUnique(tbName, name)
 				} else if index.Type == core.IndexType {
 					session := engine.NewSession()
-					session.Statement.RefTable = table
-					session.Statement.tableName = tbName
+					session.statement.RefTable = table
+					session.statement.tableName = tbName
 					defer session.Close()
 					err = session.addIndex(tbName, name)
 				}
diff --git a/session_stats.go b/session_stats.go
index 49ef0560..bb89d4c2 100644
--- a/session_stats.go
+++ b/session_stats.go
@@ -10,30 +10,30 @@ import "database/sql"
 // are conditions.
 func (session *Session) Count(bean ...interface{}) (int64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
 	var sqlStr string
 	var args []interface{}
 	var err error
-	if session.Statement.RawSQL == "" {
-		sqlStr, args, err = session.Statement.genCountSQL(bean...)
+	if session.statement.RawSQL == "" {
+		sqlStr, args, err = session.statement.genCountSQL(bean...)
 		if err != nil {
 			return 0, err
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	session.queryPreprocess(&sqlStr, args...)
 
 	var total int64
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		err = session.DB().QueryRow(sqlStr, args...).Scan(&total)
 	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).Scan(&total)
+		err = session.tx.QueryRow(sqlStr, args...).Scan(&total)
 	}
 
 	if err == sql.ErrNoRows || err == nil {
@@ -46,30 +46,30 @@ func (session *Session) Count(bean ...interface{}) (int64, error) {
 // Sum call sum some column. bean's non-empty fields are conditions.
 func (session *Session) Sum(bean interface{}, columnName string) (float64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
 	var sqlStr string
 	var args []interface{}
 	var err error
-	if len(session.Statement.RawSQL) == 0 {
-		sqlStr, args, err = session.Statement.genSumSQL(bean, columnName)
+	if len(session.statement.RawSQL) == 0 {
+		sqlStr, args, err = session.statement.genSumSQL(bean, columnName)
 		if err != nil {
 			return 0, err
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	session.queryPreprocess(&sqlStr, args...)
 
 	var res float64
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		err = session.DB().QueryRow(sqlStr, args...).Scan(&res)
 	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).Scan(&res)
+		err = session.tx.QueryRow(sqlStr, args...).Scan(&res)
 	}
 
 	if err == sql.ErrNoRows || err == nil {
@@ -81,30 +81,30 @@ func (session *Session) Sum(bean interface{}, columnName string) (float64, error
 // SumInt call sum some column. bean's non-empty fields are conditions.
 func (session *Session) SumInt(bean interface{}, columnName string) (int64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
 	var sqlStr string
 	var args []interface{}
 	var err error
-	if len(session.Statement.RawSQL) == 0 {
-		sqlStr, args, err = session.Statement.genSumSQL(bean, columnName)
+	if len(session.statement.RawSQL) == 0 {
+		sqlStr, args, err = session.statement.genSumSQL(bean, columnName)
 		if err != nil {
 			return 0, err
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	session.queryPreprocess(&sqlStr, args...)
 
 	var res int64
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		err = session.DB().QueryRow(sqlStr, args...).Scan(&res)
 	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).Scan(&res)
+		err = session.tx.QueryRow(sqlStr, args...).Scan(&res)
 	}
 
 	if err == sql.ErrNoRows || err == nil {
@@ -116,30 +116,30 @@ func (session *Session) SumInt(bean interface{}, columnName string) (int64, erro
 // Sums call sum some columns. bean's non-empty fields are conditions.
 func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
 	var sqlStr string
 	var args []interface{}
 	var err error
-	if len(session.Statement.RawSQL) == 0 {
-		sqlStr, args, err = session.Statement.genSumSQL(bean, columnNames...)
+	if len(session.statement.RawSQL) == 0 {
+		sqlStr, args, err = session.statement.genSumSQL(bean, columnNames...)
 		if err != nil {
 			return nil, err
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	session.queryPreprocess(&sqlStr, args...)
 
 	var res = make([]float64, len(columnNames), len(columnNames))
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res)
 	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).ScanSlice(&res)
+		err = session.tx.QueryRow(sqlStr, args...).ScanSlice(&res)
 	}
 
 	if err == sql.ErrNoRows || err == nil {
@@ -151,30 +151,30 @@ func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64
 // SumsInt sum specify columns and return as []int64 instead of []float64
 func (session *Session) SumsInt(bean interface{}, columnNames ...string) ([]int64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
 	var sqlStr string
 	var args []interface{}
 	var err error
-	if len(session.Statement.RawSQL) == 0 {
-		sqlStr, args, err = session.Statement.genSumSQL(bean, columnNames...)
+	if len(session.statement.RawSQL) == 0 {
+		sqlStr, args, err = session.statement.genSumSQL(bean, columnNames...)
 		if err != nil {
 			return nil, err
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
 	}
 
 	session.queryPreprocess(&sqlStr, args...)
 
 	var res = make([]int64, len(columnNames), len(columnNames))
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res)
 	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).ScanSlice(&res)
+		err = session.tx.QueryRow(sqlStr, args...).ScanSlice(&res)
 	}
 
 	if err == sql.ErrNoRows || err == nil {
diff --git a/session_tx.go b/session_tx.go
index 302bc104..84d2f7f9 100644
--- a/session_tx.go
+++ b/session_tx.go
@@ -6,14 +6,14 @@ package xorm
 
 // Begin a transaction
 func (session *Session) Begin() error {
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		tx, err := session.DB().Begin()
 		if err != nil {
 			return err
 		}
-		session.IsAutoCommit = false
-		session.IsCommitedOrRollbacked = false
-		session.Tx = tx
+		session.isAutoCommit = false
+		session.isCommitedOrRollbacked = false
+		session.tx = tx
 		session.saveLastSQL("BEGIN TRANSACTION")
 	}
 	return nil
@@ -21,25 +21,23 @@ func (session *Session) Begin() error {
 
 // Rollback When using transaction, you can rollback if any error
 func (session *Session) Rollback() error {
-	if !session.IsAutoCommit && !session.IsCommitedOrRollbacked {
-		session.saveLastSQL(session.Engine.dialect.RollBackStr())
-		session.IsCommitedOrRollbacked = true
-		return session.Tx.Rollback()
+	if !session.isAutoCommit && !session.isCommitedOrRollbacked {
+		session.saveLastSQL(session.engine.dialect.RollBackStr())
+		session.isCommitedOrRollbacked = true
+		return session.tx.Rollback()
 	}
 	return nil
 }
 
 // Commit When using transaction, Commit will commit all operations.
 func (session *Session) Commit() error {
-	if !session.IsAutoCommit && !session.IsCommitedOrRollbacked {
+	if !session.isAutoCommit && !session.isCommitedOrRollbacked {
 		session.saveLastSQL("COMMIT")
-		session.IsCommitedOrRollbacked = true
+		session.isCommitedOrRollbacked = true
 		var err error
-		if err = session.Tx.Commit(); err == nil {
+		if err = session.tx.Commit(); err == nil {
 			// handle processors after tx committed
-
 			closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
-
 				if closuresPtr != nil {
 					for _, closure := range *closuresPtr {
 						closure(bean)
diff --git a/session_update.go b/session_update.go
index a1d25bab..e80cd0b5 100644
--- a/session_update.go
+++ b/session_update.go
@@ -16,19 +16,19 @@ import (
 )
 
 func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
-	if session.Statement.RefTable == nil ||
-		session.Tx != nil {
+	if session.statement.RefTable == nil ||
+		session.tx != nil {
 		return ErrCacheFailed
 	}
 
-	oldhead, newsql := session.Statement.convertUpdateSQL(sqlStr)
+	oldhead, newsql := session.statement.convertUpdateSQL(sqlStr)
 	if newsql == "" {
 		return ErrCacheFailed
 	}
-	for _, filter := range session.Engine.dialect.Filters() {
-		newsql = filter.Do(newsql, session.Engine.dialect, session.Statement.RefTable)
+	for _, filter := range session.engine.dialect.Filters() {
+		newsql = filter.Do(newsql, session.engine.dialect, session.statement.RefTable)
 	}
-	session.Engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql)
+	session.engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql)
 
 	var nStart int
 	if len(args) > 0 {
@@ -39,10 +39,10 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
 			nStart = strings.Count(oldhead, "$")
 		}
 	}
-	table := session.Statement.RefTable
-	cacher := session.Engine.getCacher2(table)
-	tableName := session.Statement.TableName()
-	session.Engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
+	table := session.statement.RefTable
+	cacher := session.engine.getCacher2(table)
+	tableName := session.statement.TableName()
+	session.engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
 	ids, err := core.GetCacheSql(cacher, tableName, newsql, args[nStart:])
 	if err != nil {
 		rows, err := session.DB().Query(newsql, args[nStart:]...)
@@ -75,9 +75,9 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
 
 			ids = append(ids, pk)
 		}
-		session.Engine.logger.Debug("[cacheUpdate] find updated id", ids)
+		session.engine.logger.Debug("[cacheUpdate] find updated id", ids)
 	} /*else {
-	    session.Engine.LogDebug("[xorm:cacheUpdate] del cached sql:", tableName, newsql, args)
+	    session.engine.LogDebug("[xorm:cacheUpdate] del cached sql:", tableName, newsql, args)
 	    cacher.DelIds(tableName, genSqlKey(newsql, args))
 	}*/
 
@@ -103,36 +103,36 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
 				colName := sps2[len(sps2)-1]
 				if strings.Contains(colName, "`") {
 					colName = strings.TrimSpace(strings.Replace(colName, "`", "", -1))
-				} else if strings.Contains(colName, session.Engine.QuoteStr()) {
-					colName = strings.TrimSpace(strings.Replace(colName, session.Engine.QuoteStr(), "", -1))
+				} else if strings.Contains(colName, session.engine.QuoteStr()) {
+					colName = strings.TrimSpace(strings.Replace(colName, session.engine.QuoteStr(), "", -1))
 				} else {
-					session.Engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName)
+					session.engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName)
 					return ErrCacheFailed
 				}
 
 				if col := table.GetColumn(colName); col != nil {
 					fieldValue, err := col.ValueOf(bean)
 					if err != nil {
-						session.Engine.logger.Error(err)
+						session.engine.logger.Error(err)
 					} else {
-						session.Engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
-						if col.IsVersion && session.Statement.checkVersion {
+						session.engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
+						if col.IsVersion && session.statement.checkVersion {
 							fieldValue.SetInt(fieldValue.Int() + 1)
 						} else {
 							fieldValue.Set(reflect.ValueOf(args[idx]))
 						}
 					}
 				} else {
-					session.Engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's",
+					session.engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's",
 						colName, table.Name)
 				}
 			}
 
-			session.Engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean)
+			session.engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean)
 			cacher.PutBean(tableName, sid, bean)
 		}
 	}
-	session.Engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName)
+	session.engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName)
 	cacher.ClearIds(tableName)
 	return nil
 }
@@ -145,7 +145,7 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
 //        2.float32 & float64 may be not inexact as conditions
 func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int64, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
@@ -169,21 +169,21 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 	var isMap = t.Kind() == reflect.Map
 	var isStruct = t.Kind() == reflect.Struct
 	if isStruct {
-		if err := session.Statement.setRefValue(v); err != nil {
+		if err := session.statement.setRefValue(v); err != nil {
 			return 0, err
 		}
 
-		if len(session.Statement.TableName()) <= 0 {
+		if len(session.statement.TableName()) <= 0 {
 			return 0, ErrTableNotFound
 		}
 
-		if session.Statement.ColumnStr == "" {
-			colNames, args = buildUpdates(session.Engine, session.Statement.RefTable, bean, false, false,
-				false, false, session.Statement.allUseBool, session.Statement.useAllCols,
-				session.Statement.mustColumnMap, session.Statement.nullableMap,
-				session.Statement.columnMap, true, session.Statement.unscoped)
+		if session.statement.ColumnStr == "" {
+			colNames, args = buildUpdates(session.engine, session.statement.RefTable, bean, false, false,
+				false, false, session.statement.allUseBool, session.statement.useAllCols,
+				session.statement.mustColumnMap, session.statement.nullableMap,
+				session.statement.columnMap, true, session.statement.unscoped)
 		} else {
-			colNames, args, err = genCols(session.Statement.RefTable, session, bean, true, true)
+			colNames, args, err = genCols(session.statement.RefTable, session, bean, true, true)
 			if err != nil {
 				return 0, err
 			}
@@ -194,19 +194,19 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		bValue := reflect.Indirect(reflect.ValueOf(bean))
 
 		for _, v := range bValue.MapKeys() {
-			colNames = append(colNames, session.Engine.Quote(v.String())+" = ?")
+			colNames = append(colNames, session.engine.Quote(v.String())+" = ?")
 			args = append(args, bValue.MapIndex(v).Interface())
 		}
 	} else {
 		return 0, ErrParamsType
 	}
 
-	table := session.Statement.RefTable
+	table := session.statement.RefTable
 
-	if session.Statement.UseAutoTime && table != nil && table.Updated != "" {
-		colNames = append(colNames, session.Engine.Quote(table.Updated)+" = ?")
+	if session.statement.UseAutoTime && table != nil && table.Updated != "" {
+		colNames = append(colNames, session.engine.Quote(table.Updated)+" = ?")
 		col := table.UpdatedColumn()
-		val, t := session.Engine.NowTime2(col.SQLType.Name)
+		val, t := session.engine.NowTime2(col.SQLType.Name)
 		args = append(args, val)
 
 		var colName = col.Name
@@ -219,45 +219,45 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 	}
 
 	//for update action to like "column = column + ?"
-	incColumns := session.Statement.getInc()
+	incColumns := session.statement.getInc()
 	for _, v := range incColumns {
-		colNames = append(colNames, session.Engine.Quote(v.colName)+" = "+session.Engine.Quote(v.colName)+" + ?")
+		colNames = append(colNames, session.engine.Quote(v.colName)+" = "+session.engine.Quote(v.colName)+" + ?")
 		args = append(args, v.arg)
 	}
 	//for update action to like "column = column - ?"
-	decColumns := session.Statement.getDec()
+	decColumns := session.statement.getDec()
 	for _, v := range decColumns {
-		colNames = append(colNames, session.Engine.Quote(v.colName)+" = "+session.Engine.Quote(v.colName)+" - ?")
+		colNames = append(colNames, session.engine.Quote(v.colName)+" = "+session.engine.Quote(v.colName)+" - ?")
 		args = append(args, v.arg)
 	}
 	//for update action to like "column = expression"
-	exprColumns := session.Statement.getExpr()
+	exprColumns := session.statement.getExpr()
 	for _, v := range exprColumns {
-		colNames = append(colNames, session.Engine.Quote(v.colName)+" = "+v.expr)
+		colNames = append(colNames, session.engine.Quote(v.colName)+" = "+v.expr)
 	}
 
-	if err = session.Statement.processIDParam(); err != nil {
+	if err = session.statement.processIDParam(); err != nil {
 		return 0, err
 	}
 
 	var autoCond builder.Cond
-	if !session.Statement.noAutoCondition && len(condiBean) > 0 {
+	if !session.statement.noAutoCondition && len(condiBean) > 0 {
 		var err error
-		autoCond, err = session.Statement.buildConds(session.Statement.RefTable, condiBean[0], true, true, false, true, false)
+		autoCond, err = session.statement.buildConds(session.statement.RefTable, condiBean[0], true, true, false, true, false)
 		if err != nil {
 			return 0, err
 		}
 	}
 
-	st := session.Statement
+	st := session.statement
 	defer session.resetStatement()
 
 	var sqlStr string
 	var condArgs []interface{}
 	var condSQL string
-	cond := session.Statement.cond.And(autoCond)
+	cond := session.statement.cond.And(autoCond)
 
-	var doIncVer = (table != nil && table.Version != "" && session.Statement.checkVersion)
+	var doIncVer = (table != nil && table.Version != "" && session.statement.checkVersion)
 	var verValue *reflect.Value
 	if doIncVer {
 		verValue, err = table.VersionColumn().ValueOf(bean)
@@ -265,8 +265,8 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 			return 0, err
 		}
 
-		cond = cond.And(builder.Eq{session.Engine.Quote(table.Version): verValue.Interface()})
-		colNames = append(colNames, session.Engine.Quote(table.Version)+" = "+session.Engine.Quote(table.Version)+" + 1")
+		cond = cond.And(builder.Eq{session.engine.Quote(table.Version): verValue.Interface()})
+		colNames = append(colNames, session.engine.Quote(table.Version)+" = "+session.engine.Quote(table.Version)+" + 1")
 	}
 
 	condSQL, condArgs, err = builder.ToSQL(cond)
@@ -290,7 +290,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		} else if st.Engine.dialect.DBType() == core.SQLITE {
 			tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", st.LimitN)
 			cond = cond.And(builder.Expr(fmt.Sprintf("rowid IN (SELECT rowid FROM %v %v)",
-				session.Engine.Quote(session.Statement.TableName()), tempCondSQL), condArgs...))
+				session.engine.Quote(session.statement.TableName()), tempCondSQL), condArgs...))
 			condSQL, condArgs, err = builder.ToSQL(cond)
 			if err != nil {
 				return 0, err
@@ -301,7 +301,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		} else if st.Engine.dialect.DBType() == core.POSTGRES {
 			tempCondSQL := condSQL + fmt.Sprintf(" LIMIT %d", st.LimitN)
 			cond = cond.And(builder.Expr(fmt.Sprintf("CTID IN (SELECT CTID FROM %v %v)",
-				session.Engine.Quote(session.Statement.TableName()), tempCondSQL), condArgs...))
+				session.engine.Quote(session.statement.TableName()), tempCondSQL), condArgs...))
 			condSQL, condArgs, err = builder.ToSQL(cond)
 			if err != nil {
 				return 0, err
@@ -315,7 +315,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 				table != nil && len(table.PrimaryKeys) == 1 {
 				cond = builder.Expr(fmt.Sprintf("%s IN (SELECT TOP (%d) %s FROM %v%v)",
 					table.PrimaryKeys[0], st.LimitN, table.PrimaryKeys[0],
-					session.Engine.Quote(session.Statement.TableName()), condSQL), condArgs...)
+					session.engine.Quote(session.statement.TableName()), condSQL), condArgs...)
 
 				condSQL, condArgs, err = builder.ToSQL(cond)
 				if err != nil {
@@ -336,7 +336,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 
 	sqlStr = fmt.Sprintf("UPDATE %v%v SET %v %v",
 		top,
-		session.Engine.Quote(session.Statement.TableName()),
+		session.engine.Quote(session.statement.TableName()),
 		strings.Join(colNames, ", "),
 		condSQL)
 
@@ -350,19 +350,19 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 	}
 
 	if table != nil {
-		if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
-			cacher.ClearIds(session.Statement.TableName())
-			cacher.ClearBeans(session.Statement.TableName())
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+			cacher.ClearIds(session.statement.TableName())
+			cacher.ClearBeans(session.statement.TableName())
 		}
 	}
 
 	// handle after update processors
-	if session.IsAutoCommit {
+	if session.isAutoCommit {
 		for _, closure := range session.afterClosures {
 			closure(bean)
 		}
 		if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
-			session.Engine.logger.Debug("[event]", session.Statement.TableName(), " has after update processor")
+			session.engine.logger.Debug("[event]", session.statement.TableName(), " has after update processor")
 			processor.AfterUpdate()
 		}
 	} else {