@@ -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) |
@@ -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: "", | |||
} | |||
} | |||
@@ -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 += ", " | |||
} | |||
@@ -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 |
@@ -22,6 +22,7 @@ type Table struct { | |||
Cacher Cacher | |||
StoreEngine string | |||
Charset string | |||
Comment string | |||
} | |||
func (table *Table) Columns() []*Column { |
@@ -2,11 +2,9 @@ | |||
Xorm is a simple and powerful ORM for Go. | |||
[![CircleCI](https://circleci.com/gh/go-xorm/xorm/tree/master.svg?style=svg)](https://circleci.com/gh/go-xorm/xorm/tree/master) [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/go-xorm/xorm?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) | |||
# 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. | |||
[![CircleCI](https://circleci.com/gh/go-xorm/xorm.svg?style=shield)](https://circleci.com/gh/go-xorm/xorm) [![codecov](https://codecov.io/gh/go-xorm/xorm/branch/master/graph/badge.svg)](https://codecov.io/gh/go-xorm/xorm) | |||
[![](https://goreportcard.com/badge/github.com/go-xorm/xorm)](https://goreportcard.com/report/github.com/go-xorm/xorm) | |||
[![Join the chat at https://img.shields.io/discord/323460943201959939.svg](https://img.shields.io/discord/323460943201959939.svg)](https://discord.gg/HuR2CF3) | |||
# 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) | |||
@@ -4,11 +4,9 @@ | |||
xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作非常简便。 | |||
[![CircleCI](https://circleci.com/gh/go-xorm/xorm/tree/master.svg?style=svg)](https://circleci.com/gh/go-xorm/xorm/tree/master) [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/go-xorm/xorm?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) | |||
# 注意 | |||
最新的版本有不兼容的更新,您必须使用 `engine.ShowSQL()` 和 `engine.Logger().SetLevel()` 来替代 `engine.ShowSQL = `, `engine.ShowInfo = ` 等等。 | |||
[![CircleCI](https://circleci.com/gh/go-xorm/xorm.svg?style=shield)](https://circleci.com/gh/go-xorm/xorm) [![codecov](https://codecov.io/gh/go-xorm/xorm/branch/master/graph/badge.svg)](https://codecov.io/gh/go-xorm/xorm) | |||
[![](https://goreportcard.com/badge/github.com/go-xorm/xorm)](https://goreportcard.com/report/github.com/go-xorm/xorm) | |||
[![Join the chat at https://img.shields.io/discord/323460943201959939.svg](https://img.shields.io/discord/323460943201959939.svg)](https://discord.gg/HuR2CF3) | |||
## 特性 | |||
@@ -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) | |||
@@ -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 | |||
- cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./postgres.sh | |||
post: | |||
- bash <(curl -s https://codecov.io/bash) |
@@ -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 { |
@@ -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) | |||
} |
@@ -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, "`[] "), `"`) |
@@ -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") |
@@ -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) | |||
} | |||
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) | |||
if col.TimeZone != nil { | |||
return engine.formatTime(col.SQLType.Name, t.In(col.TimeZone)) | |||
} | |||
return engine.formatTime(col.SQLType.Name, t.In(engine.DatabaseTZ)) | |||
} | |||
// 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}) | |||
} |
@@ -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 | |||
} |
@@ -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) | |||
} |
@@ -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() { | |||
kind := tp.Kind() | |||
if kind == reflect.Ptr { | |||
kind = tp.Elem().Kind() | |||
} | |||
switch kind { | |||
case reflect.Int16: | |||
v = int16(id) | |||
temp := int16(id) | |||
v = &temp | |||
case reflect.Int32: | |||
v = int32(id) | |||
temp := int32(id) | |||
v = &temp | |||
case reflect.Int: | |||
v = int(id) | |||
temp := int(id) | |||
v = &temp | |||
case reflect.Int64: | |||
v = id | |||
temp := id | |||
v = &temp | |||
case reflect.Uint16: | |||
v = uint16(id) | |||
temp := uint16(id) | |||
v = &temp | |||
case reflect.Uint32: | |||
v = uint32(id) | |||
temp := uint32(id) | |||
v = &temp | |||
case reflect.Uint64: | |||
v = uint64(id) | |||
temp := uint64(id) | |||
v = &temp | |||
case reflect.Uint: | |||
v = uint(id) | |||
temp := uint(id) | |||
v = &temp | |||
} | |||
if tp.Kind() == reflect.Ptr { | |||
return reflect.ValueOf(v).Convert(tp) | |||
} | |||
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) | |||
} |
@@ -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 | |||
} |
@@ -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 | |||
} | |||
scanResults, err := rows.session.row2Slice(rows.rows, rows.fields, len(rows.fields), bean) | |||
if err != nil { | |||
return err | |||
} | |||
_, err := rows.session.row2Bean(rows.rows, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.Statement.RefTable) | |||
_, err = rows.session.slice2Bean(scanResults, rows.fields, len(rows.fields), bean, &dataStruct, rows.session.statement.RefTable) | |||
return err | |||
} | |||
// Close session if session.IsAutoClose is true, and claimed any opened resources | |||
func (rows *Rows) Close() error { | |||
if rows.session.IsAutoClose { | |||
if rows.session.isAutoClose { | |||
defer rows.session.Close() | |||
} | |||
@@ -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 | |||
} |
@@ -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 | |||
} |
@@ -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 | |||
} |
@@ -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 | |||
} | |||
} |
@@ -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) | |||
} |
@@ -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 | |||
} |
@@ -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 | |||
} |
@@ -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))) |
@@ -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) | |||
} | |||
@@ -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() | |||
} | |||
@@ -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 | |||
if session.isAutoClose { | |||
defer session.Close() | |||
} | |||
return session.createTable(bean) | |||
} | |||
func (session *Session) createTable(bean interface{}) error { | |||
defer session.resetStatement() | |||
if session.IsAutoClose { | |||
defer session.Close() | |||
v := rValue(bean) | |||
if err := session.statement.setRefValue(v); err != nil { | |||
return err | |||
} | |||
return session.createOneTable() | |||
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 | |||
if session.isAutoClose { | |||
defer session.Close() | |||
} | |||
return session.createIndexes(bean) | |||
} | |||
func (session *Session) createIndexes(bean interface{}) error { | |||
defer session.resetStatement() | |||
if session.IsAutoClose { | |||
defer session.Close() | |||
v := rValue(bean) | |||
if err := session.statement.setRefValue(v); err != nil { | |||
return err | |||
} | |||
sqls := session.Statement.genIndexSQL() | |||
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 { | |||
v := rValue(bean) | |||
if err := session.Statement.setRefValue(v); err != nil { | |||
return err | |||
if session.isAutoClose { | |||
defer session.Close() | |||
} | |||
return session.createUniques(bean) | |||
} | |||
func (session *Session) createUniques(bean interface{}) error { | |||
defer session.resetStatement() | |||
if session.IsAutoClose { | |||
defer session.Close() | |||
v := rValue(bean) | |||
if err := session.statement.setRefValue(v); err != nil { | |||
return err | |||
} | |||
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 { |
@@ -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...) | |||
} |
@@ -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 | |||
} |
@@ -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) |
@@ -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 { |
@@ -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 | |||
} | |||
func (statement *Statement) genCountSQL(bean interface{}) (string, []interface{}) { | |||
statement.setRefValue(rValue(bean)) | |||
return sqlStr, append(statement.joinArgs, condArgs...), nil | |||
} | |||
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 | |||
} | |||
sqlStr, err := statement.genSelectSQL(sumSelect, condSQL) | |||
if err != nil { | |||
return "", nil, err | |||
} | |||
return statement.genSelectSQL(sumSelect, condSQL), append(statement.joinArgs, condArgs...) | |||
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 { |
@@ -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} |
@@ -0,0 +1 @@ | |||
go test -db=mssql -conn_str="server=192.168.1.58;user id=sa;password=123456;database=xorm_test" |
@@ -0,0 +1 @@ | |||
go test -db=mymysql -conn_str="xorm_test/root/" |
@@ -0,0 +1 @@ | |||
go test -db=mysql -conn_str="root:@/xorm_test" |
@@ -0,0 +1 @@ | |||
go test -db=postgres -conn_str="dbname=xorm_test sslmode=disable" |
@@ -0,0 +1 @@ | |||
go test -db=sqlite3 -conn_str="./test.db?cache=shared&mode=rwc" |
@@ -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) |
@@ -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=", |