fix(pgtype):Adjust the usage logic of the fmt. Stringer interface to prioritize handling renamed base types - avoiding renamed base types being automatically treated as string types

Author: cruvie

pgtype/pgtype.go

@@ -1497,7 +1497,18 @@ func TryWrapBuiltinTypeEncodePlan(value any) (plan WrappedEncodePlanNextSetter,
 	case []byte:
 		return &wrapByteSliceEncodePlan{}, byteSliceWrapper(value), true
 	case fmt.Stringer:
-		return &wrapFmtStringerEncodePlan{}, fmtStringerWrapper{value}, true
+		// Check if the value is a renamed basic type. If it is, prefer the basic type encoding.
+		rv := reflect.ValueOf(value)
+		switch rv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+			reflect.Float32, reflect.Float64, reflect.Bool, reflect.String:
+			// For renamed basic types, don't use Stringer interface automatically
+			// Let the specific type match above handle it
+		default:
+			// For structs and other complex types that implement Stringer, use the Stringer interface
+			return &wrapFmtStringerEncodePlan{}, fmtStringerWrapper{value}, true
+		}
 	}
 
 	return nil, nil, false

values.go

@@ -1,10 +1,7 @@
 package pgx
 
 import (
-	"database/sql/driver"
 	"errors"
-	"reflect"
-	"time"
 
 	"github.com/jackc/pgx/v5/internal/pgio"
 	"github.com/jackc/pgx/v5/pgtype"
@@ -17,24 +14,6 @@ const (
 )
 
 func convertSimpleArgument(m *pgtype.Map, arg any) (any, error) {
-	// If arg implements driver.Valuer, use Value method
-	if valuer, ok := arg.(driver.Valuer); ok && valuer != nil {
-		v, err := valuer.Value()
-		if err != nil {
-			return nil, err
-		}
-		arg = v
-	}
-
-	fieldValue := reflect.ValueOf(arg)
-	switch fieldValue.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		if _, ok := arg.(time.Duration); !ok {
-			arg = fieldValue.Int()
-		}
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		arg = fieldValue.Uint()
-	}
 	buf, err := m.Encode(0, TextFormatCode, arg, []byte{})
 	if err != nil {
 		return nil, err

values_test.go

@@ -1004,6 +1004,57 @@ func TestEncodeTypeRename(t *testing.T) {
 	})
 }
 
+// Define custom types that are aliases of basic types but also implement fmt.Stringer
+type StringerInt32 int32
+type StringerFloat64 float64
+
+// Implement the String() method for these types
+func (s StringerInt32) String() string {
+	return fmt.Sprintf("StringerInt32(%d)", int32(s))
+}
+
+func (s StringerFloat64) String() string {
+	return fmt.Sprintf("StringerFloat64(%f)", float64(s))
+}
+
+// TestStringerTypes tests custom type aliases that implement the fmt.Stringer interface
+func TestStringerTypes(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
+	defer cancel()
+
+	pgxtest.RunWithQueryExecModes(ctx, t, defaultConnTestRunner, nil, func(ctx context.Context, t testing.TB, conn *pgx.Conn) {
+		// Test values
+		inInt := StringerInt32(42)
+		var outInt StringerInt32
+
+		inFloat := StringerFloat64(553.36)
+		var outFloat StringerFloat64
+
+		// Register types with the connection
+		conn.TypeMap().RegisterDefaultPgType(inInt, "int4")
+		conn.TypeMap().RegisterDefaultPgType(inFloat, "float8")
+
+		// Test that the underlying values are properly encoded/decoded,
+		// not the String() representation
+		err := conn.QueryRow(context.Background(), "select $1::int4, $2::float8", inInt, inFloat).
+			Scan(&outInt, &outFloat)
+		if err != nil {
+			t.Fatalf("Failed with Stringer types: %v", err)
+		}
+
+		// Check that the values are correctly preserved (not converted to their String() representation)
+		if inInt != outInt {
+			t.Errorf("StringerInt32: expected %v, got %v", inInt, outInt)
+		}
+
+		if inFloat != outFloat {
+			t.Errorf("StringerFloat64: expected %v, got %v", inFloat, outFloat)
+		}
+	})
+}
+
 // func TestRowDecodeBinary(t *testing.T) {
 // 	t.Parallel()