private Engine.LogSQL and create ILogger interface that is compatible with log/syslog package. Also fixed use of LogError instead of LogSQL

engine.go

@@ -6,7 +6,6 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
-	"io"
 	"os"
 	"reflect"
 	"strconv"
@@ -34,7 +33,7 @@ type Engine struct {
 	ShowWarn     bool
 	Pool         IConnectPool
 	Filters      []core.Filter
-	Logger       io.Writer
+	Logger       ILogger // io.Writer
 	Cacher       core.Cacher
 	tableCachers map[reflect.Type]core.Cacher
 }
@@ -144,35 +143,44 @@ func (engine *Engine) Close() error {
 func (engine *Engine) Ping() error {
 	session := engine.NewSession()
 	defer session.Close()
-	engine.LogSQL("PING DATABASE", engine.DriverName)
+	engine.LogInfo("PING DATABASE", engine.DriverName)
 	return session.Ping()
 }
 
 // logging sql
-func (engine *Engine) LogSQL(contents ...interface{}) {
+func (engine *Engine) logSQL(sqlStr string, sqlArgs ...interface{}) {
 	if engine.ShowSQL {
-		io.WriteString(engine.Logger, fmt.Sprintln(contents...))
+		if len(sqlArgs) > 0 {
+			engine.LogInfo("[sql]", sqlStr, "[args]", sqlArgs)
+		} else {
+			engine.LogInfo("[sql]", sqlStr)
+		}
 	}
 }
 
 // logging error
 func (engine *Engine) LogError(contents ...interface{}) {
 	if engine.ShowErr {
-		io.WriteString(engine.Logger, fmt.Sprintln(contents...))
+		engine.Logger.Err(fmt.Sprintln(contents...))
 	}
 }
 
+// logging error
+func (engine *Engine) LogInfo(contents ...interface{}) {
+	engine.Logger.Info(fmt.Sprintln(contents...))
+}
+
 // logging debug
 func (engine *Engine) LogDebug(contents ...interface{}) {
 	if engine.ShowDebug {
-		io.WriteString(engine.Logger, fmt.Sprintln(contents...))
+		engine.Logger.Debug(fmt.Sprintln(contents...))
 	}
 }
 
 // logging warn
 func (engine *Engine) LogWarn(contents ...interface{}) {
 	if engine.ShowWarn {
-		io.WriteString(engine.Logger, fmt.Sprintln(contents...))
+		engine.Logger.Warning(fmt.Sprintln(contents...))
 	}
 }
 

logger.go

@@ -0,0 +1,48 @@
+package xorm
+
+import (
+	"io"
+	"log"
+)
+
+// 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)
+}
+
+type SimpleLogger struct {
+	logger *log.Logger
+}
+
+func NewSimpleLogger(out io.Writer) *SimpleLogger {
+	return &SimpleLogger{
+		logger: log.New(out, "[xorm] ", log.Ldate|log.Lmicroseconds)}
+}
+
+func NewSimpleLogger2(out io.Writer, prefix string, flag int) *SimpleLogger {
+	return &SimpleLogger{
+		logger: log.New(out, prefix, flag)}
+}
+
+func (s *SimpleLogger) Debug(m string) (err error) {
+	s.logger.Println("[debug]", m)
+	return
+}
+
+func (s *SimpleLogger) Err(m string) (err error) {
+	s.logger.Println("[error]", m)
+	return
+}
+
+func (s *SimpleLogger) Info(m string) (err error) {
+	s.logger.Println("[info]", m)
+	return
+}
+
+func (s *SimpleLogger) Warning(m string) (err error) {
+	s.logger.Println("[warning]", m)
+	return
+}

rows.go

@@ -32,24 +32,23 @@ func newRows(session *Session, bean interface{}) (*Rows, error) {
 
 	defer rows.session.Statement.Init()
 
-	var sql string
+	var sqlStr string
 	var args []interface{}
 	rows.session.Statement.RefTable = rows.session.Engine.autoMap(bean)
 	if rows.session.Statement.RawSQL == "" {
-		sql, args = rows.session.Statement.genGetSql(bean)
+		sqlStr, args = rows.session.Statement.genGetSql(bean)
 	} else {
-		sql = rows.session.Statement.RawSQL
+		sqlStr = rows.session.Statement.RawSQL
 		args = rows.session.Statement.RawParams
 	}
 
 	for _, filter := range rows.session.Engine.Filters {
-		sql = filter.Do(sql, session.Engine.dialect, rows.session.Statement.RefTable)
+		sqlStr = filter.Do(sqlStr, session.Engine.dialect, rows.session.Statement.RefTable)
 	}
 
-	rows.session.Engine.LogSQL(sql)
+	rows.session.Engine.logSQL(sqlStr, args)
-	rows.session.Engine.LogSQL(args)
 
-	rows.stmt, err = rows.session.Db.Prepare(sql)
+	rows.stmt, err = rows.session.Db.Prepare(sqlStr)
 	if err != nil {
 		rows.lastError = err
 		defer rows.Close()

session.go

@@ -282,7 +282,7 @@ func (session *Session) Begin() error {
 		session.IsCommitedOrRollbacked = false
 		session.Tx = tx
 
-		session.Engine.LogSQL("BEGIN TRANSACTION")
+		session.Engine.logSQL("BEGIN TRANSACTION")
 	}
 	return nil
 }
@@ -290,7 +290,7 @@ func (session *Session) Begin() error {
 // When using transaction, you can rollback if any error
 func (session *Session) Rollback() error {
 	if !session.IsAutoCommit && !session.IsCommitedOrRollbacked {
-		session.Engine.LogSQL("ROLL BACK")
+		session.Engine.logSQL("ROLL BACK")
 		session.IsCommitedOrRollbacked = true
 		return session.Tx.Rollback()
 	}
@@ -300,7 +300,7 @@ func (session *Session) Rollback() error {
 // When using transaction, Commit will commit all operations.
 func (session *Session) Commit() error {
 	if !session.IsAutoCommit && !session.IsCommitedOrRollbacked {
-		session.Engine.LogSQL("COMMIT")
+		session.Engine.logSQL("COMMIT")
 		session.IsCommitedOrRollbacked = true
 		var err error
 		if err = session.Tx.Commit(); err == nil {
@@ -419,8 +419,7 @@ func (session *Session) exec(sqlStr string, args ...interface{}) (sql.Result, er
 		sqlStr = filter.Do(sqlStr, session.Engine.dialect, session.Statement.RefTable)
 	}
 
-	session.Engine.LogSQL(sqlStr)
+	session.Engine.logSQL(sqlStr, args)
-	session.Engine.LogSQL(args)
 
 	if session.IsAutoCommit {
 		return session.innerExec(sqlStr, args...)
@@ -1480,7 +1479,7 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 					x := reflect.New(fieldType)
 					err := json.Unmarshal([]byte(vv.String()), x.Interface())
 					if err != nil {
-						session.Engine.LogSQL(err)
+						session.Engine.LogError(err)
 						return err
 					}
 					fieldValue.Set(x.Elem())
@@ -1700,8 +1699,7 @@ func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{})
 		*sqlStr = filter.Do(*sqlStr, session.Engine.dialect, session.Statement.RefTable)
 	}
 
-	session.Engine.LogSQL(*sqlStr)
+	session.Engine.logSQL(*sqlStr, paramStr)
-	session.Engine.LogSQL(paramStr)
 }
 
 func (session *Session) query(sqlStr string, paramStr ...interface{}) (resultsSlice []map[string][]byte, err error) {
@@ -2467,7 +2465,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.LogSQL(err)
+			session.Engine.LogError(err)
 			return 0, err
 		}
 		return string(bytes), nil
@@ -2479,7 +2477,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.LogSQL(err)
+				session.Engine.LogError(err)
 				return 0, err
 			}
 			return string(bytes), nil
@@ -2492,7 +2490,7 @@ func (session *Session) value2Interface(col *core.Column, fieldValue reflect.Val
 			} else {
 				bytes, err = json.Marshal(fieldValue.Interface())
 				if err != nil {
-					session.Engine.LogSQL(err)
+					session.Engine.LogError(err)
 					return 0, err
 				}
 			}

statement.go

@@ -210,7 +210,7 @@ func (statement *Statement) Table(tableNameOrBean interface{}) *Statement {
             if col.SQLType.IsText() {
                 bytes, err := json.Marshal(fieldValue.Interface())
                 if err != nil {
-                    engine.LogSQL(err)
+                    engine.LogError(err)
                     continue
                 }
                 val = string(bytes)
@@ -227,7 +227,7 @@ func (statement *Statement) Table(tableNameOrBean interface{}) *Statement {
                 } else {
                     bytes, err = json.Marshal(fieldValue.Interface())
                     if err != nil {
-                        engine.LogSQL(err)
+                        engine.LogError(err)
                         continue
                     }
                     val = bytes
@@ -373,7 +373,7 @@ func buildConditions(engine *Engine, table *core.Table, bean interface{},
 			if col.SQLType.IsText() {
 				bytes, err := json.Marshal(fieldValue.Interface())
 				if err != nil {
-					engine.LogSQL(err)
+					engine.LogError(err)
 					continue
 				}
 				val = string(bytes)
@@ -390,7 +390,7 @@ func buildConditions(engine *Engine, table *core.Table, bean interface{},
 				} else {
 					bytes, err = json.Marshal(fieldValue.Interface())
 					if err != nil {
-						engine.LogSQL(err)
+						engine.LogError(err)
 						continue
 					}
 					val = bytes

xorm.go

@@ -46,9 +46,11 @@ func NewEngine(driverName string, dataSourceName string) (*Engine, error) {
 		return nil, err
 	}
 
-	engine := &Engine{DriverName: driverName,
+	engine := &Engine{
-		DataSourceName: dataSourceName, dialect: dialect,
+		DriverName:     driverName,
-		tableCachers: make(map[reflect.Type]core.Cacher)}
+		DataSourceName: dataSourceName,
+		dialect:        dialect,
+		tableCachers:   make(map[reflect.Type]core.Cacher)}
 
 	engine.SetMapper(core.NewCacheMapper(new(core.SnakeMapper)))
 
@@ -58,7 +60,7 @@ func NewEngine(driverName string, dataSourceName string) (*Engine, error) {
 	engine.mutex = &sync.RWMutex{}
 	engine.TagIdentifier = "xorm"
 
-	engine.Logger = os.Stdout
+	engine.Logger = NewSimpleLogger(os.Stdout)
 
 	//engine.Pool = NewSimpleConnectPool()
 	//engine.Pool = NewNoneConnectPool()