HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

golint and comments

This commit is contained in:
Lunny Xiao 2016-07-11 11:29:34 +08:00
parent b8b1711cde
commit ea9a4495ac
3 changed files with 190 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
engine.go
View File

@ -161,11 +161,16 @@ func (engine *Engine) quoteTable(keyName string) string {
return engine.dialect.QuoteStr() + keyName + engine.dialect.QuoteStr()
}
// SqlType A simple wrapper to dialect's core.SqlType method
// SqlType will be depracated, please use SQLType instead
func (engine *Engine) SqlType(c *core.Column) string {
return engine.dialect.SqlType(c)
}
// SQLType A simple wrapper to dialect's core.SqlType method
func (engine *Engine) SQLType(c *core.Column) string {
return engine.dialect.SqlType(c)
}
// AutoIncrStr Database's autoincrement statement
func (engine *Engine) AutoIncrStr() string {
return engine.dialect.AutoIncrStr()
@ -265,9 +270,8 @@ func (engine *Engine) logSQLQueryTime(sqlStr string, args []interface{}, executi
engine.logger.Infof("[sql] %s - took: %v", sqlStr, execDuration)
}
return stmt, res, err
} else {
return executionBlock()
}
return executionBlock()
}
func (engine *Engine) logSQLExecutionTime(sqlStr string, args []interface{}, executionBlock func() (sql.Result, error)) (sql.Result, error) {
@ -281,24 +285,29 @@ func (engine *Engine) logSQLExecutionTime(sqlStr string, args []interface{}, exe
engine.logger.Infof("[sql] %s - took: %v", sqlStr, execDuration)
}
return res, err
} else {
}
return executionBlock()
}
}
// Sql method let's you manualy write raw sql and operate
// For example:
//
// engine.Sql("select * from user").Find(&users)
//
// This code will execute "select * from user" and set the records to users
//
// Sql will be depracated, please use SQL instead
func (engine *Engine) Sql(querystring string, args ...interface{}) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Sql(querystring, args...)
}
// SQL method let's you manualy write raw SQL and operate
// For example:
//
// engine.SQL("select * from user").Find(&users)
//
// This code will execute "select * from user" and set the records to users
func (engine *Engine) SQL(querystring string, args ...interface{}) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.SQL(querystring, args...)
}
// NoAutoTime Default if your struct has "created" or "updated" filed tag, the fields
// will automatically be filled with current time when Insert or Update
// invoked. Call NoAutoTime if you dont' want to fill automatically.
@ -618,7 +627,7 @@ func (engine *Engine) dumpTables(tables []*core.Table, w io.Writer, tp ...core.D
return nil
}
// use cascade or not
// Cascade use cascade or not
func (engine *Engine) Cascade(trueOrFalse ...bool) *Session {
session := engine.NewSession()
session.IsAutoClose = true
@ -632,42 +641,49 @@ func (engine *Engine) Where(querystring string, args ...interface{}) *Session {
return session.Where(querystring, args...)
}
// Id mehtod provoide a condition as (id) = ?
// Id will be depracated, please use ID instead
func (engine *Engine) Id(id interface{}) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Id(id)
}
// Apply before Processor, affected bean is passed to closure arg
// ID mehtod provoide a condition as (id) = ?
func (engine *Engine) ID(id interface{}) *Session {
session := engine.NewSession()
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
return session.Before(closures)
}
// Apply after insert Processor, affected bean is passed to closure arg
// 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
return session.After(closures)
}
// set charset when create table, only support mysql now
// Charset set charset when create table, only support mysql now
func (engine *Engine) Charset(charset string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Charset(charset)
}
// set store engine when create table, only support mysql now
// StoreEngine set store engine when create table, only support mysql now
func (engine *Engine) StoreEngine(storeEngine string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.StoreEngine(storeEngine)
}
// use for distinct columns. Caution: when you are using cache,
// Distinct use for distinct columns. Caution: when you are using cache,
// distinct will not be cached because cache system need id,
// but distinct will not provide id
func (engine *Engine) Distinct(columns ...string) *Session {
@ -676,32 +692,35 @@ func (engine *Engine) Distinct(columns ...string) *Session {
return session.Distinct(columns...)
}
// Select customerize your select columns or contents
func (engine *Engine) Select(str string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Select(str)
}
// only use the paramters as select or update columns
// Cols only use the paramters as select or update columns
func (engine *Engine) Cols(columns ...string) *Session {
session := engine.NewSession()
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
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
return session.MustCols(columns...)
}
// Xorm automatically retrieve condition according struct, but
// UseBool xorm automatically retrieve condition according struct, but
// if struct has bool field, it will ignore them. So use UseBool
// to tell system to do not ignore them.
// If no paramters, it will use all the bool field of struct, or
@ -712,78 +731,77 @@ func (engine *Engine) UseBool(columns ...string) *Session {
return session.UseBool(columns...)
}
// Only not use the paramters as select or update columns
// Omit only not use the paramters as select or update columns
func (engine *Engine) Omit(columns ...string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Omit(columns...)
}
// Set null when column is zero-value and nullable for update
// 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
return session.Nullable(columns...)
}
// This method will generate "column IN (?, ?)"
// In will generate "column IN (?, ?)"
func (engine *Engine) In(column string, args ...interface{}) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.In(column, args...)
}
// Method Inc provides a update string like "column = column + ?"
// Incr provides a update string like "column = column + ?"
func (engine *Engine) Incr(column string, arg ...interface{}) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Incr(column, arg...)
}
// Method Decr provides a update string like "column = column - ?"
// Decr provides a update string like "column = column - ?"
func (engine *Engine) Decr(column string, arg ...interface{}) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Decr(column, arg...)
}
// Method SetExpr provides a update string like "column = {expression}"
// SetExpr provides a update string like "column = {expression}"
func (engine *Engine) SetExpr(column string, expression string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.SetExpr(column, expression)
}
// Temporarily change the Get, Find, Update's table
// Table temporarily change the Get, Find, Update's table
func (engine *Engine) Table(tableNameOrBean interface{}) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Table(tableNameOrBean)
}
// set the table alias
// Alias set the table alias
func (engine *Engine) Alias(alias string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Alias(alias)
}
// This method will generate "LIMIT start, limit"
// Limit will generate "LIMIT start, limit"
func (engine *Engine) Limit(limit int, start ...int) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Limit(limit, start...)
}
// Method Desc will generate "ORDER BY column1 DESC, column2 DESC"
// This will
// Desc will generate "ORDER BY column1 DESC, column2 DESC"
func (engine *Engine) Desc(colNames ...string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.Desc(colNames...)
}
// Method Asc will generate "ORDER BY column1,column2 Asc"
// Asc will generate "ORDER BY column1,column2 Asc"
// This method can chainable use.
//
// engine.Desc("name").Asc("age").Find(&users)
@ -795,28 +813,28 @@ func (engine *Engine) Asc(colNames ...string) *Session {
return session.Asc(colNames...)
}
// Method OrderBy will generate "ORDER BY order"
// OrderBy will generate "ORDER BY order"
func (engine *Engine) OrderBy(order string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.OrderBy(order)
}
// The join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN
func (engine *Engine) Join(join_operator string, tablename interface{}, condition string, args ...interface{}) *Session {
// 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
return session.Join(join_operator, tablename, condition, args...)
return session.Join(joinOperator, tablename, condition, args...)
}
// Generate Group By statement
// GroupBy generate group by statement
func (engine *Engine) GroupBy(keys string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
return session.GroupBy(keys)
}
// Generate Having statement
// Having generate having statement
func (engine *Engine) Having(conditions string) *Session {
session := engine.NewSession()
session.IsAutoClose = true
@ -842,17 +860,20 @@ func (engine *Engine) autoMapType(v reflect.Value) *core.Table {
return table
}
// GobRegister register one struct to gob for cache use
func (engine *Engine) GobRegister(v interface{}) *Engine {
//fmt.Printf("Type: %[1]T => Data: %[1]#v\n", v)
gob.Register(v)
return engine
}
// Table table struct
type Table struct {
*core.Table
Name string
}
// TableInfo get table info according to bean's content
func (engine *Engine) TableInfo(bean interface{}) *Table {
v := rValue(bean)
return &Table{engine.autoMapType(v), engine.tbName(v)}
@ -879,6 +900,7 @@ func (engine *Engine) newTable() *core.Table {
return table
}
// TableName table name interface to define customerize table name
type TableName interface {
TableName() string
}
@ -1035,7 +1057,7 @@ func (engine *Engine) mapType(v reflect.Value) *core.Table {
preKey = k
continue
}
col.SQLType = core.SQLType{fs[0], 0, 0}
col.SQLType = core.SQLType{Name: fs[0]}
if fs[0] == core.Enum && fs[1][0] == '\'' { //enum
options := strings.Split(fs[1][0:len(fs[1])-1], ",")
col.EnumOptions = make(map[string]int)
@ -1072,7 +1094,7 @@ func (engine *Engine) mapType(v reflect.Value) *core.Table {
}
} else {
if _, ok := core.SqlTypes[k]; ok {
col.SQLType = core.SQLType{k, 0, 0}
col.SQLType = core.SQLType{Name: k}
} else if key != col.Default {
col.Name = key
}
@ -1109,11 +1131,11 @@ func (engine *Engine) mapType(v reflect.Value) *core.Table {
var sqlType core.SQLType
if fieldValue.CanAddr() {
if _, ok := fieldValue.Addr().Interface().(core.Conversion); ok {
sqlType = core.SQLType{core.Text, 0, 0}
sqlType = core.SQLType{Name: core.Text}
}
}
if _, ok := fieldValue.Interface().(core.Conversion); ok {
sqlType = core.SQLType{core.Text, 0, 0}
sqlType = core.SQLType{Name: core.Text}
} else {
sqlType = core.Type2SQLType(fieldType)
}
@ -1169,24 +1191,26 @@ func (engine *Engine) mapping(beans ...interface{}) (e error) {
return
}
// If a table has any reocrd
// IsTableEmpty if a table has any reocrd
func (engine *Engine) IsTableEmpty(bean interface{}) (bool, error) {
session := engine.NewSession()
defer session.Close()
return session.IsTableEmpty(bean)
}
// If a table is exist
// IsTableExist if a table is exist
func (engine *Engine) IsTableExist(beanOrTableName interface{}) (bool, error) {
session := engine.NewSession()
defer session.Close()
return session.IsTableExist(beanOrTableName)
}
// IdOf get id from one struct
func (engine *Engine) IdOf(bean interface{}) core.PK {
return engine.IdOfV(reflect.ValueOf(bean))
}
// IdOfV get id from one value of struct
func (engine *Engine) IdOfV(rv reflect.Value) core.PK {
v := reflect.Indirect(rv)
table := engine.autoMapType(v)
@ -1205,14 +1229,14 @@ func (engine *Engine) IdOfV(rv reflect.Value) core.PK {
return core.PK(pk)
}
// create indexes
// CreateIndexes create indexes
func (engine *Engine) CreateIndexes(bean interface{}) error {
session := engine.NewSession()
defer session.Close()
return session.CreateIndexes(bean)
}
// create uniques
// CreateUniques create uniques
func (engine *Engine) CreateUniques(bean interface{}) error {
session := engine.NewSession()
defer session.Close()
@ -1230,7 +1254,7 @@ func (engine *Engine) getCacher(v reflect.Value) core.Cacher {
return engine.Cacher
}
// If enabled cache, clear the cache bean
// ClearCacheBean if enabled cache, clear the cache bean
func (engine *Engine) ClearCacheBean(bean interface{}, id string) error {
v := rValue(bean)
t := v.Type()
@ -1250,7 +1274,7 @@ func (engine *Engine) ClearCacheBean(bean interface{}, id string) error {
return nil
}
// If enabled cache, clear some tables' cache
// ClearCache if enabled cache, clear some tables' cache
func (engine *Engine) ClearCache(beans ...interface{}) error {
for _, bean := range beans {
v := rValue(bean)
@ -1369,6 +1393,7 @@ func (engine *Engine) Sync(beans ...interface{}) error {
return nil
}
// Sync2 synchronize structs to database tables
func (engine *Engine) Sync2(beans ...interface{}) error {
s := engine.NewSession()
defer s.Close()
@ -1424,6 +1449,7 @@ func (engine *Engine) CreateTables(beans ...interface{}) error {
return session.Commit()
}
// DropTables drop specify tables
func (engine *Engine) DropTables(beans ...interface{}) error {
session := engine.NewSession()
defer session.Close()
@ -1456,7 +1482,7 @@ func (engine *Engine) Exec(sql string, args ...interface{}) (sql.Result, error)
return session.Exec(sql, args...)
}
// Exec a raw sql and return records as []map[string][]byte
// Query a raw sql and return records as []map[string][]byte
func (engine *Engine) Query(sql string, paramStr ...interface{}) (resultsSlice []map[string][]byte, err error) {
session := engine.NewSession()
defer session.Close()
@ -1470,7 +1496,7 @@ func (engine *Engine) Insert(beans ...interface{}) (int64, error) {
return session.Insert(beans...)
}
// Insert only one record
// InsertOne insert only one record
func (engine *Engine) InsertOne(bean interface{}) (int64, error) {
session := engine.NewSession()
defer session.Close()
@ -1521,7 +1547,7 @@ func (engine *Engine) Iterate(bean interface{}, fun IterFunc) error {
return session.Iterate(bean, fun)
}
// Return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields
// Rows return sql.Rows compatible Rows obj, as a forward Iterator object for iterating record by record, bean's non-empty fields
// are conditions.
func (engine *Engine) Rows(bean interface{}) (*Rows, error) {
session := engine.NewSession()
@ -1556,7 +1582,7 @@ func (engine *Engine) SumsInt(bean interface{}, colNames ...string) ([]int64, er
return session.SumsInt(bean, colNames...)
}
// Import SQL DDL file
// ImportFile SQL DDL file
func (engine *Engine) ImportFile(ddlPath string) ([]sql.Result, error) {
file, err := os.Open(ddlPath)
if err != nil {
@ -1566,7 +1592,7 @@ func (engine *Engine) ImportFile(ddlPath string) ([]sql.Result, error) {
return engine.Import(file)
}
// Import SQL DDL file
// Import SQL DDL from io.Reader
func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
var results []sql.Result
var lastError error
@ -1597,7 +1623,7 @@ func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
results = append(results, result)
if err != nil {
return nil, err
lastError = err
//lastError = err
}
}
}
@ -1605,27 +1631,27 @@ func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) {
return results, lastError
}
var (
NULL_TIME time.Time
)
// TZTime change one time to xorm time location
func (engine *Engine) TZTime(t time.Time) time.Time {
if NULL_TIME != t { // if time is not initialized it's not suitable for Time.In()
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)
}
@ -1676,7 +1702,7 @@ func (engine *Engine) formatTime(tz *time.Location, sqlTypeName string, t time.T
return
}
// Always disable struct tag "deleted"
// Unscoped always disable struct tag "deleted"
func (engine *Engine) Unscoped() *Session {
session := engine.NewSession()
session.IsAutoClose = true

20
rows.go
View File

@ -12,6 +12,7 @@ import (
"github.com/go-xorm/core"
)
// Rows rows wrapper a rows to
type Rows struct {
NoTypeCheck bool
@ -52,24 +53,33 @@ func newRows(session *Session, bean interface{}) (*Rows, error) {
rows.session.saveLastSQL(sqlStr, args)
var err error
if rows.session.prepareStmt {
rows.stmt, err = rows.session.DB().Prepare(sqlStr)
if err != nil {
rows.lastError = err
defer rows.Close()
rows.Close()
return nil, err
}
rows.rows, err = rows.stmt.Query(args...)
if err != nil {
rows.lastError = err
defer rows.Close()
rows.Close()
return nil, err
}
} else {
rows.rows, err = rows.session.DB().Query(sqlStr, args...)
if err != nil {
rows.lastError = err
rows.Close()
return nil, err
}
}
rows.fields, err = rows.rows.Columns()
if err != nil {
rows.lastError = err
defer rows.Close()
rows.Close()
return nil, err
}
rows.fieldsCount = len(rows.fields)
@ -77,7 +87,7 @@ func newRows(session *Session, bean interface{}) (*Rows, error) {
return rows, nil
}
// move cursor to next record, return false if end has reached
// Next move cursor to next record, return false if end has reached
func (rows *Rows) Next() bool {
if rows.lastError == nil && rows.rows != nil {
hasNext := rows.rows.Next()
@ -107,7 +117,7 @@ func (rows *Rows) Scan(bean interface{}) error {
return rows.session.row2Bean(rows.rows, rows.fields, rows.fieldsCount, bean)
}
// close session if session.IsAutoClose is true, and claimed any opened resources
// Close session if session.IsAutoClose is true, and claimed any opened resources
func (rows *Rows) Close() error {
if rows.session.IsAutoClose {
defer rows.session.Close()

145
session.go
View File

@ -19,7 +19,7 @@ import (
"github.com/go-xorm/core"
)
// Struct Session keep a pointer to sql.DB and provides all execution of all
// Session keep a pointer to sql.DB and provides all execution of all
// kind of database operations.
type Session struct {
db *core.DB
@ -106,19 +106,25 @@ func (session *Session) resetStatement() {
}
}
// Prepare
// Prepare set a flag to session that should be prepare statment before execute query
func (session *Session) Prepare() *Session {
session.prepareStmt = true
return 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.
// Sql will be deprecated, please use SQL instead.
func (session *Session) Sql(querystring string, args ...interface{}) *Session {
session.Statement.Sql(querystring, args...)
return 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(querystring string, args ...interface{}) *Session {
session.Statement.Sql(querystring, args...)
return session
}
// Where provides custom query condition.
func (session *Session) Where(querystring string, args ...interface{}) *Session {
session.Statement.Where(querystring, args...)
@ -137,12 +143,18 @@ func (session *Session) Or(querystring string, args ...interface{}) *Session {
return session
}
// Id provides converting id as a query condition
// Id will be deprecated, please use ID instead
func (session *Session) Id(id interface{}) *Session {
session.Statement.Id(id)
return session
}
// ID provides converting id as a query condition
func (session *Session) ID(id interface{}) *Session {
session.Statement.Id(id)
return session
}
// Before Apply before Processor, affected bean is passed to closure arg
func (session *Session) Before(closures func(interface{})) *Session {
if closures != nil {
@ -213,13 +225,13 @@ func (session *Session) AllCols() *Session {
return session
}
// MustCols
// MustCols specify some columns must use even if they are empty
func (session *Session) MustCols(columns ...string) *Session {
session.Statement.MustCols(columns...)
return session
}
// NoCascade
// NoCascade indicate that no cascade load child object
func (session *Session) NoCascade() *Session {
session.Statement.UseCascade = false
return session
@ -274,44 +286,44 @@ func (session *Session) NoAutoCondition(no ...bool) *Session {
return session
}
// Method Limit provide limit and offset query condition
// Limit provide limit and offset query condition
func (session *Session) Limit(limit int, start ...int) *Session {
session.Statement.Limit(limit, start...)
return session
}
// Method OrderBy provide order by query condition, the input parameter is the content
// 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)
return session
}
// Method Desc provide desc order by query condition, the input parameters are columns.
// Desc provide desc order by query condition, the input parameters are columns.
func (session *Session) Desc(colNames ...string) *Session {
session.Statement.Desc(colNames...)
return session
}
// Method Asc provide asc order by query condition, the input parameters are columns.
// Asc provide asc order by query condition, the input parameters are columns.
func (session *Session) Asc(colNames ...string) *Session {
session.Statement.Asc(colNames...)
return session
}
// Method StoreEngine is only avialble mysql dialect currently
// StoreEngine is only avialble mysql dialect currently
func (session *Session) StoreEngine(storeEngine string) *Session {
session.Statement.StoreEngine = storeEngine
return session
}
// Method Charset is only avialble mysql dialect currently
// Charset is only avialble mysql dialect currently
func (session *Session) Charset(charset string) *Session {
session.Statement.Charset = charset
return session
}
// Method Cascade indicates if loading sub Struct
// Cascade indicates if loading sub Struct
func (session *Session) Cascade(trueOrFalse ...bool) *Session {
if len(trueOrFalse) >= 1 {
session.Statement.UseCascade = trueOrFalse[0]
@ -611,7 +623,7 @@ func (session *Session) createAll() error {
return nil
}
// drop indexes
// DropIndexes drop indexes
func (session *Session) DropIndexes(bean interface{}) error {
v := rValue(bean)
session.Statement.setRefValue(v)
@ -631,7 +643,7 @@ func (session *Session) DropIndexes(bean interface{}) error {
return nil
}
// drop table will drop table if exist, if drop failed, it will return 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 err != nil {
@ -838,8 +850,8 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
ididxes := make(map[string]int)
var ides []core.PK = make([]core.PK, 0)
var temps []interface{} = make([]interface{}, len(ids))
var ides []core.PK
var temps = make([]interface{}, len(ids))
for idx, id := range ids {
sid, err := id.ToString()
@ -1162,6 +1174,7 @@ func (session *Session) Sums(bean interface{}, columnNames ...string) ([]float64
return res, nil
}
// 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 {
@ -1507,9 +1520,8 @@ func (session *Session) isIndexExist2(tableName string, cols []string, unique bo
if sliceEq(index.Cols, cols) {
if unique {
return index.Type == core.UniqueType, nil
} else {
return index.Type == core.IndexType, nil
}
return index.Type == core.IndexType, nil
}
}
return false, nil
@ -1590,6 +1602,7 @@ func (session *Session) getField(dataStruct *reflect.Value, key string, table *c
return fieldValue
}
// Cell cell is a result of one column field
type Cell *interface{}
func (session *Session) rows2Beans(rows *core.Rows, fields []string, fieldsCount int,
@ -1940,7 +1953,7 @@ func (session *Session) _row2Bean(rows *core.Rows, fields []string, fieldsCount
//fieldValue.Set(reflect.ValueOf(v))
fieldValue.Set(structInter.Elem())
} else {
return errors.New("cascade obj is not exist!")
return errors.New("cascade obj is not exist")
}
}
} else {
@ -3579,7 +3592,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
}
}
var sqlStr, inSql string
var sqlStr, inSQL string
var inArgs []interface{}
doIncVer := false
var verValue *reflect.Value
@ -3590,12 +3603,12 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
} else {
condition = fmt.Sprintf("WHERE %v = ?", session.Engine.Quote(table.Version))
}
inSql, inArgs = session.Statement.genInSql()
if len(inSql) > 0 {
inSQL, inArgs = session.Statement.genInSql()
if len(inSQL) > 0 {
if condition != "" {
condition += " " + session.Engine.Dialect().AndStr() + " " + inSql
condition += " " + session.Engine.Dialect().AndStr() + " " + inSQL
} else {
condition = "WHERE " + inSql
condition = "WHERE " + inSQL
}
}
@ -3620,12 +3633,12 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
if condition != "" {
condition = "WHERE " + condition
}
inSql, inArgs = session.Statement.genInSql()
if len(inSql) > 0 {
inSQL, inArgs = session.Statement.genInSql()
if len(inSQL) > 0 {
if condition != "" {
condition += " " + session.Engine.Dialect().AndStr() + " " + inSql
condition += " " + session.Engine.Dialect().AndStr() + " " + inSQL
} else {
condition = "WHERE " + inSql
condition = "WHERE " + inSQL
}
}
@ -3795,62 +3808,62 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
} else {
condition = strings.Join(colNames, " "+andStr+" ")
}
inSql, inArgs := session.Statement.genInSql()
if len(inSql) > 0 {
inSQL, inArgs := session.Statement.genInSql()
if len(inSQL) > 0 {
if len(condition) > 0 {
condition += " " + andStr + " "
}
condition += inSql
condition += inSQL
args = append(args, inArgs...)
}
if len(condition) == 0 && session.Statement.LimitN == 0 {
return 0, ErrNeedDeletedCond
}
var deleteSql, realSql string
var deleteSQL, realSQL string
var tableName = session.Engine.Quote(session.Statement.TableName())
if len(condition) > 0 {
deleteSql = fmt.Sprintf("DELETE FROM %v WHERE %v", tableName, condition)
deleteSQL = fmt.Sprintf("DELETE FROM %v WHERE %v", tableName, condition)
} else {
deleteSql = fmt.Sprintf("DELETE FROM %v", tableName)
deleteSQL = fmt.Sprintf("DELETE FROM %v", tableName)
}
var orderSql string
var orderSQL string
if len(session.Statement.OrderStr) > 0 {
orderSql += fmt.Sprintf(" ORDER BY %s", session.Statement.OrderStr)
orderSQL += fmt.Sprintf(" ORDER BY %s", session.Statement.OrderStr)
}
if session.Statement.LimitN > 0 {
orderSql += fmt.Sprintf(" LIMIT %d", session.Statement.LimitN)
orderSQL += fmt.Sprintf(" LIMIT %d", session.Statement.LimitN)
}
if len(orderSql) > 0 {
if len(orderSQL) > 0 {
switch session.Engine.dialect.DBType() {
case core.POSTGRES:
inSql := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSql)
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condition) > 0 {
deleteSql += " AND " + inSql
deleteSQL += " AND " + inSQL
} else {
deleteSql += " WHERE " + inSql
deleteSQL += " WHERE " + inSQL
}
case core.SQLITE:
inSql := fmt.Sprintf("rowid IN (SELECT rowid FROM %s%s)", tableName, orderSql)
inSQL := fmt.Sprintf("rowid IN (SELECT rowid FROM %s%s)", tableName, orderSQL)
if len(condition) > 0 {
deleteSql += " AND " + inSql
deleteSQL += " AND " + inSQL
} else {
deleteSql += " WHERE " + inSql
deleteSQL += " WHERE " + inSQL
}
// TODO: how to handle delete limit on mssql?
case core.MSSQL:
return 0, ErrNotImplemented
default:
deleteSql += orderSql
deleteSQL += orderSQL
}
}
argsForCache := make([]interface{}, 0, len(args)*2)
if session.Statement.unscoped || table.DeletedColumn() == nil { // tag "deleted" is disabled
realSql = deleteSql
realSQL = deleteSQL
copy(argsForCache, args)
argsForCache = append(session.Statement.Params, argsForCache...)
} else {
@ -3859,32 +3872,32 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
argsForCache = append(session.Statement.Params, argsForCache...)
deletedColumn := table.DeletedColumn()
realSql = fmt.Sprintf("UPDATE %v SET %v = ? WHERE %v",
realSQL = fmt.Sprintf("UPDATE %v SET %v = ? WHERE %v",
session.Engine.Quote(session.Statement.TableName()),
session.Engine.Quote(deletedColumn.Name),
condition)
if len(orderSql) > 0 {
if len(orderSQL) > 0 {
switch session.Engine.dialect.DBType() {
case core.POSTGRES:
inSql := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSql)
inSQL := fmt.Sprintf("ctid IN (SELECT ctid FROM %s%s)", tableName, orderSQL)
if len(condition) > 0 {
realSql += " AND " + inSql
realSQL += " AND " + inSQL
} else {
realSql += " WHERE " + inSql
realSQL += " WHERE " + inSQL
}
case core.SQLITE:
inSql := fmt.Sprintf("rowid IN (SELECT rowid FROM %s%s)", tableName, orderSql)
inSQL := fmt.Sprintf("rowid IN (SELECT rowid FROM %s%s)", tableName, orderSQL)
if len(condition) > 0 {
realSql += " AND " + inSql
realSQL += " AND " + inSQL
} else {
realSql += " WHERE " + inSql
realSQL += " WHERE " + inSQL
}
// TODO: how to handle delete limit on mssql?
case core.MSSQL:
return 0, ErrNotImplemented
default:
realSql += orderSql
realSQL += orderSQL
}
}
@ -3906,10 +3919,10 @@ func (session *Session) Delete(bean interface{}) (int64, error) {
args = append(session.Statement.Params, args...)
if cacher := session.Engine.getCacher2(session.Statement.RefTable); cacher != nil && session.Statement.UseCache {
session.cacheDelete(deleteSql, argsForCache...)
session.cacheDelete(deleteSQL, argsForCache...)
}
res, err := session.exec(realSql, args...)
res, err := session.exec(realSQL, args...)
if err != nil {
return 0, err
}
@ -3966,8 +3979,8 @@ func (session *Session) tbNameNoSchema(table *core.Table) string {
}
// Sync2 synchronize structs to database tables
func (s *Session) Sync2(beans ...interface{}) error {
engine := s.Engine
func (session *Session) Sync2(beans ...interface{}) error {
engine := session.Engine
tables, err := engine.DBMetas()
if err != nil {
@ -3980,7 +3993,7 @@ func (s *Session) Sync2(beans ...interface{}) error {
v := rValue(bean)
table := engine.mapType(v)
structTables = append(structTables, table)
var tbName = s.tbNameNoSchema(table)
var tbName = session.tbNameNoSchema(table)
var oriTable *core.Table
for _, tb := range tables {
@ -3991,17 +4004,17 @@ func (s *Session) Sync2(beans ...interface{}) error {
}
if oriTable == nil {
err = s.StoreEngine(s.Statement.StoreEngine).CreateTable(bean)
err = session.StoreEngine(session.Statement.StoreEngine).CreateTable(bean)
if err != nil {
return err
}
err = s.CreateUniques(bean)
err = session.CreateUniques(bean)
if err != nil {
return err
}
err = s.CreateIndexes(bean)
err = session.CreateIndexes(bean)
if err != nil {
return err
}
@ -4137,7 +4150,7 @@ func (s *Session) Sync2(beans ...interface{}) error {
for _, table := range tables {
var oriTable *core.Table
for _, structTable := range structTables {
if equalNoCase(table.Name, s.tbNameNoSchema(structTable)) {
if equalNoCase(table.Name, session.tbNameNoSchema(structTable)) {
oriTable = structTable
break
}