Merge pull request #4 from randlabs/bug_fixes

Bug fixes

Author: mxmauro

copycallback.go

@@ -17,7 +17,7 @@ type copyWithCallback struct {
 
 // -----------------------------------------------------------------------------
 
-func (c copyWithCallback) Next() bool {
+func (c *copyWithCallback) Next() bool {
 	if c.err != nil || c.counter < 0 {
 		return false
 	}
@@ -37,7 +37,7 @@ func (c copyWithCallback) Next() bool {
 	return true
 }
 
-func (c copyWithCallback) Values() ([]interface{}, error) {
+func (c *copyWithCallback) Values() ([]interface{}, error) {
 	if c.err != nil {
 		return nil, c.err
 	}
@@ -49,6 +49,6 @@ func (c copyWithCallback) Values() ([]interface{}, error) {
 	return data, nil
 }
 
-func (c copyWithCallback) Err() error {
+func (c *copyWithCallback) Err() error {
 	return c.err
 }

errors.go

@@ -11,6 +11,25 @@ import (
 type Error struct {
 	message string
 	err     error // Err is the underlying error that occurred during the operation.
+	Details *ErrorDetails
+}
+
+type ErrorDetails struct {
+	Severity       string
+	Code           string
+	Message        string
+	Detail         string
+	Hint           string
+	Position       int32
+	Where          string
+	SchemaName     string
+	TableName      string
+	ColumnName     string
+	DataTypeName   string
+	ConstraintName string
+	File           string
+	Line           int32
+	Routine        string
 }
 
 // NoRowsError is the error we return if the query does not return any row.

helpers.go

@@ -1,16 +1,47 @@
 package postgres
 
 import (
+	"errors"
 	"strings"
+
+	"github.com/jackc/pgx/v5/pgconn"
 )
 
 // -----------------------------------------------------------------------------
 
 func newError(wrappedErr error, text string) *Error {
-	e := &Error{
+	var e *Error
+	var pgErr *pgconn.PgError
+
+	if errors.As(wrappedErr, &e) {
+		return e
+	}
+	e = &Error{
 		message: text,
 		err:     wrappedErr,
 	}
+
+	if errors.As(wrappedErr, &pgErr) {
+		e.Details = &ErrorDetails{
+			Severity:       pgErr.Severity,
+			Code:           pgErr.Code,
+			Message:        pgErr.Message,
+			Detail:         pgErr.Detail,
+			Hint:           pgErr.Hint,
+			Position:       pgErr.Position,
+			Where:          pgErr.Where,
+			SchemaName:     pgErr.SchemaName,
+			TableName:      pgErr.TableName,
+			ColumnName:     pgErr.ColumnName,
+			DataTypeName:   pgErr.DataTypeName,
+			ConstraintName: pgErr.ConstraintName,
+			File:           pgErr.File,
+			Line:           pgErr.Line,
+			Routine:        pgErr.Routine,
+		}
+	}
+
+	// Done
 	return e
 }
 

internal.go

@@ -21,7 +21,7 @@ func (db *Database) getTx(ctx context.Context) (pgx.Tx, error) {
 		DeferrableMode: pgx.NotDeferrable,
 	})
 	if err != nil {
-		return nil, newError(err, "unable to start db transaction")
+		return nil, newError(err, "unable to start transaction")
 	}
 
 	//Done

postgres.go

@@ -130,6 +130,9 @@ func (db *Database) SetEventHandler(handler ErrorHandler) {
 // Exec executes an SQL statement on a new connection
 func (db *Database) Exec(ctx context.Context, sql string, args ...interface{}) (int64, error) {
 	ct, err := db.pool.Exec(ctx, sql, args...)
+	if err != nil {
+		err = newError(err, "unable to execute command")
+	}
 	return ct.RowsAffected(), db.processError(err)
 }
 
@@ -145,7 +148,7 @@ func (db *Database) Exec(ctx context.Context, sql string, args ...interface{}) (
 //  3. To avoid overflows on high uint64 values, store them in NUMERIC(24,0) fields.
 //  4. For time-only fields, date is set to Jan 1, 2000 by PGX in time.Time variables.
 func (db *Database) QueryRow(ctx context.Context, sql string, args ...interface{}) Row {
-	return rowGetter{
+	return &rowGetter{
 		db:  db,
 		row: db.pool.QueryRow(ctx, sql, args...),
 	}
@@ -154,7 +157,10 @@ func (db *Database) QueryRow(ctx context.Context, sql string, args ...interface{
 // QueryRows executes a SQL query on a new connection
 func (db *Database) QueryRows(ctx context.Context, sql string, args ...interface{}) Rows {
 	rows, err := db.pool.Query(ctx, sql, args...)
-	return rowsGetter{
+	if err != nil {
+		err = newError(err, "unable to scan row")
+	}
+	return &rowsGetter{
 		db:   db,
 		ctx:  ctx,
 		rows: rows,
@@ -168,11 +174,14 @@ func (db *Database) Copy(ctx context.Context, tableName string, columnNames []st
 		ctx,
 		pgx.Identifier{tableName},
 		columnNames,
-		copyWithCallback{
+		&copyWithCallback{
 			ctx:      ctx,
 			callback: callback,
 		},
 	)
+	if err != nil {
+		err = newError(err, "unable to execute command")
+	}
 
 	// Done
 	return n, db.processError(err)

rowgetter.go

@@ -19,7 +19,10 @@ type rowGetter struct {
 	row pgx.Row
 }
 
-func (r rowGetter) Scan(dest ...interface{}) error {
+func (r *rowGetter) Scan(dest ...interface{}) error {
 	err := r.row.Scan(dest...)
+	if err != nil {
+		err = newError(err, "unable to scan row")
+	}
 	return r.db.processError(err)
 }

rowsgetter.go

@@ -26,13 +26,13 @@ type rowsGetter struct {
 	err  error
 }
 
-func (r rowsGetter) Do(callback ScanRowsCallback) error {
+func (r *rowsGetter) Do(callback ScanRowsCallback) error {
 	if r.err == nil {
 		// Scan returned rows
 		for r.rows.Next() {
 			cont, err := callback(r.ctx, r)
 			if err != nil {
-				r.err = err
+				r.err = newError(err, "callback returned failure")
 				break
 			}
 			if !cont {
@@ -46,7 +46,10 @@ func (r rowsGetter) Do(callback ScanRowsCallback) error {
 	return r.db.processError(r.err)
 }
 
-func (r rowsGetter) Scan(dest ...interface{}) error {
+func (r *rowsGetter) Scan(dest ...interface{}) error {
 	err := r.rows.Scan(dest...)
+	if err != nil {
+		err = newError(err, "unable to scan row")
+	}
 	return r.db.processError(err)
 }

transaction.go

@@ -29,7 +29,7 @@ func (tx *Tx) Exec(ctx context.Context, sql string, args ...interface{}) (int64,
 
 // QueryRow executes a SQL query within the transaction.
 func (tx *Tx) QueryRow(ctx context.Context, sql string, args ...interface{}) Row {
-	return rowGetter{
+	return &rowGetter{
 		db:  tx.db,
 		row: tx.tx.QueryRow(ctx, sql, args...),
 	}
@@ -38,7 +38,7 @@ func (tx *Tx) QueryRow(ctx context.Context, sql string, args ...interface{}) Row
 // QueryRows executes a SQL query within the transaction.
 func (tx *Tx) QueryRows(ctx context.Context, sql string, args ...interface{}) Rows {
 	rows, err := tx.tx.Query(ctx, sql, args...)
-	return rowsGetter{
+	return &rowsGetter{
 		db:   tx.db,
 		ctx:  ctx,
 		rows: rows,
@@ -52,7 +52,7 @@ func (tx *Tx) Copy(ctx context.Context, tableName string, columnNames []string,
 		ctx,
 		pgx.Identifier{tableName},
 		columnNames,
-		copyWithCallback{
+		&copyWithCallback{
 			ctx:      ctx,
 			callback: callback,
 		},