update latest xorm version to vendor (#2353)

models/models.go

@@ -31,7 +31,7 @@ import (
 // Engine represents a xorm engine or session.
 type Engine interface {
 	Table(tableNameOrBean interface{}) *xorm.Session
-	Count(interface{}) (int64, error)
+	Count(...interface{}) (int64, error)
 	Decr(column string, arg ...interface{}) *xorm.Session
 	Delete(interface{}) (int64, error)
 	Exec(string, ...interface{}) (sql.Result, error)

vendor/github.com/go-xorm/core/column.go

@@ -13,12 +13,13 @@ const (
 	ONLYFROMDB
 )
 
-// database column
+// Column defines database column
 type Column struct {
 	Name            string
 	TableName       string
 	FieldName       string
 	SQLType         SQLType
+	IsJSON          bool
 	Length          int
 	Length2         int
 	Nullable        bool
@@ -37,6 +38,7 @@ type Column struct {
 	SetOptions      map[string]int
 	DisableTimeZone bool
 	TimeZone        *time.Location // column specified time zone
+	Comment         string
 }
 
 func NewColumn(name, fieldName string, sqlType SQLType, len1, len2 int, nullable bool) *Column {
@@ -60,6 +62,7 @@ func NewColumn(name, fieldName string, sqlType SQLType, len1, len2 int, nullable
 		IsVersion:       false,
 		DefaultIsEmpty:  false,
 		EnumOptions:     make(map[string]int),
+		Comment:         "",
 	}
 }
 

vendor/github.com/go-xorm/core/dialect.go

@@ -244,6 +244,9 @@ func (b *Base) CreateTableSql(table *Table, tableName, storeEngine, charset stri
 				sql += col.StringNoPk(b.dialect)
 			}
 			sql = strings.TrimSpace(sql)
+			if b.DriverName() == MYSQL && len(col.Comment) > 0 {
+				sql += " COMMENT '" + col.Comment + "'"
+			}
 			sql += ", "
 		}
 

vendor/github.com/go-xorm/core/rows.go

@@ -247,6 +247,18 @@ type Row struct {
 	err error // deferred error for easy chaining
 }
 
+// ErrorRow return an error row
+func ErrorRow(err error) *Row {
+	return &Row{
+		err: err,
+	}
+}
+
+// NewRow from rows
+func NewRow(rows *Rows, err error) *Row {
+	return &Row{rows, err}
+}
+
 func (row *Row) Columns() ([]string, error) {
 	if row.err != nil {
 		return nil, row.err

vendor/github.com/go-xorm/core/table.go

@@ -22,6 +22,7 @@ type Table struct {
 	Cacher        Cacher
 	StoreEngine   string
 	Charset       string
+	Comment       string
 }
 
 func (table *Table) Columns() []*Column {

vendor/github.com/go-xorm/xorm/README.md

@@ -2,11 +2,9 @@
 
 Xorm is a simple and powerful ORM for Go.
 
-[![CircleCI](https://circleci.com/gh/go-xorm/xorm/tree/master.svg?style=svg)](https://circleci.com/gh/go-xorm/xorm/tree/master)  [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/go-xorm/xorm?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![CircleCI](https://circleci.com/gh/go-xorm/xorm.svg?style=shield)](https://circleci.com/gh/go-xorm/xorm) [![codecov](https://codecov.io/gh/go-xorm/xorm/branch/master/graph/badge.svg)](https://codecov.io/gh/go-xorm/xorm)
-
+[![](https://goreportcard.com/badge/github.com/go-xorm/xorm)](https://goreportcard.com/report/github.com/go-xorm/xorm) 
-# Notice
+[![Join the chat at https://img.shields.io/discord/323460943201959939.svg](https://img.shields.io/discord/323460943201959939.svg)](https://discord.gg/HuR2CF3)
-
-The last master version is not backwards compatible. You should use `engine.ShowSQL()` and `engine.Logger().SetLevel()` instead of `engine.ShowSQL = `, `engine.ShowInfo = ` and so on.
 
 # Features
 
@@ -50,6 +48,14 @@ Drivers for Go's sql package which currently support database/sql includes:
 
 # Changelog
 
+* **v0.6.3**
+    * merge tests to main project
+    * add `Exist` function
+    * add `SumInt` function
+    * Mysql now support read and create column comment.
+    * fix time related bugs.
+    * fix some other bugs.
+
 * **v0.6.2**
     * refactor tag parse methods
     * add Scan features to Get
@@ -62,22 +68,6 @@ methods can use `builder.Cond` as parameter
     * add Sum, SumInt, SumInt64 and NotIn methods
     * some bugs fixed
 
-* **v0.5.0**
-    * logging interface changed
-    * some bugs fixed
-
-* **v0.4.5**
-    * many bugs fixed
-    * extends support unlimited deepth
-    * Delete Limit support
-
-* **v0.4.4**
-    * ql database expriment support
-    * tidb database expriment support
-    * sql.NullString and etc. field support
-    * select ForUpdate support
-    * many bugs fixed
-
 [More changes ...](https://github.com/go-xorm/manual-en-US/tree/master/chapter-16)
 
 # Installation
@@ -124,7 +114,7 @@ results, err := engine.Query("select * from user")
 results, err := engine.QueryString("select * from user")
 ```
 
-* `Execute` runs a SQL string, it returns `affetcted` and `error`
+* `Execute` runs a SQL string, it returns `affected` and `error`
 
 ```Go
 affected, err := engine.Exec("update user set age = ? where name = ?", age, name)
@@ -166,6 +156,25 @@ has, err := engine.Where("id = ?", id).Cols(cols...).Get(&valuesSlice)
 // SELECT col1, col2, col3 FROM user WHERE id = ?
 ```
 
+* Check if one record exist on table
+
+```Go
+has, err := testEngine.Exist(new(RecordExist))
+// SELECT * FROM record_exist LIMIT 1
+has, err = testEngine.Exist(&RecordExist{
+		Name: "test1",
+	})
+// SELECT * FROM record_exist WHERE name = ? LIMIT 1
+has, err = testEngine.Where("name = ?", "test1").Exist(&RecordExist{})
+// SELECT * FROM record_exist WHERE name = ? LIMIT 1
+has, err = testEngine.SQL("select * from record_exist where name = ?", "test1").Exist()
+// select * from record_exist where name = ?
+has, err = testEngine.Table("record_exist").Exist()
+// SELECT * FROM record_exist LIMIT 1
+has, err = testEngine.Table("record_exist").Where("name = ?", "test1").Exist()
+// SELECT * FROM record_exist WHERE name = ? LIMIT 1
+```
+
 * Query multiple records from database, also you can use join and extends
 
 ```Go
@@ -258,13 +267,21 @@ err := engine.Where(builder.NotIn("a", 1, 2).And(builder.In("b", "c", "d", "e"))
 
 # Cases
 
+* [studygolang](http://studygolang.com/) - [github.com/studygolang/studygolang](https://github.com/studygolang/studygolang)
+
+* [Gitea](http://gitea.io) - [github.com/go-gitea/gitea](http://github.com/go-gitea/gitea)
+
+* [Gogs](http://try.gogits.org) - [github.com/gogits/gogs](http://github.com/gogits/gogs)
+
+* [grafana](https://grafana.com/) - [github.com/grafana/grafana](http://github.com/grafana/grafana)
+
 * [github.com/m3ng9i/qreader](https://github.com/m3ng9i/qreader)
 
 * [Wego](http://github.com/go-tango/wego)
 
 * [Docker.cn](https://docker.cn/)
 
-* [Gogs](http://try.gogits.org) - [github.com/gogits/gogs](http://github.com/gogits/gogs)
+* [Xorm Adapter](https://github.com/casbin/xorm-adapter) for [Casbin](https://github.com/casbin/casbin) - [github.com/casbin/xorm-adapter](https://github.com/casbin/xorm-adapter)
 
 * [Gorevel](http://gorevel.cn/) - [github.com/goofcc/gorevel](http://github.com/goofcc/gorevel)
 

vendor/github.com/go-xorm/xorm/README_CN.md

@@ -4,11 +4,9 @@
 
 xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作非常简便。
 
-[![CircleCI](https://circleci.com/gh/go-xorm/xorm/tree/master.svg?style=svg)](https://circleci.com/gh/go-xorm/xorm/tree/master)  [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/go-xorm/xorm?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![CircleCI](https://circleci.com/gh/go-xorm/xorm.svg?style=shield)](https://circleci.com/gh/go-xorm/xorm) [![codecov](https://codecov.io/gh/go-xorm/xorm/branch/master/graph/badge.svg)](https://codecov.io/gh/go-xorm/xorm)
-
+[![](https://goreportcard.com/badge/github.com/go-xorm/xorm)](https://goreportcard.com/report/github.com/go-xorm/xorm)
-# 注意
+[![Join the chat at https://img.shields.io/discord/323460943201959939.svg](https://img.shields.io/discord/323460943201959939.svg)](https://discord.gg/HuR2CF3)
-
-最新的版本有不兼容的更新，您必须使用 `engine.ShowSQL()` 和 `engine.Logger().SetLevel()` 来替代 `engine.ShowSQL = `, `engine.ShowInfo = ` 等等。
 
 ## 特性
 
@@ -54,9 +52,18 @@ xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作
 
 ## 更新日志
 
+* **v0.6.3**
+    * 合并单元测试到主工程
+    * 新增`Exist`方法
+    * 新增`SumInt`方法
+    * Mysql新增读取和创建字段注释支持
+    * 新增`SetConnMaxLifetime`方法
+    * 修正了时间相关的Bug
+    * 修复了一些其它Bug
+
 * **v0.6.2**
     * 重构Tag解析方式
-    * Get方法新增类似Sacn的特性
+    * Get方法新增类似Scan的特性
     * 新增 QueryString 方法
 
 * **v0.6.0**
@@ -70,18 +77,6 @@ xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作
     * logging接口进行不兼容改变
     * Bug修正
 
-* **v0.4.5**
-    * bug修正
-    * extends 支持无限级
-    * Delete Limit 支持
-
-* **v0.4.4**
-    * Tidb 数据库支持
-    * QL 试验性支持
-    * sql.NullString支持
-    * ForUpdate 支持
-    * bug修正
-
 [更多更新日志...](https://github.com/go-xorm/manual-zh-CN/tree/master/chapter-16)
 
 ## 安装
@@ -170,6 +165,25 @@ has, err := engine.Where("id = ?", id).Cols(cols...).Get(&valuesSlice)
 // SELECT col1, col2, col3 FROM user WHERE id = ?
 ```
 
+* 检测记录是否存在
+
+```Go
+has, err := testEngine.Exist(new(RecordExist))
+// SELECT * FROM record_exist LIMIT 1
+has, err = testEngine.Exist(&RecordExist{
+		Name: "test1",
+	})
+// SELECT * FROM record_exist WHERE name = ? LIMIT 1
+has, err = testEngine.Where("name = ?", "test1").Exist(&RecordExist{})
+// SELECT * FROM record_exist WHERE name = ? LIMIT 1
+has, err = testEngine.SQL("select * from record_exist where name = ?", "test1").Exist()
+// select * from record_exist where name = ?
+has, err = testEngine.Table("record_exist").Exist()
+// SELECT * FROM record_exist LIMIT 1
+has, err = testEngine.Table("record_exist").Where("name = ?", "test1").Exist()
+// SELECT * FROM record_exist WHERE name = ? LIMIT 1
+```
+
 * 查询多条记录，当然可以使用Join和extends来组合使用
 
 ```Go
@@ -261,13 +275,21 @@ err := engine.Where(builder.NotIn("a", 1, 2).And(builder.In("b", "c", "d", "e"))
 
 # 案例
 
+* [Go语言中文网](http://studygolang.com/) - [github.com/studygolang/studygolang](https://github.com/studygolang/studygolang)
+
+* [Gitea](http://gitea.io) - [github.com/go-gitea/gitea](http://github.com/go-gitea/gitea)
+
+* [Gogs](http://try.gogits.org) - [github.com/gogits/gogs](http://github.com/gogits/gogs)
+
+* [grafana](https://grafana.com/) - [github.com/grafana/grafana](http://github.com/grafana/grafana)
+
 * [github.com/m3ng9i/qreader](https://github.com/m3ng9i/qreader)
 
 * [Wego](http://github.com/go-tango/wego)
 
 * [Docker.cn](https://docker.cn/)
 
-* [Gogs](http://try.gogits.org) - [github.com/gogits/gogs](http://github.com/gogits/gogs)
+* [Xorm Adapter](https://github.com/casbin/xorm-adapter) for [Casbin](https://github.com/casbin/casbin) - [github.com/casbin/xorm-adapter](https://github.com/casbin/xorm-adapter)
 
 * [Gowalker](http://gowalker.org) - [github.com/Unknwon/gowalker](http://github.com/Unknwon/gowalker)
 

vendor/github.com/go-xorm/xorm/circle.yml

@@ -3,6 +3,8 @@ dependencies:
     # './...' is a relative pattern which means all subdirectories
     - go get -t -d -v ./...
     - go get -t -d -v github.com/go-xorm/tests
+    - go get -u github.com/go-xorm/core
+    - go get -u github.com/go-xorm/builder
     - go build -v
 
 database:
@@ -19,7 +21,9 @@ database:
 test:
   override:
     # './...' is a relative pattern which means all subdirectories
-    - go test -v -race
+    - go test -v -race -db="sqlite3::mysql::mymysql::postgres" -conn_str="./test.db::root:@/xorm_test::xorm_test/root/::dbname=xorm_test sslmode=disable" -coverprofile=coverage.txt -covermode=atomic
     - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./sqlite3.sh
     - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./mysql.sh
     - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./postgres.sh
+  post:
+    - bash <(curl -s https://codecov.io/bash)

vendor/github.com/go-xorm/xorm/dialect_mssql.go

@@ -215,7 +215,7 @@ func (db *mssql) SqlType(c *core.Column) string {
 	var res string
 	switch t := c.SQLType.Name; t {
 	case core.Bool:
-		res = core.TinyInt
+		res = core.Bit
 		if strings.EqualFold(c.Default, "true") {
 			c.Default = "1"
 		} else {
@@ -250,6 +250,9 @@ func (db *mssql) SqlType(c *core.Column) string {
 	case core.Uuid:
 		res = core.Varchar
 		c.Length = 40
+	case core.TinyInt:
+		res = core.TinyInt
+		c.Length = 0
 	default:
 		res = t
 	}
@@ -335,9 +338,15 @@ func (db *mssql) TableCheckSql(tableName string) (string, []interface{}) {
 func (db *mssql) GetColumns(tableName string) ([]string, map[string]*core.Column, error) {
 	args := []interface{}{}
 	s := `select a.name as name, b.name as ctype,a.max_length,a.precision,a.scale,a.is_nullable as nullable,
-	      replace(replace(isnull(c.text,''),'(',''),')','') as vdefault   
+	      replace(replace(isnull(c.text,''),'(',''),')','') as vdefault,
-          from sys.columns a left join sys.types b on a.user_type_id=b.user_type_id 
+		  ISNULL(i.is_primary_key, 0)
+          from sys.columns a 
+		  left join sys.types b on a.user_type_id=b.user_type_id
           left join sys.syscomments c on a.default_object_id=c.id
+		  LEFT OUTER JOIN 
+    sys.index_columns ic ON ic.object_id = a.object_id AND ic.column_id = a.column_id
+		  LEFT OUTER JOIN 
+    sys.indexes i ON ic.object_id = i.object_id AND ic.index_id = i.index_id
           where a.object_id=object_id('` + tableName + `')`
 	db.LogSQL(s, args)
 
@@ -352,8 +361,8 @@ func (db *mssql) GetColumns(tableName string) ([]string, map[string]*core.Column
 	for rows.Next() {
 		var name, ctype, vdefault string
 		var maxLen, precision, scale int
-		var nullable bool
+		var nullable, isPK bool
-		err = rows.Scan(&name, &ctype, &maxLen, &precision, &scale, &nullable, &vdefault)
+		err = rows.Scan(&name, &ctype, &maxLen, &precision, &scale, &nullable, &vdefault, &isPK)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -363,6 +372,7 @@ func (db *mssql) GetColumns(tableName string) ([]string, map[string]*core.Column
 		col.Name = strings.Trim(name, "` ")
 		col.Nullable = nullable
 		col.Default = vdefault
+		col.IsPrimaryKey = isPK
 		ct := strings.ToUpper(ctype)
 		if ct == "DECIMAL" {
 			col.Length = precision
@@ -536,7 +546,6 @@ type odbcDriver struct {
 func (p *odbcDriver) Parse(driverName, dataSourceName string) (*core.Uri, error) {
 	kv := strings.Split(dataSourceName, ";")
 	var dbName string
-
 	for _, c := range kv {
 		vv := strings.Split(strings.TrimSpace(c), "=")
 		if len(vv) == 2 {

vendor/github.com/go-xorm/xorm/dialect_mysql.go

@@ -299,7 +299,7 @@ func (db *mysql) TableCheckSql(tableName string) (string, []interface{}) {
 func (db *mysql) GetColumns(tableName string) ([]string, map[string]*core.Column, error) {
 	args := []interface{}{db.DbName, tableName}
 	s := "SELECT `COLUMN_NAME`, `IS_NULLABLE`, `COLUMN_DEFAULT`, `COLUMN_TYPE`," +
-		" `COLUMN_KEY`, `EXTRA` FROM `INFORMATION_SCHEMA`.`COLUMNS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ?"
+		" `COLUMN_KEY`, `EXTRA`,`COLUMN_COMMENT` FROM `INFORMATION_SCHEMA`.`COLUMNS` WHERE `TABLE_SCHEMA` = ? AND `TABLE_NAME` = ?"
 	db.LogSQL(s, args)
 
 	rows, err := db.DB().Query(s, args...)
@@ -314,13 +314,14 @@ func (db *mysql) GetColumns(tableName string) ([]string, map[string]*core.Column
 		col := new(core.Column)
 		col.Indexes = make(map[string]int)
 
-		var columnName, isNullable, colType, colKey, extra string
+		var columnName, isNullable, colType, colKey, extra, comment string
 		var colDefault *string
-		err = rows.Scan(&columnName, &isNullable, &colDefault, &colType, &colKey, &extra)
+		err = rows.Scan(&columnName, &isNullable, &colDefault, &colType, &colKey, &extra, &comment)
 		if err != nil {
 			return nil, nil, err
 		}
 		col.Name = strings.Trim(columnName, "` ")
+		col.Comment = comment
 		if "YES" == isNullable {
 			col.Nullable = true
 		}
@@ -407,7 +408,7 @@ func (db *mysql) GetColumns(tableName string) ([]string, map[string]*core.Column
 
 func (db *mysql) GetTables() ([]*core.Table, error) {
 	args := []interface{}{db.DbName}
-	s := "SELECT `TABLE_NAME`, `ENGINE`, `TABLE_ROWS`, `AUTO_INCREMENT` from " +
+	s := "SELECT `TABLE_NAME`, `ENGINE`, `TABLE_ROWS`, `AUTO_INCREMENT`, `TABLE_COMMENT` from " +
 		"`INFORMATION_SCHEMA`.`TABLES` WHERE `TABLE_SCHEMA`=? AND (`ENGINE`='MyISAM' OR `ENGINE` = 'InnoDB' OR `ENGINE` = 'TokuDB')"
 	db.LogSQL(s, args)
 
@@ -420,14 +421,15 @@ func (db *mysql) GetTables() ([]*core.Table, error) {
 	tables := make([]*core.Table, 0)
 	for rows.Next() {
 		table := core.NewEmptyTable()
-		var name, engine, tableRows string
+		var name, engine, tableRows, comment string
 		var autoIncr *string
-		err = rows.Scan(&name, &engine, &tableRows, &autoIncr)
+		err = rows.Scan(&name, &engine, &tableRows, &autoIncr, &comment)
 		if err != nil {
 			return nil, err
 		}
 
 		table.Name = name
+		table.Comment = comment
 		table.StoreEngine = engine
 		tables = append(tables, table)
 	}

vendor/github.com/go-xorm/xorm/dialect_sqlite3.go

@@ -14,10 +14,6 @@ import (
 	"github.com/go-xorm/core"
 )
 
-// func init() {
-// 	RegisterDialect("sqlite3", &sqlite3{})
-// }
-
 var (
 	sqlite3ReservedWords = map[string]bool{
 		"ABORT":             true,
@@ -310,11 +306,25 @@ func (db *sqlite3) GetColumns(tableName string) ([]string, map[string]*core.Colu
 	for _, colStr := range colCreates {
 		reg = regexp.MustCompile(`,\s`)
 		colStr = reg.ReplaceAllString(colStr, ",")
+		if strings.HasPrefix(strings.TrimSpace(colStr), "PRIMARY KEY") {
+			parts := strings.Split(strings.TrimSpace(colStr), "(")
+			if len(parts) == 2 {
+				pkCols := strings.Split(strings.TrimRight(strings.TrimSpace(parts[1]), ")"), ",")
+				for _, pk := range pkCols {
+					if col, ok := cols[strings.Trim(strings.TrimSpace(pk), "`")]; ok {
+						col.IsPrimaryKey = true
+					}
+				}
+			}
+			continue
+		}
+
 		fields := strings.Fields(strings.TrimSpace(colStr))
 		col := new(core.Column)
 		col.Indexes = make(map[string]int)
 		col.Nullable = true
 		col.DefaultIsEmpty = true
+
 		for idx, field := range fields {
 			if idx == 0 {
 				col.Name = strings.Trim(strings.Trim(field, "`[] "), `"`)

vendor/github.com/go-xorm/xorm/doc.go

@@ -8,7 +8,7 @@ Package xorm is a simple and powerful ORM for Go.
 
 Installation
 
-Make sure you have installed Go 1.1+ and then:
+Make sure you have installed Go 1.6+ and then:
 
     go get github.com/go-xorm/xorm
 
@@ -51,11 +51,15 @@ There are 8 major ORM methods and many helpful methods to use to operate databas
     // INSERT INTO struct1 () values ()
     // INSERT INTO struct2 () values (),(),()
 
-2. Query one record from database
+2. Query one record or one variable from database
 
     has, err := engine.Get(&user)
     // SELECT * FROM user LIMIT 1
 
+    var id int64
+    has, err := engine.Table("user").Where("name = ?", name).Get(&id)
+    // SELECT id FROM user WHERE name = ? LIMIT 1
+
 3. Query multiple records from database
 
     var sliceOfStructs []Struct
@@ -99,6 +103,9 @@ another is Rows
     counts, err := engine.Count(&user)
     // SELECT count(*) AS total FROM user
 
+    counts, err := engine.SQL("select count(*) FROM user").Count()
+    // select count(*) FROM user
+
 8. Sum records
 
     sumFloat64, err := engine.Sum(&user, "id")

vendor/github.com/go-xorm/xorm/engine.go

@@ -19,6 +19,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/go-xorm/builder"
 	"github.com/go-xorm/core"
 )
 
@@ -40,7 +41,7 @@ type Engine struct {
 	showExecTime bool
 
 	logger     core.ILogger
-	TZLocation *time.Location
+	TZLocation *time.Location // The timezone of the application
 	DatabaseTZ *time.Location // The timezone of the database
 
 	disableGlobalCache bool
@@ -143,7 +144,6 @@ func (engine *Engine) Quote(value string) string {
 
 // QuoteTo quotes string and writes into the buffer
 func (engine *Engine) QuoteTo(buf *bytes.Buffer, value string) {
-
 	if buf == nil {
 		return
 	}
@@ -169,7 +169,7 @@ func (engine *Engine) quote(sql string) string {
 	return engine.dialect.QuoteStr() + sql + engine.dialect.QuoteStr()
 }
 
-// SqlType will be depracated, please use SQLType instead
+// SqlType will be deprecated, please use SQLType instead
 //
 // Deprecated: use SQLType instead
 func (engine *Engine) SqlType(c *core.Column) string {
@@ -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
 }
@@ -259,7 +259,6 @@ func (engine *Engine) Close() error {
 func (engine *Engine) Ping() error {
 	session := engine.NewSession()
 	defer session.Close()
-	engine.logger.Infof("PING DATABASE %v", engine.DriverName())
 	return session.Ping()
 }
 
@@ -267,7 +266,7 @@ func (engine *Engine) Ping() error {
 func (engine *Engine) logSQL(sqlStr string, sqlArgs ...interface{}) {
 	if engine.showSQL && !engine.showExecTime {
 		if len(sqlArgs) > 0 {
-			engine.logger.Infof("[SQL] %v %v", sqlStr, sqlArgs)
+			engine.logger.Infof("[SQL] %v %#v", sqlStr, sqlArgs)
 		} else {
 			engine.logger.Infof("[SQL] %v", sqlStr)
 		}
@@ -320,7 +319,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 +328,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 +569,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
+// Id will be deprecated, 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 +627,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 +666,84 @@ 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...)
 }
 
+// NotIn will generate "column NOT IN (?, ?)"
+func (engine *Engine) NotIn(column string, args ...interface{}) *Session {
+	session := engine.NewSession()
+	session.isAutoClose = true
+	return session.NotIn(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,38 +755,44 @@ 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)
 }
 
+func (engine *Engine) unMapType(t reflect.Type) {
+	engine.mutex.Lock()
+	defer engine.mutex.Unlock()
+	delete(engine.Tables, t)
+}
+
 func (engine *Engine) autoMapType(v reflect.Value) (*core.Table, error) {
 	t := v.Type()
 	engine.mutex.Lock()
@@ -1007,6 +1019,10 @@ func (engine *Engine) mapType(v reflect.Value) (*core.Table, error) {
 			col = core.NewColumn(engine.ColumnMapper.Obj2Table(t.Field(i).Name),
 				t.Field(i).Name, sqlType, sqlType.DefaultLength,
 				sqlType.DefaultLength2, true)
+
+			if fieldType.Kind() == reflect.Int64 && (strings.ToUpper(col.FieldName) == "ID" || strings.HasSuffix(strings.ToUpper(col.FieldName), ".ID")) {
+				idFieldColName = col.Name
+			}
 		}
 		if col.IsAutoIncrement {
 			col.Nullable = false
@@ -1014,9 +1030,6 @@ func (engine *Engine) mapType(v reflect.Value) (*core.Table, error) {
 
 		table.AddColumn(col)
 
-		if fieldType.Kind() == reflect.Int64 && (strings.ToUpper(col.FieldName) == "ID" || strings.HasSuffix(strings.ToUpper(col.FieldName), ".ID")) {
-			idFieldColName = col.Name
-		}
 	} // end for
 
 	if idFieldColName != "" && len(table.PrimaryKeys) == 0 {
@@ -1097,19 +1110,39 @@ func (engine *Engine) idOfV(rv reflect.Value) (core.PK, error) {
 
 	pk := make([]interface{}, len(table.PrimaryKeys))
 	for i, col := range table.PKColumns() {
+		var err error
 		pkField := v.FieldByName(col.FieldName)
 		switch pkField.Kind() {
 		case reflect.String:
-			pk[i] = pkField.String()
+			pk[i], err = engine.idTypeAssertion(col, pkField.String())
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			pk[i] = pkField.Int()
+			pk[i], err = engine.idTypeAssertion(col, strconv.FormatInt(pkField.Int(), 10))
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			pk[i] = pkField.Uint()
+			// id of uint will be converted to int64
+			pk[i], err = engine.idTypeAssertion(col, strconv.FormatUint(pkField.Uint(), 10))
+		}
+
+		if err != nil {
+			return nil, err
 		}
 	}
 	return core.PK(pk), nil
 }
 
+func (engine *Engine) idTypeAssertion(col *core.Column, sid string) (interface{}, error) {
+	if col.SQLType.IsNumeric() {
+		n, err := strconv.ParseInt(sid, 10, 64)
+		if err != nil {
+			return nil, err
+		}
+		return n, nil
+	} else if col.SQLType.IsText() {
+		return sid, nil
+	} else {
+		return nil, errors.New("not supported")
+	}
+}
+
 // CreateIndexes create indexes
 func (engine *Engine) CreateIndexes(bean interface{}) error {
 	session := engine.NewSession()
@@ -1181,6 +1214,9 @@ func (engine *Engine) ClearCache(beans ...interface{}) error {
 // table, column, index, unique. but will not delete or change anything.
 // If you change some field, you should change the database manually.
 func (engine *Engine) Sync(beans ...interface{}) error {
+	session := engine.NewSession()
+	defer session.Close()
+
 	for _, bean := range beans {
 		v := rValue(bean)
 		tableName := engine.tbName(v)
@@ -1189,14 +1225,12 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 			return err
 		}
 
-		s := engine.NewSession()
+		isExist, err := session.Table(bean).isTableExist(tableName)
-		defer s.Close()
-		isExist, err := s.Table(bean).isTableExist(tableName)
 		if err != nil {
 			return err
 		}
 		if !isExist {
-			err = engine.CreateTables(bean)
+			err = session.createTable(bean)
 			if err != nil {
 				return err
 			}
@@ -1207,11 +1241,11 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 		  }*/
 		var isEmpty bool
 		if isEmpty {
-			err = engine.DropTables(bean)
+			err = session.dropTable(bean)
 			if err != nil {
 				return err
 			}
-			err = engine.CreateTables(bean)
+			err = session.createTable(bean)
 			if err != nil {
 				return err
 			}
@@ -1222,9 +1256,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 					return err
 				}
 				if !isExist {
-					session := engine.NewSession()
+					if err := session.statement.setRefValue(v); err != nil {
-					defer session.Close()
-					if err := session.Statement.setRefValue(v); err != nil {
 						return err
 					}
 					err = session.addColumn(col.Name)
@@ -1235,21 +1267,16 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 			}
 
 			for name, index := range table.Indexes {
-				session := engine.NewSession()
+				if err := session.statement.setRefValue(v); err != nil {
-				defer session.Close()
-				if err := session.Statement.setRefValue(v); err != nil {
 					return err
 				}
 				if index.Type == core.UniqueType {
-					//isExist, err := session.isIndexExist(table.Name, name, true)
 					isExist, err := session.isIndexExist2(tableName, index.Cols, true)
 					if err != nil {
 						return err
 					}
 					if !isExist {
-						session := engine.NewSession()
+						if err := session.statement.setRefValue(v); err != nil {
-						defer session.Close()
-						if err := session.Statement.setRefValue(v); err != nil {
 							return err
 						}
 
@@ -1264,9 +1291,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
 						return err
 					}
 					if !isExist {
-						session := engine.NewSession()
+						if err := session.statement.setRefValue(v); err != nil {
-						defer session.Close()
-						if err := session.Statement.setRefValue(v); err != nil {
 							return err
 						}
 
@@ -1291,23 +1316,6 @@ func (engine *Engine) Sync2(beans ...interface{}) error {
 	return s.Sync2(beans...)
 }
 
-// Drop all mapped table
-func (engine *Engine) dropAll() error {
-	session := engine.NewSession()
-	defer session.Close()
-
-	err := session.Begin()
-	if err != nil {
-		return err
-	}
-	err = session.dropAll()
-	if err != nil {
-		session.Rollback()
-		return err
-	}
-	return session.Commit()
-}
-
 // CreateTables create tabls according bean
 func (engine *Engine) CreateTables(beans ...interface{}) error {
 	session := engine.NewSession()
@@ -1319,7 +1327,7 @@ func (engine *Engine) CreateTables(beans ...interface{}) error {
 	}
 
 	for _, bean := range beans {
-		err = session.CreateTable(bean)
+		err = session.createTable(bean)
 		if err != nil {
 			session.Rollback()
 			return err
@@ -1339,7 +1347,7 @@ func (engine *Engine) DropTables(beans ...interface{}) error {
 	}
 
 	for _, bean := range beans {
-		err = session.DropTable(bean)
+		err = session.dropTable(bean)
 		if err != nil {
 			session.Rollback()
 			return err
@@ -1348,10 +1356,11 @@ func (engine *Engine) DropTables(beans ...interface{}) error {
 	return session.Commit()
 }
 
-func (engine *Engine) createAll() error {
+// DropIndexes drop indexes of a table
+func (engine *Engine) DropIndexes(bean interface{}) error {
 	session := engine.NewSession()
 	defer session.Close()
-	return session.createAll()
+	return session.DropIndexes(bean)
 }
 
 // Exec raw sql
@@ -1416,6 +1425,13 @@ func (engine *Engine) Get(bean interface{}) (bool, error) {
 	return session.Get(bean)
 }
 
+// Exist returns true if the record exist otherwise return false
+func (engine *Engine) Exist(bean ...interface{}) (bool, error) {
+	session := engine.NewSession()
+	defer session.Close()
+	return session.Exist(bean...)
+}
+
 // Find retrieve records from table, condiBeans's non-empty fields
 // are conditions. beans could be []Struct, []*Struct, map[int64]Struct
 // map[int64]*Struct
@@ -1441,10 +1457,10 @@ func (engine *Engine) Rows(bean interface{}) (*Rows, error) {
 }
 
 // Count counts the records. bean's non-empty fields are conditions.
-func (engine *Engine) Count(bean interface{}) (int64, error) {
+func (engine *Engine) Count(bean ...interface{}) (int64, error) {
 	session := engine.NewSession()
 	defer session.Close()
-	return session.Count(bean)
+	return session.Count(bean...)
 }
 
 // Sum sum the records by some column. bean's non-empty fields are conditions.
@@ -1454,6 +1470,13 @@ func (engine *Engine) Sum(bean interface{}, colName string) (float64, error) {
 	return session.Sum(bean, colName)
 }
 
+// SumInt sum the records by some column. bean's non-empty fields are conditions.
+func (engine *Engine) SumInt(bean interface{}, colName string) (int64, error) {
+	session := engine.NewSession()
+	defer session.Close()
+	return session.SumInt(bean, colName)
+}
+
 // Sums sum the records by some columns. bean's non-empty fields are conditions.
 func (engine *Engine) Sums(bean interface{}, colNames ...string) ([]float64, error) {
 	session := engine.NewSession()
@@ -1509,7 +1532,6 @@ func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
 			results = append(results, result)
 			if err != nil {
 				return nil, err
-				//lastError = err
 			}
 		}
 	}
@@ -1517,49 +1539,28 @@ func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
 	return results, lastError
 }
 
-// TZTime change one time to xorm time location
-func (engine *Engine) TZTime(t time.Time) time.Time {
-	if !t.IsZero() { // if time is not initialized it's not suitable for Time.In()
-		return t.In(engine.TZLocation)
-	}
-	return t
-}
-
-// NowTime return current time
-func (engine *Engine) NowTime(sqlTypeName string) interface{} {
-	t := time.Now()
-	return engine.FormatTime(sqlTypeName, t)
-}
-
 // NowTime2 return current time
 func (engine *Engine) NowTime2(sqlTypeName string) (interface{}, time.Time) {
 	t := time.Now()
-	return engine.FormatTime(sqlTypeName, t), t
+	return engine.formatTime(sqlTypeName, t.In(engine.DatabaseTZ)), t.In(engine.TZLocation)
-}
-
-// FormatTime format time
-func (engine *Engine) FormatTime(sqlTypeName string, t time.Time) (v interface{}) {
-	return engine.formatTime(engine.TZLocation, sqlTypeName, t)
 }
 
 func (engine *Engine) formatColTime(col *core.Column, t time.Time) (v interface{}) {
-	if col.DisableTimeZone {
+	if t.IsZero() {
-		return engine.formatTime(nil, col.SQLType.Name, t)
+		if col.Nullable {
-	} else if col.TimeZone != nil {
+			return nil
-		return engine.formatTime(col.TimeZone, col.SQLType.Name, t)
 		}
-	return engine.formatTime(engine.TZLocation, col.SQLType.Name, t)
+		return ""
 	}
 
-func (engine *Engine) formatTime(tz *time.Location, sqlTypeName string, t time.Time) (v interface{}) {
+	if col.TimeZone != nil {
-	if engine.dialect.DBType() == core.ORACLE {
+		return engine.formatTime(col.SQLType.Name, t.In(col.TimeZone))
-		return t
 	}
-	if tz != nil {
+	return engine.formatTime(col.SQLType.Name, t.In(engine.DatabaseTZ))
-		t = t.In(tz)
-	} else {
-		t = engine.TZTime(t)
 }
+
+// formatTime format time as column type
+func (engine *Engine) formatTime(sqlTypeName string, t time.Time) (v interface{}) {
 	switch sqlTypeName {
 	case core.Time:
 		s := t.Format("2006-01-02 15:04:05") //time.RFC3339
@@ -1567,18 +1568,10 @@ func (engine *Engine) formatTime(tz *time.Location, sqlTypeName string, t time.T
 	case core.Date:
 		v = t.Format("2006-01-02")
 	case core.DateTime, core.TimeStamp:
-		if engine.dialect.DBType() == "ql" {
-			v = t
-		} else if engine.dialect.DBType() == "sqlite3" {
-			v = t.UTC().Format("2006-01-02 15:04:05")
-		} else {
 		v = t.Format("2006-01-02 15:04:05")
-		}
 	case core.TimeStampz:
 		if engine.dialect.DBType() == core.MSSQL {
 			v = t.Format("2006-01-02T15:04:05.9999999Z07:00")
-		} else if engine.DriverName() == "mssql" {
-			v = t
 		} else {
 			v = t.Format(time.RFC3339Nano)
 		}
@@ -1593,6 +1586,14 @@ func (engine *Engine) formatTime(tz *time.Location, sqlTypeName string, t time.T
 // Unscoped always disable struct tag "deleted"
 func (engine *Engine) Unscoped() *Session {
 	session := engine.NewSession()
-	session.IsAutoClose = true
+	session.isAutoClose = true
 	return session.Unscoped()
 }
+
+// CondDeleted returns the conditions whether a record is soft deleted.
+func (engine *Engine) CondDeleted(colName string) builder.Cond {
+	if engine.dialect.DBType() == core.MSSQL {
+		return builder.IsNull{colName}
+	}
+	return builder.IsNull{colName}.Or(builder.Eq{colName: zeroTime1})
+}

vendor/github.com/go-xorm/xorm/engine_cond.go

@@ -0,0 +1,230 @@
+// Copyright 2017 The Xorm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xorm
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/go-xorm/builder"
+	"github.com/go-xorm/core"
+)
+
+func (engine *Engine) buildConds(table *core.Table, bean interface{},
+	includeVersion bool, includeUpdated bool, includeNil bool,
+	includeAutoIncr bool, allUseBool bool, useAllCols bool, unscoped bool,
+	mustColumnMap map[string]bool, tableName, aliasName string, addedTableName bool) (builder.Cond, error) {
+	var conds []builder.Cond
+	for _, col := range table.Columns() {
+		if !includeVersion && col.IsVersion {
+			continue
+		}
+		if !includeUpdated && col.IsUpdated {
+			continue
+		}
+		if !includeAutoIncr && col.IsAutoIncrement {
+			continue
+		}
+
+		if engine.dialect.DBType() == core.MSSQL && (col.SQLType.Name == core.Text || col.SQLType.IsBlob() || col.SQLType.Name == core.TimeStampz) {
+			continue
+		}
+		if col.SQLType.IsJson() {
+			continue
+		}
+
+		var colName string
+		if addedTableName {
+			var nm = tableName
+			if len(aliasName) > 0 {
+				nm = aliasName
+			}
+			colName = engine.Quote(nm) + "." + engine.Quote(col.Name)
+		} else {
+			colName = engine.Quote(col.Name)
+		}
+
+		fieldValuePtr, err := col.ValueOf(bean)
+		if err != nil {
+			engine.logger.Error(err)
+			continue
+		}
+
+		if col.IsDeleted && !unscoped { // tag "deleted" is enabled
+			conds = append(conds, engine.CondDeleted(colName))
+		}
+
+		fieldValue := *fieldValuePtr
+		if fieldValue.Interface() == nil {
+			continue
+		}
+
+		fieldType := reflect.TypeOf(fieldValue.Interface())
+		requiredField := useAllCols
+
+		if b, ok := getFlagForColumn(mustColumnMap, col); ok {
+			if b {
+				requiredField = true
+			} else {
+				continue
+			}
+		}
+
+		if fieldType.Kind() == reflect.Ptr {
+			if fieldValue.IsNil() {
+				if includeNil {
+					conds = append(conds, builder.Eq{colName: nil})
+				}
+				continue
+			} else if !fieldValue.IsValid() {
+				continue
+			} else {
+				// dereference ptr type to instance type
+				fieldValue = fieldValue.Elem()
+				fieldType = reflect.TypeOf(fieldValue.Interface())
+				requiredField = true
+			}
+		}
+
+		var val interface{}
+		switch fieldType.Kind() {
+		case reflect.Bool:
+			if allUseBool || requiredField {
+				val = fieldValue.Interface()
+			} else {
+				// if a bool in a struct, it will not be as a condition because it default is false,
+				// please use Where() instead
+				continue
+			}
+		case reflect.String:
+			if !requiredField && fieldValue.String() == "" {
+				continue
+			}
+			// for MyString, should convert to string or panic
+			if fieldType.String() != reflect.String.String() {
+				val = fieldValue.String()
+			} else {
+				val = fieldValue.Interface()
+			}
+		case reflect.Int8, reflect.Int16, reflect.Int, reflect.Int32, reflect.Int64:
+			if !requiredField && fieldValue.Int() == 0 {
+				continue
+			}
+			val = fieldValue.Interface()
+		case reflect.Float32, reflect.Float64:
+			if !requiredField && fieldValue.Float() == 0.0 {
+				continue
+			}
+			val = fieldValue.Interface()
+		case reflect.Uint8, reflect.Uint16, reflect.Uint, reflect.Uint32, reflect.Uint64:
+			if !requiredField && fieldValue.Uint() == 0 {
+				continue
+			}
+			t := int64(fieldValue.Uint())
+			val = reflect.ValueOf(&t).Interface()
+		case reflect.Struct:
+			if fieldType.ConvertibleTo(core.TimeType) {
+				t := fieldValue.Convert(core.TimeType).Interface().(time.Time)
+				if !requiredField && (t.IsZero() || !fieldValue.IsValid()) {
+					continue
+				}
+				val = engine.formatColTime(col, t)
+			} else if _, ok := reflect.New(fieldType).Interface().(core.Conversion); ok {
+				continue
+			} else if valNul, ok := fieldValue.Interface().(driver.Valuer); ok {
+				val, _ = valNul.Value()
+				if val == nil {
+					continue
+				}
+			} else {
+				if col.SQLType.IsJson() {
+					if col.SQLType.IsText() {
+						bytes, err := json.Marshal(fieldValue.Interface())
+						if err != nil {
+							engine.logger.Error(err)
+							continue
+						}
+						val = string(bytes)
+					} else if col.SQLType.IsBlob() {
+						var bytes []byte
+						var err error
+						bytes, err = json.Marshal(fieldValue.Interface())
+						if err != nil {
+							engine.logger.Error(err)
+							continue
+						}
+						val = bytes
+					}
+				} else {
+					engine.autoMapType(fieldValue)
+					if table, ok := engine.Tables[fieldValue.Type()]; ok {
+						if len(table.PrimaryKeys) == 1 {
+							pkField := reflect.Indirect(fieldValue).FieldByName(table.PKColumns()[0].FieldName)
+							// fix non-int pk issues
+							//if pkField.Int() != 0 {
+							if pkField.IsValid() && !isZero(pkField.Interface()) {
+								val = pkField.Interface()
+							} else {
+								continue
+							}
+						} else {
+							//TODO: how to handler?
+							return nil, fmt.Errorf("not supported %v as %v", fieldValue.Interface(), table.PrimaryKeys)
+						}
+					} else {
+						val = fieldValue.Interface()
+					}
+				}
+			}
+		case reflect.Array:
+			continue
+		case reflect.Slice, reflect.Map:
+			if fieldValue == reflect.Zero(fieldType) {
+				continue
+			}
+			if fieldValue.IsNil() || !fieldValue.IsValid() || fieldValue.Len() == 0 {
+				continue
+			}
+
+			if col.SQLType.IsText() {
+				bytes, err := json.Marshal(fieldValue.Interface())
+				if err != nil {
+					engine.logger.Error(err)
+					continue
+				}
+				val = string(bytes)
+			} else if col.SQLType.IsBlob() {
+				var bytes []byte
+				var err error
+				if (fieldType.Kind() == reflect.Array || fieldType.Kind() == reflect.Slice) &&
+					fieldType.Elem().Kind() == reflect.Uint8 {
+					if fieldValue.Len() > 0 {
+						val = fieldValue.Bytes()
+					} else {
+						continue
+					}
+				} else {
+					bytes, err = json.Marshal(fieldValue.Interface())
+					if err != nil {
+						engine.logger.Error(err)
+						continue
+					}
+					val = bytes
+				}
+			} else {
+				continue
+			}
+		default:
+			val = fieldValue.Interface()
+		}
+
+		conds = append(conds, builder.Eq{colName: val})
+	}
+
+	return builder.And(conds...), nil
+}

vendor/github.com/go-xorm/xorm/engine_maxlife.go

@@ -0,0 +1,14 @@
+// Copyright 2017 The Xorm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.6
+
+package xorm
+
+import "time"
+
+// SetConnMaxLifetime sets the maximum amount of time a connection may be reused.
+func (engine *Engine) SetConnMaxLifetime(d time.Duration) {
+	engine.db.SetConnMaxLifetime(d)
+}

vendor/github.com/go-xorm/xorm/helpers.go

@@ -196,26 +196,44 @@ func isArrayValueZero(v reflect.Value) bool {
 
 func int64ToIntValue(id int64, tp reflect.Type) reflect.Value {
 	var v interface{}
-	switch tp.Kind() {
+	kind := tp.Kind()
-	case reflect.Int16:
+
-		v = int16(id)
+	if kind == reflect.Ptr {
-	case reflect.Int32:
+		kind = tp.Elem().Kind()
-		v = int32(id)
-	case reflect.Int:
-		v = int(id)
-	case reflect.Int64:
-		v = id
-	case reflect.Uint16:
-		v = uint16(id)
-	case reflect.Uint32:
-		v = uint32(id)
-	case reflect.Uint64:
-		v = uint64(id)
-	case reflect.Uint:
-		v = uint(id)
 	}
+
+	switch kind {
+	case reflect.Int16:
+		temp := int16(id)
+		v = &temp
+	case reflect.Int32:
+		temp := int32(id)
+		v = &temp
+	case reflect.Int:
+		temp := int(id)
+		v = &temp
+	case reflect.Int64:
+		temp := id
+		v = &temp
+	case reflect.Uint16:
+		temp := uint16(id)
+		v = &temp
+	case reflect.Uint32:
+		temp := uint32(id)
+		v = &temp
+	case reflect.Uint64:
+		temp := uint64(id)
+		v = &temp
+	case reflect.Uint:
+		temp := uint(id)
+		v = &temp
+	}
+
+	if tp.Kind() == reflect.Ptr {
 		return reflect.ValueOf(v).Convert(tp)
 	}
+	return reflect.ValueOf(v).Elem().Convert(tp)
+}
 
 func int64ToInt(id int64, tp reflect.Type) interface{} {
 	return int64ToIntValue(id, tp).Interface()
@@ -302,175 +320,6 @@ func sliceEq(left, right []string) bool {
 	return true
 }
 
-func reflect2value(rawValue *reflect.Value) (str string, err error) {
-	aa := reflect.TypeOf((*rawValue).Interface())
-	vv := reflect.ValueOf((*rawValue).Interface())
-	switch aa.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		str = strconv.FormatInt(vv.Int(), 10)
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		str = strconv.FormatUint(vv.Uint(), 10)
-	case reflect.Float32, reflect.Float64:
-		str = strconv.FormatFloat(vv.Float(), 'f', -1, 64)
-	case reflect.String:
-		str = vv.String()
-	case reflect.Array, reflect.Slice:
-		switch aa.Elem().Kind() {
-		case reflect.Uint8:
-			data := rawValue.Interface().([]byte)
-			str = string(data)
-		default:
-			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
-		}
-	// time type
-	case reflect.Struct:
-		if aa.ConvertibleTo(core.TimeType) {
-			str = vv.Convert(core.TimeType).Interface().(time.Time).Format(time.RFC3339Nano)
-		} else {
-			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
-		}
-	case reflect.Bool:
-		str = strconv.FormatBool(vv.Bool())
-	case reflect.Complex128, reflect.Complex64:
-		str = fmt.Sprintf("%v", vv.Complex())
-	/* TODO: unsupported types below
-	   case reflect.Map:
-	   case reflect.Ptr:
-	   case reflect.Uintptr:
-	   case reflect.UnsafePointer:
-	   case reflect.Chan, reflect.Func, reflect.Interface:
-	*/
-	default:
-		err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
-	}
-	return
-}
-
-func value2Bytes(rawValue *reflect.Value) (data []byte, err error) {
-	var str string
-	str, err = reflect2value(rawValue)
-	if err != nil {
-		return
-	}
-	data = []byte(str)
-	return
-}
-
-func value2String(rawValue *reflect.Value) (data string, err error) {
-	data, err = reflect2value(rawValue)
-	if err != nil {
-		return
-	}
-	return
-}
-
-func rows2Strings(rows *core.Rows) (resultsSlice []map[string]string, err error) {
-	fields, err := rows.Columns()
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		result, err := row2mapStr(rows, fields)
-		if err != nil {
-			return nil, err
-		}
-		resultsSlice = append(resultsSlice, result)
-	}
-
-	return resultsSlice, nil
-}
-
-func rows2maps(rows *core.Rows) (resultsSlice []map[string][]byte, err error) {
-	fields, err := rows.Columns()
-	if err != nil {
-		return nil, err
-	}
-	for rows.Next() {
-		result, err := row2map(rows, fields)
-		if err != nil {
-			return nil, err
-		}
-		resultsSlice = append(resultsSlice, result)
-	}
-
-	return resultsSlice, nil
-}
-
-func row2map(rows *core.Rows, fields []string) (resultsMap map[string][]byte, err error) {
-	result := make(map[string][]byte)
-	scanResultContainers := make([]interface{}, len(fields))
-	for i := 0; i < len(fields); i++ {
-		var scanResultContainer interface{}
-		scanResultContainers[i] = &scanResultContainer
-	}
-	if err := rows.Scan(scanResultContainers...); err != nil {
-		return nil, err
-	}
-
-	for ii, key := range fields {
-		rawValue := reflect.Indirect(reflect.ValueOf(scanResultContainers[ii]))
-		//if row is null then ignore
-		if rawValue.Interface() == nil {
-			//fmt.Println("ignore ...", key, rawValue)
-			continue
-		}
-
-		if data, err := value2Bytes(&rawValue); err == nil {
-			result[key] = data
-		} else {
-			return nil, err // !nashtsai! REVIEW, should return err or just error log?
-		}
-	}
-	return result, nil
-}
-
-func row2mapStr(rows *core.Rows, fields []string) (resultsMap map[string]string, err error) {
-	result := make(map[string]string)
-	scanResultContainers := make([]interface{}, len(fields))
-	for i := 0; i < len(fields); i++ {
-		var scanResultContainer interface{}
-		scanResultContainers[i] = &scanResultContainer
-	}
-	if err := rows.Scan(scanResultContainers...); err != nil {
-		return nil, err
-	}
-
-	for ii, key := range fields {
-		rawValue := reflect.Indirect(reflect.ValueOf(scanResultContainers[ii]))
-		//if row is null then ignore
-		if rawValue.Interface() == nil {
-			//fmt.Println("ignore ...", key, rawValue)
-			continue
-		}
-
-		if data, err := value2String(&rawValue); err == nil {
-			result[key] = data
-		} else {
-			return nil, err // !nashtsai! REVIEW, should return err or just error log?
-		}
-	}
-	return result, nil
-}
-
-func txQuery2(tx *core.Tx, sqlStr string, params ...interface{}) ([]map[string]string, error) {
-	rows, err := tx.Query(sqlStr, params...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	return rows2Strings(rows)
-}
-
-func query2(db *core.DB, sqlStr string, params ...interface{}) ([]map[string]string, error) {
-	rows, err := db.Query(sqlStr, params...)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	return rows2Strings(rows)
-}
-
 func setColumnInt(bean interface{}, col *core.Column, t int64) {
 	v, err := col.ValueOf(bean)
 	if err != nil {
@@ -509,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
 			}
 		}
@@ -537,6 +386,10 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
 				if len(fieldValue.String()) == 0 {
 					continue
 				}
+			case reflect.Ptr:
+				if fieldValue.Pointer() == 0 {
+					continue
+				}
 			}
 		}
 
@@ -544,28 +397,32 @@ func genCols(table *core.Table, session *Session, bean interface{}, useCol bool,
 			continue
 		}
 
-		if session.Statement.ColumnStr != "" {
+		if session.statement.ColumnStr != "" {
-			if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+			if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
+				continue
+			} else if _, ok := session.statement.incrColumns[col.Name]; ok {
+				continue
+			} else if _, ok := session.statement.decrColumns[col.Name]; ok {
 				continue
 			}
 		}
-		if session.Statement.OmitStr != "" {
+		if session.statement.OmitStr != "" {
-			if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+			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
@@ -573,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)
@@ -584,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)
 		}

vendor/github.com/go-xorm/xorm/helpler_time.go

@@ -0,0 +1,21 @@
+// Copyright 2017 The Xorm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xorm
+
+import "time"
+
+const (
+	zeroTime0 = "0000-00-00 00:00:00"
+	zeroTime1 = "0001-01-01 00:00:00"
+)
+
+func formatTime(t time.Time) string {
+	return t.Format("2006-01-02 15:04:05")
+}
+
+func isTimeZero(t time.Time) bool {
+	return t.IsZero() || formatTime(t) == zeroTime0 ||
+		formatTime(t) == zeroTime1
+}

vendor/github.com/go-xorm/xorm/rows.go

@@ -33,28 +33,31 @@ func newRows(session *Session, bean interface{}) (*Rows, error) {
 
 	var sqlStr string
 	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 == "" {
+	if rows.session.statement.RawSQL == "" {
-		sqlStr, args = rows.session.Statement.genGetSQL(bean)
+		sqlStr, args, err = rows.session.statement.genGetSQL(bean)
+		if err != nil {
+			return nil, err
+		}
 	} else {
-		sqlStr = rows.session.Statement.RawSQL
+		sqlStr = rows.session.statement.RawSQL
-		args = rows.session.Statement.RawParams
+		args = rows.session.statement.RawParams
 	}
 
-	for _, filter := range rows.session.Engine.dialect.Filters() {
+	for _, filter := range rows.session.engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, rows.session.Statement.RefTable)
+		sqlStr = filter.Do(sqlStr, session.engine.dialect, rows.session.statement.RefTable)
 	}
 
 	rows.session.saveLastSQL(sqlStr, args...)
-	var err error
 	if rows.session.prepareStmt {
 		rows.stmt, err = rows.session.DB().Prepare(sqlStr)
 		if err != nil {
@@ -116,17 +119,22 @@ 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
 	}
-	_, err := rows.session.row2Bean(rows.rows, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.Statement.RefTable)
 
+	scanResults, err := rows.session.row2Slice(rows.rows, rows.fields, len(rows.fields), bean)
+	if err != nil {
+		return err
+	}
+
+	_, 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()
 	}
 

vendor/github.com/go-xorm/xorm/session.go

@@ -21,16 +21,16 @@ import (
 // kind of database operations.
 type Session struct {
 	db                     *core.DB
-	Engine                 *Engine
+	engine                 *Engine
-	Tx                     *core.Tx
+	tx                     *core.Tx
-	Statement              Statement
+	statement              Statement
-	IsAutoCommit           bool
+	isAutoCommit           bool
-	IsCommitedOrRollbacked bool
+	isCommitedOrRollbacked bool
-	IsAutoClose            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{})
@@ -48,6 +48,8 @@ type Session struct {
 	//beforeSQLExec func(string, ...interface{})
 	lastSQL     string
 	lastSQLArgs []interface{}
+
+	err error
 }
 
 // Clone copy all the session's content and return a new session
@@ -58,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.Init()
-	session.Statement.Engine = session.Engine
+	session.statement.Engine = session.engine
-	session.IsAutoCommit = true
+	session.isAutoCommit = true
-	session.IsCommitedOrRollbacked = false
+	session.isCommitedOrRollbacked = false
-	session.IsAutoClose = false
+	session.isAutoClose = false
-	session.AutoResetStatement = true
+	session.autoResetStatement = true
 	session.prepareStmt = false
 
 	// !nashtsai! is lazy init better?
@@ -86,19 +88,23 @@ 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.Init()
 		session.db = nil
 	}
 }
 
+// IsClosed returns if session is closed
+func (session *Session) IsClosed() bool {
+	return session.db == nil
+}
+
 func (session *Session) resetStatement() {
-	if session.AutoResetStatement {
+	if session.autoResetStatement {
-		session.Statement.Init()
+		session.statement.Init()
 	}
 }
 
@@ -126,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
 }
@@ -202,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
@@ -240,13 +246,13 @@ func cleanupProcessorsClosures(slices *[]func(interface{})) {
 }
 
 func (session *Session) canCache() bool {
-	if session.Statement.RefTable == nil ||
+	if session.statement.RefTable == nil ||
-		session.Statement.JoinStr != "" ||
+		session.statement.JoinStr != "" ||
-		session.Statement.RawSQL != "" ||
+		session.statement.RawSQL != "" ||
-		!session.Statement.UseCache ||
+		!session.statement.UseCache ||
-		session.Statement.IsForUpdate ||
+		session.statement.IsForUpdate ||
-		session.Tx != nil ||
+		session.tx != nil ||
-		len(session.Statement.selectStr) > 0 {
+		len(session.statement.selectStr) > 0 {
 		return false
 	}
 	return true
@@ -270,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
@@ -297,7 +303,12 @@ func (session *Session) rows2Beans(rows *core.Rows, fields []string, fieldsCount
 		var newValue = newElemFunc(fields)
 		bean := newValue.Interface()
 		dataStruct := rValue(bean)
-		pk, err := session.row2Bean(rows, fields, fieldsCount, bean, &dataStruct, table)
+		// handle beforeClosures
+		scanResults, err := session.row2Slice(rows, fields, fieldsCount, bean)
+		if err != nil {
+			return err
+		}
+		pk, err := session.slice2Bean(scanResults, fields, fieldsCount, bean, &dataStruct, table)
 		if err != nil {
 			return err
 		}
@@ -310,8 +321,7 @@ func (session *Session) rows2Beans(rows *core.Rows, fields []string, fieldsCount
 	return nil
 }
 
-func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount int, bean interface{}, dataStruct *reflect.Value, table *core.Table) (core.PK, error) {
+func (session *Session) row2Slice(rows *core.Rows, fields []string, fieldsCount int, bean interface{}) ([]interface{}, error) {
-	// handle beforeClosures
 	for _, closure := range session.beforeClosures {
 		closure(bean)
 	}
@@ -330,7 +340,10 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 			b.BeforeSet(key, Cell(scanResults[ii].(*interface{})))
 		}
 	}
+	return scanResults, nil
+}
 
+func (session *Session) slice2Bean(scanResults []interface{}, fields []string, fieldsCount int, bean interface{}, dataStruct *reflect.Value, table *core.Table) (core.PK, error) {
 	defer func() {
 		if b, hasAfterSet := bean.(AfterSetProcessor); hasAfterSet {
 			for ii, key := range fields {
@@ -344,15 +357,6 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 		}
 	}()
 
-	dbTZ := session.Engine.DatabaseTZ
-	if dbTZ == nil {
-		if session.Engine.dialect.DBType() == core.SQLITE {
-			dbTZ = time.UTC
-		} else {
-			dbTZ = time.Local
-		}
-	}
-
 	var tempMap = make(map[string]int)
 	var pk core.PK
 	for ii, key := range fields {
@@ -528,11 +532,9 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 				}
 			case reflect.Struct:
 				if fieldType.ConvertibleTo(core.TimeType) {
-					var tz *time.Location
+					dbTZ := session.engine.DatabaseTZ
-					if col.TimeZone == nil {
+					if col.TimeZone != nil {
-						tz = session.Engine.TZLocation
+						dbTZ = col.TimeZone
-					} else {
-						tz = col.TimeZone
 					}
 
 					if rawValueType == core.TimeType {
@@ -543,26 +545,25 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 						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)
 						}
 
-						// !nashtsai! convert to engine location
+						t = t.In(session.engine.TZLocation)
-						t = t.In(tz)
 						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(tz)
+						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))
@@ -571,20 +572,20 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 							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))
 							}
 						} else {
-							panic(fmt.Sprintf("rawValueType is %v, value is %v", rawValueType, vv.Interface()))
+							return nil, fmt.Errorf("rawValueType is %v, value is %v", rawValueType, vv.Interface())
 						}
 					}
 				} else if nulVal, ok := fieldValue.Addr().Interface().(sql.Scanner); ok {
 					// !<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() {
@@ -609,15 +610,15 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 							fieldValue.Set(x.Elem())
 						}
 					}
-				} else if session.Statement.UseCascade {
+				} else if session.statement.UseCascade {
-					table, err := session.Engine.autoMapType(*fieldValue)
+					table, err := session.engine.autoMapType(*fieldValue)
 					if err != nil {
 						return nil, err
 					}
 
 					hasAssigned = true
 					if len(table.PrimaryKeys) != 1 {
-						panic("unsupported non or composited primary key cascade")
+						return nil, errors.New("unsupported non or composited primary key cascade")
 					}
 					var pk = make(core.PK, len(table.PrimaryKeys))
 					pk[0], err = asKind(vv, rawValueType)
@@ -630,9 +631,9 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 						// 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())
+						has, err := newsession.ID(pk).NoCascade().Get(structInter.Interface())
 						if err != nil {
 							return nil, err
 						}
@@ -777,8 +778,8 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 }
 
 func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) {
-	for _, filter := range session.Engine.dialect.Filters() {
+	for _, filter := range session.engine.dialect.Filters() {
-		*sqlStr = filter.Do(*sqlStr, session.Engine.dialect, session.Statement.RefTable)
+		*sqlStr = filter.Do(*sqlStr, session.engine.dialect, session.statement.RefTable)
 	}
 
 	session.saveLastSQL(*sqlStr, paramStr...)
@@ -788,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
@@ -798,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 {
+	if len(session.statement.AltTableName) > 0 {
-		return session.Statement.AltTableName
+		return session.statement.AltTableName
 	}
 
 	return table.Name
@@ -807,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
 }

vendor/github.com/go-xorm/xorm/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
 }

vendor/github.com/go-xorm/xorm/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
+// Conds returns session query conditions except auto bean conditions
 func (session *Session) Conds() builder.Cond {
-	return session.Statement.cond
+	return session.statement.cond
 }

vendor/github.com/go-xorm/xorm/session_convert.go

@@ -23,41 +23,38 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
 	var x time.Time
 	var err error
 
-	if sdata == "0000-00-00 00:00:00" ||
+	var parseLoc = session.engine.DatabaseTZ
-		sdata == "0001-01-01 00:00:00" {
+	if col.TimeZone != nil {
+		parseLoc = col.TimeZone
+	}
+
+	if sdata == zeroTime0 || sdata == zeroTime1 {
 	} else if !strings.ContainsAny(sdata, "- :") { // !nashtsai! has only found that mymysql driver is using this for time type column
 		// time stamp
 		sd, err := strconv.ParseInt(sdata, 10, 64)
 		if err == nil {
 			x = time.Unix(sd, 0)
-			// !nashtsai! HACK mymysql driver is causing Local location being change to CHAT and cause wrong time conversion
+			session.engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
-			if col.TimeZone == nil {
-				x = x.In(session.Engine.TZLocation)
 		} else {
-				x = x.In(col.TimeZone)
+			session.engine.logger.Debugf("time(0) err 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)
 		}
 	} else if len(sdata) > 19 && strings.Contains(sdata, "-") {
-		x, err = time.ParseInLocation(time.RFC3339Nano, sdata, session.Engine.TZLocation)
+		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, session.Engine.TZLocation)
+			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, session.Engine.TZLocation)
+			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, session.Engine.TZLocation)
+		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, session.Engine.TZLocation)
+		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, " ")
@@ -65,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, session.Engine.TZLocation)
+		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
@@ -80,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
+	outTime = x.In(session.engine.TZLocation)
 	return
 }
 
@@ -108,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())
@@ -122,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())
@@ -135,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())
@@ -159,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 {
@@ -207,16 +204,17 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
 				}
 				v = x
 				fieldValue.Set(reflect.ValueOf(v).Convert(fieldType))
-			} else if session.Statement.UseCascade {
+			} else if session.statement.UseCascade {
-				table, err := session.Engine.autoMapType(*fieldValue)
+				table, err := session.engine.autoMapType(*fieldValue)
 				if err != nil {
 					return err
 				}
 
 				// TODO: current only support 1 primary key
 				if len(table.PrimaryKeys) > 1 {
-					panic("unsupported composited primary key cascade")
+					return errors.New("unsupported composited primary key cascade")
 				}
+
 				var pk = make(core.PK, len(table.PrimaryKeys))
 				rawValueType := table.ColumnType(table.PKColumns()[0].FieldName)
 				pk[0], err = str2PK(string(data), rawValueType)
@@ -229,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 {
@@ -266,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))
@@ -277,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))
@@ -349,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 {
@@ -374,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 {
@@ -402,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 {
@@ -430,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 {
@@ -458,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 {
@@ -490,16 +488,17 @@ 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
 					}
 
 					if len(table.PrimaryKeys) > 1 {
-						panic("unsupported composited primary key cascade")
+						return errors.New("unsupported composited primary key cascade")
 					}
+
 					var pk = make(core.PK, len(table.PrimaryKeys))
 					rawValueType := table.ColumnType(table.PKColumns()[0].FieldName)
 					pk[0], err = str2PK(string(data), rawValueType)
@@ -511,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 {
@@ -570,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
@@ -588,12 +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)
-			if session.Engine.dialect.DBType() == core.MSSQL {
+			tf := session.engine.formatColTime(col, t)
-				if t.IsZero() {
-					return nil, nil
-				}
-			}
-			tf := session.Engine.FormatTime(col.SQLType.Name, t)
 			return tf, nil
 		}
 
@@ -603,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
 			}
@@ -617,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
@@ -633,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
@@ -645,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
@@ -658,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
 				}
 			}

vendor/github.com/go-xorm/xorm/session_delete.go

@@ -13,22 +13,22 @@ import (
 )
 
 func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
-	if session.Statement.RefTable == nil ||
+	if session.statement.RefTable == nil ||
-		session.Tx != nil {
+		session.tx != nil {
 		return ErrCacheFailed
 	}
 
-	for _, filter := range session.Engine.dialect.Filters() {
+	for _, filter := range session.engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+		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)
+	cacher := session.engine.getCacher2(session.statement.RefTable)
-	tableName := session.Statement.TableName()
+	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,13 +98,15 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 		processor.BeforeDelete()
 	}
 
-	// --
+	condSQL, condArgs, err := session.statement.genConds(bean)
-	condSQL, condArgs, _ := session.Statement.genConds(bean)
+	if err != nil {
-	if len(condSQL) == 0 && session.Statement.LimitN == 0 {
+		return 0, err
+	}
+	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)
@@ -113,15 +115,15 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
 	}
 
 	var orderSQL string
-	if len(session.Statement.OrderStr) > 0 {
+	if len(session.statement.OrderStr) > 0 {
-		orderSQL += fmt.Sprintf(" ORDER BY %s", session.Statement.OrderStr)
+		orderSQL += fmt.Sprintf(" ORDER BY %s", session.statement.OrderStr)
 	}
-	if session.Statement.LimitN > 0 {
+	if session.statement.LimitN > 0 {
-		orderSQL += fmt.Sprintf(" LIMIT %d", session.Statement.LimitN)
+		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 {
@@ -146,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...)
@@ -157,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(session.statement.TableName()),
-			session.Engine.Quote(deletedColumn.Name),
+			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 {
@@ -185,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
@@ -200,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...)
 	}
 
@@ -210,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)
 		}

vendor/github.com/go-xorm/xorm/session_exist.go

@@ -0,0 +1,87 @@
+// Copyright 2017 The Xorm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xorm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+
+	"github.com/go-xorm/builder"
+	"github.com/go-xorm/core"
+)
+
+// Exist returns true if the record exist otherwise return false
+func (session *Session) Exist(bean ...interface{}) (bool, error) {
+	defer session.resetStatement()
+	if session.isAutoClose {
+		defer session.Close()
+	}
+
+	var sqlStr string
+	var args []interface{}
+	var err error
+
+	if session.statement.RawSQL == "" {
+		if len(bean) == 0 {
+			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 err != nil {
+					return false, err
+				}
+
+				sqlStr = fmt.Sprintf("SELECT * FROM %s WHERE %s LIMIT 1", tableName, condSQL)
+				args = condArgs
+			} else {
+				sqlStr = fmt.Sprintf("SELECT * FROM %s LIMIT 1", tableName)
+				args = []interface{}{}
+			}
+		} else {
+			beanValue := reflect.ValueOf(bean[0])
+			if beanValue.Kind() != reflect.Ptr {
+				return false, errors.New("needs a pointer")
+			}
+
+			if beanValue.Elem().Kind() == reflect.Struct {
+				if err := session.statement.setRefValue(beanValue.Elem()); err != nil {
+					return false, err
+				}
+			}
+
+			if len(session.statement.TableName()) <= 0 {
+				return false, ErrTableNotFound
+			}
+			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
+	}
+
+	session.queryPreprocess(&sqlStr, args...)
+
+	var rawRows *core.Rows
+	if session.isAutoCommit {
+		_, rawRows, err = session.innerQuery(sqlStr, args...)
+	} else {
+		rawRows, err = session.tx.Query(sqlStr, args...)
+	}
+	if err != nil {
+		return false, err
+	}
+
+	defer rawRows.Close()
+
+	return rawRows.Next(), nil
+}

vendor/github.com/go-xorm/xorm/session_find.go

@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
-	"strconv"
 	"strings"
 
 	"github.com/go-xorm/builder"
@@ -25,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()
 	}
 
@@ -37,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 {
@@ -49,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 {
@@ -57,61 +56,59 @@ 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 {
-				panic(err)
+				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
+			if col := table.DeletedColumn(); col != nil && !session.statement.unscoped { // tag "deleted" is enabled
-				var colName = session.Engine.Quote(col.Name)
+				var colName = session.engine.Quote(col.Name)
 				if addedTableName {
-					var nm = session.Statement.TableName()
+					var nm = session.statement.TableName()
-					if len(session.Statement.TableAlias) > 0 {
+					if len(session.statement.TableAlias) > 0 {
-						nm = session.Statement.TableAlias
+						nm = session.statement.TableAlias
 					}
-					colName = session.Engine.Quote(nm) + "." + colName
+					colName = session.engine.Quote(nm) + "." + colName
-				}
-				if session.Engine.dialect.DBType() == core.MSSQL {
-					autoCond = builder.IsNull{colName}
-				} else {
-					autoCond = builder.IsNull{colName}.Or(builder.Eq{colName: "0001-01-01 00:00:00"})
 				}
+
+				autoCond = session.engine.CondDeleted(colName)
 			}
 		}
 	}
 
 	var sqlStr string
 	var args []interface{}
-	if session.Statement.RawSQL == "" {
+	var err error
-		if len(session.Statement.TableName()) <= 0 {
+	if session.statement.RawSQL == "" {
+		if len(session.statement.TableName()) <= 0 {
 			return ErrTableNotFound
 		}
 
-		var columnStr = session.Statement.ColumnStr
+		var columnStr = session.statement.ColumnStr
-		if len(session.Statement.selectStr) > 0 {
+		if len(session.statement.selectStr) > 0 {
-			columnStr = session.Statement.selectStr
+			columnStr = session.statement.selectStr
 		} else {
-			if session.Statement.JoinStr == "" {
+			if session.statement.JoinStr == "" {
 				if columnStr == "" {
-					if session.Statement.GroupByStr != "" {
+					if session.statement.GroupByStr != "" {
-						columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1))
+						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 != "" {
+					if session.statement.GroupByStr != "" {
-						columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1))
+						columnStr = session.statement.Engine.Quote(strings.Replace(session.statement.GroupByStr, ",", session.engine.Quote(","), -1))
 					} else {
 						columnStr = "*"
 					}
@@ -122,31 +119,37 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{})
 			}
 		}
 
-		condSQL, condArgs, _ := builder.ToSQL(session.Statement.cond.And(autoCond))
+		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...)
+		args = append(session.statement.joinArgs, condArgs...)
-		sqlStr = session.Statement.genSelectSQL(columnStr, condSQL)
+		sqlStr, err = session.statement.genSelectSQL(columnStr, condSQL)
+		if err != nil {
+			return err
+		}
 		// for mssql and use limit
 		qs := strings.Count(sqlStr, "?")
 		if len(args)*2 == qs {
 			args = append(args, args...)
 		}
 	} else {
-		sqlStr = session.Statement.RawSQL
+		sqlStr = session.statement.RawSQL
-		args = session.Statement.RawParams
+		args = session.statement.RawParams
 	}
 
-	var err error
 	if session.canCache() {
-		if cacher := session.Engine.getCacher2(table); cacher != nil &&
+		if cacher := session.engine.getCacher2(table); cacher != nil &&
-			!session.Statement.IsDistinct &&
+			!session.statement.IsDistinct &&
-			!session.Statement.unscoped {
+			!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")
 		}
 	}
 
@@ -158,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
@@ -238,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
 		}
@@ -286,19 +289,19 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 		return ErrCacheFailed
 	}
 
-	for _, filter := range session.Engine.dialect.Filters() {
+	for _, filter := range session.engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+		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
+	table := session.statement.RefTable
-	cacher := session.Engine.getCacher2(table)
+	cacher := session.engine.getCacher2(table)
 	ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
 	if err != nil {
 		rows, err := session.DB().Query(newsql, args...)
@@ -312,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))
@@ -320,32 +323,24 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
 			if err != nil {
 				return err
 			}
-
 			var pk core.PK = make([]interface{}, len(table.PrimaryKeys))
 			for i, col := range table.PKColumns() {
-				if col.SQLType.IsNumeric() {
+				pk[i], err = session.engine.idTypeAssertion(col, res[i])
-					n, err := strconv.ParseInt(res[i], 10, 64)
 				if err != nil {
 					return err
 				}
-					pk[i] = n
-				} else if col.SQLType.IsText() {
-					pk[i] = res[i]
-				} else {
-					return errors.New("not supported")
-				}
 			}
 
 			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))
@@ -364,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
@@ -381,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))
@@ -415,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
 			}
@@ -426,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)
 		}
 	}
@@ -434,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
 		}

vendor/github.com/go-xorm/xorm/session_get.go

@@ -16,38 +16,44 @@ 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()
 	}
 
 	beanValue := reflect.ValueOf(bean)
 	if beanValue.Kind() != reflect.Ptr {
-		return false, errors.New("needs a pointer")
+		return false, errors.New("needs a pointer to a value")
+	} else if beanValue.Elem().Kind() == reflect.Ptr {
+		return false, errors.New("a pointer to a pointer is not allowed")
 	}
 
 	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
 		}
 	}
 
 	var sqlStr string
 	var args []interface{}
+	var err error
 
-	if session.Statement.RawSQL == "" {
+	if session.statement.RawSQL == "" {
-		if len(session.Statement.TableName()) <= 0 {
+		if len(session.statement.TableName()) <= 0 {
 			return false, ErrTableNotFound
 		}
-		session.Statement.Limit(1)
+		session.statement.Limit(1)
-		sqlStr, args = session.Statement.genGetSQL(bean)
+		sqlStr, args, err = session.statement.genGetSQL(bean)
+		if err != nil {
+			return false, err
+		}
 	} else {
-		sqlStr = session.Statement.RawSQL
+		sqlStr = session.statement.RawSQL
-		args = session.Statement.RawParams
+		args = session.statement.RawParams
 	}
 
 	if session.canCache() && beanValue.Elem().Kind() == reflect.Struct {
-		if cacher := session.Engine.getCacher2(session.Statement.RefTable); cacher != nil &&
+		if cacher := session.engine.getCacher2(session.statement.RefTable); cacher != nil &&
-			!session.Statement.unscoped {
+			!session.statement.unscoped {
 			has, err := session.cacheGet(bean, sqlStr, args...)
 			if err != ErrCacheFailed {
 				return has, err
@@ -63,10 +69,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
@@ -74,7 +80,10 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
 
 	defer rawRows.Close()
 
-	if rawRows.Next() {
+	if !rawRows.Next() {
+		return false, nil
+	}
+
 	switch beanKind {
 	case reflect.Struct:
 		fields, err := rawRows.Columns()
@@ -83,10 +92,17 @@ 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
 		}
-			_, err = session.row2Bean(rawRows, fields, len(fields), bean, &dataStruct, session.Statement.RefTable)
+
+		scanResults, err := session.row2Slice(rawRows, fields, len(fields), bean)
+		if err != nil {
+			return false, err
+		}
+		rawRows.Close()
+
+		_, err = session.slice2Bean(scanResults, fields, len(fields), bean, &dataStruct, session.statement.RefTable)
 	case reflect.Slice:
 		err = rawRows.ScanSlice(bean)
 	case reflect.Map:
@@ -97,8 +113,6 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
 
 	return true, err
 }
-	return false, nil
-}
 
 func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interface{}) (has bool, err error) {
 	// if has no reftable, then don't use cache currently
@@ -106,19 +120,19 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
 		return false, ErrCacheFailed
 	}
 
-	for _, filter := range session.Engine.dialect.Filters() {
+	for _, filter := range session.engine.dialect.Filters() {
-		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+		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)
+	cacher := session.engine.getCacher2(session.statement.RefTable)
-	tableName := session.Statement.TableName()
+	tableName := session.statement.TableName()
-	session.Engine.logger.Debug("[cacheGet] find sql:", newsql, args)
+	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...)
@@ -152,19 +166,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
@@ -177,10 +191,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)))

vendor/github.com/go-xorm/xorm/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(sliceValue.Index(0)); 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 session.statement.ColumnStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
 						continue
 					}
 				}
-				if session.Statement.OmitStr != "" {
+				if session.statement.OmitStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
 						continue
 					}
 				}
-				if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime {
+				if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
-					val, t := session.Engine.NowTime2(col.SQLType.Name)
+					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 session.statement.ColumnStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
 						continue
 					}
 				}
-				if session.Statement.OmitStr != "" {
+				if session.statement.OmitStr != "" {
-					if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+					if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
 						continue
 					}
 				}
-				if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime {
+				if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
-					val, t := session.Engine.NowTime2(col.SQLType.Name)
+					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.Quote(session.statement.TableName()),
-			session.Engine.QuoteStr(),
+			session.engine.QuoteStr(),
-			strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
+			strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
-			session.Engine.QuoteStr())
+			session.engine.QuoteStr())
 		statement = fmt.Sprintf(sql,
-			session.Engine.Quote(session.Statement.TableName()),
+			session.engine.Quote(session.statement.TableName()),
-			session.Engine.QuoteStr(),
+			session.engine.QuoteStr(),
-			strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
+			strings.Join(colNames, session.engine.QuoteStr()+", "+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.Quote(session.statement.TableName()),
-			session.Engine.QuoteStr(),
+			session.engine.QuoteStr(),
-			strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
+			strings.Join(colNames, session.engine.QuoteStr()+", "+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 {
+	if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
-		session.cacheInsert(session.Statement.TableName())
+		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
@@ -343,18 +343,29 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 	if len(exprColVals) > 0 {
 		colPlaces = colPlaces + strings.Join(exprColVals, ", ")
 	} else {
+		if len(colPlaces) > 0 {
 			colPlaces = colPlaces[0 : len(colPlaces)-2]
 		}
+	}
 
-	sqlStr := fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)",
+	var sqlStr string
-		session.Engine.Quote(session.Statement.TableName()),
+	if len(colPlaces) > 0 {
-		session.Engine.QuoteStr(),
+		sqlStr = fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)",
-		strings.Join(colNames, session.Engine.Quote(", ")),
+			session.engine.Quote(session.statement.TableName()),
-		session.Engine.QuoteStr(),
+			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()))
+		} else {
+			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)
 			}
@@ -383,8 +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 {
-		//assert table.AutoIncrement != ""
 		res, err := session.query("select seq_atable.currval from dual", args...)
 		if err != nil {
 			return 0, err
@@ -392,14 +402,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 		handleAfterInsertProcessorFunc(bean)
 
-		if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
-			session.cacheInsert(session.Statement.TableName())
+			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)
 			}
@@ -417,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() {
@@ -427,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 {
@@ -437,14 +447,14 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		}
 		handleAfterInsertProcessorFunc(bean)
 
-		if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
-			session.cacheInsert(session.Statement.TableName())
+			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)
 			}
@@ -462,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() {
@@ -480,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 {
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
-			session.cacheInsert(session.Statement.TableName())
+			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)
 			}
@@ -505,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() {
@@ -523,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()
 	}
 
@@ -531,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
+	table := session.statement.RefTable
-	cacher := session.Engine.getCacher2(table)
+	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)
 	}
 

vendor/github.com/go-xorm/xorm/session_raw.go

@@ -6,6 +6,10 @@ package xorm
 
 import (
 	"database/sql"
+	"fmt"
+	"reflect"
+	"strconv"
+	"time"
 
 	"github.com/go-xorm/core"
 )
@@ -13,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) {
@@ -52,13 +56,67 @@ 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
 	}
 	return stmt, rows, nil
 }
 
+func rows2maps(rows *core.Rows) (resultsSlice []map[string][]byte, err error) {
+	fields, err := rows.Columns()
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		result, err := row2map(rows, fields)
+		if err != nil {
+			return nil, err
+		}
+		resultsSlice = append(resultsSlice, result)
+	}
+
+	return resultsSlice, nil
+}
+
+func value2Bytes(rawValue *reflect.Value) (data []byte, err error) {
+	var str string
+	str, err = reflect2value(rawValue)
+	if err != nil {
+		return
+	}
+	data = []byte(str)
+	return
+}
+
+func row2map(rows *core.Rows, fields []string) (resultsMap map[string][]byte, err error) {
+	result := make(map[string][]byte)
+	scanResultContainers := make([]interface{}, len(fields))
+	for i := 0; i < len(fields); i++ {
+		var scanResultContainer interface{}
+		scanResultContainers[i] = &scanResultContainer
+	}
+	if err := rows.Scan(scanResultContainers...); err != nil {
+		return nil, err
+	}
+
+	for ii, key := range fields {
+		rawValue := reflect.Indirect(reflect.ValueOf(scanResultContainers[ii]))
+		//if row is null then ignore
+		if rawValue.Interface() == nil {
+			//fmt.Println("ignore ...", key, rawValue)
+			continue
+		}
+
+		if data, err := value2Bytes(&rawValue); err == nil {
+			result[key] = data
+		} else {
+			return nil, err // !nashtsai! REVIEW, should return err or just error log?
+		}
+	}
+	return result, nil
+}
+
 func (session *Session) innerQuery2(sqlStr string, params ...interface{}) ([]map[string][]byte, error) {
 	_, rows, err := session.innerQuery(sqlStr, params...)
 	if rows != nil {
@@ -73,26 +131,141 @@ 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()
 	}
 
 	return session.query(sqlStr, paramStr...)
 }
 
+func rows2Strings(rows *core.Rows) (resultsSlice []map[string]string, err error) {
+	fields, err := rows.Columns()
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		result, err := row2mapStr(rows, fields)
+		if err != nil {
+			return nil, err
+		}
+		resultsSlice = append(resultsSlice, result)
+	}
+
+	return resultsSlice, nil
+}
+
+func reflect2value(rawValue *reflect.Value) (str string, err error) {
+	aa := reflect.TypeOf((*rawValue).Interface())
+	vv := reflect.ValueOf((*rawValue).Interface())
+	switch aa.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		str = strconv.FormatInt(vv.Int(), 10)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		str = strconv.FormatUint(vv.Uint(), 10)
+	case reflect.Float32, reflect.Float64:
+		str = strconv.FormatFloat(vv.Float(), 'f', -1, 64)
+	case reflect.String:
+		str = vv.String()
+	case reflect.Array, reflect.Slice:
+		switch aa.Elem().Kind() {
+		case reflect.Uint8:
+			data := rawValue.Interface().([]byte)
+			str = string(data)
+		default:
+			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
+		}
+	// time type
+	case reflect.Struct:
+		if aa.ConvertibleTo(core.TimeType) {
+			str = vv.Convert(core.TimeType).Interface().(time.Time).Format(time.RFC3339Nano)
+		} else {
+			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
+		}
+	case reflect.Bool:
+		str = strconv.FormatBool(vv.Bool())
+	case reflect.Complex128, reflect.Complex64:
+		str = fmt.Sprintf("%v", vv.Complex())
+	/* TODO: unsupported types below
+	   case reflect.Map:
+	   case reflect.Ptr:
+	   case reflect.Uintptr:
+	   case reflect.UnsafePointer:
+	   case reflect.Chan, reflect.Func, reflect.Interface:
+	*/
+	default:
+		err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
+	}
+	return
+}
+
+func value2String(rawValue *reflect.Value) (data string, err error) {
+	data, err = reflect2value(rawValue)
+	if err != nil {
+		return
+	}
+	return
+}
+
+func row2mapStr(rows *core.Rows, fields []string) (resultsMap map[string]string, err error) {
+	result := make(map[string]string)
+	scanResultContainers := make([]interface{}, len(fields))
+	for i := 0; i < len(fields); i++ {
+		var scanResultContainer interface{}
+		scanResultContainers[i] = &scanResultContainer
+	}
+	if err := rows.Scan(scanResultContainers...); err != nil {
+		return nil, err
+	}
+
+	for ii, key := range fields {
+		rawValue := reflect.Indirect(reflect.ValueOf(scanResultContainers[ii]))
+		//if row is null then ignore
+		if rawValue.Interface() == nil {
+			//fmt.Println("ignore ...", key, rawValue)
+			continue
+		}
+
+		if data, err := value2String(&rawValue); err == nil {
+			result[key] = data
+		} else {
+			return nil, err // !nashtsai! REVIEW, should return err or just error log?
+		}
+	}
+	return result, nil
+}
+
+func txQuery2(tx *core.Tx, sqlStr string, params ...interface{}) ([]map[string]string, error) {
+	rows, err := tx.Query(sqlStr, params...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	return rows2Strings(rows)
+}
+
+func query2(db *core.DB, sqlStr string, params ...interface{}) ([]map[string]string, error) {
+	rows, err := db.Query(sqlStr, params...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	return rows2Strings(rows)
+}
+
 // 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
@@ -114,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) {
+	return session.engine.logSQLExecutionTime(sqlStr, args, func() (sql.Result, error) {
-		if session.IsAutoCommit {
+		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()
 	}
 

vendor/github.com/go-xorm/xorm/session_schema.go

@@ -17,41 +17,52 @@ import (
 // Ping test if database is ok
 func (session *Session) Ping() error {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	if session.isAutoClose {
 		defer session.Close()
 	}
 
+	session.engine.logger.Infof("PING DATABASE %v", session.engine.DriverName())
 	return session.DB().Ping()
 }
 
 // CreateTable create a table according a bean
 func (session *Session) CreateTable(bean interface{}) error {
-	v := rValue(bean)
+	if session.isAutoClose {
-	if err := session.Statement.setRefValue(v); err != nil {
-		return err
-	}
-
-	defer session.resetStatement()
-	if session.IsAutoClose {
 		defer session.Close()
 	}
 
-	return session.createOneTable()
+	return session.createTable(bean)
+}
+
+func (session *Session) createTable(bean interface{}) error {
+	defer session.resetStatement()
+	v := rValue(bean)
+	if err := session.statement.setRefValue(v); err != nil {
+		return err
+	}
+
+	sqlStr := session.statement.genCreateTableSQL()
+	_, err := session.exec(sqlStr)
+	return err
 }
 
 // CreateIndexes create indexes
 func (session *Session) CreateIndexes(bean interface{}) error {
-	v := rValue(bean)
+	if session.isAutoClose {
-	if err := session.Statement.setRefValue(v); err != nil {
-		return err
-	}
-
-	defer session.resetStatement()
-	if session.IsAutoClose {
 		defer session.Close()
 	}
 
-	sqls := session.Statement.genIndexSQL()
+	return session.createIndexes(bean)
+}
+
+func (session *Session) createIndexes(bean interface{}) error {
+	defer session.resetStatement()
+	v := rValue(bean)
+	if err := session.statement.setRefValue(v); err != nil {
+		return err
+	}
+
+	sqls := session.statement.genIndexSQL()
 	for _, sqlStr := range sqls {
 		_, err := session.exec(sqlStr)
 		if err != nil {
@@ -63,17 +74,20 @@ func (session *Session) CreateIndexes(bean interface{}) error {
 
 // CreateUniques create uniques
 func (session *Session) CreateUniques(bean interface{}) error {
+	if session.isAutoClose {
+		defer session.Close()
+	}
+	return session.createUniques(bean)
+}
+
+func (session *Session) createUniques(bean interface{}) error {
+	defer session.resetStatement()
 	v := rValue(bean)
-	if err := session.Statement.setRefValue(v); err != nil {
+	if err := session.statement.setRefValue(v); err != nil {
 		return err
 	}
 
-	defer session.resetStatement()
+	sqls := session.statement.genUniqueSQL()
-	if session.IsAutoClose {
-		defer session.Close()
-	}
-
-	sqls := session.Statement.genUniqueSQL()
 	for _, sqlStr := range sqls {
 		_, err := session.exec(sqlStr)
 		if err != nil {
@@ -83,43 +97,23 @@ func (session *Session) CreateUniques(bean interface{}) error {
 	return nil
 }
 
-func (session *Session) createOneTable() error {
-	sqlStr := session.Statement.genCreateTableSQL()
-	_, err := session.exec(sqlStr)
-	return err
-}
-
-// to be deleted
-func (session *Session) createAll() error {
-	if session.IsAutoClose {
-		defer session.Close()
-	}
-
-	for _, table := range session.Engine.Tables {
-		session.Statement.RefTable = table
-		session.Statement.tableName = table.Name
-		err := session.createOneTable()
-		session.resetStatement()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // DropIndexes drop indexes
 func (session *Session) DropIndexes(bean interface{}) error {
-	v := rValue(bean)
+	if session.isAutoClose {
-	if err := session.Statement.setRefValue(v); err != nil {
-		return err
-	}
-
-	defer session.resetStatement()
-	if session.IsAutoClose {
 		defer session.Close()
 	}
 
-	sqls := session.Statement.genDelIndexSQL()
+	return session.dropIndexes(bean)
+}
+
+func (session *Session) dropIndexes(bean interface{}) error {
+	defer session.resetStatement()
+	v := rValue(bean)
+	if err := session.statement.setRefValue(v); err != nil {
+		return err
+	}
+
+	sqls := session.statement.genDelIndexSQL()
 	for _, sqlStr := range sqls {
 		_, err := session.exec(sqlStr)
 		if err != nil {
@@ -131,14 +125,23 @@ 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)
+	if session.isAutoClose {
+		defer session.Close()
+	}
+
+	return session.dropTable(beanOrTableName)
+}
+
+func (session *Session) dropTable(beanOrTableName interface{}) error {
+	defer session.resetStatement()
+	tableName, err := session.engine.tableName(beanOrTableName)
 	if err != nil {
 		return err
 	}
 
 	var needDrop = true
-	if !session.Engine.dialect.SupportDropIfExists() {
+	if !session.engine.dialect.SupportDropIfExists() {
-		sqlStr, args := session.Engine.dialect.TableCheckSql(tableName)
+		sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
 		results, err := session.query(sqlStr, args...)
 		if err != nil {
 			return err
@@ -147,7 +150,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
 	}
@@ -156,7 +159,11 @@ 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)
+	if session.isAutoClose {
+		defer session.Close()
+	}
+
+	tableName, err := session.engine.tableName(beanOrTableName)
 	if err != nil {
 		return false, err
 	}
@@ -166,10 +173,7 @@ func (session *Session) IsTableExist(beanOrTableName interface{}) (bool, error)
 
 func (session *Session) isTableExist(tableName string) (bool, error) {
 	defer session.resetStatement()
-	if session.IsAutoClose {
+	sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
-		defer session.Close()
-	}
-	sqlStr, args := session.Engine.dialect.TableCheckSql(tableName)
 	results, err := session.query(sqlStr, args...)
 	return len(results) > 0, err
 }
@@ -180,6 +184,9 @@ func (session *Session) IsTableEmpty(bean interface{}) (bool, error) {
 	t := v.Type()
 
 	if t.Kind() == reflect.String {
+		if session.isAutoClose {
+			defer session.Close()
+		}
 		return session.isTableEmpty(bean.(string))
 	} else if t.Kind() == reflect.Struct {
 		rows, err := session.Count(bean)
@@ -190,12 +197,9 @@ func (session *Session) IsTableEmpty(bean interface{}) (bool, error) {
 
 func (session *Session) isTableEmpty(tableName string) (bool, error) {
 	defer session.resetStatement()
-	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 {
@@ -208,30 +212,11 @@ func (session *Session) isTableEmpty(tableName string) (bool, error) {
 	return total == 0, nil
 }
 
-func (session *Session) isIndexExist(tableName, idxName string, unique bool) (bool, error) {
-	defer session.resetStatement()
-	if session.IsAutoClose {
-		defer session.Close()
-	}
-	var idx string
-	if unique {
-		idx = uniqueName(tableName, idxName)
-	} else {
-		idx = indexName(tableName, idxName)
-	}
-	sqlStr, args := session.Engine.dialect.IndexCheckSql(tableName, idx)
-	results, err := session.query(sqlStr, args...)
-	return len(results) > 0, err
-}
-
 // 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 {
-		defer session.Close()
-	}
 
-	indexes, err := session.Engine.dialect.GetIndexes(tableName)
+	indexes, err := session.engine.dialect.GetIndexes(tableName)
 	if err != nil {
 		return false, err
 	}
@@ -249,23 +234,18 @@ func (session *Session) isIndexExist2(tableName string, cols []string, unique bo
 
 func (session *Session) addColumn(colName string) error {
 	defer session.resetStatement()
-	if session.IsAutoClose {
-		defer session.Close()
-	}
 
-	col := session.Statement.RefTable.GetColumn(colName)
+	col := session.statement.RefTable.GetColumn(colName)
-	sql, args := session.Statement.genAddColumnStr(col)
+	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 {
+
-		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
@@ -273,37 +253,21 @@ func (session *Session) addIndex(tableName, idxName string) error {
 
 func (session *Session) addUnique(tableName, uqeName string) error {
 	defer session.resetStatement()
-	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
 }
 
-// To be deleted
-func (session *Session) dropAll() error {
-	defer session.resetStatement()
-	if session.IsAutoClose {
-		defer session.Close()
-	}
-
-	for _, table := range session.Engine.Tables {
-		session.Statement.Init()
-		session.Statement.RefTable = table
-		sqlStr := session.Engine.Dialect().DropTableSql(session.Statement.TableName())
-		_, err := session.exec(sqlStr)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // Sync2 synchronize structs to database tables
 func (session *Session) Sync2(beans ...interface{}) error {
-	engine := session.Engine
+	engine := session.engine
+
+	if session.isAutoClose {
+		session.isAutoClose = false
+		defer session.Close()
+	}
 
 	tables, err := engine.DBMetas()
 	if err != nil {
@@ -330,17 +294,17 @@ 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
 			}
 
-			err = session.CreateUniques(bean)
+			err = session.createUniques(bean)
 			if err != nil {
 				return err
 			}
 
-			err = session.CreateIndexes(bean)
+			err = session.createIndexes(bean)
 			if err != nil {
 				return err
 			}
@@ -365,7 +329,7 @@ func (session *Session) Sync2(beans ...interface{}) error {
 								engine.dialect.DBType() == core.POSTGRES {
 								engine.logger.Infof("Table %s column %s change type from %s to %s\n",
 									tbName, col.Name, curType, expectedType)
-								_, err = engine.Exec(engine.dialect.ModifyColumnSql(table.Name, col))
+								_, err = session.exec(engine.dialect.ModifyColumnSql(table.Name, col))
 							} else {
 								engine.logger.Warnf("Table %s column %s db type is %s, struct type is %s\n",
 									tbName, col.Name, curType, expectedType)
@@ -375,7 +339,7 @@ func (session *Session) Sync2(beans ...interface{}) error {
 								if oriCol.Length < col.Length {
 									engine.logger.Infof("Table %s column %s change type from varchar(%d) to varchar(%d)\n",
 										tbName, col.Name, oriCol.Length, col.Length)
-									_, err = engine.Exec(engine.dialect.ModifyColumnSql(table.Name, col))
+									_, err = session.exec(engine.dialect.ModifyColumnSql(table.Name, col))
 								}
 							}
 						} else {
@@ -389,7 +353,7 @@ func (session *Session) Sync2(beans ...interface{}) error {
 							if oriCol.Length < col.Length {
 								engine.logger.Infof("Table %s column %s change type from varchar(%d) to varchar(%d)\n",
 									tbName, col.Name, oriCol.Length, col.Length)
-								_, err = engine.Exec(engine.dialect.ModifyColumnSql(table.Name, col))
+								_, err = session.exec(engine.dialect.ModifyColumnSql(table.Name, col))
 							}
 						}
 					}
@@ -402,10 +366,8 @@ func (session *Session) Sync2(beans ...interface{}) error {
 							tbName, col.Name, oriCol.Nullable, col.Nullable)
 					}
 				} else {
-					session := engine.NewSession()
+					session.statement.RefTable = table
-					session.Statement.RefTable = table
+					session.statement.tableName = tbName
-					session.Statement.tableName = tbName
-					defer session.Close()
 					err = session.addColumn(col.Name)
 				}
 				if err != nil {
@@ -429,7 +391,7 @@ func (session *Session) Sync2(beans ...interface{}) error {
 				if oriIndex != nil {
 					if oriIndex.Type != index.Type {
 						sql := engine.dialect.DropIndexSql(tbName, oriIndex)
-						_, err = engine.Exec(sql)
+						_, err = session.exec(sql)
 						if err != nil {
 							return err
 						}
@@ -445,7 +407,7 @@ func (session *Session) Sync2(beans ...interface{}) error {
 			for name2, index2 := range oriTable.Indexes {
 				if _, ok := foundIndexNames[name2]; !ok {
 					sql := engine.dialect.DropIndexSql(tbName, index2)
-					_, err = engine.Exec(sql)
+					_, err = session.exec(sql)
 					if err != nil {
 						return err
 					}
@@ -454,16 +416,12 @@ 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.RefTable = table
+					session.statement.tableName = tbName
-					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.RefTable = table
+					session.statement.tableName = tbName
-					session.Statement.tableName = tbName
-					defer session.Close()
 					err = session.addIndex(tbName, name)
 				}
 				if err != nil {

vendor/github.com/go-xorm/xorm/session_stats.go

@@ -0,0 +1,118 @@
+// Copyright 2016 The Xorm Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package xorm
+
+import (
+	"database/sql"
+	"errors"
+	"reflect"
+)
+
+// Count counts the records. bean's non-empty fields
+// are conditions.
+func (session *Session) Count(bean ...interface{}) (int64, error) {
+	defer session.resetStatement()
+	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 err != nil {
+			return 0, err
+		}
+	} else {
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
+	}
+
+	session.queryPreprocess(&sqlStr, args...)
+
+	var total int64
+	if session.isAutoCommit {
+		err = session.DB().QueryRow(sqlStr, args...).Scan(&total)
+	} else {
+		err = session.tx.QueryRow(sqlStr, args...).Scan(&total)
+	}
+
+	if err == sql.ErrNoRows || err == nil {
+		return total, nil
+	}
+
+	return 0, err
+}
+
+// sum call sum some column. bean's non-empty fields are conditions.
+func (session *Session) sum(res interface{}, bean interface{}, columnNames ...string) error {
+	defer session.resetStatement()
+	if session.isAutoClose {
+		defer session.Close()
+	}
+
+	v := reflect.ValueOf(res)
+	if v.Kind() != reflect.Ptr {
+		return errors.New("need a pointer to a variable")
+	}
+
+	var isSlice = v.Elem().Kind() == reflect.Slice
+	var sqlStr string
+	var args []interface{}
+	var err error
+	if len(session.statement.RawSQL) == 0 {
+		sqlStr, args, err = session.statement.genSumSQL(bean, columnNames...)
+		if err != nil {
+			return err
+		}
+	} else {
+		sqlStr = session.statement.RawSQL
+		args = session.statement.RawParams
+	}
+
+	session.queryPreprocess(&sqlStr, args...)
+
+	if isSlice {
+		if session.isAutoCommit {
+			err = session.DB().QueryRow(sqlStr, args...).ScanSlice(res)
+		} else {
+			err = session.tx.QueryRow(sqlStr, args...).ScanSlice(res)
+		}
+	} else {
+		if session.isAutoCommit {
+			err = session.DB().QueryRow(sqlStr, args...).Scan(res)
+		} else {
+			err = session.tx.QueryRow(sqlStr, args...).Scan(res)
+		}
+	}
+
+	if err == sql.ErrNoRows || err == nil {
+		return nil
+	}
+	return err
+}
+
+// Sum call sum some column. bean's non-empty fields are conditions.
+func (session *Session) Sum(bean interface{}, columnName string) (res float64, err error) {
+	return res, session.sum(&res, bean, columnName)
+}
+
+// SumInt call sum some column. bean's non-empty fields are conditions.
+func (session *Session) SumInt(bean interface{}, columnName string) (res int64, err error) {
+	return res, session.sum(&res, bean, columnName)
+}
+
+// Sums call sum some columns. bean's non-empty fields are conditions.
+func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64, error) {
+	var res = make([]float64, len(columnNames), len(columnNames))
+	return res, session.sum(&res, bean, columnNames...)
+}
+
+// SumsInt sum specify columns and return as []int64 instead of []float64
+func (session *Session) SumsInt(bean interface{}, columnNames ...string) ([]int64, error) {
+	var res = make([]int64, len(columnNames), len(columnNames))
+	return res, session.sum(&res, bean, columnNames...)
+}

vendor/github.com/go-xorm/xorm/session_sum.go

@@ -1,137 +0,0 @@
-// Copyright 2016 The Xorm Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package xorm
-
-import "database/sql"
-
-// Count counts the records. bean's non-empty fields
-// are conditions.
-func (session *Session) Count(bean interface{}) (int64, error) {
-	defer session.resetStatement()
-	if session.IsAutoClose {
-		defer session.Close()
-	}
-
-	var sqlStr string
-	var args []interface{}
-	if session.Statement.RawSQL == "" {
-		sqlStr, args = session.Statement.genCountSQL(bean)
-	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
-	}
-
-	session.queryPreprocess(&sqlStr, args...)
-
-	var err error
-	var total int64
-	if session.IsAutoCommit {
-		err = session.DB().QueryRow(sqlStr, args...).Scan(&total)
-	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).Scan(&total)
-	}
-
-	if err == sql.ErrNoRows || err == nil {
-		return total, nil
-	}
-
-	return 0, err
-}
-
-// 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 {
-		defer session.Close()
-	}
-
-	var sqlStr string
-	var args []interface{}
-	if len(session.Statement.RawSQL) == 0 {
-		sqlStr, args = session.Statement.genSumSQL(bean, columnName)
-	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
-	}
-
-	session.queryPreprocess(&sqlStr, args...)
-
-	var err error
-	var res float64
-	if session.IsAutoCommit {
-		err = session.DB().QueryRow(sqlStr, args...).Scan(&res)
-	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).Scan(&res)
-	}
-
-	if err == sql.ErrNoRows || err == nil {
-		return res, nil
-	}
-	return 0, err
-}
-
-// 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 {
-		defer session.Close()
-	}
-
-	var sqlStr string
-	var args []interface{}
-	if len(session.Statement.RawSQL) == 0 {
-		sqlStr, args = session.Statement.genSumSQL(bean, columnNames...)
-	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
-	}
-
-	session.queryPreprocess(&sqlStr, args...)
-
-	var err error
-	var res = make([]float64, len(columnNames), len(columnNames))
-	if session.IsAutoCommit {
-		err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res)
-	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).ScanSlice(&res)
-	}
-
-	if err == sql.ErrNoRows || err == nil {
-		return res, nil
-	}
-	return nil, err
-}
-
-// 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 {
-		defer session.Close()
-	}
-
-	var sqlStr string
-	var args []interface{}
-	if len(session.Statement.RawSQL) == 0 {
-		sqlStr, args = session.Statement.genSumSQL(bean, columnNames...)
-	} else {
-		sqlStr = session.Statement.RawSQL
-		args = session.Statement.RawParams
-	}
-
-	session.queryPreprocess(&sqlStr, args...)
-
-	var err error
-	var res = make([]int64, len(columnNames), len(columnNames))
-	if session.IsAutoCommit {
-		err = session.DB().QueryRow(sqlStr, args...).ScanSlice(&res)
-	} else {
-		err = session.Tx.QueryRow(sqlStr, args...).ScanSlice(&res)
-	}
-
-	if err == sql.ErrNoRows || err == nil {
-		return res, nil
-	}
-	return nil, err
-}

vendor/github.com/go-xorm/xorm/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.isAutoCommit = false
-		session.IsCommitedOrRollbacked = false
+		session.isCommitedOrRollbacked = false
-		session.Tx = tx
+		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 {
+	if !session.isAutoCommit && !session.isCommitedOrRollbacked {
-		session.saveLastSQL(session.Engine.dialect.RollBackStr())
+		session.saveLastSQL(session.engine.dialect.RollBackStr())
-		session.IsCommitedOrRollbacked = true
+		session.isCommitedOrRollbacked = true
-		return session.Tx.Rollback()
+		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)

vendor/github.com/go-xorm/xorm/session_update.go

@@ -16,19 +16,19 @@ import (
 )
 
 func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
-	if session.Statement.RefTable == nil ||
+	if session.statement.RefTable == nil ||
-		session.Tx != 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() {
+	for _, filter := range session.engine.dialect.Filters() {
-		newsql = filter.Do(newsql, session.Engine.dialect, session.Statement.RefTable)
+		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
+	table := session.statement.RefTable
-	cacher := session.Engine.getCacher2(table)
+	cacher := session.engine.getCacher2(table)
-	tableName := session.Statement.TableName()
+	tableName := session.statement.TableName()
-	session.Engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
+	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()) {
+				} else if strings.Contains(colName, session.engine.QuoteStr()) {
-					colName = strings.TrimSpace(strings.Replace(colName, session.Engine.QuoteStr(), "", -1))
+					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())
+						session.engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
-						if col.IsVersion && session.Statement.checkVersion {
+						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 == "" {
+		if session.statement.ColumnStr == "" {
-			colNames, args = buildUpdates(session.Engine, session.Statement.RefTable, bean, false, false,
+			colNames, args = buildUpdates(session.engine, session.statement.RefTable, bean, false, false,
-				false, false, session.Statement.allUseBool, session.Statement.useAllCols,
+				false, false, session.statement.allUseBool, session.statement.useAllCols,
-				session.Statement.mustColumnMap, session.Statement.nullableMap,
+				session.statement.mustColumnMap, session.statement.nullableMap,
-				session.Statement.columnMap, true, session.Statement.unscoped)
+				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 != "" {
+	if session.statement.UseAutoTime && table != nil && table.Updated != "" {
-		colNames = append(colNames, session.Engine.Quote(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,43 +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)
 	}
 
-	session.Statement.processIDParam()
+	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)
@@ -263,11 +265,15 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 			return 0, err
 		}
 
-		cond = cond.And(builder.Eq{session.Engine.Quote(table.Version): verValue.Interface()})
+		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")
+		colNames = append(colNames, session.engine.Quote(table.Version)+" = "+session.engine.Quote(table.Version)+" + 1")
+	}
+
+	condSQL, condArgs, err = builder.ToSQL(cond)
+	if err != nil {
+		return 0, err
 	}
 
-	condSQL, condArgs, _ = builder.ToSQL(cond)
 	if len(condSQL) > 0 {
 		condSQL = "WHERE " + condSQL
 	}
@@ -284,27 +290,53 @@ 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, _ = builder.ToSQL(cond)
+			condSQL, condArgs, err = builder.ToSQL(cond)
+			if err != nil {
+				return 0, err
+			}
 			if len(condSQL) > 0 {
 				condSQL = "WHERE " + condSQL
 			}
 		} 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, _ = builder.ToSQL(cond)
+			condSQL, condArgs, err = builder.ToSQL(cond)
+			if err != nil {
+				return 0, err
+			}
+
 			if len(condSQL) > 0 {
 				condSQL = "WHERE " + condSQL
 			}
 		} else if st.Engine.dialect.DBType() == core.MSSQL {
-			top = fmt.Sprintf("top (%d) ", st.LimitN)
+			if st.OrderStr != "" && st.Engine.dialect.DBType() == core.MSSQL &&
+				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...)
+
+				condSQL, condArgs, err = builder.ToSQL(cond)
+				if err != nil {
+					return 0, err
 				}
+				if len(condSQL) > 0 {
+					condSQL = "WHERE " + condSQL
+				}
+			} else {
+				top = fmt.Sprintf("TOP (%d) ", st.LimitN)
+			}
+		}
+	}
+
+	if len(colNames) <= 0 {
+		return 0, errors.New("No content found to be updated")
 	}
 
 	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)
 
@@ -318,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 {
+		if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
-			cacher.ClearIds(session.Statement.TableName())
+			cacher.ClearIds(session.statement.TableName())
-			cacher.ClearBeans(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 {

vendor/github.com/go-xorm/xorm/statement.go

@@ -272,6 +272,9 @@ func buildUpdates(engine *Engine, table *core.Table, bean interface{},
 
 		fieldValue := *fieldValuePtr
 		fieldType := reflect.TypeOf(fieldValue.Interface())
+		if fieldType == nil {
+			continue
+		}
 
 		requiredField := useAllCols
 		includeNil := useAllCols
@@ -376,7 +379,7 @@ func buildUpdates(engine *Engine, table *core.Table, bean interface{},
 				if !requiredField && (t.IsZero() || !fieldValue.IsValid()) {
 					continue
 				}
-				val = engine.FormatTime(col.SQLType.Name, t)
+				val = engine.formatColTime(col, t)
 			} else if nulType, ok := fieldValue.Interface().(driver.Valuer); ok {
 				val, _ = nulType.Value()
 			} else {
@@ -490,224 +493,6 @@ func (statement *Statement) colName(col *core.Column, tableName string) string {
 	return statement.Engine.Quote(col.Name)
 }
 
-func buildConds(engine *Engine, table *core.Table, bean interface{},
-	includeVersion bool, includeUpdated bool, includeNil bool,
-	includeAutoIncr bool, allUseBool bool, useAllCols bool, unscoped bool,
-	mustColumnMap map[string]bool, tableName, aliasName string, addedTableName bool) (builder.Cond, error) {
-	var conds []builder.Cond
-	for _, col := range table.Columns() {
-		if !includeVersion && col.IsVersion {
-			continue
-		}
-		if !includeUpdated && col.IsUpdated {
-			continue
-		}
-		if !includeAutoIncr && col.IsAutoIncrement {
-			continue
-		}
-
-		if engine.dialect.DBType() == core.MSSQL && (col.SQLType.Name == core.Text || col.SQLType.IsBlob() || col.SQLType.Name == core.TimeStampz) {
-			continue
-		}
-		if col.SQLType.IsJson() {
-			continue
-		}
-
-		var colName string
-		if addedTableName {
-			var nm = tableName
-			if len(aliasName) > 0 {
-				nm = aliasName
-			}
-			colName = engine.Quote(nm) + "." + engine.Quote(col.Name)
-		} else {
-			colName = engine.Quote(col.Name)
-		}
-
-		fieldValuePtr, err := col.ValueOf(bean)
-		if err != nil {
-			engine.logger.Error(err)
-			continue
-		}
-
-		if col.IsDeleted && !unscoped { // tag "deleted" is enabled
-			if engine.dialect.DBType() == core.MSSQL {
-				conds = append(conds, builder.IsNull{colName})
-			} else {
-				conds = append(conds, builder.IsNull{colName}.Or(builder.Eq{colName: "0001-01-01 00:00:00"}))
-			}
-		}
-
-		fieldValue := *fieldValuePtr
-		if fieldValue.Interface() == nil {
-			continue
-		}
-
-		fieldType := reflect.TypeOf(fieldValue.Interface())
-		requiredField := useAllCols
-
-		if b, ok := getFlagForColumn(mustColumnMap, col); ok {
-			if b {
-				requiredField = true
-			} else {
-				continue
-			}
-		}
-
-		if fieldType.Kind() == reflect.Ptr {
-			if fieldValue.IsNil() {
-				if includeNil {
-					conds = append(conds, builder.Eq{colName: nil})
-				}
-				continue
-			} else if !fieldValue.IsValid() {
-				continue
-			} else {
-				// dereference ptr type to instance type
-				fieldValue = fieldValue.Elem()
-				fieldType = reflect.TypeOf(fieldValue.Interface())
-				requiredField = true
-			}
-		}
-
-		var val interface{}
-		switch fieldType.Kind() {
-		case reflect.Bool:
-			if allUseBool || requiredField {
-				val = fieldValue.Interface()
-			} else {
-				// if a bool in a struct, it will not be as a condition because it default is false,
-				// please use Where() instead
-				continue
-			}
-		case reflect.String:
-			if !requiredField && fieldValue.String() == "" {
-				continue
-			}
-			// for MyString, should convert to string or panic
-			if fieldType.String() != reflect.String.String() {
-				val = fieldValue.String()
-			} else {
-				val = fieldValue.Interface()
-			}
-		case reflect.Int8, reflect.Int16, reflect.Int, reflect.Int32, reflect.Int64:
-			if !requiredField && fieldValue.Int() == 0 {
-				continue
-			}
-			val = fieldValue.Interface()
-		case reflect.Float32, reflect.Float64:
-			if !requiredField && fieldValue.Float() == 0.0 {
-				continue
-			}
-			val = fieldValue.Interface()
-		case reflect.Uint8, reflect.Uint16, reflect.Uint, reflect.Uint32, reflect.Uint64:
-			if !requiredField && fieldValue.Uint() == 0 {
-				continue
-			}
-			t := int64(fieldValue.Uint())
-			val = reflect.ValueOf(&t).Interface()
-		case reflect.Struct:
-			if fieldType.ConvertibleTo(core.TimeType) {
-				t := fieldValue.Convert(core.TimeType).Interface().(time.Time)
-				if !requiredField && (t.IsZero() || !fieldValue.IsValid()) {
-					continue
-				}
-				val = engine.FormatTime(col.SQLType.Name, t)
-			} else if _, ok := reflect.New(fieldType).Interface().(core.Conversion); ok {
-				continue
-			} else if valNul, ok := fieldValue.Interface().(driver.Valuer); ok {
-				val, _ = valNul.Value()
-				if val == nil {
-					continue
-				}
-			} else {
-				if col.SQLType.IsJson() {
-					if col.SQLType.IsText() {
-						bytes, err := json.Marshal(fieldValue.Interface())
-						if err != nil {
-							engine.logger.Error(err)
-							continue
-						}
-						val = string(bytes)
-					} else if col.SQLType.IsBlob() {
-						var bytes []byte
-						var err error
-						bytes, err = json.Marshal(fieldValue.Interface())
-						if err != nil {
-							engine.logger.Error(err)
-							continue
-						}
-						val = bytes
-					}
-				} else {
-					engine.autoMapType(fieldValue)
-					if table, ok := engine.Tables[fieldValue.Type()]; ok {
-						if len(table.PrimaryKeys) == 1 {
-							pkField := reflect.Indirect(fieldValue).FieldByName(table.PKColumns()[0].FieldName)
-							// fix non-int pk issues
-							//if pkField.Int() != 0 {
-							if pkField.IsValid() && !isZero(pkField.Interface()) {
-								val = pkField.Interface()
-							} else {
-								continue
-							}
-						} else {
-							//TODO: how to handler?
-							panic(fmt.Sprintln("not supported", fieldValue.Interface(), "as", table.PrimaryKeys))
-						}
-					} else {
-						val = fieldValue.Interface()
-					}
-				}
-			}
-		case reflect.Array:
-			continue
-		case reflect.Slice, reflect.Map:
-			if fieldValue == reflect.Zero(fieldType) {
-				continue
-			}
-			if fieldValue.IsNil() || !fieldValue.IsValid() || fieldValue.Len() == 0 {
-				continue
-			}
-
-			if col.SQLType.IsText() {
-				bytes, err := json.Marshal(fieldValue.Interface())
-				if err != nil {
-					engine.logger.Error(err)
-					continue
-				}
-				val = string(bytes)
-			} else if col.SQLType.IsBlob() {
-				var bytes []byte
-				var err error
-				if (fieldType.Kind() == reflect.Array || fieldType.Kind() == reflect.Slice) &&
-					fieldType.Elem().Kind() == reflect.Uint8 {
-					if fieldValue.Len() > 0 {
-						val = fieldValue.Bytes()
-					} else {
-						continue
-					}
-				} else {
-					bytes, err = json.Marshal(fieldValue.Interface())
-					if err != nil {
-						engine.logger.Error(err)
-						continue
-					}
-					val = bytes
-				}
-			} else {
-				continue
-			}
-		default:
-			val = fieldValue.Interface()
-		}
-
-		conds = append(conds, builder.Eq{colName: val})
-	}
-
-	return builder.And(conds...), nil
-}
-
 // TableName return current tableName
 func (statement *Statement) TableName() string {
 	if statement.AltTableName != "" {
@@ -810,6 +595,22 @@ func (statement *Statement) col2NewColsWithQuote(columns ...string) []string {
 	return newColumns
 }
 
+func (statement *Statement) colmap2NewColsWithQuote() []string {
+	newColumns := make([]string, 0, len(statement.columnMap))
+	for col := range statement.columnMap {
+		fields := strings.Split(strings.TrimSpace(col), ".")
+		if len(fields) == 1 {
+			newColumns = append(newColumns, statement.Engine.quote(fields[0]))
+		} else if len(fields) == 2 {
+			newColumns = append(newColumns, statement.Engine.quote(fields[0])+"."+
+				statement.Engine.quote(fields[1]))
+		} else {
+			panic(errors.New("unwanted colnames"))
+		}
+	}
+	return newColumns
+}
+
 // Distinct generates "DISTINCT col1, col2 " statement
 func (statement *Statement) Distinct(columns ...string) *Statement {
 	statement.IsDistinct = true
@@ -836,7 +637,7 @@ func (statement *Statement) Cols(columns ...string) *Statement {
 		statement.columnMap[strings.ToLower(nc)] = true
 	}
 
-	newColumns := statement.col2NewColsWithQuote(columns...)
+	newColumns := statement.colmap2NewColsWithQuote()
 	statement.ColumnStr = strings.Join(newColumns, ", ")
 	statement.ColumnStr = strings.Replace(statement.ColumnStr, statement.Engine.quote("*"), "*", -1)
 	return statement
@@ -1104,26 +905,35 @@ func (statement *Statement) genAddColumnStr(col *core.Column) (string, []interfa
 }
 
 func (statement *Statement) buildConds(table *core.Table, bean interface{}, includeVersion bool, includeUpdated bool, includeNil bool, includeAutoIncr bool, addedTableName bool) (builder.Cond, error) {
-	return buildConds(statement.Engine, table, bean, includeVersion, includeUpdated, includeNil, includeAutoIncr, statement.allUseBool, statement.useAllCols,
+	return statement.Engine.buildConds(table, bean, includeVersion, includeUpdated, includeNil, includeAutoIncr, statement.allUseBool, statement.useAllCols,
 		statement.unscoped, statement.mustColumnMap, statement.TableName(), statement.TableAlias, addedTableName)
 }
 
-func (statement *Statement) genConds(bean interface{}) (string, []interface{}, error) {
+func (statement *Statement) mergeConds(bean interface{}) error {
 	if !statement.noAutoCondition {
 		var addedTableName = (len(statement.JoinStr) > 0)
 		autoCond, err := statement.buildConds(statement.RefTable, bean, true, true, false, true, addedTableName)
 		if err != nil {
-			return "", nil, err
+			return err
 		}
 		statement.cond = statement.cond.And(autoCond)
 	}
 
-	statement.processIDParam()
+	if err := statement.processIDParam(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (statement *Statement) genConds(bean interface{}) (string, []interface{}, error) {
+	if err := statement.mergeConds(bean); err != nil {
+		return "", nil, err
+	}
 
 	return builder.ToSQL(statement.cond)
 }
 
-func (statement *Statement) genGetSQL(bean interface{}) (string, []interface{}) {
+func (statement *Statement) genGetSQL(bean interface{}) (string, []interface{}, error) {
 	v := rValue(bean)
 	isStruct := v.Kind() == reflect.Struct
 	if isStruct {
@@ -1156,22 +966,38 @@ func (statement *Statement) genGetSQL(bean interface{}) (string, []interface{})
 		columnStr = "*"
 	}
 
+	if isStruct {
+		if err := statement.mergeConds(bean); err != nil {
+			return "", nil, err
+		}
+	}
+	condSQL, condArgs, err := builder.ToSQL(statement.cond)
+	if err != nil {
+		return "", nil, err
+	}
+
+	sqlStr, err := statement.genSelectSQL(columnStr, condSQL)
+	if err != nil {
+		return "", nil, err
+	}
+
+	return sqlStr, append(statement.joinArgs, condArgs...), nil
+}
+
+func (statement *Statement) genCountSQL(beans ...interface{}) (string, []interface{}, error) {
 	var condSQL string
 	var condArgs []interface{}
-	if isStruct {
+	var err error
-		condSQL, condArgs, _ = statement.genConds(bean)
+	if len(beans) > 0 {
+		statement.setRefValue(rValue(beans[0]))
+		condSQL, condArgs, err = statement.genConds(beans[0])
 	} else {
-		condSQL, condArgs, _ = builder.ToSQL(statement.cond)
+		condSQL, condArgs, err = builder.ToSQL(statement.cond)
 	}
-
+	if err != nil {
-	return statement.genSelectSQL(columnStr, condSQL), append(statement.joinArgs, condArgs...)
+		return "", nil, err
 	}
 
-func (statement *Statement) genCountSQL(bean interface{}) (string, []interface{}) {
-	statement.setRefValue(rValue(bean))
-
-	condSQL, condArgs, _ := statement.genConds(bean)
-
 	var selectSQL = statement.selectStr
 	if len(selectSQL) <= 0 {
 		if statement.IsDistinct {
@@ -1180,10 +1006,15 @@ func (statement *Statement) genCountSQL(bean interface{}) (string, []interface{}
 			selectSQL = "count(*)"
 		}
 	}
-	return statement.genSelectSQL(selectSQL, condSQL), append(statement.joinArgs, condArgs...)
+	sqlStr, err := statement.genSelectSQL(selectSQL, condSQL)
+	if err != nil {
+		return "", nil, err
 	}
 
-func (statement *Statement) genSumSQL(bean interface{}, columns ...string) (string, []interface{}) {
+	return sqlStr, append(statement.joinArgs, condArgs...), nil
+}
+
+func (statement *Statement) genSumSQL(bean interface{}, columns ...string) (string, []interface{}, error) {
 	statement.setRefValue(rValue(bean))
 
 	var sumStrs = make([]string, 0, len(columns))
@@ -1195,12 +1026,20 @@ func (statement *Statement) genSumSQL(bean interface{}, columns ...string) (stri
 	}
 	sumSelect := strings.Join(sumStrs, ", ")
 
-	condSQL, condArgs, _ := statement.genConds(bean)
+	condSQL, condArgs, err := statement.genConds(bean)
-
+	if err != nil {
-	return statement.genSelectSQL(sumSelect, condSQL), append(statement.joinArgs, condArgs...)
+		return "", nil, err
 	}
 
-func (statement *Statement) genSelectSQL(columnStr, condSQL string) (a string) {
+	sqlStr, err := statement.genSelectSQL(sumSelect, condSQL)
+	if err != nil {
+		return "", nil, err
+	}
+
+	return sqlStr, append(statement.joinArgs, condArgs...), nil
+}
+
+func (statement *Statement) genSelectSQL(columnStr, condSQL string) (a string, err error) {
 	var distinct string
 	if statement.IsDistinct && !strings.HasPrefix(columnStr, "count") {
 		distinct = "DISTINCT "
@@ -1211,7 +1050,9 @@ func (statement *Statement) genSelectSQL(columnStr, condSQL string) (a string) {
 	var top string
 	var mssqlCondi string
 
-	statement.processIDParam()
+	if err := statement.processIDParam(); err != nil {
+		return "", err
+	}
 
 	var buf bytes.Buffer
 	if len(condSQL) > 0 {
@@ -1278,7 +1119,7 @@ func (statement *Statement) genSelectSQL(columnStr, condSQL string) (a string) {
 	}
 
 	// !nashtsai! REVIEW Sprintf is considered slowest mean of string concatnation, better to work with builder pattern
-	a = fmt.Sprintf("SELECT %v%v%v%v%v", top, distinct, columnStr, fromStr, whereStr)
+	a = fmt.Sprintf("SELECT %v%v%v%v%v", distinct, top, columnStr, fromStr, whereStr)
 	if len(mssqlCondi) > 0 {
 		if len(whereStr) > 0 {
 			a += " AND " + mssqlCondi
@@ -1314,19 +1155,23 @@ func (statement *Statement) genSelectSQL(columnStr, condSQL string) (a string) {
 	return
 }
 
-func (statement *Statement) processIDParam() {
+func (statement *Statement) processIDParam() error {
 	if statement.idParam == nil {
-		return
+		return nil
+	}
+
+	if len(statement.RefTable.PrimaryKeys) != len(*statement.idParam) {
+		return fmt.Errorf("ID condition is error, expect %d primarykeys, there are %d",
+			len(statement.RefTable.PrimaryKeys),
+			len(*statement.idParam),
+		)
 	}
 
 	for i, col := range statement.RefTable.PKColumns() {
 		var colName = statement.colName(col, statement.TableName())
-		if i < len(*(statement.idParam)) {
 		statement.cond = statement.cond.And(builder.Eq{colName: (*(statement.idParam))[i]})
-		} else {
-			statement.cond = statement.cond.And(builder.Eq{colName: ""})
-		}
 	}
+	return nil
 }
 
 func (statement *Statement) joinColumns(cols []*core.Column, includeTableName bool) string {

vendor/github.com/go-xorm/xorm/tag.go

@@ -54,6 +54,7 @@ var (
 		"UNIQUE":   UniqueTagHandler,
 		"CACHE":    CacheTagHandler,
 		"NOCACHE":  NoCacheTagHandler,
+		"COMMENT":  CommentTagHandler,
 	}
 )
 
@@ -192,6 +193,14 @@ func UniqueTagHandler(ctx *tagContext) error {
 	return nil
 }
 
+// CommentTagHandler add comment to column
+func CommentTagHandler(ctx *tagContext) error {
+	if len(ctx.params) > 0 {
+		ctx.col.Comment = strings.Trim(ctx.params[0], "' ")
+	}
+	return nil
+}
+
 // SQLTypeTagHandler describes SQL Type tag handler
 func SQLTypeTagHandler(ctx *tagContext) error {
 	ctx.col.SQLType = core.SQLType{Name: ctx.tagName}

vendor/github.com/go-xorm/xorm/test_mssql.sh

@@ -0,0 +1 @@
+go test -db=mssql -conn_str="server=192.168.1.58;user id=sa;password=123456;database=xorm_test"

vendor/github.com/go-xorm/xorm/test_mymysql.sh

@@ -0,0 +1 @@
+go test -db=mymysql -conn_str="xorm_test/root/"

vendor/github.com/go-xorm/xorm/test_mysql.sh

@@ -0,0 +1 @@
+go test -db=mysql -conn_str="root:@/xorm_test"

vendor/github.com/go-xorm/xorm/test_postgres.sh

@@ -0,0 +1 @@
+go test -db=postgres -conn_str="dbname=xorm_test sslmode=disable"

vendor/github.com/go-xorm/xorm/test_sqlite.sh

@@ -0,0 +1 @@
+go test -db=sqlite3 -conn_str="./test.db?cache=shared&mode=rwc"

vendor/github.com/go-xorm/xorm/xorm.go

@@ -17,7 +17,7 @@ import (
 
 const (
 	// Version show the xorm's version
-	Version string = "0.6.2.0412"
+	Version string = "0.6.3.0713"
 )
 
 func regDrvsNDialects() bool {
@@ -50,10 +50,13 @@ func close(engine *Engine) {
 	engine.Close()
 }
 
+func init() {
+	regDrvsNDialects()
+}
+
 // NewEngine new a db manager according to the parameter. Currently support four
 // drivers
 func NewEngine(driverName string, dataSourceName string) (*Engine, error) {
-	regDrvsNDialects()
 	driver := core.QueryDriver(driverName)
 	if driver == nil {
 		return nil, fmt.Errorf("Unsupported driver name: %v", driverName)
@@ -89,6 +92,12 @@ func NewEngine(driverName string, dataSourceName string) (*Engine, error) {
 		tagHandlers:   defaultTagHandlers,
 	}
 
+	if uri.DbType == core.SQLITE {
+		engine.DatabaseTZ = time.UTC
+	} else {
+		engine.DatabaseTZ = time.Local
+	}
+
 	logger := NewSimpleLogger(os.Stdout)
 	logger.SetLevel(core.LOG_INFO)
 	engine.SetLogger(logger)

vendor/vendor.json

@@ -452,14 +452,14 @@
 		{
 			"checksumSHA1": "9SXbj96wb1PgppBZzxMIN0axbFQ=",
 			"path": "github.com/go-xorm/builder",
-			"revision": "043186300e9b2c22abdfc83567a979e3af04d9ae",
+			"revision": "c8871c857d2555fbfbd8524f895be5386d3d8836",
-			"revisionTime": "2017-05-18T21:58:56Z"
+			"revisionTime": "2017-05-19T03:21:30Z"
 		},
 		{
-			"checksumSHA1": "vt2CGANHLNXPAZ01ve3UlsgQ0uU=",
+			"checksumSHA1": "KOHXTLwpgTMxBB9aGF2aIxkWdm8=",
 			"path": "github.com/go-xorm/core",
-			"revision": "e8409d73255791843585964791443dbad877058c",
+			"revision": "71c1070a861118827352b1394eb86cbfeef5c513",
-			"revisionTime": "2017-03-17T12:25:07Z"
+			"revisionTime": "2017-08-22T05:50:40Z"
 		},
 		{
 			"checksumSHA1": "k52lEKLp8j5M+jFpe+3u+bIFpxQ=",
@@ -468,10 +468,10 @@
 			"revisionTime": "2016-08-11T02:11:45Z"
 		},
 		{
-			"checksumSHA1": "Ka4hFMvc75Fb57ZNLALyYSM7CCE=",
+			"checksumSHA1": "0F65zfDi1ys3KD/wMKtxC2k13DA=",
 			"path": "github.com/go-xorm/xorm",
-			"revision": "d52a762fba17a2ed265463c1c7b608c14836eaaf",
+			"revision": "a10b5aba4bb97b30daa74e7c0363d3084ede0514",
-			"revisionTime": "2017-04-20T16:02:48Z"
+			"revisionTime": "2017-08-20T09:05:42Z"
 		},
 		{
 			"checksumSHA1": "1ft/4j5MFa7C9dPI9whL03HSUzk=",