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 }