diff --git a/engine.go b/engine.go index 1f03e334..624f1015 100644 --- a/engine.go +++ b/engine.go @@ -31,13 +31,16 @@ type Engine struct { mutex *sync.RWMutex Cacher core.Cacher + ShowSQL bool + + // !nashtsai! TODO ought to deprecate these but having logger to control its log level ShowInfo bool - ShowSQL bool ShowErr bool ShowDebug bool ShowWarn bool + // -- - Logger ILogger // io.Writer + Logger core.ILogger TZLocation *time.Location disableGlobalCache bool @@ -182,6 +185,7 @@ func (engine *Engine) Ping() error { // logging sql func (engine *Engine) logSQL(sqlStr string, sqlArgs ...interface{}) { if engine.ShowSQL { + overrideLogLevel(LOG_INFO) if len(sqlArgs) > 0 { engine.Logger.Info(fmt.Sprintf("[sql] %v [args] %v", sqlStr, sqlArgs)) } else { @@ -215,54 +219,73 @@ func (engine *Engine) LogSQLExecutionTime(sqlStr string, args interface{}, execu } // logging error +func (engine *Engine) overrideLogLevel(overrideLevel core.LogLevel) { + logLevel := engine.Logger.Level() + if logLevel == core.LOG_UNKNOWN { + // intend to left empty + } + else if logLevel < core.overrideLevel { // TODO can remove if deprecated engine.ShowErr + engine.Logger.SetLevel(LOG_ERR) // try override logger's log level + } + +} + func (engine *Engine) LogError(contents ...interface{}) { if engine.ShowErr { - engine.Logger.Err(fmt.Sprint(contents...)) + overrideLogLevel(LOG_ERR) + engine.Logger.Err(contents...) } } func (engine *Engine) LogErrorf(format string, contents ...interface{}) { if engine.ShowErr { - engine.Logger.Err(fmt.Sprintf(format, contents...)) + overrideLogLevel(LOG_ERR) + engine.Logger.Errf(format, contents...) } } // logging info func (engine *Engine) LogInfo(contents ...interface{}) { if engine.ShowInfo { - engine.Logger.Info(fmt.Sprint(contents...)) + overrideLogLevel(LOG_INFO) + engine.Logger.Info(contents...) } } func (engine *Engine) LogInfof(format string, contents ...interface{}) { if engine.ShowErr { - engine.Logger.Info(fmt.Sprintf(format, contents...)) + overrideLogLevel(LOG_INFO) + engine.Logger.Infof(format, contents...) } } // logging debug func (engine *Engine) LogDebug(contents ...interface{}) { if engine.ShowDebug { - engine.Logger.Debug(fmt.Sprint(contents...)) + overrideLogLevel(LOG_DEBUG) + engine.Logger.Debug(contents...) } } func (engine *Engine) LogDebugf(format string, contents ...interface{}) { if engine.ShowDebug { - engine.Logger.Debug(fmt.Sprintf(format, contents...)) + overrideLogLevel(LOG_DEBUG) + engine.Logger.Debugf(format, contents...) } } // logging warn func (engine *Engine) LogWarn(contents ...interface{}) { if engine.ShowWarn { - engine.Logger.Warning(fmt.Sprint(contents...)) + overrideLogLevel(LOG_WARNING) + engine.Logger.Warning(contents...) } } func (engine *Engine) LogWarnf(format string, contents ...interface{}) { if engine.ShowWarn { - engine.Logger.Warning(fmt.Sprintf(format, contents...)) + overrideLogLevel(LOG_WARNING) + engine.Logger.Warningf(format, contents...) } } @@ -1467,8 +1490,16 @@ func (engine *Engine) Import(r io.Reader) ([]sql.Result, error) { return results, lastError } +var ( + NULL_TIME time.Time +) + func (engine *Engine) TZTime(t time.Time) time.Time { - return t.In(engine.TZLocation) + + if NULL_TIME != t { // if time is not initialized it's not suitable for Time.In() + return t.In(engine.TZLocation) + } + return t } func (engine *Engine) NowTime(sqlTypeName string) interface{} { diff --git a/logger.go b/logger.go index f9d529a1..da3ba019 100644 --- a/logger.go +++ b/logger.go @@ -4,57 +4,103 @@ import ( "fmt" "io" "log" + + "github.com/go-xorm/core" ) -// logger interface, log/syslog conform with this interface -type ILogger interface { - Debug(m string) (err error) - Err(m string) (err error) - Info(m string) (err error) - Warning(m string) (err error) -} +const ( + DEFAULT_LOG_PREFIX = "[xorm]" + DEFAULT_LOG_FLAG = log.Ldate | log.Lmicroseconds + DEFAULT_LOG_LEVEL = core.LOG_DEBUG +) type SimpleLogger struct { DEBUG *log.Logger ERR *log.Logger INFO *log.Logger WARN *log.Logger + level core.LogLevel } func NewSimpleLogger(out io.Writer) *SimpleLogger { - return &SimpleLogger{ - DEBUG: log.New(out, "[xorm] [debug] ", log.Ldate|log.Lmicroseconds), - ERR: log.New(out, "[xorm] [error] ", log.Ldate|log.Lmicroseconds), - INFO: log.New(out, "[xorm] [info] ", log.Ldate|log.Lmicroseconds), - WARN: log.New(out, "[xorm] [warn] ", log.Ldate|log.Lmicroseconds), - } + return NewSimpleLogger2(out, DEFAULT_LOG_PREFIX, DEFAULT_LOG_FLAG) } func NewSimpleLogger2(out io.Writer, prefix string, flag int) *SimpleLogger { + return NewSimpleLogger3(out, prefix, flag, DEFAULT_LOG_LEVEL) +} + +func NewSimpleLogger3(out io.Writer, prefix string, flag int, l core.LogLevel) *SimpleLogger { return &SimpleLogger{ - DEBUG: log.New(out, fmt.Sprintf("%s [debug] ", prefix), log.Ldate|log.Lmicroseconds), - ERR: log.New(out, fmt.Sprintf("%s [error] ", prefix), log.Ldate|log.Lmicroseconds), - INFO: log.New(out, fmt.Sprintf("%s [info] ", prefix), log.Ldate|log.Lmicroseconds), - WARN: log.New(out, fmt.Sprintf("%s [warn] ", prefix), log.Ldate|log.Lmicroseconds), + DEBUG: log.New(out, fmt.Sprintf("%s [debug] ", prefix), flag), + ERR: log.New(out, fmt.Sprintf("%s [error] ", prefix), flag), + INFO: log.New(out, fmt.Sprintf("%s [info] ", prefix), flag), + WARN: log.New(out, fmt.Sprintf("%s [warn] ", prefix), flag), + level: l, } } -func (s *SimpleLogger) Debug(m string) (err error) { - s.DEBUG.Println(m) +func (s *SimpleLogger) Err(v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level <= core.LOG_ERR { + s.ERR.Println(v...) + } return } -func (s *SimpleLogger) Err(m string) (err error) { - s.ERR.Println(m) +func (s *SimpleLogger) Errf(format string, v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level <= core.LOG_ERR { + s.ERR.Printf(format, v...) + } return } -func (s *SimpleLogger) Info(m string) (err error) { - s.INFO.Println(m) +func (s *SimpleLogger) Debug(v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level <= core.LOG_DEBUG { + s.DEBUG.Println(v...) + } return } -func (s *SimpleLogger) Warning(m string) (err error) { - s.WARN.Println(m) +func (s *SimpleLogger) Debugf(format string, v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level >= core.LOG_DEBUG { + s.DEBUG.Printf(format, v...) + } + return +} + +func (s *SimpleLogger) Info(v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level >= core.LOG_INFO { + s.INFO.Println(v...) + } + return +} + +func (s *SimpleLogger) Infof(format string, v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level >= core.LOG_INFO { + s.INFO.Printf(format, v...) + } + return +} + +func (s *SimpleLogger) Warning(v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level >= core.LOG_WARNING { + s.WARN.Println(v...) + } + return +} + +func (s *SimpleLogger) Warningf(format string, v ...interface{}) (err error) { + if s.level > core.LOG_OFF && s.level >= core.LOG_WARNING { + s.WARN.Printf(format, v...) + } + return +} + +func (s *SimpleLogger) Level() core.LogLevel { + return s.level +} + +func (s *SimpleLogger) SetLevel(l core.LogLevel) (err error) { + s.level = l return } diff --git a/lru_cacher.go b/lru_cacher.go index a81c4ccc..8c912879 100644 --- a/lru_cacher.go +++ b/lru_cacher.go @@ -24,7 +24,7 @@ type LRUCacher struct { } func NewLRUCacher(store core.CacheStore, maxElementSize int) *LRUCacher { - return NewLRUCacher2(store, 0, maxElementSize) + return NewLRUCacher2(store, 3600*time.Second, maxElementSize) } func NewLRUCacher2(store core.CacheStore, expired time.Duration, maxElementSize int) *LRUCacher { diff --git a/mysql_dialect.go b/mysql_dialect.go index b9911138..479e6347 100644 --- a/mysql_dialect.go +++ b/mysql_dialect.go @@ -56,24 +56,20 @@ func (db *mysql) SqlType(c *core.Column) string { case core.Enum: //mysql enum res = core.Enum res += "(" - for v, k := range c.EnumOptions { - if k > 0 { - res += fmt.Sprintf(",'%v'", v) - } else { - res += fmt.Sprintf("'%v'", v) - } + opts := "" + for v, _ := range c.EnumOptions { + opts += fmt.Sprintf(",'%v'", v) } + res += strings.TrimLeft(opts,",") res += ")" case core.Set: //mysql set res = core.Set res += "(" - for v, k := range c.SetOptions { - if k > 0 { - res += fmt.Sprintf(",'%v'", v) - } else { - res += fmt.Sprintf("'%v'", v) - } + opts := "" + for v, _ := range c.SetOptions { + opts += fmt.Sprintf(",'%v'", v) } + res += strings.TrimLeft(opts,",") res += ")" default: res = t diff --git a/session.go b/session.go index d68f9783..f7f80712 100644 --- a/session.go +++ b/session.go @@ -219,12 +219,7 @@ func (session *Session) OrderBy(order string) *Session { // Method Desc provide desc order by query condition, the input parameters are columns. func (session *Session) Desc(colNames ...string) *Session { - if session.Statement.OrderStr != "" { - session.Statement.OrderStr += ", " - } - newColNames := col2NewCols(colNames...) - sqlStr := strings.Join(newColNames, session.Engine.Quote(" DESC, ")) - session.Statement.OrderStr += session.Engine.Quote(sqlStr) + " DESC" + session.Statement.Desc(colNames...) return session } @@ -850,8 +845,9 @@ 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.LogError("[xorm:cacheFind] cache error:", tableName, ides[j], bean) - return errors.New("cache error") + session.Engine.LogWarn("[xorm:cacheFind] cache no hit:", tableName, ides[j]) + // return errors.New("cache error") // !nashtsai! no need to return error, but continue instead + continue } if sliceValue.Kind() == reflect.Slice { if t.Kind() == reflect.Ptr { @@ -1186,16 +1182,15 @@ func (session *Session) Find(rowsSlicePtr interface{}, condiBean ...interface{}) } } - for rawRows.Next() { - var newValue reflect.Value = newElemFunc() - if sliceValueSetFunc != nil { - err := session.row2Bean(rawRows, fields, fieldsCount, newValue.Interface()) - if err != nil { - return err - } - sliceValueSetFunc(&newValue) - } + var newValue reflect.Value = newElemFunc() + dataStruct := rValue(newValue.Interface()) + if dataStruct.Kind() != reflect.Struct { + return errors.New("Expected a pointer to a struct") } + + table := session.Engine.autoMapType(dataStruct) + + return session.rows2Beans(rawRows, fields, fieldsCount, table, newElemFunc, sliceValueSetFunc) } else { resultsSlice, err := session.query(sqlStr, args...) if err != nil { @@ -1452,6 +1447,24 @@ func (session *Session) getField(dataStruct *reflect.Value, key string, table *c type Cell *interface{} +func (session *Session) rows2Beans(rows *core.Rows, fields []string, fieldsCount int, + table *core.Table, newElemFunc func() reflect.Value, + sliceValueSetFunc func(*reflect.Value)) error { + + for rows.Next() { + var newValue reflect.Value = newElemFunc() + bean := newValue.Interface() + dataStruct := rValue(bean) + err := session._row2Bean(rows, fields, fieldsCount, bean, &dataStruct, table) + if err != nil { + return err + } + sliceValueSetFunc(&newValue) + + } + return nil +} + func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount int, bean interface{}) error { dataStruct := rValue(bean) if dataStruct.Kind() != reflect.Struct { @@ -1459,8 +1472,12 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i } table := session.Engine.autoMapType(dataStruct) + return session._row2Bean(rows, fields, fieldsCount, bean, &dataStruct, table) +} - scanResults := make([]interface{}, len(fields)) +func (session *Session) _row2Bean(rows *core.Rows, fields []string, fieldsCount int, bean interface{}, dataStruct *reflect.Value, table *core.Table) error { + + scanResults := make([]interface{}, fieldsCount) for i := 0; i < len(fields); i++ { var cell interface{} scanResults[i] = &cell @@ -1486,7 +1503,7 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i } tempMap[strings.ToLower(key)] = idx - if fieldValue := session.getField(&dataStruct, key, table, idx); fieldValue != nil { + if fieldValue := session.getField(dataStruct, key, table, idx); fieldValue != nil { rawValue := reflect.Indirect(reflect.ValueOf(scanResults[ii])) //if row is null then ignore diff --git a/statement.go b/statement.go index 74daf9fb..e7a253d6 100644 --- a/statement.go +++ b/statement.go @@ -2,6 +2,7 @@ package xorm import ( "encoding/json" + "errors" "fmt" "reflect" "strings" @@ -87,6 +88,7 @@ func (statement *Statement) Init() { statement.UseAutoTime = true statement.IsDistinct = false statement.allUseBool = false + statement.useAllCols = false statement.mustColumnMap = make(map[string]bool) statement.checkVersion = true statement.inColumns = make(map[string]*inParam) @@ -771,6 +773,27 @@ func col2NewCols(columns ...string) []string { return newColumns } +func (statement *Statement) col2NewColsWithQuote(columns ...string) []string { + newColumns := make([]string, 0) + for _, col := range columns { + strings.Replace(col, "`", "", -1) + strings.Replace(col, statement.Engine.QuoteStr(), "", -1) + ccols := strings.Split(col, ",") + for _, c := range ccols { + fields := strings.Split(strings.TrimSpace(c), ".") + 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 +} + // Generate "Distince col1, col2 " statment func (statement *Statement) Distinct(columns ...string) *Statement { statement.IsDistinct = true @@ -851,10 +874,34 @@ func (statement *Statement) Limit(limit int, start ...int) *Statement { // Generate "Order By order" statement func (statement *Statement) OrderBy(order string) *Statement { + if statement.OrderStr != "" { + statement.OrderStr += ", " + } statement.OrderStr = order return statement } +func (statement *Statement) Desc(colNames ...string) *Statement { + if statement.OrderStr != "" { + statement.OrderStr += ", " + } + newColNames := statement.col2NewColsWithQuote(colNames...) + sqlStr := strings.Join(newColNames, " DESC, ") + statement.OrderStr += sqlStr + " DESC" + return statement +} + +// Method Asc provide asc order by query condition, the input parameters are columns. +func (statement *Statement) Asc(colNames ...string) *Statement { + if statement.OrderStr != "" { + statement.OrderStr += ", " + } + newColNames := statement.col2NewColsWithQuote(colNames...) + sqlStr := strings.Join(newColNames, " ASC, ") + statement.OrderStr += sqlStr + " ASC" + return statement +} + //The join_operator should be one of INNER, LEFT OUTER, CROSS etc - this will be prepended to JOIN func (statement *Statement) Join(join_operator, tablename, condition string) *Statement { if statement.JoinStr != "" { diff --git a/syslogger.go b/syslogger.go new file mode 100644 index 00000000..5c78fecb --- /dev/null +++ b/syslogger.go @@ -0,0 +1,59 @@ +// +build !windows,!nacl,!plan9 + +package xorm + +import ( + "fmt" + "log/syslog" + + "github.com/go-xorm/core" +) + +type SyslogLogger struct { + w *syslog.Writer +} + +func NewSyslogLogger(w *syslog.Writer) *SyslogLogger { + return &SyslogLogger{w: w} +} + +func (s *SyslogLogger) Debug(v ...interface{}) (err error) { + return s.w.Debug(fmt.Sprint(v...)) +} + +func (s *SyslogLogger) Debugf(format string, v ...interface{}) (err error) { + return s.w.Debug(fmt.Sprintf(format, v...)) +} + +func (s *SyslogLogger) Err(v ...interface{}) (err error) { + return s.w.Err(fmt.Sprint(v...)) +} + +func (s *SyslogLogger) Errf(format string, v ...interface{}) (err error) { + return s.w.Err(fmt.Sprintf(format, v...)) +} + +func (s *SyslogLogger) Info(v ...interface{}) (err error) { + return s.w.Info(fmt.Sprint(v...)) +} + +func (s *SyslogLogger) Infof(format string, v ...interface{}) (err error) { + return s.w.Info(fmt.Sprintf(format, v...)) +} + +func (s *SyslogLogger) Warning(v ...interface{}) (err error) { + return s.w.Warning(fmt.Sprint(v...)) +} + +func (s *SyslogLogger) Warningf(format string, v ...interface{}) (err error) { + return s.w.Warning(fmt.Sprintf(format, v...)) +} + +func (s *SyslogLogger) Level() core.LogLevel { + return core.LOG_UNKNOWN +} + +// SetLevel always return error, as current log/syslog package doesn't allow to set priority level after syslog.Writer created +func (s *SyslogLogger) SetLevel(l core.LogLevel) (err error) { + return fmt.Errorf("unable to set syslog level") +}