From 2c6a0fdca83ab4ccc2e5628e4ca7d229c844618c Mon Sep 17 00:00:00 2001
From: Lunny Xiao <xiaolunwen@gmail.com>
Date: Tue, 22 Aug 2017 19:39:52 +0800
Subject: [PATCH] update latest xorm version to vendor (#2353)
---
models/models.go | 2 +-
vendor/github.com/go-xorm/core/column.go | 5 +-
vendor/github.com/go-xorm/core/dialect.go | 3 +
vendor/github.com/go-xorm/core/rows.go | 12 +
vendor/github.com/go-xorm/core/table.go | 1 +
vendor/github.com/go-xorm/xorm/README.md | 63 ++--
vendor/github.com/go-xorm/xorm/README_CN.md | 60 ++-
.../xorm/{lru_cacher.go => cache_lru.go} | 0
...{memory_store.go => cache_memory_store.go} | 0
vendor/github.com/go-xorm/xorm/circle.yml | 8 +-
.../github.com/go-xorm/xorm/dialect_mssql.go | 23 +-
.../github.com/go-xorm/xorm/dialect_mysql.go | 14 +-
.../go-xorm/xorm/dialect_sqlite3.go | 18 +-
vendor/github.com/go-xorm/xorm/doc.go | 11 +-
vendor/github.com/go-xorm/xorm/engine.go | 269 +++++++-------
vendor/github.com/go-xorm/xorm/engine_cond.go | 230 ++++++++++++
.../github.com/go-xorm/xorm/engine_maxlife.go | 14 +
vendor/github.com/go-xorm/xorm/helpers.go | 251 +++----------
.../github.com/go-xorm/xorm/helpler_time.go | 21 ++
vendor/github.com/go-xorm/xorm/rows.go | 32 +-
vendor/github.com/go-xorm/xorm/session.go | 163 ++++-----
.../github.com/go-xorm/xorm/session_cols.go | 24 +-
.../github.com/go-xorm/xorm/session_cond.go | 18 +-
.../go-xorm/xorm/session_convert.go | 108 +++---
.../github.com/go-xorm/xorm/session_delete.go | 64 ++--
.../github.com/go-xorm/xorm/session_exist.go | 87 +++++
.../github.com/go-xorm/xorm/session_find.go | 139 ++++---
vendor/github.com/go-xorm/xorm/session_get.go | 106 +++---
.../github.com/go-xorm/xorm/session_insert.go | 156 ++++----
vendor/github.com/go-xorm/xorm/session_raw.go | 203 ++++++++++-
.../github.com/go-xorm/xorm/session_schema.go | 238 +++++-------
.../github.com/go-xorm/xorm/session_stats.go | 118 ++++++
vendor/github.com/go-xorm/xorm/session_sum.go | 137 -------
vendor/github.com/go-xorm/xorm/session_tx.go | 24 +-
.../github.com/go-xorm/xorm/session_update.go | 154 ++++----
vendor/github.com/go-xorm/xorm/statement.go | 343 +++++-------------
vendor/github.com/go-xorm/xorm/tag.go | 9 +
vendor/github.com/go-xorm/xorm/test_mssql.sh | 1 +
.../github.com/go-xorm/xorm/test_mymysql.sh | 1 +
vendor/github.com/go-xorm/xorm/test_mysql.sh | 1 +
.../github.com/go-xorm/xorm/test_postgres.sh | 1 +
vendor/github.com/go-xorm/xorm/test_sqlite.sh | 1 +
vendor/github.com/go-xorm/xorm/xorm.go | 13 +-
vendor/vendor.json | 16 +-
44 files changed, 1748 insertions(+), 1414 deletions(-)
rename vendor/github.com/go-xorm/xorm/{lru_cacher.go => cache_lru.go} (100%)
rename vendor/github.com/go-xorm/xorm/{memory_store.go => cache_memory_store.go} (100%)
create mode 100644 vendor/github.com/go-xorm/xorm/engine_cond.go
create mode 100644 vendor/github.com/go-xorm/xorm/engine_maxlife.go
create mode 100644 vendor/github.com/go-xorm/xorm/helpler_time.go
create mode 100644 vendor/github.com/go-xorm/xorm/session_exist.go
create mode 100644 vendor/github.com/go-xorm/xorm/session_stats.go
delete mode 100644 vendor/github.com/go-xorm/xorm/session_sum.go
create mode 100755 vendor/github.com/go-xorm/xorm/test_mssql.sh
create mode 100755 vendor/github.com/go-xorm/xorm/test_mymysql.sh
create mode 100755 vendor/github.com/go-xorm/xorm/test_mysql.sh
create mode 100755 vendor/github.com/go-xorm/xorm/test_postgres.sh
create mode 100755 vendor/github.com/go-xorm/xorm/test_sqlite.sh
diff --git a/models/models.go b/models/models.go
index 1688a63649..e5d3597ce7 100644
--- a/models/models.go
+++ b/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)
diff --git a/vendor/github.com/go-xorm/core/column.go b/vendor/github.com/go-xorm/core/column.go
index c59d01021f..d9362e9857 100644
--- a/vendor/github.com/go-xorm/core/column.go
+++ b/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: "",
}
}
diff --git a/vendor/github.com/go-xorm/core/dialect.go b/vendor/github.com/go-xorm/core/dialect.go
index 74478301e4..6f2e81d017 100644
--- a/vendor/github.com/go-xorm/core/dialect.go
+++ b/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 += ", "
}
diff --git a/vendor/github.com/go-xorm/core/rows.go b/vendor/github.com/go-xorm/core/rows.go
index c4dec23e0d..4a4acaa4c2 100644
--- a/vendor/github.com/go-xorm/core/rows.go
+++ b/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
diff --git a/vendor/github.com/go-xorm/core/table.go b/vendor/github.com/go-xorm/core/table.go
index e6f6a7518b..88199bedd6 100644
--- a/vendor/github.com/go-xorm/core/table.go
+++ b/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 {
diff --git a/vendor/github.com/go-xorm/xorm/README.md b/vendor/github.com/go-xorm/xorm/README.md
index da55878ea0..bf35488903 100644
--- a/vendor/github.com/go-xorm/xorm/README.md
+++ b/vendor/github.com/go-xorm/xorm/README.md
@@ -2,11 +2,9 @@
Xorm is a simple and powerful ORM for Go.
-[](https://circleci.com/gh/go-xorm/xorm/tree/master) [](https://gitter.im/go-xorm/xorm?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-
-# Notice
-
-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.
+[](https://circleci.com/gh/go-xorm/xorm) [](https://codecov.io/gh/go-xorm/xorm)
+[](https://goreportcard.com/report/github.com/go-xorm/xorm)
+[](https://discord.gg/HuR2CF3)
# 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)
diff --git a/vendor/github.com/go-xorm/xorm/README_CN.md b/vendor/github.com/go-xorm/xorm/README_CN.md
index 40f5f6009a..cb2c1799ea 100644
--- a/vendor/github.com/go-xorm/xorm/README_CN.md
+++ b/vendor/github.com/go-xorm/xorm/README_CN.md
@@ -4,11 +4,9 @@
xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作非常简便。
-[](https://circleci.com/gh/go-xorm/xorm/tree/master) [](https://gitter.im/go-xorm/xorm?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-
-# 注意
-
-最新的版本有不兼容的更新，您必须使用 `engine.ShowSQL()` 和 `engine.Logger().SetLevel()` 来替代 `engine.ShowSQL = `, `engine.ShowInfo = ` 等等。
+[](https://circleci.com/gh/go-xorm/xorm) [](https://codecov.io/gh/go-xorm/xorm)
+[](https://goreportcard.com/report/github.com/go-xorm/xorm)
+[](https://discord.gg/HuR2CF3)
## 特性
@@ -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)
diff --git a/vendor/github.com/go-xorm/xorm/lru_cacher.go b/vendor/github.com/go-xorm/xorm/cache_lru.go
similarity index 100%
rename from vendor/github.com/go-xorm/xorm/lru_cacher.go
rename to vendor/github.com/go-xorm/xorm/cache_lru.go
diff --git a/vendor/github.com/go-xorm/xorm/memory_store.go b/vendor/github.com/go-xorm/xorm/cache_memory_store.go
similarity index 100%
rename from vendor/github.com/go-xorm/xorm/memory_store.go
rename to vendor/github.com/go-xorm/xorm/cache_memory_store.go
diff --git a/vendor/github.com/go-xorm/xorm/circle.yml b/vendor/github.com/go-xorm/xorm/circle.yml
index 8faa627d10..e81bdb0e30 100644
--- a/vendor/github.com/go-xorm/xorm/circle.yml
+++ b/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
\ No newline at end of file
+ - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./postgres.sh
+ post:
+ - bash <(curl -s https://codecov.io/bash)
\ No newline at end of file
diff --git a/vendor/github.com/go-xorm/xorm/dialect_mssql.go b/vendor/github.com/go-xorm/xorm/dialect_mssql.go
index f83cfc1733..6d2291dc1d 100644
--- a/vendor/github.com/go-xorm/xorm/dialect_mssql.go
+++ b/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
- 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
+ replace(replace(isnull(c.text,''),'(',''),')','') as vdefault,
+ 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
- err = rows.Scan(&name, &ctype, &maxLen, &precision, &scale, &nullable, &vdefault)
+ var nullable, isPK bool
+ 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 {
diff --git a/vendor/github.com/go-xorm/xorm/dialect_mysql.go b/vendor/github.com/go-xorm/xorm/dialect_mysql.go
index 55cfdd7640..99100b2325 100644
--- a/vendor/github.com/go-xorm/xorm/dialect_mysql.go
+++ b/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)
}
diff --git a/vendor/github.com/go-xorm/xorm/dialect_sqlite3.go b/vendor/github.com/go-xorm/xorm/dialect_sqlite3.go
index c13fd02bed..a55b1615e7 100644
--- a/vendor/github.com/go-xorm/xorm/dialect_sqlite3.go
+++ b/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, "`[] "), `"`)
diff --git a/vendor/github.com/go-xorm/xorm/doc.go b/vendor/github.com/go-xorm/xorm/doc.go
index 5b36fcd80b..bf412bdaa8 100644
--- a/vendor/github.com/go-xorm/xorm/doc.go
+++ b/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")
diff --git a/vendor/github.com/go-xorm/xorm/engine.go b/vendor/github.com/go-xorm/xorm/engine.go
index a788c11755..cfa0933ee3 100644
--- a/vendor/github.com/go-xorm/xorm/engine.go
+++ b/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()
- defer s.Close()
- isExist, err := s.Table(bean).isTableExist(tableName)
+ isExist, err := session.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()
- defer session.Close()
- if err := session.Statement.setRefValue(v); err != nil {
+ if err := session.statement.setRefValue(v); err != nil {
return err
}
err = session.addColumn(col.Name)
@@ -1235,21 +1267,16 @@ func (engine *Engine) Sync(beans ...interface{}) error {
}
for name, index := range table.Indexes {
- session := engine.NewSession()
- defer session.Close()
- if err := session.Statement.setRefValue(v); err != nil {
+ if err := session.statement.setRefValue(v); err != nil {
return err
}
if index.Type == core.UniqueType {
- //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()
- defer session.Close()
- if err := session.Statement.setRefValue(v); err != nil {
+ 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()
- defer session.Close()
- if err := session.Statement.setRefValue(v); err != nil {
+ 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
-}
-
-// FormatTime format time
-func (engine *Engine) FormatTime(sqlTypeName string, t time.Time) (v interface{}) {
- return engine.formatTime(engine.TZLocation, sqlTypeName, t)
+ return engine.formatTime(sqlTypeName, t.In(engine.DatabaseTZ)), t.In(engine.TZLocation)
}
func (engine *Engine) formatColTime(col *core.Column, t time.Time) (v interface{}) {
- if col.DisableTimeZone {
- return engine.formatTime(nil, col.SQLType.Name, t)
- } else if col.TimeZone != nil {
- return engine.formatTime(col.TimeZone, col.SQLType.Name, t)
+ if t.IsZero() {
+ if col.Nullable {
+ return nil
+ }
+ return ""
}
- return engine.formatTime(engine.TZLocation, col.SQLType.Name, t)
+
+ if col.TimeZone != nil {
+ return engine.formatTime(col.SQLType.Name, t.In(col.TimeZone))
+ }
+ return engine.formatTime(col.SQLType.Name, t.In(engine.DatabaseTZ))
}
-func (engine *Engine) formatTime(tz *time.Location, sqlTypeName string, t time.Time) (v interface{}) {
- if engine.dialect.DBType() == core.ORACLE {
- return t
- }
- if tz != nil {
- 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")
- }
+ 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})
+}
diff --git a/vendor/github.com/go-xorm/xorm/engine_cond.go b/vendor/github.com/go-xorm/xorm/engine_cond.go
new file mode 100644
index 0000000000..6c8e3879ce
--- /dev/null
+++ b/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
+}
diff --git a/vendor/github.com/go-xorm/xorm/engine_maxlife.go b/vendor/github.com/go-xorm/xorm/engine_maxlife.go
new file mode 100644
index 0000000000..21daeaa1b8
--- /dev/null
+++ b/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)
+}
diff --git a/vendor/github.com/go-xorm/xorm/helpers.go b/vendor/github.com/go-xorm/xorm/helpers.go
index 324c5beae8..5a0fe7c839 100644
--- a/vendor/github.com/go-xorm/xorm/helpers.go
+++ b/vendor/github.com/go-xorm/xorm/helpers.go
@@ -196,25 +196,43 @@ func isArrayValueZero(v reflect.Value) bool {
func int64ToIntValue(id int64, tp reflect.Type) reflect.Value {
var v interface{}
- switch tp.Kind() {
- case reflect.Int16:
- v = int16(id)
- case reflect.Int32:
- 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)
+ kind := tp.Kind()
+
+ if kind == reflect.Ptr {
+ kind = tp.Elem().Kind()
}
- return reflect.ValueOf(v).Convert(tp)
+
+ 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{} {
@@ -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 _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+ if session.statement.ColumnStr != "" {
+ if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
+ continue
+ } else if _, ok := session.statement.incrColumns[col.Name]; ok {
+ continue
+ } else if _, ok := session.statement.decrColumns[col.Name]; ok {
continue
}
}
- if session.Statement.OmitStr != "" {
- if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+ if session.statement.OmitStr != "" {
+ if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
continue
}
}
// !evalphobia! set fieldValue as nil when column is nullable and zero-value
- if _, ok := getFlagForColumn(session.Statement.nullableMap, col); ok {
+ if _, ok := getFlagForColumn(session.statement.nullableMap, col); ok {
if col.Nullable && isZero(fieldValue.Interface()) {
var nilValue *int
fieldValue = reflect.ValueOf(nilValue)
}
}
- if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ {
+ if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime /*&& isZero(fieldValue.Interface())*/ {
// if time is non-empty, then set to auto time
- val, t := session.Engine.NowTime2(col.SQLType.Name)
+ val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val)
var colName = col.Name
@@ -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)
}
diff --git a/vendor/github.com/go-xorm/xorm/helpler_time.go b/vendor/github.com/go-xorm/xorm/helpler_time.go
new file mode 100644
index 0000000000..f4013e27e1
--- /dev/null
+++ b/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
+}
diff --git a/vendor/github.com/go-xorm/xorm/rows.go b/vendor/github.com/go-xorm/xorm/rows.go
index 47bc322f3d..444e3d435a 100644
--- a/vendor/github.com/go-xorm/xorm/rows.go
+++ b/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 == "" {
- sqlStr, args = rows.session.Statement.genGetSQL(bean)
+ if rows.session.statement.RawSQL == "" {
+ sqlStr, args, err = rows.session.statement.genGetSQL(bean)
+ if err != nil {
+ return nil, err
+ }
} else {
- sqlStr = rows.session.Statement.RawSQL
- args = rows.session.Statement.RawParams
+ sqlStr = rows.session.statement.RawSQL
+ args = rows.session.statement.RawParams
}
- for _, filter := range rows.session.Engine.dialect.Filters() {
- sqlStr = filter.Do(sqlStr, session.Engine.dialect, rows.session.Statement.RefTable)
+ for _, filter := range rows.session.engine.dialect.Filters() {
+ sqlStr = filter.Do(sqlStr, session.engine.dialect, rows.session.statement.RefTable)
}
rows.session.saveLastSQL(sqlStr, args...)
- 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()
}
diff --git a/vendor/github.com/go-xorm/xorm/session.go b/vendor/github.com/go-xorm/xorm/session.go
index 475c769f79..9d04140279 100644
--- a/vendor/github.com/go-xorm/xorm/session.go
+++ b/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
- Tx *core.Tx
- Statement Statement
- IsAutoCommit bool
- IsCommitedOrRollbacked bool
- IsAutoClose bool
+ engine *Engine
+ tx *core.Tx
+ statement Statement
+ isAutoCommit bool
+ isCommitedOrRollbacked bool
+ isAutoClose bool
// Automatically reset the statement after operations that execute a SQL
// query such as Count(), Find(), Get(), ...
- AutoResetStatement bool
+ autoResetStatement bool
// !nashtsai! storing these beans due to yet committed tx
afterInsertBeans map[interface{}]*[]func(interface{})
@@ -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.Engine = session.Engine
- session.IsAutoCommit = true
- session.IsCommitedOrRollbacked = false
- session.IsAutoClose = false
- session.AutoResetStatement = true
+ session.statement.Init()
+ session.statement.Engine = session.engine
+ session.isAutoCommit = true
+ session.isCommitedOrRollbacked = false
+ session.isAutoClose = false
+ session.autoResetStatement = true
session.prepareStmt = false
// !nashtsai! is lazy init better?
@@ -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 {
- session.Statement.Init()
+ if session.autoResetStatement {
+ 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 ||
- session.Statement.JoinStr != "" ||
- session.Statement.RawSQL != "" ||
- !session.Statement.UseCache ||
- session.Statement.IsForUpdate ||
- session.Tx != nil ||
- len(session.Statement.selectStr) > 0 {
+ if session.statement.RefTable == nil ||
+ session.statement.JoinStr != "" ||
+ session.statement.RawSQL != "" ||
+ !session.statement.UseCache ||
+ session.statement.IsForUpdate ||
+ session.tx != nil ||
+ len(session.statement.selectStr) > 0 {
return false
}
return true
@@ -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) {
- // handle beforeClosures
+func (session *Session) row2Slice(rows *core.Rows, fields []string, fieldsCount int, bean interface{}) ([]interface{}, error) {
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
- if col.TimeZone == nil {
- tz = session.Engine.TZLocation
- } else {
- tz = col.TimeZone
+ dbTZ := session.engine.DatabaseTZ
+ if col.TimeZone != nil {
+ dbTZ = 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(tz)
+ t = t.In(session.engine.TZLocation)
fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
} else if rawValueType == core.IntType || rawValueType == core.Int64Type ||
rawValueType == core.Int32Type {
hasAssigned = true
- t := time.Unix(vv.Int(), 0).In(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 {
- table, err := session.Engine.autoMapType(*fieldValue)
+ } else if session.statement.UseCascade {
+ 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() {
- *sqlStr = filter.Do(*sqlStr, session.Engine.dialect, session.Statement.RefTable)
+ for _, filter := range session.engine.dialect.Filters() {
+ *sqlStr = filter.Do(*sqlStr, session.engine.dialect, session.statement.RefTable)
}
session.saveLastSQL(*sqlStr, paramStr...)
@@ -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 {
- return session.Statement.AltTableName
+ if len(session.statement.AltTableName) > 0 {
+ 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
}
diff --git a/vendor/github.com/go-xorm/xorm/session_cols.go b/vendor/github.com/go-xorm/xorm/session_cols.go
index 91185defc8..9972cb0ae4 100644
--- a/vendor/github.com/go-xorm/xorm/session_cols.go
+++ b/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
}
diff --git a/vendor/github.com/go-xorm/xorm/session_cond.go b/vendor/github.com/go-xorm/xorm/session_cond.go
index 948a90bc1f..e1d528f2db 100644
--- a/vendor/github.com/go-xorm/xorm/session_cond.go
+++ b/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
}
diff --git a/vendor/github.com/go-xorm/xorm/session_convert.go b/vendor/github.com/go-xorm/xorm/session_convert.go
index 7ef57b5f38..85002d27ca 100644
--- a/vendor/github.com/go-xorm/xorm/session_convert.go
+++ b/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" ||
- sdata == "0001-01-01 00:00:00" {
+ var parseLoc = session.engine.DatabaseTZ
+ 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
- if col.TimeZone == nil {
- x = x.In(session.Engine.TZLocation)
- } else {
- x = x.In(col.TimeZone)
- }
- session.Engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ session.engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else {
- session.Engine.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ session.engine.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
}
} else if len(sdata) > 19 && strings.Contains(sdata, "-") {
- x, err = time.ParseInLocation(time.RFC3339Nano, sdata, session.Engine.TZLocation)
- session.Engine.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ x, err = time.ParseInLocation(time.RFC3339Nano, sdata, parseLoc)
+ session.engine.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
if err != nil {
- x, err = time.ParseInLocation("2006-01-02 15:04:05.999999999", sdata, session.Engine.TZLocation)
- session.Engine.logger.Debugf("time(2) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ 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)
}
if err != nil {
- x, err = time.ParseInLocation("2006-01-02 15:04:05.9999999 Z07:00", sdata, session.Engine.TZLocation)
- session.Engine.logger.Debugf("time(3) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ 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)
}
-
} else if len(sdata) == 19 && strings.Contains(sdata, "-") {
- x, err = time.ParseInLocation("2006-01-02 15:04:05", sdata, session.Engine.TZLocation)
- session.Engine.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ x, err = time.ParseInLocation("2006-01-02 15:04:05", sdata, parseLoc)
+ session.engine.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else if len(sdata) == 10 && sdata[4] == '-' && sdata[7] == '-' {
- x, err = time.ParseInLocation("2006-01-02", sdata, session.Engine.TZLocation)
- session.Engine.logger.Debugf("time(5) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ 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)
} 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)
- session.Engine.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
+ x, err = time.ParseInLocation("2006-01-02 15:04:05", st, parseLoc)
+ session.engine.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} 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 {
- table, err := session.Engine.autoMapType(*fieldValue)
+ } else if session.statement.UseCascade {
+ 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 {
- if t.IsZero() {
- return nil, nil
- }
- }
- tf := session.Engine.FormatTime(col.SQLType.Name, t)
+ tf := session.engine.formatColTime(col, 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
}
}
diff --git a/vendor/github.com/go-xorm/xorm/session_delete.go b/vendor/github.com/go-xorm/xorm/session_delete.go
index 0c1e705e7e..9fd7b8aff8 100644
--- a/vendor/github.com/go-xorm/xorm/session_delete.go
+++ b/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 ||
- session.Tx != nil {
+ if session.statement.RefTable == nil ||
+ session.tx != nil {
return ErrCacheFailed
}
- for _, filter := range session.Engine.dialect.Filters() {
- sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+ for _, filter := range session.engine.dialect.Filters() {
+ sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
}
- newsql := session.Statement.convertIDSQL(sqlStr)
+ newsql := session.statement.convertIDSQL(sqlStr)
if newsql == "" {
return ErrCacheFailed
}
- cacher := session.Engine.getCacher2(session.Statement.RefTable)
- tableName := session.Statement.TableName()
+ cacher := session.engine.getCacher2(session.statement.RefTable)
+ tableName := session.statement.TableName()
ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
if err != nil {
resultsSlice, err := session.query(newsql, args...)
@@ -40,7 +40,7 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
for _, data := range resultsSlice {
var id int64
var pk core.PK = make([]interface{}, 0)
- for _, col := range session.Statement.RefTable.PKColumns() {
+ for _, col := range session.statement.RefTable.PKColumns() {
if v, ok := data[col.Name]; !ok {
return errors.New("no id")
} else if col.SQLType.IsText() {
@@ -59,19 +59,19 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
}
}
} /*else {
- session.Engine.LogDebug("delete cache sql %v", newsql)
+ session.engine.LogDebug("delete cache sql %v", newsql)
cacher.DelIds(tableName, genSqlKey(newsql, args))
}*/
for _, id := range ids {
- session.Engine.logger.Debug("[cacheDelete] delete cache obj", tableName, id)
+ session.engine.logger.Debug("[cacheDelete] delete cache obj", tableName, id)
sid, err := id.ToString()
if err != nil {
return err
}
cacher.DelBean(tableName, sid)
}
- session.Engine.logger.Debug("[cacheDelete] clear cache sql", tableName)
+ session.engine.logger.Debug("[cacheDelete] clear cache sql", tableName)
cacher.ClearIds(tableName)
return nil
}
@@ -79,14 +79,14 @@ func (session *Session) cacheDelete(sqlStr string, args ...interface{}) error {
// Delete records, bean's non-empty fields are conditions
func (session *Session) Delete(bean interface{}) (int64, error) {
defer session.resetStatement()
- if session.IsAutoClose {
+ if session.isAutoClose {
defer session.Close()
}
- if err := session.Statement.setRefValue(rValue(bean)); err != nil {
+ if err := session.statement.setRefValue(rValue(bean)); err != nil {
return 0, err
}
- var table = session.Statement.RefTable
+ var table = session.statement.RefTable
// handle before delete processors
for _, closure := range session.beforeClosures {
@@ -98,13 +98,15 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
processor.BeforeDelete()
}
- // --
- condSQL, condArgs, _ := session.Statement.genConds(bean)
- if len(condSQL) == 0 && session.Statement.LimitN == 0 {
+ condSQL, condArgs, err := session.statement.genConds(bean)
+ if err != nil {
+ 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 {
- orderSQL += fmt.Sprintf(" ORDER BY %s", session.Statement.OrderStr)
+ if len(session.statement.OrderStr) > 0 {
+ orderSQL += fmt.Sprintf(" ORDER BY %s", session.statement.OrderStr)
}
- if session.Statement.LimitN > 0 {
- orderSQL += fmt.Sprintf(" LIMIT %d", session.Statement.LimitN)
+ if session.statement.LimitN > 0 {
+ orderSQL += fmt.Sprintf(" LIMIT %d", session.statement.LimitN)
}
if len(orderSQL) > 0 {
- switch session.Engine.dialect.DBType() {
+ switch session.engine.dialect.DBType() {
case core.POSTGRES:
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 {
@@ -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(deletedColumn.Name),
+ session.engine.Quote(session.statement.TableName()),
+ session.engine.Quote(deletedColumn.Name),
condSQL)
if len(orderSQL) > 0 {
- switch session.Engine.dialect.DBType() {
+ switch session.engine.dialect.DBType() {
case core.POSTGRES:
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condSQL) > 0 {
@@ -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)
}
diff --git a/vendor/github.com/go-xorm/xorm/session_exist.go b/vendor/github.com/go-xorm/xorm/session_exist.go
new file mode 100644
index 0000000000..91d1cd601a
--- /dev/null
+++ b/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
+}
diff --git a/vendor/github.com/go-xorm/xorm/session_find.go b/vendor/github.com/go-xorm/xorm/session_find.go
index 16c6ff4fd2..42b3506eb0 100644
--- a/vendor/github.com/go-xorm/xorm/session_find.go
+++ b/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
- var colName = session.Engine.Quote(col.Name)
+ if col := table.DeletedColumn(); col != nil && !session.statement.unscoped { // tag "deleted" is enabled
+ var colName = session.engine.Quote(col.Name)
if addedTableName {
- var nm = session.Statement.TableName()
- if len(session.Statement.TableAlias) > 0 {
- nm = session.Statement.TableAlias
+ var nm = session.statement.TableName()
+ if len(session.statement.TableAlias) > 0 {
+ nm = session.statement.TableAlias
}
- colName = session.Engine.Quote(nm) + "." + colName
- }
- 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"})
+ colName = session.engine.Quote(nm) + "." + colName
}
+
+ autoCond = session.engine.CondDeleted(colName)
}
}
}
var sqlStr string
var args []interface{}
- if session.Statement.RawSQL == "" {
- if len(session.Statement.TableName()) <= 0 {
+ var err error
+ if session.statement.RawSQL == "" {
+ if len(session.statement.TableName()) <= 0 {
return ErrTableNotFound
}
- var columnStr = session.Statement.ColumnStr
- if len(session.Statement.selectStr) > 0 {
- columnStr = session.Statement.selectStr
+ var columnStr = session.statement.ColumnStr
+ if len(session.statement.selectStr) > 0 {
+ columnStr = session.statement.selectStr
} else {
- if session.Statement.JoinStr == "" {
+ if session.statement.JoinStr == "" {
if columnStr == "" {
- if session.Statement.GroupByStr != "" {
- columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1))
+ if session.statement.GroupByStr != "" {
+ columnStr = session.statement.Engine.Quote(strings.Replace(session.statement.GroupByStr, ",", session.engine.Quote(","), -1))
} else {
- columnStr = session.Statement.genColumnStr()
+ columnStr = session.statement.genColumnStr()
}
}
} else {
if columnStr == "" {
- if session.Statement.GroupByStr != "" {
- columnStr = session.Statement.Engine.Quote(strings.Replace(session.Statement.GroupByStr, ",", session.Engine.Quote(","), -1))
+ if session.statement.GroupByStr != "" {
+ columnStr = session.statement.Engine.Quote(strings.Replace(session.statement.GroupByStr, ",", session.engine.Quote(","), -1))
} else {
columnStr = "*"
}
@@ -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...)
- sqlStr = session.Statement.genSelectSQL(columnStr, condSQL)
+ args = append(session.statement.joinArgs, condArgs...)
+ 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
- args = session.Statement.RawParams
+ sqlStr = session.statement.RawSQL
+ args = session.statement.RawParams
}
- var err error
if session.canCache() {
- if cacher := session.Engine.getCacher2(table); cacher != nil &&
- !session.Statement.IsDistinct &&
- !session.Statement.unscoped {
+ if cacher := session.engine.getCacher2(table); cacher != nil &&
+ !session.statement.IsDistinct &&
+ !session.statement.unscoped {
err = session.cacheFind(sliceElementType, sqlStr, rowsSlicePtr, args...)
if err != ErrCacheFailed {
return err
}
err = nil // !nashtsai! reset err to nil for ErrCacheFailed
- session.Engine.logger.Warn("Cache Find Failed")
+ session.engine.logger.Warn("Cache Find Failed")
}
}
@@ -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() {
- sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+ for _, filter := range session.engine.dialect.Filters() {
+ sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
}
- newsql := session.Statement.convertIDSQL(sqlStr)
+ newsql := session.statement.convertIDSQL(sqlStr)
if newsql == "" {
return ErrCacheFailed
}
- tableName := session.Statement.TableName()
+ tableName := session.statement.TableName()
- table := session.Statement.RefTable
- cacher := session.Engine.getCacher2(table)
+ table := session.statement.RefTable
+ cacher := session.engine.getCacher2(table)
ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
if err != nil {
rows, err := session.DB().Query(newsql, args...)
@@ -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() {
- 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")
+ pk[i], err = session.engine.idTypeAssertion(col, res[i])
+ if err != nil {
+ return err
}
}
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
}
diff --git a/vendor/github.com/go-xorm/xorm/session_get.go b/vendor/github.com/go-xorm/xorm/session_get.go
index c7c03d9019..d5f768c69d 100644
--- a/vendor/github.com/go-xorm/xorm/session_get.go
+++ b/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 len(session.Statement.TableName()) <= 0 {
+ if session.statement.RawSQL == "" {
+ if len(session.statement.TableName()) <= 0 {
return false, ErrTableNotFound
}
- session.Statement.Limit(1)
- sqlStr, args = session.Statement.genGetSQL(bean)
+ session.statement.Limit(1)
+ sqlStr, args, err = session.statement.genGetSQL(bean)
+ if err != nil {
+ return false, err
+ }
} else {
- sqlStr = session.Statement.RawSQL
- args = session.Statement.RawParams
+ sqlStr = session.statement.RawSQL
+ args = session.statement.RawParams
}
if session.canCache() && beanValue.Elem().Kind() == reflect.Struct {
- if cacher := session.Engine.getCacher2(session.Statement.RefTable); cacher != nil &&
- !session.Statement.unscoped {
+ if cacher := session.engine.getCacher2(session.statement.RefTable); cacher != nil &&
+ !session.statement.unscoped {
has, err := session.cacheGet(bean, sqlStr, args...)
if err != ErrCacheFailed {
return has, err
@@ -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,30 +80,38 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, bean interface{}, sqlS
defer rawRows.Close()
- if rawRows.Next() {
- switch beanKind {
- case reflect.Struct:
- fields, err := rawRows.Columns()
- if err != nil {
- // WARN: Alougth rawRows return true, but get fields failed
- return true, err
- }
- dataStruct := rValue(bean)
- if err := session.Statement.setRefValue(dataStruct); err != nil {
- return false, err
- }
- _, err = session.row2Bean(rawRows, fields, len(fields), bean, &dataStruct, session.Statement.RefTable)
- case reflect.Slice:
- err = rawRows.ScanSlice(bean)
- case reflect.Map:
- err = rawRows.ScanMap(bean)
- default:
- err = rawRows.Scan(bean)
+ if !rawRows.Next() {
+ return false, nil
+ }
+
+ switch beanKind {
+ case reflect.Struct:
+ fields, err := rawRows.Columns()
+ if err != nil {
+ // WARN: Alougth rawRows return true, but get fields failed
+ return true, err
+ }
+ dataStruct := rValue(bean)
+ if err := session.statement.setRefValue(dataStruct); err != nil {
+ return false, err
}
- return true, err
+ 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:
+ err = rawRows.ScanMap(bean)
+ default:
+ err = rawRows.Scan(bean)
}
- return false, nil
+
+ return true, err
}
func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interface{}) (has bool, err error) {
@@ -106,19 +120,19 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
return false, ErrCacheFailed
}
- for _, filter := range session.Engine.dialect.Filters() {
- sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
+ for _, filter := range session.engine.dialect.Filters() {
+ sqlStr = filter.Do(sqlStr, session.engine.dialect, session.statement.RefTable)
}
- newsql := session.Statement.convertIDSQL(sqlStr)
+ newsql := session.statement.convertIDSQL(sqlStr)
if newsql == "" {
return false, ErrCacheFailed
}
- cacher := session.Engine.getCacher2(session.Statement.RefTable)
- tableName := session.Statement.TableName()
- session.Engine.logger.Debug("[cacheGet] find sql:", newsql, args)
+ cacher := session.engine.getCacher2(session.statement.RefTable)
+ tableName := session.statement.TableName()
+ session.engine.logger.Debug("[cacheGet] find sql:", newsql, args)
ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
- table := session.Statement.RefTable
+ table := session.statement.RefTable
if err != nil {
var res = make([]string, len(table.PrimaryKeys))
rows, err := session.DB().Query(newsql, args...)
@@ -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)))
diff --git a/vendor/github.com/go-xorm/xorm/session_insert.go b/vendor/github.com/go-xorm/xorm/session_insert.go
index 2c8ad7829b..02edf57440 100644
--- a/vendor/github.com/go-xorm/xorm/session_insert.go
+++ b/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 _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+ if session.statement.ColumnStr != "" {
+ if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
continue
}
}
- if session.Statement.OmitStr != "" {
- if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+ if session.statement.OmitStr != "" {
+ if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
continue
}
}
- if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime {
- val, t := session.Engine.NowTime2(col.SQLType.Name)
+ if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
+ val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val)
var colName = col.Name
@@ -135,7 +135,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
col := table.GetColumn(colName)
setColumnTime(bean, col, t)
})
- } else if col.IsVersion && session.Statement.checkVersion {
+ } else if col.IsVersion && session.statement.checkVersion {
args = append(args, 1)
var colName = col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) {
@@ -171,18 +171,18 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
if col.IsDeleted {
continue
}
- if session.Statement.ColumnStr != "" {
- if _, ok := getFlagForColumn(session.Statement.columnMap, col); !ok {
+ if session.statement.ColumnStr != "" {
+ if _, ok := getFlagForColumn(session.statement.columnMap, col); !ok {
continue
}
}
- if session.Statement.OmitStr != "" {
- if _, ok := getFlagForColumn(session.Statement.columnMap, col); ok {
+ if session.statement.OmitStr != "" {
+ if _, ok := getFlagForColumn(session.statement.columnMap, col); ok {
continue
}
}
- if (col.IsCreated || col.IsUpdated) && session.Statement.UseAutoTime {
- val, t := session.Engine.NowTime2(col.SQLType.Name)
+ if (col.IsCreated || col.IsUpdated) && session.statement.UseAutoTime {
+ val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val)
var colName = col.Name
@@ -190,7 +190,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
col := table.GetColumn(colName)
setColumnTime(bean, col, t)
})
- } else if col.IsVersion && session.Statement.checkVersion {
+ } else if col.IsVersion && session.statement.checkVersion {
args = append(args, 1)
var colName = col.Name
session.afterClosures = append(session.afterClosures, func(bean interface{}) {
@@ -214,25 +214,25 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
var sql = "INSERT INTO %s (%v%v%v) VALUES (%v)"
var statement string
- if session.Engine.dialect.DBType() == core.ORACLE {
+ if session.engine.dialect.DBType() == core.ORACLE {
sql = "INSERT ALL INTO %s (%v%v%v) VALUES (%v) SELECT 1 FROM DUAL"
temp := fmt.Sprintf(") INTO %s (%v%v%v) VALUES (",
- session.Engine.Quote(session.Statement.TableName()),
- session.Engine.QuoteStr(),
- strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
- session.Engine.QuoteStr())
+ session.engine.Quote(session.statement.TableName()),
+ session.engine.QuoteStr(),
+ strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
+ session.engine.QuoteStr())
statement = fmt.Sprintf(sql,
- session.Engine.Quote(session.Statement.TableName()),
- session.Engine.QuoteStr(),
- strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
- session.Engine.QuoteStr(),
+ session.engine.Quote(session.statement.TableName()),
+ session.engine.QuoteStr(),
+ strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
+ session.engine.QuoteStr(),
strings.Join(colMultiPlaces, temp))
} else {
statement = fmt.Sprintf(sql,
- session.Engine.Quote(session.Statement.TableName()),
- session.Engine.QuoteStr(),
- strings.Join(colNames, session.Engine.QuoteStr()+", "+session.Engine.QuoteStr()),
- session.Engine.QuoteStr(),
+ session.engine.Quote(session.statement.TableName()),
+ session.engine.QuoteStr(),
+ strings.Join(colNames, session.engine.QuoteStr()+", "+session.engine.QuoteStr()),
+ session.engine.QuoteStr(),
strings.Join(colMultiPlaces, "),("))
}
res, err := session.exec(statement, args...)
@@ -240,8 +240,8 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
return 0, err
}
- if cacher := session.Engine.getCacher2(table); cacher != nil && session.Statement.UseCache {
- session.cacheInsert(session.Statement.TableName())
+ if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+ session.cacheInsert(session.statement.TableName())
}
lenAfterClosures := len(session.afterClosures)
@@ -249,7 +249,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
elemValue := reflect.Indirect(sliceValue.Index(i)).Addr().Interface()
// handle AfterInsertProcessor
- if session.IsAutoCommit {
+ if session.isAutoCommit {
// !nashtsai! does user expect it's same slice to passed closure when using Before()/After() when insert multi??
for _, closure := range session.afterClosures {
closure(elemValue)
@@ -281,7 +281,7 @@ func (session *Session) innerInsertMulti(rowsSlicePtr interface{}) (int64, error
// InsertMulti insert multiple records
func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
defer session.resetStatement()
- if session.IsAutoClose {
+ if session.isAutoClose {
defer session.Close()
}
@@ -299,14 +299,14 @@ func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
}
func (session *Session) innerInsert(bean interface{}) (int64, error) {
- if err := session.Statement.setRefValue(rValue(bean)); err != nil {
+ if err := session.statement.setRefValue(rValue(bean)); err != nil {
return 0, err
}
- if len(session.Statement.TableName()) <= 0 {
+ if len(session.statement.TableName()) <= 0 {
return 0, ErrTableNotFound
}
- table := session.Statement.RefTable
+ table := session.statement.RefTable
// handle BeforeInsertProcessor
for _, closure := range session.beforeClosures {
@@ -318,12 +318,12 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
processor.BeforeInsert()
}
// --
- colNames, args, err := genCols(session.Statement.RefTable, session, bean, false, false)
+ colNames, args, err := genCols(session.statement.RefTable, session, bean, false, false)
if err != nil {
return 0, err
}
// insert expr columns, override if exists
- exprColumns := session.Statement.getExpr()
+ exprColumns := session.statement.getExpr()
exprColVals := make([]string, 0, len(exprColumns))
for _, v := range exprColumns {
// remove the expr columns
@@ -343,18 +343,29 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
if len(exprColVals) > 0 {
colPlaces = colPlaces + strings.Join(exprColVals, ", ")
} else {
- colPlaces = colPlaces[0 : len(colPlaces)-2]
+ if len(colPlaces) > 0 {
+ colPlaces = colPlaces[0 : len(colPlaces)-2]
+ }
}
- sqlStr := fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)",
- session.Engine.Quote(session.Statement.TableName()),
- session.Engine.QuoteStr(),
- strings.Join(colNames, session.Engine.Quote(", ")),
- session.Engine.QuoteStr(),
- colPlaces)
+ var sqlStr string
+ if len(colPlaces) > 0 {
+ sqlStr = fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)",
+ session.engine.Quote(session.statement.TableName()),
+ session.engine.QuoteStr(),
+ strings.Join(colNames, session.engine.Quote(", ")),
+ session.engine.QuoteStr(),
+ 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 {
- //assert table.AutoIncrement != ""
+ if session.engine.dialect.DBType() == core.ORACLE && len(table.AutoIncrement) > 0 {
res, err := session.query("select seq_atable.currval from dual", args...)
if err != nil {
return 0, err
@@ -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 {
- session.cacheInsert(session.Statement.TableName())
+ if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+ session.cacheInsert(session.statement.TableName())
}
- if table.Version != "" && session.Statement.checkVersion {
+ if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil {
- session.Engine.logger.Error(err)
+ session.engine.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() {
verValue.SetInt(1)
}
@@ -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 {
- session.cacheInsert(session.Statement.TableName())
+ if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+ session.cacheInsert(session.statement.TableName())
}
- if table.Version != "" && session.Statement.checkVersion {
+ if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil {
- session.Engine.logger.Error(err)
+ session.engine.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() {
verValue.SetInt(1)
}
@@ -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 {
- session.cacheInsert(session.Statement.TableName())
+ if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+ session.cacheInsert(session.statement.TableName())
}
- if table.Version != "" && session.Statement.checkVersion {
+ if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil {
- session.Engine.logger.Error(err)
+ session.engine.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() {
verValue.SetInt(1)
}
@@ -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
- cacher := session.Engine.getCacher2(table)
+ table := session.statement.RefTable
+ cacher := session.engine.getCacher2(table)
for _, t := range tables {
- session.Engine.logger.Debug("[cache] clear sql:", t)
+ session.engine.logger.Debug("[cache] clear sql:", t)
cacher.ClearIds(t)
}
diff --git a/vendor/github.com/go-xorm/xorm/session_raw.go b/vendor/github.com/go-xorm/xorm/session_raw.go
index 0f5a0a43cf..05223c465e 100644
--- a/vendor/github.com/go-xorm/xorm/session_raw.go
+++ b/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) {
- if session.IsAutoCommit {
+ return session.engine.logSQLExecutionTime(sqlStr, args, func() (sql.Result, error) {
+ if session.isAutoCommit {
// FIXME: oci8 can not auto commit (github.com/mattn/go-oci8)
- if session.Engine.dialect.DBType() == core.ORACLE {
+ if session.engine.dialect.DBType() == core.ORACLE {
session.Begin()
- r, err := session.Tx.Exec(sqlStr, args...)
+ r, err := session.tx.Exec(sqlStr, args...)
session.Commit()
return r, err
}
return session.innerExec(sqlStr, args...)
}
- return session.Tx.Exec(sqlStr, args...)
+ return session.tx.Exec(sqlStr, args...)
})
}
// Exec raw sql
func (session *Session) Exec(sqlStr string, args ...interface{}) (sql.Result, error) {
defer session.resetStatement()
- if session.IsAutoClose {
+ if session.isAutoClose {
defer session.Close()
}
diff --git a/vendor/github.com/go-xorm/xorm/session_schema.go b/vendor/github.com/go-xorm/xorm/session_schema.go
index 19c0cbf539..c1d5088d78 100644
--- a/vendor/github.com/go-xorm/xorm/session_schema.go
+++ b/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 err := session.Statement.setRefValue(v); err != nil {
- return err
- }
-
- defer session.resetStatement()
- if session.IsAutoClose {
+ 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 err := session.Statement.setRefValue(v); err != nil {
- return err
- }
-
- defer session.resetStatement()
- if session.IsAutoClose {
+ if session.isAutoClose {
defer session.Close()
}
- sqls := session.Statement.genIndexSQL()
+ 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()
- if session.IsAutoClose {
- defer session.Close()
- }
-
- sqls := session.Statement.genUniqueSQL()
+ sqls := session.statement.genUniqueSQL()
for _, sqlStr := range sqls {
_, err := session.exec(sqlStr)
if err != nil {
@@ -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 {
+// DropIndexes drop indexes
+func (session *Session) DropIndexes(bean interface{}) 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
+ return session.dropIndexes(bean)
}
-// DropIndexes drop indexes
-func (session *Session) DropIndexes(bean interface{}) error {
+func (session *Session) dropIndexes(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()
- if session.IsAutoClose {
- defer session.Close()
- }
-
- sqls := session.Statement.genDelIndexSQL()
+ sqls := session.statement.genDelIndexSQL()
for _, sqlStr := range sqls {
_, err := session.exec(sqlStr)
if err != nil {
@@ -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() {
- sqlStr, args := session.Engine.dialect.TableCheckSql(tableName)
+ if !session.engine.dialect.SupportDropIfExists() {
+ sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
results, err := session.query(sqlStr, args...)
if err != nil {
return err
@@ -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 {
- defer session.Close()
- }
- sqlStr, args := session.Engine.dialect.TableCheckSql(tableName)
+ sqlStr, args := session.engine.dialect.TableCheckSql(tableName)
results, err := session.query(sqlStr, args...)
return len(results) > 0, err
}
@@ -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)
- sql, args := session.Statement.genAddColumnStr(col)
+ col := session.statement.RefTable.GetColumn(colName)
+ sql, args := session.statement.genAddColumnStr(col)
_, err := session.exec(sql, args...)
return err
}
func (session *Session) addIndex(tableName, idxName string) error {
defer session.resetStatement()
- if session.IsAutoClose {
- 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.tableName = tbName
- defer session.Close()
+ session.statement.RefTable = table
+ session.statement.tableName = tbName
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.tableName = tbName
- defer session.Close()
+ session.statement.RefTable = table
+ session.statement.tableName = tbName
err = session.addUnique(tbName, name)
} else if index.Type == core.IndexType {
- session := engine.NewSession()
- session.Statement.RefTable = table
- session.Statement.tableName = tbName
- defer session.Close()
+ session.statement.RefTable = table
+ session.statement.tableName = tbName
err = session.addIndex(tbName, name)
}
if err != nil {
diff --git a/vendor/github.com/go-xorm/xorm/session_stats.go b/vendor/github.com/go-xorm/xorm/session_stats.go
new file mode 100644
index 0000000000..df02e95a8a
--- /dev/null
+++ b/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...)
+}
diff --git a/vendor/github.com/go-xorm/xorm/session_sum.go b/vendor/github.com/go-xorm/xorm/session_sum.go
deleted file mode 100644
index e1409c7ff4..0000000000
--- a/vendor/github.com/go-xorm/xorm/session_sum.go
+++ /dev/null
@@ -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
-}
diff --git a/vendor/github.com/go-xorm/xorm/session_tx.go b/vendor/github.com/go-xorm/xorm/session_tx.go
index 302bc104d5..84d2f7f9dc 100644
--- a/vendor/github.com/go-xorm/xorm/session_tx.go
+++ b/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.IsCommitedOrRollbacked = false
- session.Tx = tx
+ session.isAutoCommit = false
+ session.isCommitedOrRollbacked = false
+ session.tx = tx
session.saveLastSQL("BEGIN TRANSACTION")
}
return nil
@@ -21,25 +21,23 @@ func (session *Session) Begin() error {
// Rollback When using transaction, you can rollback if any error
func (session *Session) Rollback() error {
- if !session.IsAutoCommit && !session.IsCommitedOrRollbacked {
- session.saveLastSQL(session.Engine.dialect.RollBackStr())
- session.IsCommitedOrRollbacked = true
- return session.Tx.Rollback()
+ if !session.isAutoCommit && !session.isCommitedOrRollbacked {
+ session.saveLastSQL(session.engine.dialect.RollBackStr())
+ session.isCommitedOrRollbacked = true
+ return session.tx.Rollback()
}
return nil
}
// Commit When using transaction, Commit will commit all operations.
func (session *Session) Commit() error {
- if !session.IsAutoCommit && !session.IsCommitedOrRollbacked {
+ if !session.isAutoCommit && !session.isCommitedOrRollbacked {
session.saveLastSQL("COMMIT")
- session.IsCommitedOrRollbacked = true
+ session.isCommitedOrRollbacked = true
var err error
- if err = session.Tx.Commit(); err == nil {
+ if err = session.tx.Commit(); err == nil {
// handle processors after tx committed
-
closureCallFunc := func(closuresPtr *[]func(interface{}), bean interface{}) {
-
if closuresPtr != nil {
for _, closure := range *closuresPtr {
closure(bean)
diff --git a/vendor/github.com/go-xorm/xorm/session_update.go b/vendor/github.com/go-xorm/xorm/session_update.go
index 1d77d294f3..e80cd0b577 100644
--- a/vendor/github.com/go-xorm/xorm/session_update.go
+++ b/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 ||
- session.Tx != nil {
+ if session.statement.RefTable == nil ||
+ session.tx != nil {
return ErrCacheFailed
}
- oldhead, newsql := session.Statement.convertUpdateSQL(sqlStr)
+ oldhead, newsql := session.statement.convertUpdateSQL(sqlStr)
if newsql == "" {
return ErrCacheFailed
}
- for _, filter := range session.Engine.dialect.Filters() {
- newsql = filter.Do(newsql, session.Engine.dialect, session.Statement.RefTable)
+ for _, filter := range session.engine.dialect.Filters() {
+ newsql = filter.Do(newsql, session.engine.dialect, session.statement.RefTable)
}
- session.Engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql)
+ session.engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql)
var nStart int
if len(args) > 0 {
@@ -39,10 +39,10 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
nStart = strings.Count(oldhead, "$")
}
}
- table := session.Statement.RefTable
- cacher := session.Engine.getCacher2(table)
- tableName := session.Statement.TableName()
- session.Engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
+ table := session.statement.RefTable
+ cacher := session.engine.getCacher2(table)
+ tableName := session.statement.TableName()
+ session.engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
ids, err := core.GetCacheSql(cacher, tableName, newsql, args[nStart:])
if err != nil {
rows, err := session.DB().Query(newsql, args[nStart:]...)
@@ -75,9 +75,9 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
ids = append(ids, pk)
}
- session.Engine.logger.Debug("[cacheUpdate] find updated id", ids)
+ session.engine.logger.Debug("[cacheUpdate] find updated id", ids)
} /*else {
- session.Engine.LogDebug("[xorm:cacheUpdate] del cached sql:", tableName, newsql, args)
+ session.engine.LogDebug("[xorm:cacheUpdate] del cached sql:", tableName, newsql, args)
cacher.DelIds(tableName, genSqlKey(newsql, args))
}*/
@@ -103,36 +103,36 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
colName := sps2[len(sps2)-1]
if strings.Contains(colName, "`") {
colName = strings.TrimSpace(strings.Replace(colName, "`", "", -1))
- } else if strings.Contains(colName, session.Engine.QuoteStr()) {
- colName = strings.TrimSpace(strings.Replace(colName, session.Engine.QuoteStr(), "", -1))
+ } else if strings.Contains(colName, session.engine.QuoteStr()) {
+ colName = strings.TrimSpace(strings.Replace(colName, session.engine.QuoteStr(), "", -1))
} else {
- session.Engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName)
+ session.engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName)
return ErrCacheFailed
}
if col := table.GetColumn(colName); col != nil {
fieldValue, err := col.ValueOf(bean)
if err != nil {
- session.Engine.logger.Error(err)
+ session.engine.logger.Error(err)
} else {
- session.Engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
- if col.IsVersion && session.Statement.checkVersion {
+ session.engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
+ if col.IsVersion && session.statement.checkVersion {
fieldValue.SetInt(fieldValue.Int() + 1)
} else {
fieldValue.Set(reflect.ValueOf(args[idx]))
}
}
} else {
- session.Engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's",
+ session.engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's",
colName, table.Name)
}
}
- session.Engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean)
+ session.engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean)
cacher.PutBean(tableName, sid, bean)
}
}
- session.Engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName)
+ session.engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName)
cacher.ClearIds(tableName)
return nil
}
@@ -145,7 +145,7 @@ func (session *Session) cacheUpdate(sqlStr string, args ...interface{}) error {
// 2.float32 & float64 may be not inexact as conditions
func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int64, error) {
defer session.resetStatement()
- if session.IsAutoClose {
+ if session.isAutoClose {
defer session.Close()
}
@@ -169,21 +169,21 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
var isMap = t.Kind() == reflect.Map
var isStruct = t.Kind() == reflect.Struct
if isStruct {
- if err := session.Statement.setRefValue(v); err != nil {
+ if err := session.statement.setRefValue(v); err != nil {
return 0, err
}
- if len(session.Statement.TableName()) <= 0 {
+ if len(session.statement.TableName()) <= 0 {
return 0, ErrTableNotFound
}
- if session.Statement.ColumnStr == "" {
- colNames, args = buildUpdates(session.Engine, session.Statement.RefTable, bean, false, false,
- false, false, session.Statement.allUseBool, session.Statement.useAllCols,
- session.Statement.mustColumnMap, session.Statement.nullableMap,
- session.Statement.columnMap, true, session.Statement.unscoped)
+ if session.statement.ColumnStr == "" {
+ colNames, args = buildUpdates(session.engine, session.statement.RefTable, bean, false, false,
+ false, false, session.statement.allUseBool, session.statement.useAllCols,
+ session.statement.mustColumnMap, session.statement.nullableMap,
+ session.statement.columnMap, true, session.statement.unscoped)
} else {
- colNames, args, err = genCols(session.Statement.RefTable, session, bean, true, true)
+ colNames, args, err = genCols(session.statement.RefTable, session, bean, true, true)
if err != nil {
return 0, err
}
@@ -194,19 +194,19 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
bValue := reflect.Indirect(reflect.ValueOf(bean))
for _, v := range bValue.MapKeys() {
- colNames = append(colNames, session.Engine.Quote(v.String())+" = ?")
+ colNames = append(colNames, session.engine.Quote(v.String())+" = ?")
args = append(args, bValue.MapIndex(v).Interface())
}
} else {
return 0, ErrParamsType
}
- table := session.Statement.RefTable
+ table := session.statement.RefTable
- if session.Statement.UseAutoTime && table != nil && table.Updated != "" {
- colNames = append(colNames, session.Engine.Quote(table.Updated)+" = ?")
+ if session.statement.UseAutoTime && table != nil && table.Updated != "" {
+ colNames = append(colNames, session.engine.Quote(table.Updated)+" = ?")
col := table.UpdatedColumn()
- val, t := session.Engine.NowTime2(col.SQLType.Name)
+ val, t := session.engine.NowTime2(col.SQLType.Name)
args = append(args, val)
var colName = col.Name
@@ -219,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()})
- colNames = append(colNames, session.Engine.Quote(table.Version)+" = "+session.Engine.Quote(table.Version)+" + 1")
+ cond = cond.And(builder.Eq{session.engine.Quote(table.Version): verValue.Interface()})
+ colNames = append(colNames, session.engine.Quote(table.Version)+" = "+session.engine.Quote(table.Version)+" + 1")
+ }
+
+ condSQL, condArgs, err = builder.ToSQL(cond)
+ 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...))
- condSQL, condArgs, _ = builder.ToSQL(cond)
+ session.engine.Quote(session.statement.TableName()), tempCondSQL), condArgs...))
+ 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...))
- condSQL, condArgs, _ = builder.ToSQL(cond)
+ session.engine.Quote(session.statement.TableName()), tempCondSQL), condArgs...))
+ 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 {
- cacher.ClearIds(session.Statement.TableName())
- cacher.ClearBeans(session.Statement.TableName())
+ if cacher := session.engine.getCacher2(table); cacher != nil && session.statement.UseCache {
+ cacher.ClearIds(session.statement.TableName())
+ cacher.ClearBeans(session.statement.TableName())
}
}
// handle after update processors
- if session.IsAutoCommit {
+ if session.isAutoCommit {
for _, closure := range session.afterClosures {
closure(bean)
}
if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
- session.Engine.logger.Debug("[event]", session.Statement.TableName(), " has after update processor")
+ session.engine.logger.Debug("[event]", session.statement.TableName(), " has after update processor")
processor.AfterUpdate()
}
} else {
diff --git a/vendor/github.com/go-xorm/xorm/statement.go b/vendor/github.com/go-xorm/xorm/statement.go
index b6f0baf206..50008d1dd8 100644
--- a/vendor/github.com/go-xorm/xorm/statement.go
+++ b/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,21 +966,37 @@ func (statement *Statement) genGetSQL(bean interface{}) (string, []interface{})
columnStr = "*"
}
- var condSQL string
- var condArgs []interface{}
if isStruct {
- condSQL, condArgs, _ = statement.genConds(bean)
- } else {
- condSQL, condArgs, _ = builder.ToSQL(statement.cond)
+ if err := statement.mergeConds(bean); err != nil {
+ return "", nil, err
+ }
+ }
+ condSQL, condArgs, err := builder.ToSQL(statement.cond)
+ if err != nil {
+ return "", nil, err
}
- return statement.genSelectSQL(columnStr, condSQL), append(statement.joinArgs, condArgs...)
+ sqlStr, err := statement.genSelectSQL(columnStr, condSQL)
+ if err != nil {
+ return "", nil, err
+ }
+
+ return sqlStr, append(statement.joinArgs, condArgs...), nil
}
-func (statement *Statement) genCountSQL(bean interface{}) (string, []interface{}) {
- statement.setRefValue(rValue(bean))
-
- condSQL, condArgs, _ := statement.genConds(bean)
+func (statement *Statement) genCountSQL(beans ...interface{}) (string, []interface{}, error) {
+ var condSQL string
+ var condArgs []interface{}
+ var err error
+ if len(beans) > 0 {
+ statement.setRefValue(rValue(beans[0]))
+ condSQL, condArgs, err = statement.genConds(beans[0])
+ } else {
+ condSQL, condArgs, err = builder.ToSQL(statement.cond)
+ }
+ if err != nil {
+ return "", nil, err
+ }
var selectSQL = statement.selectStr
if len(selectSQL) <= 0 {
@@ -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
+ }
+
+ return sqlStr, append(statement.joinArgs, condArgs...), nil
}
-func (statement *Statement) genSumSQL(bean interface{}, columns ...string) (string, []interface{}) {
+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 "", nil, err
+ }
- return statement.genSelectSQL(sumSelect, condSQL), append(statement.joinArgs, condArgs...)
+ 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) {
+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: ""})
- }
+ statement.cond = statement.cond.And(builder.Eq{colName: (*(statement.idParam))[i]})
}
+ return nil
}
func (statement *Statement) joinColumns(cols []*core.Column, includeTableName bool) string {
diff --git a/vendor/github.com/go-xorm/xorm/tag.go b/vendor/github.com/go-xorm/xorm/tag.go
index 4b0e3f54a5..e1c821fb54 100644
--- a/vendor/github.com/go-xorm/xorm/tag.go
+++ b/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}
diff --git a/vendor/github.com/go-xorm/xorm/test_mssql.sh b/vendor/github.com/go-xorm/xorm/test_mssql.sh
new file mode 100755
index 0000000000..6f9cf7295f
--- /dev/null
+++ b/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"
\ No newline at end of file
diff --git a/vendor/github.com/go-xorm/xorm/test_mymysql.sh b/vendor/github.com/go-xorm/xorm/test_mymysql.sh
new file mode 100755
index 0000000000..f7780d14fa
--- /dev/null
+++ b/vendor/github.com/go-xorm/xorm/test_mymysql.sh
@@ -0,0 +1 @@
+go test -db=mymysql -conn_str="xorm_test/root/"
\ No newline at end of file
diff --git a/vendor/github.com/go-xorm/xorm/test_mysql.sh b/vendor/github.com/go-xorm/xorm/test_mysql.sh
new file mode 100755
index 0000000000..650e4ee170
--- /dev/null
+++ b/vendor/github.com/go-xorm/xorm/test_mysql.sh
@@ -0,0 +1 @@
+go test -db=mysql -conn_str="root:@/xorm_test"
\ No newline at end of file
diff --git a/vendor/github.com/go-xorm/xorm/test_postgres.sh b/vendor/github.com/go-xorm/xorm/test_postgres.sh
new file mode 100755
index 0000000000..dc1152e0a6
--- /dev/null
+++ b/vendor/github.com/go-xorm/xorm/test_postgres.sh
@@ -0,0 +1 @@
+go test -db=postgres -conn_str="dbname=xorm_test sslmode=disable"
\ No newline at end of file
diff --git a/vendor/github.com/go-xorm/xorm/test_sqlite.sh b/vendor/github.com/go-xorm/xorm/test_sqlite.sh
new file mode 100755
index 0000000000..6352b5cb5f
--- /dev/null
+++ b/vendor/github.com/go-xorm/xorm/test_sqlite.sh
@@ -0,0 +1 @@
+go test -db=sqlite3 -conn_str="./test.db?cache=shared&mode=rwc"
\ No newline at end of file
diff --git a/vendor/github.com/go-xorm/xorm/xorm.go b/vendor/github.com/go-xorm/xorm/xorm.go
index c22c1b652c..4434c7ff37 100644
--- a/vendor/github.com/go-xorm/xorm/xorm.go
+++ b/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)
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 2d7eb74660..5fd393b8be 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -452,14 +452,14 @@
{
"checksumSHA1": "9SXbj96wb1PgppBZzxMIN0axbFQ=",
"path": "github.com/go-xorm/builder",
- "revision": "043186300e9b2c22abdfc83567a979e3af04d9ae",
- "revisionTime": "2017-05-18T21:58:56Z"
+ "revision": "c8871c857d2555fbfbd8524f895be5386d3d8836",
+ "revisionTime": "2017-05-19T03:21:30Z"
},
{
- "checksumSHA1": "vt2CGANHLNXPAZ01ve3UlsgQ0uU=",
+ "checksumSHA1": "KOHXTLwpgTMxBB9aGF2aIxkWdm8=",
"path": "github.com/go-xorm/core",
- "revision": "e8409d73255791843585964791443dbad877058c",
- "revisionTime": "2017-03-17T12:25:07Z"
+ "revision": "71c1070a861118827352b1394eb86cbfeef5c513",
+ "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",
- "revisionTime": "2017-04-20T16:02:48Z"
+ "revision": "a10b5aba4bb97b30daa74e7c0363d3084ede0514",
+ "revisionTime": "2017-08-20T09:05:42Z"
},
{
"checksumSHA1": "1ft/4j5MFa7C9dPI9whL03HSUzk=",