mirror of
https://github.com/yunionio/cloudpods.git
synced 2026-05-06 21:52:54 +08:00
608 lines
18 KiB
Go
608 lines
18 KiB
Go
/*
|
|
* Copyright (c) 2000-2018, 达梦数据库有限公司.
|
|
* All rights reserved.
|
|
*/
|
|
|
|
package dm
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"database/sql/driver"
|
|
"fmt"
|
|
"reflect"
|
|
"time"
|
|
)
|
|
|
|
type statFilter struct {
|
|
}
|
|
|
|
//DmDriver
|
|
func (sf *statFilter) DmDriverOpen(filterChain *filterChain, d *DmDriver, dsn string) (*DmConnection, error) {
|
|
conn, err := filterChain.DmDriverOpen(d, dsn)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
conn.statInfo.init(conn)
|
|
conn.statInfo.setConstructNano()
|
|
conn.statInfo.getConnStat().incrementConn()
|
|
return conn, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmDriverOpenConnector(filterChain *filterChain, d *DmDriver, dsn string) (*DmConnector, error) {
|
|
return filterChain.DmDriverOpenConnector(d, dsn)
|
|
}
|
|
|
|
//DmConnector
|
|
func (sf *statFilter) DmConnectorConnect(filterChain *filterChain, c *DmConnector, ctx context.Context) (*DmConnection, error) {
|
|
conn, err := filterChain.DmConnectorConnect(c, ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
conn.statInfo.init(conn)
|
|
conn.statInfo.setConstructNano()
|
|
conn.statInfo.getConnStat().incrementConn()
|
|
return conn, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectorDriver(filterChain *filterChain, c *DmConnector) *DmDriver {
|
|
return filterChain.DmConnectorDriver(c)
|
|
}
|
|
|
|
//DmConnection
|
|
func (sf *statFilter) DmConnectionBegin(filterChain *filterChain, c *DmConnection) (*DmConnection, error) {
|
|
return filterChain.DmConnectionBegin(c)
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionBeginTx(filterChain *filterChain, c *DmConnection, ctx context.Context, opts driver.TxOptions) (*DmConnection, error) {
|
|
return filterChain.DmConnectionBeginTx(c, ctx, opts)
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionCommit(filterChain *filterChain, c *DmConnection) error {
|
|
err := filterChain.DmConnectionCommit(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.statInfo.getConnStat().incrementCommitCount()
|
|
return nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionRollback(filterChain *filterChain, c *DmConnection) error {
|
|
err := filterChain.DmConnectionRollback(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.statInfo.getConnStat().incrementRollbackCount()
|
|
return nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionClose(filterChain *filterChain, c *DmConnection) error {
|
|
if !c.closed.IsSet() {
|
|
c.statInfo.getConnStat().decrementStmtByActiveStmtCount(int64(getActiveStmtCount(c)))
|
|
c.statInfo.getConnStat().decrementConn()
|
|
}
|
|
|
|
return filterChain.DmConnectionClose(c)
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionPing(filterChain *filterChain, c *DmConnection, ctx context.Context) error {
|
|
return c.ping(ctx)
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionExec(filterChain *filterChain, c *DmConnection, query string, args []driver.Value) (*DmResult, error) {
|
|
connExecBefore(c, query)
|
|
dr, err := filterChain.DmConnectionExec(c, query, args)
|
|
if err != nil {
|
|
connExecuteErrorAfter(c, args, err)
|
|
return nil, err
|
|
}
|
|
connExecAfter(c, query, args, int(dr.affectedRows))
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionExecContext(filterChain *filterChain, c *DmConnection, ctx context.Context, query string, args []driver.NamedValue) (*DmResult, error) {
|
|
connExecBefore(c, query)
|
|
dr, err := filterChain.DmConnectionExecContext(c, ctx, query, args)
|
|
if err != nil {
|
|
connExecuteErrorAfter(c, args, err)
|
|
return nil, err
|
|
}
|
|
connExecAfter(c, query, args, int(dr.affectedRows))
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionQuery(filterChain *filterChain, c *DmConnection, query string, args []driver.Value) (*DmRows, error) {
|
|
connQueryBefore(c, query)
|
|
dr, err := filterChain.DmConnectionQuery(c, query, args)
|
|
if err != nil {
|
|
connExecuteErrorAfter(c, args, err)
|
|
return nil, err
|
|
}
|
|
connQueryAfter(c, query, args, dr)
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionQueryContext(filterChain *filterChain, c *DmConnection, ctx context.Context, query string, args []driver.NamedValue) (*DmRows, error) {
|
|
connQueryBefore(c, query)
|
|
dr, err := filterChain.DmConnectionQueryContext(c, ctx, query, args)
|
|
if err != nil {
|
|
connExecuteErrorAfter(c, args, err)
|
|
return nil, err
|
|
}
|
|
connQueryAfter(c, query, args, dr)
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionPrepare(filterChain *filterChain, c *DmConnection, query string) (*DmStatement, error) {
|
|
stmt, err := filterChain.DmConnectionPrepare(c, query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
statementCreateAfter(c, stmt)
|
|
return stmt, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionPrepareContext(filterChain *filterChain, c *DmConnection, ctx context.Context, query string) (*DmStatement, error) {
|
|
stmt, err := filterChain.DmConnectionPrepareContext(c, ctx, query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
statementCreateAfter(c, stmt)
|
|
return stmt, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionResetSession(filterChain *filterChain, c *DmConnection, ctx context.Context) error {
|
|
return filterChain.DmConnectionResetSession(c, ctx)
|
|
}
|
|
|
|
func (sf *statFilter) DmConnectionCheckNamedValue(filterChain *filterChain, c *DmConnection, nv *driver.NamedValue) error {
|
|
return filterChain.DmConnectionCheckNamedValue(c, nv)
|
|
}
|
|
|
|
//DmStatement
|
|
func (sf *statFilter) DmStatementClose(filterChain *filterChain, s *DmStatement) error {
|
|
if !s.closed {
|
|
statementCloseBefore(s)
|
|
}
|
|
return filterChain.DmStatementClose(s)
|
|
}
|
|
|
|
func (sf *statFilter) DmStatementNumInput(filterChain *filterChain, s *DmStatement) int {
|
|
return filterChain.DmStatementNumInput(s)
|
|
}
|
|
|
|
func (sf *statFilter) DmStatementExec(filterChain *filterChain, s *DmStatement, args []driver.Value) (*DmResult, error) {
|
|
stmtExecBefore(s)
|
|
dr, err := filterChain.DmStatementExec(s, args)
|
|
if err != nil {
|
|
statementExecuteErrorAfter(s, args, err)
|
|
return nil, err
|
|
}
|
|
stmtExecAfter(s, args, int(dr.affectedRows))
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmStatementExecContext(filterChain *filterChain, s *DmStatement, ctx context.Context, args []driver.NamedValue) (*DmResult, error) {
|
|
stmtExecBefore(s)
|
|
dr, err := filterChain.DmStatementExecContext(s, ctx, args)
|
|
if err != nil {
|
|
statementExecuteErrorAfter(s, args, err)
|
|
return nil, err
|
|
}
|
|
stmtExecAfter(s, args, int(dr.affectedRows))
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmStatementQuery(filterChain *filterChain, s *DmStatement, args []driver.Value) (*DmRows, error) {
|
|
stmtQueryBefore(s)
|
|
dr, err := filterChain.DmStatementQuery(s, args)
|
|
if err != nil {
|
|
statementExecuteErrorAfter(s, args, err)
|
|
return nil, err
|
|
}
|
|
stmtQueryAfter(s, args, dr)
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmStatementQueryContext(filterChain *filterChain, s *DmStatement, ctx context.Context, args []driver.NamedValue) (*DmRows, error) {
|
|
stmtQueryBefore(s)
|
|
dr, err := filterChain.DmStatementQueryContext(s, ctx, args)
|
|
if err != nil {
|
|
statementExecuteErrorAfter(s, args, err)
|
|
return nil, err
|
|
}
|
|
stmtQueryAfter(s, args, dr)
|
|
return dr, nil
|
|
}
|
|
|
|
func (sf *statFilter) DmStatementCheckNamedValue(filterChain *filterChain, s *DmStatement, nv *driver.NamedValue) error {
|
|
return filterChain.DmStatementCheckNamedValue(s, nv)
|
|
}
|
|
|
|
//DmResult
|
|
func (sf *statFilter) DmResultLastInsertId(filterChain *filterChain, r *DmResult) (int64, error) {
|
|
return filterChain.DmResultLastInsertId(r)
|
|
}
|
|
|
|
func (sf *statFilter) DmResultRowsAffected(filterChain *filterChain, r *DmResult) (int64, error) {
|
|
return filterChain.DmResultRowsAffected(r)
|
|
}
|
|
|
|
//DmRows
|
|
func (sf *statFilter) DmRowsColumns(filterChain *filterChain, r *DmRows) []string {
|
|
return filterChain.DmRowsColumns(r)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsClose(filterChain *filterChain, r *DmRows) error {
|
|
if !r.CurrentRows.closed {
|
|
resultSetCloseBefore(r)
|
|
}
|
|
return filterChain.DmRowsClose(r)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsNext(filterChain *filterChain, r *DmRows, dest []driver.Value) error {
|
|
return filterChain.DmRowsNext(r, dest)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsHasNextResultSet(filterChain *filterChain, r *DmRows) bool {
|
|
return filterChain.DmRowsHasNextResultSet(r)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsNextResultSet(filterChain *filterChain, r *DmRows) error {
|
|
return filterChain.DmRowsNextResultSet(r)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsColumnTypeScanType(filterChain *filterChain, r *DmRows, index int) reflect.Type {
|
|
return filterChain.DmRowsColumnTypeScanType(r, index)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsColumnTypeDatabaseTypeName(filterChain *filterChain, r *DmRows, index int) string {
|
|
return filterChain.DmRowsColumnTypeDatabaseTypeName(r, index)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsColumnTypeLength(filterChain *filterChain, r *DmRows, index int) (length int64, ok bool) {
|
|
return filterChain.DmRowsColumnTypeLength(r, index)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsColumnTypeNullable(filterChain *filterChain, r *DmRows, index int) (nullable, ok bool) {
|
|
return filterChain.DmRowsColumnTypeNullable(r, index)
|
|
}
|
|
|
|
func (sf *statFilter) DmRowsColumnTypePrecisionScale(filterChain *filterChain, r *DmRows, index int) (precision, scale int64, ok bool) {
|
|
return filterChain.DmRowsColumnTypePrecisionScale(r, index)
|
|
}
|
|
|
|
func getActiveStmtCount(conn *DmConnection) int {
|
|
if conn.stmtMap == nil {
|
|
return 0
|
|
} else {
|
|
return len(conn.stmtMap)
|
|
}
|
|
}
|
|
|
|
func statementCreateAfter(conn *DmConnection, stmt *DmStatement) {
|
|
stmt.statInfo.setConstructNano()
|
|
conn.statInfo.getConnStat().incrementStmt()
|
|
}
|
|
|
|
func connExecBefore(conn *DmConnection, sql string) {
|
|
conn.statInfo.setLastExecuteSql(sql)
|
|
conn.statInfo.setFirstResultSet(false)
|
|
conn.statInfo.setLastExecuteType(ExecuteUpdate)
|
|
internalBeforeConnExecute(conn, sql)
|
|
}
|
|
|
|
func connExecAfter(conn *DmConnection, sql string, args interface{}, updateCount int) {
|
|
internalAfterConnExecute(conn, args, updateCount)
|
|
}
|
|
|
|
func connQueryBefore(conn *DmConnection, sql string) {
|
|
conn.statInfo.setLastExecuteSql(sql)
|
|
conn.statInfo.setFirstResultSet(true)
|
|
conn.statInfo.setLastExecuteType(ExecuteQuery)
|
|
internalBeforeConnExecute(conn, sql)
|
|
}
|
|
|
|
func connQueryAfter(conn *DmConnection, sql string, args interface{}, resultSet *DmRows) {
|
|
if resultSet != nil {
|
|
connResultSetCreateAfter(resultSet, conn)
|
|
}
|
|
internalAfterConnExecute(conn, args, 0)
|
|
}
|
|
|
|
func stmtExecBefore(stmt *DmStatement) {
|
|
stmt.statInfo.setLastExecuteSql(stmt.nativeSql)
|
|
stmt.statInfo.setFirstResultSet(false)
|
|
stmt.statInfo.setLastExecuteType(ExecuteUpdate)
|
|
internalBeforeStatementExecute(stmt, stmt.nativeSql)
|
|
}
|
|
|
|
func stmtExecAfter(stmt *DmStatement, args interface{}, updateCount int) {
|
|
internalAfterStatementExecute(stmt, args, updateCount)
|
|
}
|
|
|
|
func stmtQueryBefore(stmt *DmStatement) {
|
|
stmt.statInfo.setLastExecuteSql(stmt.nativeSql)
|
|
stmt.statInfo.setFirstResultSet(true)
|
|
stmt.statInfo.setLastExecuteType(ExecuteQuery)
|
|
internalBeforeStatementExecute(stmt, stmt.nativeSql)
|
|
}
|
|
|
|
func stmtQueryAfter(stmt *DmStatement, args interface{}, resultSet *DmRows) {
|
|
if resultSet != nil {
|
|
stmtResultSetCreateAfter(resultSet, stmt)
|
|
}
|
|
internalAfterStatementExecute(stmt, args, 0)
|
|
}
|
|
|
|
func internalBeforeConnExecute(conn *DmConnection, sql string) {
|
|
connStat := conn.statInfo.getConnStat()
|
|
connStat.incrementExecuteCount()
|
|
conn.statInfo.beforeExecute()
|
|
|
|
sqlStat := conn.statInfo.getSqlStat()
|
|
if sqlStat == nil || sqlStat.Removed == 1 || !(sqlStat.Sql == sql) {
|
|
sqlStat = connStat.createSqlStat(sql)
|
|
conn.statInfo.setSqlStat(sqlStat)
|
|
}
|
|
|
|
inTransaction := false
|
|
inTransaction = !conn.autoCommit
|
|
|
|
if sqlStat != nil {
|
|
sqlStat.ExecuteLastStartTime = time.Now().UnixNano()
|
|
sqlStat.incrementRunningCount()
|
|
|
|
if inTransaction {
|
|
sqlStat.incrementInTransactionCount()
|
|
}
|
|
}
|
|
}
|
|
|
|
func internalAfterConnExecute(conn *DmConnection, args interface{}, updateCount int) {
|
|
nowNano := time.Now().UnixNano()
|
|
nanos := nowNano - conn.statInfo.getLastExecuteStartNano()
|
|
|
|
conn.statInfo.afterExecute(nanos)
|
|
|
|
sqlStat := conn.statInfo.getSqlStat()
|
|
|
|
if sqlStat != nil {
|
|
sqlStat.incrementExecuteSuccessCount()
|
|
|
|
sqlStat.decrementRunningCount()
|
|
|
|
parameters := buildSlowParameters(args)
|
|
|
|
sqlStat.addExecuteTimeAndResultHoldTimeHistogramRecord(conn.statInfo.getLastExecuteType(), conn.statInfo.isFirstResultSet(),
|
|
nanos, parameters)
|
|
|
|
if !conn.statInfo.isFirstResultSet() &&
|
|
conn.statInfo.getLastExecuteType() == ExecuteUpdate {
|
|
if updateCount < 0 {
|
|
updateCount = 0
|
|
}
|
|
sqlStat.addUpdateCount(int64(updateCount))
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func internalBeforeStatementExecute(stmt *DmStatement, sql string) {
|
|
connStat := stmt.dmConn.statInfo.getConnStat()
|
|
connStat.incrementExecuteCount()
|
|
stmt.statInfo.beforeExecute()
|
|
|
|
sqlStat := stmt.statInfo.getSqlStat()
|
|
if sqlStat == nil || sqlStat.Removed == 1 || !(sqlStat.Sql == sql) {
|
|
sqlStat = connStat.createSqlStat(sql)
|
|
stmt.statInfo.setSqlStat(sqlStat)
|
|
}
|
|
|
|
inTransaction := false
|
|
inTransaction = !stmt.dmConn.autoCommit
|
|
|
|
if sqlStat != nil {
|
|
sqlStat.ExecuteLastStartTime = time.Now().UnixNano()
|
|
sqlStat.incrementRunningCount()
|
|
|
|
if inTransaction {
|
|
sqlStat.incrementInTransactionCount()
|
|
}
|
|
}
|
|
}
|
|
|
|
func internalAfterStatementExecute(stmt *DmStatement, args interface{}, updateCount int) {
|
|
nowNano := time.Now().UnixNano()
|
|
nanos := nowNano - stmt.statInfo.getLastExecuteStartNano()
|
|
|
|
stmt.statInfo.afterExecute(nanos)
|
|
|
|
sqlStat := stmt.statInfo.getSqlStat()
|
|
|
|
if sqlStat != nil {
|
|
sqlStat.incrementExecuteSuccessCount()
|
|
|
|
sqlStat.decrementRunningCount()
|
|
|
|
parameters := ""
|
|
if stmt.paramCount > 0 {
|
|
parameters = buildStmtSlowParameters(stmt, args)
|
|
}
|
|
sqlStat.addExecuteTimeAndResultHoldTimeHistogramRecord(stmt.statInfo.getLastExecuteType(), stmt.statInfo.isFirstResultSet(),
|
|
nanos, parameters)
|
|
|
|
if (!stmt.statInfo.isFirstResultSet()) &&
|
|
stmt.statInfo.getLastExecuteType() == ExecuteUpdate {
|
|
updateCount := stmt.execInfo.updateCount
|
|
if updateCount < 0 {
|
|
updateCount = 0
|
|
}
|
|
sqlStat.addUpdateCount(updateCount)
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func buildSlowParameters(args interface{}) string {
|
|
switch v := args.(type) {
|
|
case []driver.Value:
|
|
sb := bytes.NewBufferString("")
|
|
for i := 0; i < len(v); i++ {
|
|
if i != 0 {
|
|
sb.WriteString(",")
|
|
} else {
|
|
sb.WriteString("[")
|
|
}
|
|
|
|
sb.WriteString(fmt.Sprint(v[i]))
|
|
}
|
|
|
|
if len(v) > 0 {
|
|
sb.WriteString("]")
|
|
}
|
|
return sb.String()
|
|
case []driver.NamedValue:
|
|
sb := bytes.NewBufferString("")
|
|
for i := 0; i < len(v); i++ {
|
|
if i != 0 {
|
|
sb.WriteString(",")
|
|
} else {
|
|
sb.WriteString("[")
|
|
}
|
|
|
|
sb.WriteString(fmt.Sprint(v[i]))
|
|
}
|
|
if len(v) > 0 {
|
|
sb.WriteString("]")
|
|
}
|
|
return sb.String()
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func buildStmtSlowParameters(stmt *DmStatement, args interface{}) string {
|
|
switch v := args.(type) {
|
|
case []driver.Value:
|
|
sb := bytes.NewBufferString("")
|
|
for i := 0; i < int(stmt.paramCount); i++ {
|
|
if i != 0 {
|
|
sb.WriteString(",")
|
|
} else {
|
|
sb.WriteString("[")
|
|
}
|
|
|
|
sb.WriteString(fmt.Sprint(v[i]))
|
|
}
|
|
if len(v) > 0 {
|
|
sb.WriteString("]")
|
|
}
|
|
return sb.String()
|
|
case []driver.NamedValue:
|
|
sb := bytes.NewBufferString("")
|
|
for i := 0; i < int(stmt.paramCount); i++ {
|
|
if i != 0 {
|
|
sb.WriteString(",")
|
|
} else {
|
|
sb.WriteString("[")
|
|
}
|
|
|
|
sb.WriteString(fmt.Sprint(v[i]))
|
|
}
|
|
if len(v) > 0 {
|
|
sb.WriteString("]")
|
|
}
|
|
return sb.String()
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func connExecuteErrorAfter(conn *DmConnection, args interface{}, err error) {
|
|
nanos := time.Now().UnixNano() - conn.statInfo.getLastExecuteStartNano()
|
|
conn.statInfo.getConnStat().incrementErrorCount()
|
|
conn.statInfo.afterExecute(nanos)
|
|
|
|
// SQL
|
|
sqlStat := conn.statInfo.getSqlStat()
|
|
if sqlStat != nil {
|
|
sqlStat.decrementRunningCount()
|
|
sqlStat.error(err)
|
|
parameters := buildSlowParameters(args)
|
|
sqlStat.addExecuteTimeAndResultHoldTimeHistogramRecord(conn.statInfo.getLastExecuteType(), conn.statInfo.isFirstResultSet(),
|
|
nanos, parameters)
|
|
}
|
|
|
|
}
|
|
|
|
func statementExecuteErrorAfter(stmt *DmStatement, args interface{}, err error) {
|
|
nanos := time.Now().UnixNano() - stmt.statInfo.getLastExecuteStartNano()
|
|
stmt.dmConn.statInfo.getConnStat().incrementErrorCount()
|
|
stmt.statInfo.afterExecute(nanos)
|
|
|
|
// SQL
|
|
sqlStat := stmt.statInfo.getSqlStat()
|
|
if sqlStat != nil {
|
|
sqlStat.decrementRunningCount()
|
|
sqlStat.error(err)
|
|
parameters := ""
|
|
if stmt.paramCount > 0 {
|
|
parameters = buildStmtSlowParameters(stmt, args)
|
|
}
|
|
sqlStat.addExecuteTimeAndResultHoldTimeHistogramRecord(stmt.statInfo.getLastExecuteType(), stmt.statInfo.isFirstResultSet(),
|
|
nanos, parameters)
|
|
}
|
|
|
|
}
|
|
|
|
func statementCloseBefore(stmt *DmStatement) {
|
|
stmt.dmConn.statInfo.getConnStat().decrementStmt()
|
|
}
|
|
|
|
func connResultSetCreateAfter(dmdbResultSet *DmRows, conn *DmConnection) {
|
|
dmdbResultSet.statInfo.setSql(conn.statInfo.getLastExecuteSql())
|
|
dmdbResultSet.statInfo.setSqlStat(conn.statInfo.getSqlStat())
|
|
dmdbResultSet.statInfo.setConstructNano()
|
|
}
|
|
|
|
func stmtResultSetCreateAfter(dmdbResultSet *DmRows, stmt *DmStatement) {
|
|
dmdbResultSet.statInfo.setSql(stmt.statInfo.getLastExecuteSql())
|
|
dmdbResultSet.statInfo.setSqlStat(stmt.statInfo.getSqlStat())
|
|
dmdbResultSet.statInfo.setConstructNano()
|
|
}
|
|
|
|
func resultSetCloseBefore(resultSet *DmRows) {
|
|
nanos := time.Now().UnixNano() - resultSet.statInfo.getConstructNano()
|
|
fetchRowCount := getFetchedRows(resultSet)
|
|
sqlStat := resultSet.statInfo.getSqlStat()
|
|
if sqlStat != nil && resultSet.statInfo.getCloseCount() == 0 {
|
|
sqlStat.addFetchRowCount(fetchRowCount)
|
|
stmtExecuteNano := resultSet.statInfo.getLastExecuteTimeNano()
|
|
sqlStat.addResultSetHoldTimeNano2(stmtExecuteNano, nanos)
|
|
if resultSet.statInfo.getReadStringLength() > 0 {
|
|
sqlStat.addStringReadLength(resultSet.statInfo.getReadStringLength())
|
|
}
|
|
if resultSet.statInfo.getReadBytesLength() > 0 {
|
|
sqlStat.addReadBytesLength(resultSet.statInfo.getReadBytesLength())
|
|
}
|
|
if resultSet.statInfo.getOpenInputStreamCount() > 0 {
|
|
sqlStat.addInputStreamOpenCount(int64(resultSet.statInfo.getOpenInputStreamCount()))
|
|
}
|
|
if resultSet.statInfo.getOpenReaderCount() > 0 {
|
|
sqlStat.addReaderOpenCount(int64(resultSet.statInfo.getOpenReaderCount()))
|
|
}
|
|
}
|
|
|
|
resultSet.statInfo.incrementCloseCount()
|
|
}
|
|
|
|
func getFetchedRows(rs *DmRows) int64 {
|
|
if rs.CurrentRows.currentPos >= rs.CurrentRows.totalRowCount {
|
|
return rs.CurrentRows.totalRowCount
|
|
} else {
|
|
return rs.CurrentRows.currentPos + 1
|
|
}
|
|
}
|