v0.0.518 Improve sq db-listener interface (breaking)

sq/database.go

@@ -7,6 +7,7 @@ import (
 	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"sync"
+	"time"
 )
 
 type DB interface {
@@ -57,86 +58,118 @@ func (db *database) AddListener(listener Listener) {
 
 func (db *database) Exec(ctx context.Context, sqlstr string, prep PP) (sql.Result, error) {
 	origsql := sqlstr
+
+	t0 := time.Now()
+
+	preMeta := PreExecMeta{}
 	for _, v := range db.lstr {
-		err := v.PreExec(ctx, nil, &sqlstr, &prep)
+		err := v.PreExec(ctx, nil, &sqlstr, &prep, preMeta)
 		if err != nil {
 			return nil, exerr.Wrap(err, "failed to call SQL pre-exec listener").Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 		}
 	}
 
+	t1 := time.Now()
+
 	res, err := db.db.NamedExecContext(ctx, sqlstr, prep)
 
+	postMeta := PostExecMeta{Init: t0, Start: t1, End: time.Now()}
 	for _, v := range db.lstr {
-		v.PostExec(nil, origsql, sqlstr, prep)
+		v.PostExec(nil, origsql, sqlstr, prep, postMeta)
 	}
 
 	if err != nil {
 		return nil, exerr.Wrap(err, "Failed to [exec] sql statement").Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 	}
+
 	return res, nil
 }
 
 func (db *database) Query(ctx context.Context, sqlstr string, prep PP) (*sqlx.Rows, error) {
 	origsql := sqlstr
+
+	t0 := time.Now()
+
+	preMeta := PreQueryMeta{}
 	for _, v := range db.lstr {
-		err := v.PreQuery(ctx, nil, &sqlstr, &prep)
+		err := v.PreQuery(ctx, nil, &sqlstr, &prep, preMeta)
 		if err != nil {
 			return nil, exerr.Wrap(err, "failed to call SQL pre-query listener").Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 		}
 	}
 
+	t1 := time.Now()
+
 	rows, err := sqlx.NamedQueryContext(ctx, db.db, sqlstr, prep)
 
+	postMeta := PostQueryMeta{Init: t0, Start: t1, End: time.Now()}
 	for _, v := range db.lstr {
-		v.PostQuery(nil, origsql, sqlstr, prep)
+		v.PostQuery(nil, origsql, sqlstr, prep, postMeta)
 	}
 
 	if err != nil {
 		return nil, exerr.Wrap(err, "Failed to [query] sql statement").Str("original_sql", origsql).Str("sql", sqlstr).Any("sql_params", prep).Build()
 	}
+
 	return rows, nil
 }
 
 func (db *database) Ping(ctx context.Context) error {
+
+	t0 := time.Now()
+
+	preMeta := PrePingMeta{}
 	for _, v := range db.lstr {
-		err := v.PrePing(ctx)
+		err := v.PrePing(ctx, preMeta)
 		if err != nil {
 			return err
 		}
 	}
 
+	t1 := time.Now()
+
 	err := db.db.PingContext(ctx)
 
+	postMeta := PostPingMeta{Init: t0, Start: t1, End: time.Now()}
 	for _, v := range db.lstr {
-		v.PostPing(err)
+		v.PostPing(err, postMeta)
 	}
 
 	if err != nil {
 		return exerr.Wrap(err, "Failed to [ping] sql database").Build()
 	}
+
 	return nil
 }
 
 func (db *database) BeginTransaction(ctx context.Context, iso sql.IsolationLevel) (Tx, error) {
+
+	t0 := time.Now()
+
 	db.lock.Lock()
 	txid := db.txctr
 	db.txctr += 1 // with overflow !
 	db.lock.Unlock()
 
+	preMeta := PreTxBeginMeta{}
 	for _, v := range db.lstr {
-		err := v.PreTxBegin(ctx, txid)
+		err := v.PreTxBegin(ctx, txid, preMeta)
 		if err != nil {
 			return nil, err
 		}
 	}
 
+	t1 := time.Now()
+
 	xtx, err := db.db.BeginTxx(ctx, &sql.TxOptions{Isolation: iso})
-	if err != nil {
-		return nil, exerr.Wrap(err, "Failed to start sql transaction").Build()
+
+	postMeta := PostTxBeginMeta{Init: t0, Start: t1, End: time.Now()}
+	for _, v := range db.lstr {
+		v.PostTxBegin(txid, err, postMeta)
 	}
 
-	for _, v := range db.lstr {
-		v.PostTxBegin(txid, err)
+	if err != nil {
+		return nil, exerr.Wrap(err, "Failed to start sql transaction").Build()
 	}
 
 	return NewTransaction(xtx, txid, db), nil