github.com/wanlay/gorm-dm8@v1.0.5/dmr/ze.go (about)

     1  /*
     2   * Copyright (c) 2000-2018, 达梦数据库有限公司.
     3   * All rights reserved.
     4   */
     5  
     6  package dmr
     7  
     8  import (
     9  	"context"
    10  	"database/sql/driver"
    11  	"reflect"
    12  	"strconv"
    13  	"time"
    14  
    15  	"github.com/wanlay/gorm-dm8/dmr/util"
    16  )
    17  
    18  type logFilter struct{}
    19  
    20  func (filter *logFilter) DmDriverOpen(filterChain *filterChain, d *DmDriver, dsn string) (ret *DmConnection, err error) {
    21  	var logRecord = d.logInfo.logRecord
    22  	logRecord.Set(d, "open", dsn)
    23  	defer func() {
    24  		filter.doLog(logRecord)
    25  	}()
    26  	ret, err = filterChain.DmDriverOpen(d, dsn)
    27  	if err != nil {
    28  		logRecord.SetError(err)
    29  		return
    30  	}
    31  	logRecord.SetReturnValue(ret)
    32  	return
    33  }
    34  
    35  func (filter *logFilter) DmDriverOpenConnector(filterChain *filterChain, d *DmDriver, dsn string) (ret *DmConnector, err error) {
    36  	var logRecord = d.logInfo.logRecord
    37  	logRecord.Set(d, "openConnector", dsn)
    38  	defer func() {
    39  		filter.doLog(logRecord)
    40  	}()
    41  	ret, err = filterChain.DmDriverOpenConnector(d, dsn)
    42  	if err != nil {
    43  		logRecord.SetError(err)
    44  		return
    45  	}
    46  	logRecord.SetReturnValue(ret)
    47  	return
    48  }
    49  
    50  func (filter *logFilter) DmConnectorConnect(filterChain *filterChain, c *DmConnector, ctx context.Context) (ret *DmConnection, err error) {
    51  	var logRecord = c.logInfo.logRecord
    52  	logRecord.Set(c, "connect")
    53  	defer func() {
    54  		filter.doLog(logRecord)
    55  	}()
    56  	ret, err = filterChain.DmConnectorConnect(c, ctx)
    57  	if err != nil {
    58  		logRecord.SetError(err)
    59  		return
    60  	}
    61  	logRecord.SetReturnValue(ret)
    62  	return
    63  }
    64  
    65  func (filter *logFilter) DmConnectorDriver(filterChain *filterChain, c *DmConnector) (ret *DmDriver) {
    66  	var logRecord = c.logInfo.logRecord
    67  	logRecord.Set(c, "dmr")
    68  	defer func() {
    69  		filter.doLog(logRecord)
    70  	}()
    71  	ret = filterChain.DmConnectorDriver(c)
    72  	logRecord.SetReturnValue(ret)
    73  	return
    74  }
    75  
    76  func (filter *logFilter) DmConnectionBegin(filterChain *filterChain, c *DmConnection) (ret *DmConnection, err error) {
    77  	var logRecord = c.logInfo.logRecord
    78  	logRecord.Set(c, "begin")
    79  	defer func() {
    80  		filter.doLog(logRecord)
    81  	}()
    82  	ret, err = filterChain.DmConnectionBegin(c)
    83  	if err != nil {
    84  		logRecord.SetError(err)
    85  		return
    86  	}
    87  	logRecord.SetReturnValue(ret)
    88  	return
    89  }
    90  
    91  func (filter *logFilter) DmConnectionBeginTx(filterChain *filterChain, c *DmConnection, ctx context.Context, opts driver.TxOptions) (ret *DmConnection, err error) {
    92  	var logRecord = c.logInfo.logRecord
    93  	logRecord.Set(c, "beginTx", opts)
    94  	defer func() {
    95  		filter.doLog(logRecord)
    96  	}()
    97  	ret, err = filterChain.DmConnectionBeginTx(c, ctx, opts)
    98  	if err != nil {
    99  		logRecord.SetError(err)
   100  		return
   101  	}
   102  	logRecord.SetReturnValue(ret)
   103  	return
   104  }
   105  
   106  func (filter *logFilter) DmConnectionCommit(filterChain *filterChain, c *DmConnection) (err error) {
   107  	var logRecord = c.logInfo.logRecord
   108  	logRecord.Set(c, "commit")
   109  	defer func() {
   110  		filter.doLog(logRecord)
   111  	}()
   112  	err = filterChain.DmConnectionCommit(c)
   113  	if err != nil {
   114  		logRecord.SetError(err)
   115  		return
   116  	}
   117  	return
   118  }
   119  
   120  func (filter *logFilter) DmConnectionRollback(filterChain *filterChain, c *DmConnection) (err error) {
   121  	var logRecord = c.logInfo.logRecord
   122  	logRecord.Set(c, "rollback")
   123  	defer func() {
   124  		filter.doLog(logRecord)
   125  	}()
   126  	err = filterChain.DmConnectionRollback(c)
   127  	if err != nil {
   128  		logRecord.SetError(err)
   129  		return
   130  	}
   131  	return
   132  }
   133  
   134  func (filter *logFilter) DmConnectionClose(filterChain *filterChain, c *DmConnection) (err error) {
   135  	var logRecord = c.logInfo.logRecord
   136  	logRecord.Set(c, "close")
   137  	defer func() {
   138  		filter.doLog(logRecord)
   139  	}()
   140  	err = filterChain.DmConnectionClose(c)
   141  	if err != nil {
   142  		logRecord.SetError(err)
   143  		return
   144  	}
   145  	return
   146  }
   147  
   148  func (filter *logFilter) DmConnectionPing(filterChain *filterChain, c *DmConnection, ctx context.Context) (err error) {
   149  	var logRecord = c.logInfo.logRecord
   150  	logRecord.Set(c, "ping")
   151  	defer func() {
   152  		filter.doLog(logRecord)
   153  	}()
   154  	err = filterChain.DmConnectionPing(c, ctx)
   155  	if err != nil {
   156  		logRecord.SetError(err)
   157  		return
   158  	}
   159  	return
   160  }
   161  
   162  func (filter *logFilter) DmConnectionExec(filterChain *filterChain, c *DmConnection, query string, args []driver.Value) (ret *DmResult, err error) {
   163  	var logRecord = c.logInfo.logRecord
   164  	logRecord.Set(c, "executeByStmt", query, args)
   165  	defer func() {
   166  		filter.executeAfter(c.logInfo, logRecord)
   167  		filter.doLog(logRecord)
   168  	}()
   169  	logRecord.SetSql(query)
   170  	filter.executeBefore(c.logInfo)
   171  	ret, err = filterChain.DmConnectionExec(c, query, args)
   172  	if err != nil {
   173  		logRecord.SetError(err)
   174  		return
   175  	}
   176  	logRecord.SetReturnValue(ret)
   177  	return
   178  }
   179  
   180  func (filter *logFilter) DmConnectionExecContext(filterChain *filterChain, c *DmConnection, ctx context.Context, query string, args []driver.NamedValue) (ret *DmResult, err error) {
   181  	var logRecord = c.logInfo.logRecord
   182  	logRecord.Set(c, "executeCtx", query, args)
   183  	defer func() {
   184  		filter.executeAfter(c.logInfo, logRecord)
   185  		filter.doLog(logRecord)
   186  	}()
   187  	logRecord.SetSql(query)
   188  	filter.executeBefore(c.logInfo)
   189  	ret, err = filterChain.DmConnectionExecContext(c, ctx, query, args)
   190  	if err != nil {
   191  		logRecord.SetError(err)
   192  		return
   193  	}
   194  	logRecord.SetReturnValue(ret)
   195  	return
   196  }
   197  
   198  func (filter *logFilter) DmConnectionQuery(filterChain *filterChain, c *DmConnection, query string, args []driver.Value) (ret *DmRows, err error) {
   199  	var logRecord = c.logInfo.logRecord
   200  	logRecord.Set(c, "query", query, args)
   201  	defer func() {
   202  		filter.executeAfter(c.logInfo, logRecord)
   203  		filter.doLog(logRecord)
   204  	}()
   205  	logRecord.SetSql(query)
   206  	filter.executeBefore(c.logInfo)
   207  	ret, err = filterChain.DmConnectionQuery(c, query, args)
   208  	if err != nil {
   209  		logRecord.SetError(err)
   210  		return
   211  	}
   212  	logRecord.SetReturnValue(ret)
   213  	return
   214  }
   215  
   216  func (filter *logFilter) DmConnectionQueryContext(filterChain *filterChain, c *DmConnection, ctx context.Context, query string, args []driver.NamedValue) (ret *DmRows, err error) {
   217  	var logRecord = c.logInfo.logRecord
   218  	logRecord.Set(c, "queryCtx", query, args)
   219  	defer func() {
   220  		filter.executeAfter(c.logInfo, logRecord)
   221  		filter.doLog(logRecord)
   222  	}()
   223  	logRecord.SetSql(query)
   224  	filter.executeBefore(c.logInfo)
   225  	ret, err = filterChain.DmConnectionQueryContext(c, ctx, query, args)
   226  	if err != nil {
   227  		logRecord.SetError(err)
   228  		return
   229  	}
   230  	logRecord.SetReturnValue(ret)
   231  	return
   232  }
   233  
   234  func (filter *logFilter) DmConnectionPrepare(filterChain *filterChain, c *DmConnection, query string) (ret *DmStatement, err error) {
   235  	var logRecord = c.logInfo.logRecord
   236  	logRecord.Set(c, "prepareStatement", query)
   237  	defer func() {
   238  		filter.doLog(logRecord)
   239  	}()
   240  	logRecord.SetSql(query)
   241  	ret, err = filterChain.DmConnectionPrepare(c, query)
   242  	if err != nil {
   243  		logRecord.SetError(err)
   244  		return
   245  	}
   246  	logRecord.SetReturnValue(ret)
   247  	return
   248  }
   249  
   250  func (filter *logFilter) DmConnectionPrepareContext(filterChain *filterChain, c *DmConnection, ctx context.Context, query string) (ret *DmStatement, err error) {
   251  	var logRecord = c.logInfo.logRecord
   252  	logRecord.Set(c, "prepareStatementCtx", query)
   253  	defer func() {
   254  		filter.doLog(logRecord)
   255  	}()
   256  	logRecord.SetSql(query)
   257  	ret, err = filterChain.DmConnectionPrepareContext(c, ctx, query)
   258  	if err != nil {
   259  		logRecord.SetError(err)
   260  		return
   261  	}
   262  	logRecord.SetReturnValue(ret)
   263  	return
   264  }
   265  
   266  func (filter *logFilter) DmConnectionResetSession(filterChain *filterChain, c *DmConnection, ctx context.Context) (err error) {
   267  	var logRecord = c.logInfo.logRecord
   268  	logRecord.Set(c, "resetSession")
   269  	defer func() {
   270  		filter.doLog(logRecord)
   271  	}()
   272  	err = filterChain.DmConnectionResetSession(c, ctx)
   273  	if err != nil {
   274  		logRecord.SetError(err)
   275  		return
   276  	}
   277  	return
   278  }
   279  
   280  func (filter *logFilter) DmConnectionCheckNamedValue(filterChain *filterChain, c *DmConnection, nv *driver.NamedValue) (err error) {
   281  	var logRecord = c.logInfo.logRecord
   282  	logRecord.Set(c, "checkNamedValue", nv)
   283  	defer func() {
   284  		filter.doLog(logRecord)
   285  	}()
   286  	err = filterChain.DmConnectionCheckNamedValue(c, nv)
   287  	if err != nil {
   288  		logRecord.SetError(err)
   289  		return
   290  	}
   291  	return
   292  }
   293  
   294  func (filter *logFilter) DmStatementClose(filterChain *filterChain, s *DmStatement) (err error) {
   295  	var logRecord = s.logInfo.logRecord
   296  	logRecord.Set(s, "close")
   297  	defer func() {
   298  		filter.doLog(logRecord)
   299  	}()
   300  	err = filterChain.DmStatementClose(s)
   301  	if err != nil {
   302  		logRecord.SetError(err)
   303  		return
   304  	}
   305  	return
   306  }
   307  
   308  func (filter *logFilter) DmStatementNumInput(filterChain *filterChain, s *DmStatement) (ret int) {
   309  	var logRecord = s.logInfo.logRecord
   310  	logRecord.Set(s, "numInput")
   311  	defer func() {
   312  		filter.doLog(logRecord)
   313  	}()
   314  	ret = filterChain.DmStatementNumInput(s)
   315  	logRecord.SetReturnValue(ret)
   316  	return
   317  }
   318  
   319  func (filter *logFilter) DmStatementExec(filterChain *filterChain, s *DmStatement, args []driver.Value) (ret *DmResult, err error) {
   320  	var logRecord = s.logInfo.logRecord
   321  	logRecord.Set(s, "executeByStmt", args)
   322  	defer func() {
   323  		filter.executeAfter(s.logInfo, logRecord)
   324  		filter.doLog(logRecord)
   325  	}()
   326  	logRecord.SetSql(s.nativeSql)
   327  	filter.executeBefore(s.logInfo)
   328  	ret, err = filterChain.DmStatementExec(s, args)
   329  	if err != nil {
   330  		logRecord.SetError(err)
   331  		return
   332  	}
   333  	logRecord.SetReturnValue(ret)
   334  	return
   335  }
   336  
   337  func (filter *logFilter) DmStatementExecContext(filterChain *filterChain, s *DmStatement, ctx context.Context, args []driver.NamedValue) (ret *DmResult, err error) {
   338  	var logRecord = s.logInfo.logRecord
   339  	logRecord.Set(s, "executeCtx", args)
   340  	defer func() {
   341  		filter.executeAfter(s.logInfo, logRecord)
   342  		filter.doLog(logRecord)
   343  	}()
   344  	logRecord.SetSql(s.nativeSql)
   345  	filter.executeBefore(s.logInfo)
   346  	ret, err = filterChain.DmStatementExecContext(s, ctx, args)
   347  	if err != nil {
   348  		logRecord.SetError(err)
   349  		return
   350  	}
   351  	logRecord.SetReturnValue(ret)
   352  	return
   353  }
   354  
   355  func (filter *logFilter) DmStatementQuery(filterChain *filterChain, s *DmStatement, args []driver.Value) (ret *DmRows, err error) {
   356  	var logRecord = s.logInfo.logRecord
   357  	logRecord.Set(s, "query", args)
   358  	defer func() {
   359  		filter.executeAfter(s.logInfo, logRecord)
   360  		filter.doLog(logRecord)
   361  	}()
   362  	logRecord.SetSql(s.nativeSql)
   363  	filter.executeBefore(s.logInfo)
   364  	ret, err = filterChain.DmStatementQuery(s, args)
   365  	if err != nil {
   366  		logRecord.SetError(err)
   367  		return
   368  	}
   369  	logRecord.SetReturnValue(ret)
   370  	return
   371  }
   372  
   373  func (filter *logFilter) DmStatementQueryContext(filterChain *filterChain, s *DmStatement, ctx context.Context, args []driver.NamedValue) (ret *DmRows, err error) {
   374  	var logRecord = s.logInfo.logRecord
   375  	logRecord.Set(s, "queryCtx", args)
   376  	defer func() {
   377  		filter.executeAfter(s.logInfo, logRecord)
   378  		filter.doLog(logRecord)
   379  	}()
   380  	logRecord.SetSql(s.nativeSql)
   381  	filter.executeBefore(s.logInfo)
   382  	ret, err = filterChain.DmStatementQueryContext(s, ctx, args)
   383  	if err != nil {
   384  		logRecord.SetError(err)
   385  		return
   386  	}
   387  	logRecord.SetReturnValue(ret)
   388  	return
   389  }
   390  
   391  func (filter *logFilter) DmStatementCheckNamedValue(filterChain *filterChain, s *DmStatement, nv *driver.NamedValue) (err error) {
   392  	var logRecord = s.logInfo.logRecord
   393  	logRecord.Set(s, "checkNamedValue", nv)
   394  	defer func() {
   395  		filter.doLog(logRecord)
   396  	}()
   397  	err = filterChain.DmStatementCheckNamedValue(s, nv)
   398  	if err != nil {
   399  		logRecord.SetError(err)
   400  		return
   401  	}
   402  	return
   403  }
   404  
   405  func (filter *logFilter) DmResultLastInsertId(filterChain *filterChain, r *DmResult) (ret int64, err error) {
   406  	var logRecord = r.logInfo.logRecord
   407  	logRecord.Set(r, "lastInsertId")
   408  	defer func() {
   409  		filter.doLog(logRecord)
   410  	}()
   411  	ret, err = filterChain.DmResultLastInsertId(r)
   412  	if err != nil {
   413  		logRecord.SetError(err)
   414  		return
   415  	}
   416  	logRecord.SetReturnValue(ret)
   417  	return
   418  }
   419  
   420  func (filter *logFilter) DmResultRowsAffected(filterChain *filterChain, r *DmResult) (ret int64, err error) {
   421  	var logRecord = r.logInfo.logRecord
   422  	logRecord.Set(r, "rowsAffected")
   423  	defer func() {
   424  		filter.doLog(logRecord)
   425  	}()
   426  	ret, err = filterChain.DmResultRowsAffected(r)
   427  	if err != nil {
   428  		logRecord.SetError(err)
   429  		return
   430  	}
   431  	logRecord.SetReturnValue(ret)
   432  	return
   433  }
   434  
   435  func (filter *logFilter) DmRowsColumns(filterChain *filterChain, r *DmRows) (ret []string) {
   436  	var logRecord = r.logInfo.logRecord
   437  	logRecord.Set(r, "columns")
   438  	defer func() {
   439  		filter.doLog(logRecord)
   440  	}()
   441  	ret = filterChain.DmRowsColumns(r)
   442  	logRecord.SetReturnValue(ret)
   443  	return
   444  }
   445  
   446  func (filter *logFilter) DmRowsClose(filterChain *filterChain, r *DmRows) (err error) {
   447  	var logRecord = r.logInfo.logRecord
   448  	logRecord.Set(r, "close")
   449  	defer func() {
   450  		filter.doLog(logRecord)
   451  	}()
   452  	err = filterChain.DmRowsClose(r)
   453  	if err != nil {
   454  		logRecord.SetError(err)
   455  		return
   456  	}
   457  	return
   458  }
   459  
   460  func (filter *logFilter) DmRowsNext(filterChain *filterChain, r *DmRows, dest []driver.Value) (err error) {
   461  	var logRecord = r.logInfo.logRecord
   462  	logRecord.Set(r, "next", dest)
   463  	defer func() {
   464  		filter.doLog(logRecord)
   465  	}()
   466  	err = filterChain.DmRowsNext(r, dest)
   467  	if err != nil {
   468  		logRecord.SetError(err)
   469  		return
   470  	}
   471  	return
   472  }
   473  
   474  func (filter *logFilter) DmRowsHasNextResultSet(filterChain *filterChain, r *DmRows) (ret bool) {
   475  	var logRecord = r.logInfo.logRecord
   476  	logRecord.Set(r, "hasNextResultSet")
   477  	defer func() {
   478  		filter.doLog(logRecord)
   479  	}()
   480  	ret = filterChain.DmRowsHasNextResultSet(r)
   481  	logRecord.SetReturnValue(ret)
   482  	return
   483  }
   484  
   485  func (filter *logFilter) DmRowsNextResultSet(filterChain *filterChain, r *DmRows) (err error) {
   486  	var logRecord = r.logInfo.logRecord
   487  	logRecord.Set(r, "nextResultSet")
   488  	defer func() {
   489  		filter.doLog(logRecord)
   490  	}()
   491  	err = filterChain.DmRowsNextResultSet(r)
   492  	if err != nil {
   493  		logRecord.SetError(err)
   494  		return
   495  	}
   496  	return
   497  }
   498  
   499  func (filter *logFilter) DmRowsColumnTypeScanType(filterChain *filterChain, r *DmRows, index int) (ret reflect.Type) {
   500  	var logRecord = r.logInfo.logRecord
   501  	logRecord.Set(r, "columnTypeScanType", index)
   502  	defer func() {
   503  		filter.doLog(logRecord)
   504  	}()
   505  	ret = filterChain.DmRowsColumnTypeScanType(r, index)
   506  	logRecord.SetReturnValue(ret)
   507  	return
   508  }
   509  
   510  func (filter *logFilter) DmRowsColumnTypeDatabaseTypeName(filterChain *filterChain, r *DmRows, index int) (ret string) {
   511  	var logRecord = r.logInfo.logRecord
   512  	logRecord.Set(r, "columnTypeDatabaseTypeName", index)
   513  	defer func() {
   514  		filter.doLog(logRecord)
   515  	}()
   516  	ret = filterChain.DmRowsColumnTypeDatabaseTypeName(r, index)
   517  	logRecord.SetReturnValue(ret)
   518  	return
   519  }
   520  
   521  func (filter *logFilter) DmRowsColumnTypeLength(filterChain *filterChain, r *DmRows, index int) (length int64, ok bool) {
   522  	var logRecord = r.logInfo.logRecord
   523  	logRecord.Set(r, "columnTypeLength", index)
   524  	defer func() {
   525  		filter.doLog(logRecord)
   526  	}()
   527  	length, ok = filterChain.DmRowsColumnTypeLength(r, index)
   528  	if ok {
   529  		logRecord.SetReturnValue(length)
   530  	} else {
   531  		logRecord.SetReturnValue(-1)
   532  	}
   533  	return
   534  }
   535  
   536  func (filter *logFilter) DmRowsColumnTypeNullable(filterChain *filterChain, r *DmRows, index int) (nullable, ok bool) {
   537  	var logRecord = r.logInfo.logRecord
   538  	logRecord.Set(r, "columnTypeNullable", index)
   539  	defer func() {
   540  		filter.doLog(logRecord)
   541  	}()
   542  	nullable, ok = filterChain.DmRowsColumnTypeNullable(r, index)
   543  	if ok {
   544  		logRecord.SetReturnValue(nullable)
   545  	} else {
   546  		logRecord.SetReturnValue(false)
   547  	}
   548  	return
   549  }
   550  
   551  func (filter *logFilter) DmRowsColumnTypePrecisionScale(filterChain *filterChain, r *DmRows, index int) (precision, scale int64, ok bool) {
   552  	var logRecord = r.logInfo.logRecord
   553  	logRecord.Set(r, "columnTypePrecisionScale", index)
   554  	defer func() {
   555  		filter.doLog(logRecord)
   556  	}()
   557  	precision, scale, ok = filterChain.DmRowsColumnTypePrecisionScale(r, index)
   558  	if ok {
   559  		logRecord.SetReturnValue(strconv.FormatInt(precision, 10) + "&" + strconv.FormatInt(scale, 10))
   560  	} else {
   561  		logRecord.SetReturnValue("-1&-1")
   562  	}
   563  	return
   564  }
   565  
   566  func (filter *logFilter) executeBefore(logInfo *logInfo) {
   567  	if LogFilterLogger.IsSqlEnabled() {
   568  		logInfo.lastExecuteStartNano = time.Now()
   569  	}
   570  }
   571  
   572  func (filter *logFilter) executeAfter(logInfo *logInfo, record *LogRecord) {
   573  	if LogFilterLogger.IsSqlEnabled() {
   574  		record.SetUsedTime(time.Since(logInfo.lastExecuteStartNano))
   575  	}
   576  }
   577  
   578  func (filter *logFilter) doLog(record *LogRecord) {
   579  
   580  	if record == nil {
   581  		return
   582  	}
   583  	if record.GetError() != nil {
   584  		LogFilterLogger.ErrorWithErr(record.ToString(), record.GetError())
   585  	} else if record.GetSql() != "" && LogFilterLogger.IsSqlEnabled() {
   586  		LogFilterLogger.Sql(record.ToString())
   587  	} else {
   588  		LogFilterLogger.Info(record.ToString())
   589  	}
   590  }
   591  
   592  /************************************************************************************************************/
   593  type Logger struct {
   594  }
   595  
   596  var LogFilterLogger = &Logger{}
   597  var ConnLogger = &Logger{}
   598  var AccessLogger = &Logger{}
   599  
   600  func (logger Logger) IsDebugEnabled() bool {
   601  	return LogLevel >= LOG_DEBUG
   602  }
   603  func (logger Logger) IsErrorEnabled() bool {
   604  	return LogLevel >= LOG_ERROR
   605  }
   606  func (logger Logger) IsInfoEnabled() bool {
   607  	return LogLevel >= LOG_INFO
   608  }
   609  func (logger Logger) IsWarnEnabled() bool {
   610  	return LogLevel >= LOG_WARN
   611  }
   612  func (logger Logger) IsSqlEnabled() bool {
   613  	return LogLevel >= LOG_SQL
   614  }
   615  func (logger Logger) Debug(msg string) {
   616  	if logger.IsDebugEnabled() {
   617  		logger.println(logger.formatHead("DEBUG") + msg)
   618  	}
   619  }
   620  func (logger Logger) DebugWithErr(msg string, err error) {
   621  	if logger.IsDebugEnabled() {
   622  		if e, ok := err.(*DmError); ok {
   623  			logger.println(logger.formatHead("DEBUG") + msg + util.LINE_SEPARATOR + e.FormatStack())
   624  		} else {
   625  			logger.println(logger.formatHead("DEBUG") + msg + util.LINE_SEPARATOR + err.Error())
   626  		}
   627  	}
   628  }
   629  func (logger Logger) Info(msg string) {
   630  	if logger.IsInfoEnabled() {
   631  		logger.println(logger.formatHead("INFO ") + msg)
   632  	}
   633  }
   634  func (logger Logger) Sql(msg string) {
   635  	if logger.IsSqlEnabled() {
   636  		logger.println(logger.formatHead("SQL  ") + msg)
   637  	}
   638  }
   639  func (logger Logger) Warn(msg string) {
   640  	if logger.IsWarnEnabled() {
   641  		logger.println(logger.formatHead("WARN ") + msg)
   642  	}
   643  }
   644  func (logger Logger) ErrorWithErr(msg string, err error) {
   645  	if e, ok := err.(*DmError); ok {
   646  		logger.println(logger.formatHead("ERROR") + msg + util.LINE_SEPARATOR + e.FormatStack())
   647  	} else {
   648  		logger.println(logger.formatHead("ERROR") + msg + util.LINE_SEPARATOR + err.Error())
   649  	}
   650  }
   651  
   652  // TODO: 获取goroutine objId
   653  func (logger Logger) formatHead(head string) string {
   654  	// return "[" + head + " - " + StringUtil.formatTime() + "] tid:" + Thread.currentThread().getId();
   655  	return "[" + head + " - " + util.StringUtil.FormatTime() + "]"
   656  }
   657  func (logger Logger) println(msg string) {
   658  	goMap["log"].(*logWriter).WriteLine(msg)
   659  }
   660  
   661  /*************************************************************************************************/
   662  func formatSource(source interface{}) string {
   663  	if source == nil {
   664  		return ""
   665  	}
   666  	var str string
   667  	switch src := source.(type) {
   668  	case string:
   669  		str += src
   670  	case *DmDriver:
   671  		str += formatDriver(src)
   672  	case *DmConnector:
   673  		str += formatContor(src)
   674  	case *DmConnection:
   675  		str += formatConn(src)
   676  	case *DmStatement:
   677  		str += formatConn(src.dmConn) + ", "
   678  		str += formatStmt(src)
   679  	case *DmResult:
   680  		str += formatConn(src.dmStmt.dmConn) + ", "
   681  		str += formatStmt(src.dmStmt) + ", "
   682  		str += formatRs(src)
   683  	case *DmRows:
   684  		str += formatConn(src.CurrentRows.dmStmt.dmConn) + ", "
   685  		str += formatStmt(src.CurrentRows.dmStmt) + ", "
   686  		str += formatRows(src)
   687  	default:
   688  		str += reflect.TypeOf(src).String() + "@" + reflect.ValueOf(src).Addr().String()
   689  	}
   690  	return str
   691  }
   692  
   693  func formatDriver(driver *DmDriver) string {
   694  	if driver != nil && driver.logInfo != nil {
   695  		return "dmr-" + strconv.FormatInt(driver.getID(), 10)
   696  	}
   697  	return "dmr-nil"
   698  }
   699  
   700  func formatContor(contor *DmConnector) string {
   701  	if contor != nil && contor.logInfo != nil {
   702  		return "contor-" + strconv.FormatInt(contor.getID(), 10)
   703  	}
   704  	return "contor-nil"
   705  }
   706  
   707  func formatConn(conn *DmConnection) string {
   708  	if conn != nil && conn.logInfo != nil {
   709  		return "conn-" + strconv.FormatInt(conn.getID(), 10)
   710  	}
   711  	return "conn-nil"
   712  }
   713  
   714  func formatStmt(stmt *DmStatement) string {
   715  	if stmt != nil && stmt.logInfo != nil {
   716  		return "stmt-" + strconv.FormatInt(stmt.getID(), 10)
   717  	}
   718  	return "stmt-nil"
   719  }
   720  
   721  func formatRs(result *DmResult) string {
   722  	if result != nil && result.logInfo != nil {
   723  		return "rs-" + strconv.FormatInt(result.getID(), 10)
   724  	}
   725  	return "rs-nil"
   726  }
   727  
   728  func formatRows(rows *DmRows) string {
   729  	if rows != nil && rows.logInfo != nil {
   730  		return "rows-" + strconv.FormatInt(rows.getID(), 10)
   731  	}
   732  	return "rows-nil"
   733  }
   734  
   735  func formatTrace(source string, method string, returnValue interface{}, params ...interface{}) string {
   736  	var str string
   737  	if source != "" {
   738  		str += "{ " + source + " } "
   739  	}
   740  	str += method + "("
   741  	var paramStartIndex = 0
   742  	if params != nil && len(params) > paramStartIndex {
   743  		for i := paramStartIndex; i < len(params); i++ {
   744  			if i != paramStartIndex {
   745  				str += ", "
   746  			}
   747  			if params[i] != nil {
   748  				str += reflect.TypeOf(params[i]).String()
   749  			} else {
   750  				str += "nil"
   751  			}
   752  		}
   753  	}
   754  	str += ")"
   755  	if returnValue != nil {
   756  		str += ": " + formatReturn(returnValue)
   757  	}
   758  	str += ";  "
   759  	if params != nil && len(params) > paramStartIndex {
   760  		str += "[PARAMS]: "
   761  		for i := paramStartIndex; i < len(params); i++ {
   762  			if i != 0 {
   763  				str += ", "
   764  			}
   765  			if s, ok := params[i].(string); ok {
   766  				str += "\"" + s + "\""
   767  			} else {
   768  				str += reflect.ValueOf(params[i]).String()
   769  			}
   770  		}
   771  		str += "; "
   772  	}
   773  	return str
   774  }
   775  
   776  func formatReturn(returnObj interface{}) string {
   777  	var str string
   778  	switch o := returnObj.(type) {
   779  	case *DmConnection:
   780  		str = formatConn(o)
   781  		sessID := o.SessionID
   782  		if sessID != -1 {
   783  			str += ", sessionID-0x" + strconv.FormatInt(sessID, 16)
   784  		}
   785  	case *DmStatement:
   786  		str = formatStmt(o)
   787  		str += ", handle-" + strconv.Itoa(int(o.id))
   788  	case *DmResult:
   789  		str = formatRs(o)
   790  	case *DmRows:
   791  		str = formatRows(o)
   792  	case string:
   793  		str = `"` + o + `"`
   794  	case nullData:
   795  		str = "nil"
   796  	default:
   797  		str = "unknown"
   798  	}
   799  	return str
   800  }
   801  
   802  func formatUsedTime(duration time.Duration) string {
   803  	return "[USED TIME]: " + duration.String()
   804  }
   805  
   806  /************************************************************************************************************/
   807  
   808  type nullData struct{}
   809  
   810  var null = nullData{}
   811  
   812  type LogRecord struct {
   813  	source      string
   814  	method      string
   815  	params      []interface{}
   816  	returnValue interface{}
   817  	e           error
   818  	usedTime    time.Duration
   819  	sql         string
   820  }
   821  
   822  func (record *LogRecord) Set(source interface{}, method string, params ...interface{}) {
   823  	record.source = formatSource(source)
   824  	record.method = method
   825  	record.params = params
   826  }
   827  
   828  func (record *LogRecord) SetReturnValue(retValue interface{}) {
   829  	if retValue == nil {
   830  		record.returnValue = null
   831  	} else {
   832  		record.returnValue = retValue
   833  	}
   834  }
   835  
   836  func (record *LogRecord) GetReturnValue() interface{} {
   837  	return record.returnValue
   838  }
   839  
   840  func (record *LogRecord) SetSql(sql string) {
   841  	record.sql = sql
   842  }
   843  
   844  func (record *LogRecord) GetSql() string {
   845  	return record.sql
   846  }
   847  
   848  func (record *LogRecord) SetUsedTime(usedTime time.Duration) {
   849  	record.usedTime = usedTime
   850  }
   851  
   852  func (record *LogRecord) GetUsedTime() time.Duration {
   853  	return record.usedTime
   854  }
   855  
   856  func (record *LogRecord) SetError(err error) {
   857  	record.e = err
   858  }
   859  
   860  func (record *LogRecord) GetError() error {
   861  	return record.e
   862  }
   863  
   864  func (record *LogRecord) ToString() string {
   865  	var str string
   866  	str += formatTrace(record.source, record.method, record.returnValue, record.params...)
   867  	if record.usedTime > 0 {
   868  		str += formatUsedTime(record.usedTime)
   869  	}
   870  	return str
   871  }