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

add logger of session

This commit is contained in:
reign_dev 2019-04-30 15:45:33 +08:00
parent ce804aee6c
commit 7794e58950
10 changed files with 87 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
session.go
View File

@ -35,6 +35,8 @@ type Session struct {
isCommitedOrRollbacked bool isCommitedOrRollbacked bool
isAutoClose bool isAutoClose bool
logger core.ILogger
// Automatically reset the statement after operations that execute a SQL // Automatically reset the statement after operations that execute a SQL
// query such as Count(), Find(), Get(), ... // query such as Count(), Find(), Get(), ...
autoResetStatement bool autoResetStatement bool
@ -88,6 +90,8 @@ func (session *Session) Init() {
session.afterProcessors = make([]executedProcessor, 0) session.afterProcessors = make([]executedProcessor, 0)
session.logger = session.logger
session.lastSQL = "" session.lastSQL = ""
session.lastSQLArgs = []interface{}{} session.lastSQLArgs = []interface{}{}
@ -424,7 +428,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
fieldValue, err := session.getField(dataStruct, key, table, idx) fieldValue, err := session.getField(dataStruct, key, table, idx)
if err != nil { if err != nil {
if !strings.Contains(err.Error(), "is not valid") { if !strings.Contains(err.Error(), "is not valid") {
session.engine.logger.Warn(err) session.logger.Warn(err)
} }
continue continue
} }
@ -609,7 +613,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
z, _ := t.Zone() z, _ := t.Zone()
// set new location if database don't save timezone or give an incorrect timezone // 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 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.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 = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(),
t.Minute(), t.Second(), t.Nanosecond(), dbTZ) t.Minute(), t.Second(), t.Nanosecond(), dbTZ)
} }
@ -627,7 +631,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
hasAssigned = true hasAssigned = true
t, err := session.byte2Time(col, d) t, err := session.byte2Time(col, d)
if err != nil { if err != nil {
session.engine.logger.Error("byte2Time error:", err.Error()) session.logger.Error("byte2Time error:", err.Error())
hasAssigned = false hasAssigned = false
} else { } else {
fieldValue.Set(reflect.ValueOf(t).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
@ -636,7 +640,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
hasAssigned = true hasAssigned = true
t, err := session.str2Time(col, d) t, err := session.str2Time(col, d)
if err != nil { if err != nil {
session.engine.logger.Error("byte2Time error:", err.Error()) session.logger.Error("byte2Time error:", err.Error())
hasAssigned = false hasAssigned = false
} else { } else {
fieldValue.Set(reflect.ValueOf(t).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
@ -649,7 +653,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
// !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString // !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString
hasAssigned = true hasAssigned = true
if err := nulVal.Scan(vv.Interface()); err != nil { if err := nulVal.Scan(vv.Interface()); err != nil {
session.engine.logger.Error("sql.Sanner error:", err.Error()) session.logger.Error("sql.Sanner error:", err.Error())
hasAssigned = false hasAssigned = false
} }
} else if col.SQLType.IsJson() { } else if col.SQLType.IsJson() {
@ -864,3 +868,18 @@ func (session *Session) incrVersionFieldValue(fieldValue *reflect.Value) {
fieldValue.SetUint(fieldValue.Uint() + 1) fieldValue.SetUint(fieldValue.Uint() + 1)
} }
} }
// SetLogger set the new logger
func (session *Session) SetLogger(logger core.ILogger) {
session.logger = logger
}
// Logger return the logger interface
func (session *Session) Logger() core.ILogger {
return session.logger
}
// SetLogLevel sets the logger level
func (session *Session) SetLogLevel(level core.LogLevel) {
session.logger.SetLevel(level)
}

2
session_context.go
View File

@ -18,6 +18,6 @@ func (session *Session) PingContext(ctx context.Context) error {
defer session.Close() defer session.Close()
} }
session.engine.logger.Infof("PING DATABASE %v", session.engine.DriverName()) session.logger.Infof("PING DATABASE %v", session.engine.DriverName())
return session.DB().PingContext(ctx) return session.DB().PingContext(ctx)
} }

38
session_convert.go
View File

@ -33,27 +33,27 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
sd, err := strconv.ParseInt(sdata, 10, 64) sd, err := strconv.ParseInt(sdata, 10, 64)
if err == nil { if err == nil {
x = time.Unix(sd, 0) x = time.Unix(sd, 0)
//session.engine.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) //session.logger.Debugf("time(0) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else { } else {
//session.engine.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) //session.logger.Debugf("time(0) err key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} }
} else if len(sdata) > 19 && strings.Contains(sdata, "-") { } else if len(sdata) > 19 && strings.Contains(sdata, "-") {
x, err = time.ParseInLocation(time.RFC3339Nano, sdata, parseLoc) x, err = time.ParseInLocation(time.RFC3339Nano, sdata, parseLoc)
session.engine.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) session.logger.Debugf("time(1) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
if err != nil { if err != nil {
x, err = time.ParseInLocation("2006-01-02 15:04:05.999999999", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05.999999999", sdata, parseLoc)
//session.engine.logger.Debugf("time(2) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) //session.logger.Debugf("time(2) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} }
if err != nil { if err != nil {
x, err = time.ParseInLocation("2006-01-02 15:04:05.9999999 Z07:00", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05.9999999 Z07:00", sdata, parseLoc)
//session.engine.logger.Debugf("time(3) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) //session.logger.Debugf("time(3) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} }
} else if len(sdata) == 19 && strings.Contains(sdata, "-") { } else if len(sdata) == 19 && strings.Contains(sdata, "-") {
x, err = time.ParseInLocation("2006-01-02 15:04:05", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05", sdata, parseLoc)
//session.engine.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) //session.logger.Debugf("time(4) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else if len(sdata) == 10 && sdata[4] == '-' && sdata[7] == '-' { } else if len(sdata) == 10 && sdata[4] == '-' && sdata[7] == '-' {
x, err = time.ParseInLocation("2006-01-02", sdata, parseLoc) x, err = time.ParseInLocation("2006-01-02", sdata, parseLoc)
//session.engine.logger.Debugf("time(5) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) //session.logger.Debugf("time(5) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else if col.SQLType.Name == core.Time { } else if col.SQLType.Name == core.Time {
if strings.Contains(sdata, " ") { if strings.Contains(sdata, " ") {
ssd := strings.Split(sdata, " ") ssd := strings.Split(sdata, " ")
@ -67,7 +67,7 @@ func (session *Session) str2Time(col *core.Column, data string) (outTime time.Ti
st := fmt.Sprintf("2006-01-02 %v", sdata) st := fmt.Sprintf("2006-01-02 %v", sdata)
x, err = time.ParseInLocation("2006-01-02 15:04:05", st, parseLoc) x, err = time.ParseInLocation("2006-01-02 15:04:05", st, parseLoc)
//session.engine.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata) //session.logger.Debugf("time(6) key[%v]: %+v | sdata: [%v]\n", col.FieldName, x, sdata)
} else { } else {
outErr = fmt.Errorf("unsupported time format %v", sdata) outErr = fmt.Errorf("unsupported time format %v", sdata)
return return
@ -104,7 +104,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := DefaultJSONHandler.Unmarshal(data, x.Interface()) err := DefaultJSONHandler.Unmarshal(data, x.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return err return err
} }
fieldValue.Set(x.Elem()) fieldValue.Set(x.Elem())
@ -118,7 +118,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := DefaultJSONHandler.Unmarshal(data, x.Interface()) err := DefaultJSONHandler.Unmarshal(data, x.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return err return err
} }
fieldValue.Set(x.Elem()) fieldValue.Set(x.Elem())
@ -131,7 +131,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := DefaultJSONHandler.Unmarshal(data, x.Interface()) err := DefaultJSONHandler.Unmarshal(data, x.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return err return err
} }
fieldValue.Set(x.Elem()) fieldValue.Set(x.Elem())
@ -260,7 +260,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := DefaultJSONHandler.Unmarshal(data, &x) err := DefaultJSONHandler.Unmarshal(data, &x)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return err return err
} }
fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
@ -271,7 +271,7 @@ func (session *Session) bytes2Value(col *core.Column, fieldValue *reflect.Value,
if len(data) > 0 { if len(data) > 0 {
err := DefaultJSONHandler.Unmarshal(data, &x) err := DefaultJSONHandler.Unmarshal(data, &x)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return err return err
} }
fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType)) fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
@ -563,7 +563,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
if fieldValue.IsNil() { if fieldValue.IsNil() {
return nil, nil return nil, nil
} else if !fieldValue.IsValid() { } else if !fieldValue.IsValid() {
session.engine.logger.Warn("the field[", col.FieldName, "] is invalid") session.logger.Warn("the field[", col.FieldName, "] is invalid")
return nil, nil return nil, nil
} else { } else {
// !nashtsai! deference pointer type to instance type // !nashtsai! deference pointer type to instance type
@ -605,14 +605,14 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
if col.SQLType.IsText() { if col.SQLType.IsText() {
bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface()) bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return 0, err return 0, err
} }
return string(bytes), nil return string(bytes), nil
} else if col.SQLType.IsBlob() { } else if col.SQLType.IsBlob() {
bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface()) bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return 0, err return 0, err
} }
return bytes, nil return bytes, nil
@ -621,7 +621,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
case reflect.Complex64, reflect.Complex128: case reflect.Complex64, reflect.Complex128:
bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface()) bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return 0, err return 0, err
} }
return string(bytes), nil return string(bytes), nil
@ -633,7 +633,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
if col.SQLType.IsText() { if col.SQLType.IsText() {
bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface()) bytes, err := DefaultJSONHandler.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return 0, err return 0, err
} }
return string(bytes), nil return string(bytes), nil
@ -646,7 +646,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
} else { } else {
bytes, err = DefaultJSONHandler.Marshal(fieldValue.Interface()) bytes, err = DefaultJSONHandler.Marshal(fieldValue.Interface())
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
return 0, err return 0, err
} }
} }

4
session_delete.go
View File

@ -61,14 +61,14 @@ func (session *Session) cacheDelete(table *core.Table, tableName, sqlStr string,
} }
for _, id := range ids { for _, id := range ids {
session.engine.logger.Debug("[cacheDelete] delete cache obj:", tableName, id) session.logger.Debug("[cacheDelete] delete cache obj:", tableName, id)
sid, err := id.ToString() sid, err := id.ToString()
if err != nil { if err != nil {
return err return err
} }
cacher.DelBean(tableName, sid) cacher.DelBean(tableName, sid)
} }
session.engine.logger.Debug("[cacheDelete] clear cache table:", tableName) session.logger.Debug("[cacheDelete] clear cache table:", tableName)
cacher.ClearIds(tableName) cacher.ClearIds(tableName)
return nil return nil
} }

16
session_find.go
View File

@ -188,7 +188,7 @@ func (session *Session) find(rowsSlicePtr interface{}, condiBean ...interface{})
return err return err
} }
err = nil // !nashtsai! reset err to nil for ErrCacheFailed err = nil // !nashtsai! reset err to nil for ErrCacheFailed
session.engine.logger.Warn("Cache Find Failed") session.logger.Warn("Cache Find Failed")
} }
} }
@ -354,7 +354,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
for rows.Next() { for rows.Next() {
i++ i++
if i > 500 { if i > 500 {
session.engine.logger.Debug("[cacheFind] ids length > 500, no cache") session.logger.Debug("[cacheFind] ids length > 500, no cache")
return ErrCacheFailed return ErrCacheFailed
} }
var res = make([]string, len(table.PrimaryKeys)) var res = make([]string, len(table.PrimaryKeys))
@ -373,13 +373,13 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
ids = append(ids, pk) ids = append(ids, pk)
} }
session.engine.logger.Debug("[cacheFind] cache sql:", ids, tableName, sqlStr, newsql, args) session.logger.Debug("[cacheFind] cache sql:", ids, tableName, sqlStr, newsql, args)
err = core.PutCacheSql(cacher, ids, tableName, newsql, args) err = core.PutCacheSql(cacher, ids, tableName, newsql, args)
if err != nil { if err != nil {
return err return err
} }
} else { } else {
session.engine.logger.Debug("[cacheFind] cache hit sql:", tableName, sqlStr, newsql, args) session.logger.Debug("[cacheFind] cache hit sql:", tableName, sqlStr, newsql, args)
} }
sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr)) sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
@ -398,7 +398,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
ides = append(ides, id) ides = append(ides, id)
ididxes[sid] = idx ididxes[sid] = idx
} else { } else {
session.engine.logger.Debug("[cacheFind] cache hit bean:", tableName, id, bean) session.logger.Debug("[cacheFind] cache hit bean:", tableName, id, bean)
pk := session.engine.IdOf(bean) pk := session.engine.IdOf(bean)
xid, err := pk.ToString() xid, err := pk.ToString()
@ -407,7 +407,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
} }
if sid != xid { if sid != xid {
session.engine.logger.Error("[cacheFind] error cache", xid, sid, bean) session.logger.Error("[cacheFind] error cache", xid, sid, bean)
return ErrCacheFailed return ErrCacheFailed
} }
temps[idx] = bean temps[idx] = bean
@ -457,7 +457,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
bean := rv.Interface() bean := rv.Interface()
temps[ididxes[sid]] = bean temps[ididxes[sid]] = bean
session.engine.logger.Debug("[cacheFind] cache bean:", tableName, id, bean, temps) session.logger.Debug("[cacheFind] cache bean:", tableName, id, bean, temps)
cacher.PutBean(tableName, sid, bean) cacher.PutBean(tableName, sid, bean)
} }
} }
@ -465,7 +465,7 @@ func (session *Session) cacheFind(t reflect.Type, sqlStr string, rowsSlicePtr in
for j := 0; j < len(temps); j++ { for j := 0; j < len(temps); j++ {
bean := temps[j] bean := temps[j]
if bean == nil { if bean == nil {
session.engine.logger.Warn("[cacheFind] cache no hit:", tableName, ids[j], temps) session.logger.Warn("[cacheFind] cache no hit:", tableName, ids[j], temps)
// return errors.New("cache error") // !nashtsai! no need to return error, but continue instead // return errors.New("cache error") // !nashtsai! no need to return error, but continue instead
continue continue
} }

12
session_get.go
View File

@ -166,7 +166,7 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
tableName := session.statement.TableName() tableName := session.statement.TableName()
cacher := session.engine.getCacher(tableName) cacher := session.engine.getCacher(tableName)
session.engine.logger.Debug("[cacheGet] find sql:", newsql, args) session.logger.Debug("[cacheGet] find sql:", newsql, args)
table := session.statement.RefTable table := session.statement.RefTable
ids, err := core.GetCacheSql(cacher, tableName, newsql, args) ids, err := core.GetCacheSql(cacher, tableName, newsql, args)
if err != nil { if err != nil {
@ -202,19 +202,19 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
} }
ids = []core.PK{pk} ids = []core.PK{pk}
session.engine.logger.Debug("[cacheGet] cache ids:", newsql, ids) session.logger.Debug("[cacheGet] cache ids:", newsql, ids)
err = core.PutCacheSql(cacher, ids, tableName, newsql, args) err = core.PutCacheSql(cacher, ids, tableName, newsql, args)
if err != nil { if err != nil {
return false, err return false, err
} }
} else { } else {
session.engine.logger.Debug("[cacheGet] cache hit sql:", newsql, ids) session.logger.Debug("[cacheGet] cache hit sql:", newsql, ids)
} }
if len(ids) > 0 { if len(ids) > 0 {
structValue := reflect.Indirect(reflect.ValueOf(bean)) structValue := reflect.Indirect(reflect.ValueOf(bean))
id := ids[0] id := ids[0]
session.engine.logger.Debug("[cacheGet] get bean:", tableName, id) session.logger.Debug("[cacheGet] get bean:", tableName, id)
sid, err := id.ToString() sid, err := id.ToString()
if err != nil { if err != nil {
return false, err return false, err
@ -227,10 +227,10 @@ func (session *Session) cacheGet(bean interface{}, sqlStr string, args ...interf
return has, err return has, err
} }
session.engine.logger.Debug("[cacheGet] cache bean:", tableName, id, cacheBean) session.logger.Debug("[cacheGet] cache bean:", tableName, id, cacheBean)
cacher.PutBean(tableName, sid, cacheBean) cacher.PutBean(tableName, sid, cacheBean)
} else { } else {
session.engine.logger.Debug("[cacheGet] cache hit bean:", tableName, id, cacheBean) session.logger.Debug("[cacheGet] cache hit bean:", tableName, id, cacheBean)
has = true has = true
} }
structValue.Set(reflect.Indirect(reflect.ValueOf(cacheBean))) structValue.Set(reflect.Indirect(reflect.ValueOf(cacheBean)))

14
session_insert.go
View File

@ -440,7 +440,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
if table.Version != "" && session.statement.checkVersion { if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean) verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() { } else if verValue.IsValid() && verValue.CanSet() {
session.incrVersionFieldValue(verValue) session.incrVersionFieldValue(verValue)
} }
@ -458,7 +458,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
aiValue, err := table.AutoIncrColumn().ValueOf(bean) aiValue, err := table.AutoIncrColumn().ValueOf(bean)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
} }
if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() { if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@ -481,7 +481,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
if table.Version != "" && session.statement.checkVersion { if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean) verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() { } else if verValue.IsValid() && verValue.CanSet() {
session.incrVersionFieldValue(verValue) session.incrVersionFieldValue(verValue)
} }
@ -499,7 +499,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
aiValue, err := table.AutoIncrColumn().ValueOf(bean) aiValue, err := table.AutoIncrColumn().ValueOf(bean)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
} }
if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() { if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@ -522,7 +522,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
if table.Version != "" && session.statement.checkVersion { if table.Version != "" && session.statement.checkVersion {
verValue, err := table.VersionColumn().ValueOf(bean) verValue, err := table.VersionColumn().ValueOf(bean)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
} else if verValue.IsValid() && verValue.CanSet() { } else if verValue.IsValid() && verValue.CanSet() {
session.incrVersionFieldValue(verValue) session.incrVersionFieldValue(verValue)
} }
@ -540,7 +540,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
aiValue, err := table.AutoIncrColumn().ValueOf(bean) aiValue, err := table.AutoIncrColumn().ValueOf(bean)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
} }
if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() { if aiValue == nil || !aiValue.IsValid() || !aiValue.CanSet() {
@ -572,7 +572,7 @@ func (session *Session) cacheInsert(table string) error {
if cacher == nil { if cacher == nil {
return nil return nil
} }
session.engine.logger.Debug("[cache] clear sql:", table) session.logger.Debug("[cache] clear sql:", table)
cacher.ClearIds(table) cacher.ClearIds(table)
return nil return nil
} }

16
session_raw.go
View File

@ -33,16 +33,16 @@ func (session *Session) queryRows(sqlStr string, args ...interface{}) (*core.Row
defer func() { defer func() {
execDuration := time.Since(b4ExecTime) execDuration := time.Since(b4ExecTime)
if len(args) > 0 { if len(args) > 0 {
session.engine.logger.Infof("[SQL] %s %#v - took: %v", sqlStr, args, execDuration) session.logger.Infof("[SQL] %s %#v - took: %v", sqlStr, args, execDuration)
} else { } else {
session.engine.logger.Infof("[SQL] %s - took: %v", sqlStr, execDuration) session.logger.Infof("[SQL] %s - took: %v", sqlStr, execDuration)
} }
}() }()
} else { } else {
if len(args) > 0 { if len(args) > 0 {
session.engine.logger.Infof("[SQL] %v %#v", sqlStr, args) session.logger.Infof("[SQL] %v %#v", sqlStr, args)
} else { } else {
session.engine.logger.Infof("[SQL] %v", sqlStr) session.logger.Infof("[SQL] %v", sqlStr)
} }
} }
} }
@ -160,16 +160,16 @@ func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, er
defer func() { defer func() {
execDuration := time.Since(b4ExecTime) execDuration := time.Since(b4ExecTime)
if len(args) > 0 { if len(args) > 0 {
session.engine.logger.Infof("[SQL] %s %#v - took: %v", sqlStr, args, execDuration) session.logger.Infof("[SQL] %s %#v - took: %v", sqlStr, args, execDuration)
} else { } else {
session.engine.logger.Infof("[SQL] %s - took: %v", sqlStr, execDuration) session.logger.Infof("[SQL] %s - took: %v", sqlStr, execDuration)
} }
}() }()
} else { } else {
if len(args) > 0 { if len(args) > 0 {
session.engine.logger.Infof("[SQL] %v %#v", sqlStr, args) session.logger.Infof("[SQL] %v %#v", sqlStr, args)
} else { } else {
session.engine.logger.Infof("[SQL] %v", sqlStr) session.logger.Infof("[SQL] %v", sqlStr)
} }
} }
} }

2
session_schema.go
View File

@ -18,7 +18,7 @@ func (session *Session) Ping() error {
defer session.Close() defer session.Close()
} }
session.engine.logger.Infof("PING DATABASE %v", session.engine.DriverName()) session.logger.Infof("PING DATABASE %v", session.engine.DriverName())
return session.DB().PingContext(session.ctx) return session.DB().PingContext(session.ctx)
} }

22
session_update.go
View File

@ -28,7 +28,7 @@ func (session *Session) cacheUpdate(table *core.Table, tableName, sqlStr string,
for _, filter := range session.engine.dialect.Filters() { for _, filter := range session.engine.dialect.Filters() {
newsql = filter.Do(newsql, session.engine.dialect, table) newsql = filter.Do(newsql, session.engine.dialect, table)
} }
session.engine.logger.Debug("[cacheUpdate] new sql", oldhead, newsql) session.logger.Debug("[cacheUpdate] new sql", oldhead, newsql)
var nStart int var nStart int
if len(args) > 0 { if len(args) > 0 {
@ -41,7 +41,7 @@ func (session *Session) cacheUpdate(table *core.Table, tableName, sqlStr string,
} }
cacher := session.engine.getCacher(tableName) cacher := session.engine.getCacher(tableName)
session.engine.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:]) session.logger.Debug("[cacheUpdate] get cache sql", newsql, args[nStart:])
ids, err := core.GetCacheSql(cacher, tableName, newsql, args[nStart:]) ids, err := core.GetCacheSql(cacher, tableName, newsql, args[nStart:])
if err != nil { if err != nil {
rows, err := session.NoCache().queryRows(newsql, args[nStart:]...) rows, err := session.NoCache().queryRows(newsql, args[nStart:]...)
@ -74,7 +74,7 @@ func (session *Session) cacheUpdate(table *core.Table, tableName, sqlStr string,
ids = append(ids, pk) ids = append(ids, pk)
} }
session.engine.logger.Debug("[cacheUpdate] find updated id", ids) session.logger.Debug("[cacheUpdate] find updated id", ids)
} /*else { } /*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)) cacher.DelIds(tableName, genSqlKey(newsql, args))
@ -105,16 +105,16 @@ func (session *Session) cacheUpdate(table *core.Table, tableName, sqlStr string,
} else if strings.Contains(colName, session.engine.QuoteStr()) { } else if strings.Contains(colName, session.engine.QuoteStr()) {
colName = strings.TrimSpace(strings.Replace(colName, session.engine.QuoteStr(), "", -1)) colName = strings.TrimSpace(strings.Replace(colName, session.engine.QuoteStr(), "", -1))
} else { } else {
session.engine.logger.Debug("[cacheUpdate] cannot find column", tableName, colName) session.logger.Debug("[cacheUpdate] cannot find column", tableName, colName)
return ErrCacheFailed return ErrCacheFailed
} }
if col := table.GetColumn(colName); col != nil { if col := table.GetColumn(colName); col != nil {
fieldValue, err := col.ValueOf(bean) fieldValue, err := col.ValueOf(bean)
if err != nil { if err != nil {
session.engine.logger.Error(err) session.logger.Error(err)
} else { } else {
session.engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface()) session.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
if col.IsVersion && session.statement.checkVersion { if col.IsVersion && session.statement.checkVersion {
session.incrVersionFieldValue(fieldValue) session.incrVersionFieldValue(fieldValue)
} else { } else {
@ -122,16 +122,16 @@ func (session *Session) cacheUpdate(table *core.Table, tableName, sqlStr string,
} }
} }
} else { } else {
session.engine.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's", session.logger.Errorf("[cacheUpdate] ERROR: column %v is not table %v's",
colName, table.Name) colName, table.Name)
} }
} }
session.engine.logger.Debug("[cacheUpdate] update cache", tableName, id, bean) session.logger.Debug("[cacheUpdate] update cache", tableName, id, bean)
cacher.PutBean(tableName, sid, bean) cacher.PutBean(tableName, sid, bean)
} }
} }
session.engine.logger.Debug("[cacheUpdate] clear cached table sql:", tableName) session.logger.Debug("[cacheUpdate] clear cached table sql:", tableName)
cacher.ClearIds(tableName) cacher.ClearIds(tableName)
return nil return nil
} }
@ -383,7 +383,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
if cacher := session.engine.getCacher(tableName); cacher != nil && session.statement.UseCache { if cacher := session.engine.getCacher(tableName); cacher != nil && session.statement.UseCache {
//session.cacheUpdate(table, tableName, sqlStr, args...) //session.cacheUpdate(table, tableName, sqlStr, args...)
session.engine.logger.Debug("[cacheUpdate] clear table ", tableName) session.logger.Debug("[cacheUpdate] clear table ", tableName)
cacher.ClearIds(tableName) cacher.ClearIds(tableName)
cacher.ClearBeans(tableName) cacher.ClearBeans(tableName)
} }
@ -394,7 +394,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
closure(bean) closure(bean)
} }
if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok { if processor, ok := interface{}(bean).(AfterUpdateProcessor); ok {
session.engine.logger.Debug("[event]", tableName, " has after update processor") session.logger.Debug("[event]", tableName, " has after update processor")
processor.AfterUpdate() processor.AfterUpdate()
} }
} else { } else {