Set Event.Result for queries built by Bun

db.go

@@ -3,7 +3,6 @@ package bun
 import (
 	"context"
 	"database/sql"
-	"errors"
 	"fmt"
 	"reflect"
 	"strings"
@@ -473,30 +472,9 @@ func (tx Tx) NewDropColumn() *DropColumnQuery {
 	return NewDropColumnQuery(tx.db).Conn(tx)
 }
 
-//------------------------------------------------------------------------------0
+//------------------------------------------------------------------------------
 
 func (db *DB) makeQueryBytes() []byte {
 	// TODO: make this configurable?
 	return make([]byte, 0, 4096)
 }
-
-//------------------------------------------------------------------------------
-
-type result struct {
-	r sql.Result
-	n int
-}
-
-func (r result) RowsAffected() (int64, error) {
-	if r.r != nil {
-		return r.r.RowsAffected()
-	}
-	return int64(r.n), nil
-}
-
-func (r result) LastInsertId() (int64, error) {
-	if r.r != nil {
-		return r.r.LastInsertId()
-	}
-	return 0, errors.New("LastInsertId is not available")
-}

extra/bunotel/otel.go

@@ -54,14 +54,21 @@ func (h *QueryHook) AfterQuery(ctx context.Context, event *bun.QueryEvent) {
 
 	attrs := make([]attribute.KeyValue, 0, 10)
 	attrs = append(attrs,
-		attribute.String("db.system", dbSystem(event.DB)),
 		attribute.String("db.statement", query),
-
 		attribute.String("code.function", fn),
 		attribute.String("code.filepath", file),
 		attribute.Int("code.lineno", line),
 	)
 
+	if s := dbSystem(event.DB); s != "" {
+		attrs = append(attrs, attribute.String("db.system", s))
+	}
+	if event.Result != nil {
+		if n, _ := event.Result.RowsAffected(); n > 0 {
+			attrs = append(attrs, attribute.Int64("db.rows_affected", n))
+		}
+	}
+
 	if event.Err != nil {
 		switch event.Err {
 		case sql.ErrNoRows:
@@ -163,6 +170,6 @@ func dbSystem(db *bun.DB) string {
 	case dialect.SQLite:
 		return "sqlite"
 	default:
-		return "unknown"
+		return ""
 	}
 }

query_base.go

@@ -3,6 +3,7 @@ package bun
 import (
 	"context"
 	"database/sql"
+	"database/sql/driver"
 	"errors"
 	"fmt"
 
@@ -430,28 +431,28 @@ func (q *baseQuery) scan(
 	query string,
 	model model,
 	hasDest bool,
-) (res result, _ error) {
+) (sql.Result, error) {
 	ctx, event := q.db.beforeQuery(ctx, queryApp, query, nil)
 
 	rows, err := q.conn.QueryContext(ctx, query)
 	if err != nil {
 		q.db.afterQuery(ctx, event, nil, err)
-		return res, err
+		return nil, err
 	}
 	defer rows.Close()
 
-	n, err := model.ScanRows(ctx, rows)
+	numRow, err := model.ScanRows(ctx, rows)
 	if err != nil {
 		q.db.afterQuery(ctx, event, nil, err)
-		return res, err
+		return nil, err
 	}
 
-	res.n = n
-	if n == 0 && hasDest && isSingleRowModel(model) {
+	if numRow == 0 && hasDest && isSingleRowModel(model) {
 		err = sql.ErrNoRows
 	}
 
-	q.db.afterQuery(ctx, event, nil, err)
+	res := driver.RowsAffected(numRow)
+	q.db.afterQuery(ctx, event, res, err)
 
 	return res, err
 }
@@ -460,18 +461,16 @@ func (q *baseQuery) exec(
 	ctx context.Context,
 	queryApp schema.QueryAppender,
 	query string,
-) (res result, _ error) {
+) (sql.Result, error) {
 	ctx, event := q.db.beforeQuery(ctx, queryApp, query, nil)
 
-	r, err := q.conn.ExecContext(ctx, query)
+	res, err := q.conn.ExecContext(ctx, query)
 	if err != nil {
 		q.db.afterQuery(ctx, event, nil, err)
 		return res, err
 	}
 
-	res.r = r
-
-	q.db.afterQuery(ctx, event, nil, err)
+	q.db.afterQuery(ctx, event, res, err)
 	return res, nil
 }
 

query_select.go

@@ -695,7 +695,7 @@ func (q *SelectQuery) Scan(ctx context.Context, dest ...interface{}) error {
 		return err
 	}
 
-	if res.n > 0 {
+	if n, _ := res.RowsAffected(); n > 0 {
 		if tableModel, ok := model.(tableModel); ok {
 			if err := q.selectJoins(ctx, tableModel.GetJoins()); err != nil {
 				return err