Convert Interval to Codec

pgtype/builtin_wrappers.go

@@ -342,6 +342,22 @@ func (w timeWrapper) DateValue() (Date, error) {
 	return Date{Time: time.Time(w), Valid: true}, nil
 }
 
+type durationWrapper time.Duration
+
+func (w *durationWrapper) ScanInterval(v Interval) error {
+	if !v.Valid {
+		return fmt.Errorf("cannot scan NULL into *time.Interval")
+	}
+
+	us := int64(v.Months)*microsecondsPerMonth + int64(v.Days)*microsecondsPerDay + v.Microseconds
+	*w = durationWrapper(time.Duration(us) * time.Microsecond)
+	return nil
+}
+
+func (w durationWrapper) IntervalValue() (Interval, error) {
+	return Interval{Microseconds: int64(w) / 1000, Valid: true}, nil
+}
+
 type netIPNetWrapper net.IPNet
 
 func (w *netIPNetWrapper) ScanInet(v Inet) error {

pgtype/interval.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/jackc/pgio"
 )
@@ -19,6 +18,14 @@ const (
 	microsecondsPerMonth  = 30 * microsecondsPerDay
 )
 
+type IntervalScanner interface {
+	ScanInterval(v Interval) error
+}
+
+type IntervalValuer interface {
+	IntervalValue() (Interval, error)
+}
+
 type Interval struct {
 	Microseconds int64
 	Days         int32
@@ -26,61 +33,169 @@ type Interval struct {
 	Valid        bool
 }
 
-func (dst *Interval) Set(src interface{}) error {
+func (interval *Interval) ScanInterval(v Interval) error {
+	*interval = v
+	return nil
+}
+
+func (interval Interval) IntervalValue() (Interval, error) {
+	return interval, nil
+}
+
+// Scan implements the database/sql Scanner interface.
+func (interval *Interval) Scan(src interface{}) error {
 	if src == nil {
-		*dst = Interval{}
+		*interval = Interval{}
 		return nil
 	}
 
-	if value, ok := src.(interface{ Get() interface{} }); ok {
+	switch src := src.(type) {
-		value2 := value.Get()
+	case string:
-		if value2 != value {
+		return scanPlanTextAnyToIntervalScanner{}.Scan(nil, 0, TextFormatCode, []byte(src), interval)
-			return dst.Set(value2)
-		}
 	}
 
-	switch value := src.(type) {
+	return fmt.Errorf("cannot scan %T", src)
-	case time.Duration:
+}
-		*dst = Interval{Microseconds: int64(value) / 1000, Valid: true}
+
-	default:
+// Value implements the database/sql/driver Valuer interface.
-		if originalSrc, ok := underlyingPtrType(src); ok {
+func (interval Interval) Value() (driver.Value, error) {
-			return dst.Set(originalSrc)
+	if !interval.Valid {
-		}
+		return nil, nil
-		return fmt.Errorf("cannot convert %v to Interval", value)
+	}
+
+	buf, err := IntervalCodec{}.PlanEncode(nil, 0, TextFormatCode, interval).Encode(interval, nil)
+	if err != nil {
+		return nil, err
+	}
+	return string(buf), err
+}
+
+type IntervalCodec struct{}
+
+func (IntervalCodec) FormatSupported(format int16) bool {
+	return format == TextFormatCode || format == BinaryFormatCode
+}
+
+func (IntervalCodec) PreferredFormat() int16 {
+	return BinaryFormatCode
+}
+
+func (IntervalCodec) PlanEncode(ci *ConnInfo, oid uint32, format int16, value interface{}) EncodePlan {
+	if _, ok := value.(IntervalValuer); !ok {
+		return nil
+	}
+
+	switch format {
+	case BinaryFormatCode:
+		return encodePlanIntervalCodecBinary{}
+	case TextFormatCode:
+		return encodePlanIntervalCodecText{}
 	}
 
 	return nil
 }
 
-func (dst Interval) Get() interface{} {
+type encodePlanIntervalCodecBinary struct{}
-	if !dst.Valid {
+
-		return nil
+func (encodePlanIntervalCodecBinary) Encode(value interface{}, buf []byte) (newBuf []byte, err error) {
+	interval, err := value.(IntervalValuer).IntervalValue()
+	if err != nil {
+		return nil, err
 	}
-	return dst
+
+	if !interval.Valid {
+		return nil, nil
+	}
+
+	buf = pgio.AppendInt64(buf, interval.Microseconds)
+	buf = pgio.AppendInt32(buf, interval.Days)
+	buf = pgio.AppendInt32(buf, interval.Months)
+	return buf, nil
 }
 
-func (src *Interval) AssignTo(dst interface{}) error {
+type encodePlanIntervalCodecText struct{}
-	if !src.Valid {
+
-		return NullAssignTo(dst)
+func (encodePlanIntervalCodecText) Encode(value interface{}, buf []byte) (newBuf []byte, err error) {
+	interval, err := value.(IntervalValuer).IntervalValue()
+	if err != nil {
+		return nil, err
 	}
 
-	switch v := dst.(type) {
+	if !interval.Valid {
-	case *time.Duration:
+		return nil, nil
-		us := int64(src.Months)*microsecondsPerMonth + int64(src.Days)*microsecondsPerDay + src.Microseconds
+	}
-		*v = time.Duration(us) * time.Microsecond
+
-		return nil
+	if interval.Months != 0 {
-	default:
+		buf = append(buf, strconv.FormatInt(int64(interval.Months), 10)...)
-		if nextDst, retry := GetAssignToDstType(dst); retry {
+		buf = append(buf, " mon "...)
-			return src.AssignTo(nextDst)
+	}
+
+	if interval.Days != 0 {
+		buf = append(buf, strconv.FormatInt(int64(interval.Days), 10)...)
+		buf = append(buf, " day "...)
+	}
+
+	absMicroseconds := interval.Microseconds
+	if absMicroseconds < 0 {
+		absMicroseconds = -absMicroseconds
+		buf = append(buf, '-')
+	}
+
+	hours := absMicroseconds / microsecondsPerHour
+	minutes := (absMicroseconds % microsecondsPerHour) / microsecondsPerMinute
+	seconds := (absMicroseconds % microsecondsPerMinute) / microsecondsPerSecond
+	microseconds := absMicroseconds % microsecondsPerSecond
+
+	timeStr := fmt.Sprintf("%02d:%02d:%02d.%06d", hours, minutes, seconds, microseconds)
+	buf = append(buf, timeStr...)
+	return buf, nil
+}
+
+func (IntervalCodec) PlanScan(ci *ConnInfo, oid uint32, format int16, target interface{}, actualTarget bool) ScanPlan {
+
+	switch format {
+	case BinaryFormatCode:
+		switch target.(type) {
+		case IntervalScanner:
+			return scanPlanBinaryIntervalToIntervalScanner{}
+		}
+	case TextFormatCode:
+		switch target.(type) {
+		case IntervalScanner:
+			return scanPlanTextAnyToIntervalScanner{}
 		}
-		return fmt.Errorf("unable to assign to %T", dst)
 	}
+
+	return nil
 }
 
-func (dst *Interval) DecodeText(ci *ConnInfo, src []byte) error {
+type scanPlanBinaryIntervalToIntervalScanner struct{}
+
+func (scanPlanBinaryIntervalToIntervalScanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error {
+	scanner := (dst).(IntervalScanner)
+
 	if src == nil {
-		*dst = Interval{}
+		return scanner.ScanInterval(Interval{})
-		return nil
+	}
+
+	if len(src) != 16 {
+		return fmt.Errorf("Received an invalid size for a interval: %d", len(src))
+	}
+
+	microseconds := int64(binary.BigEndian.Uint64(src))
+	days := int32(binary.BigEndian.Uint32(src[8:]))
+	months := int32(binary.BigEndian.Uint32(src[12:]))
+
+	return scanner.ScanInterval(Interval{Microseconds: microseconds, Days: days, Months: months, Valid: true})
+}
+
+type scanPlanTextAnyToIntervalScanner struct{}
+
+func (scanPlanTextAnyToIntervalScanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error {
+	scanner := (dst).(IntervalScanner)
+
+	if src == nil {
+		return scanner.ScanInterval(Interval{})
 	}
 
 	var microseconds int64
@@ -156,89 +271,22 @@ func (dst *Interval) DecodeText(ci *ConnInfo, src []byte) error {
 		}
 	}
 
-	*dst = Interval{Months: months, Days: days, Microseconds: microseconds, Valid: true}
+	return scanner.ScanInterval(Interval{Months: months, Days: days, Microseconds: microseconds, Valid: true})
-	return nil
 }
 
-func (dst *Interval) DecodeBinary(ci *ConnInfo, src []byte) error {
+func (c IntervalCodec) DecodeDatabaseSQLValue(ci *ConnInfo, oid uint32, format int16, src []byte) (driver.Value, error) {
+	return codecDecodeToTextFormat(c, ci, oid, format, src)
+}
+
+func (c IntervalCodec) DecodeValue(ci *ConnInfo, oid uint32, format int16, src []byte) (interface{}, error) {
 	if src == nil {
-		*dst = Interval{}
-		return nil
-	}
-
-	if len(src) != 16 {
-		return fmt.Errorf("Received an invalid size for a interval: %d", len(src))
-	}
-
-	microseconds := int64(binary.BigEndian.Uint64(src))
-	days := int32(binary.BigEndian.Uint32(src[8:]))
-	months := int32(binary.BigEndian.Uint32(src[12:]))
-
-	*dst = Interval{Microseconds: microseconds, Days: days, Months: months, Valid: true}
-	return nil
-}
-
-func (src Interval) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
-	if !src.Valid {
 		return nil, nil
 	}
 
-	if src.Months != 0 {
+	var interval Interval
-		buf = append(buf, strconv.FormatInt(int64(src.Months), 10)...)
+	err := codecScan(c, ci, oid, format, src, &interval)
-		buf = append(buf, " mon "...)
+	if err != nil {
+		return nil, err
 	}
-
+	return interval, nil
-	if src.Days != 0 {
-		buf = append(buf, strconv.FormatInt(int64(src.Days), 10)...)
-		buf = append(buf, " day "...)
-	}
-
-	absMicroseconds := src.Microseconds
-	if absMicroseconds < 0 {
-		absMicroseconds = -absMicroseconds
-		buf = append(buf, '-')
-	}
-
-	hours := absMicroseconds / microsecondsPerHour
-	minutes := (absMicroseconds % microsecondsPerHour) / microsecondsPerMinute
-	seconds := (absMicroseconds % microsecondsPerMinute) / microsecondsPerSecond
-	microseconds := absMicroseconds % microsecondsPerSecond
-
-	timeStr := fmt.Sprintf("%02d:%02d:%02d.%06d", hours, minutes, seconds, microseconds)
-	return append(buf, timeStr...), nil
-}
-
-// EncodeBinary encodes src into w.
-func (src Interval) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
-	if !src.Valid {
-		return nil, nil
-	}
-
-	buf = pgio.AppendInt64(buf, src.Microseconds)
-	buf = pgio.AppendInt32(buf, src.Days)
-	return pgio.AppendInt32(buf, src.Months), nil
-}
-
-// Scan implements the database/sql Scanner interface.
-func (dst *Interval) Scan(src interface{}) error {
-	if src == nil {
-		*dst = Interval{}
-		return nil
-	}
-
-	switch src := src.(type) {
-	case string:
-		return dst.DecodeText(nil, []byte(src))
-	case []byte:
-		srcCopy := make([]byte, len(src))
-		copy(srcCopy, src)
-		return dst.DecodeText(nil, srcCopy)
-	}
-
-	return fmt.Errorf("cannot scan %T", src)
-}
-
-// Value implements the database/sql/driver Valuer interface.
-func (src Interval) Value() (driver.Value, error) {
-	return EncodeValueText(src)
 }

pgtype/interval_test.go

@@ -5,70 +5,132 @@ import (
 	"time"
 
 	"github.com/jackc/pgx/v5/pgtype"
-	"github.com/jackc/pgx/v5/pgtype/testutil"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-func TestIntervalTranscode(t *testing.T) {
+func TestIntervalCodec(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "interval", []interface{}{
+	testPgxCodec(t, "interval", []PgxTranscodeTestCase{
-		&pgtype.Interval{Microseconds: 1, Valid: true},
+		{
-		&pgtype.Interval{Microseconds: 1000000, Valid: true},
+			pgtype.Interval{Microseconds: 1, Valid: true},
-		&pgtype.Interval{Microseconds: 1000001, Valid: true},
+			new(pgtype.Interval),
-		&pgtype.Interval{Microseconds: 123202800000000, Valid: true},
+			isExpectedEq(pgtype.Interval{Microseconds: 1, Valid: true}),
-		&pgtype.Interval{Days: 1, Valid: true},
+		},
-		&pgtype.Interval{Months: 1, Valid: true},
+		{
-		&pgtype.Interval{Months: 12, Valid: true},
+			pgtype.Interval{Microseconds: 1000000, Valid: true},
-		&pgtype.Interval{Months: 13, Days: 15, Microseconds: 1000001, Valid: true},
+			new(pgtype.Interval),
-		&pgtype.Interval{Microseconds: -1, Valid: true},
+			isExpectedEq(pgtype.Interval{Microseconds: 1000000, Valid: true}),
-		&pgtype.Interval{Microseconds: -1000000, Valid: true},
+		},
-		&pgtype.Interval{Microseconds: -1000001, Valid: true},
+		{
-		&pgtype.Interval{Microseconds: -123202800000000, Valid: true},
+			pgtype.Interval{Microseconds: 1000001, Valid: true},
-		&pgtype.Interval{Days: -1, Valid: true},
+			new(pgtype.Interval),
-		&pgtype.Interval{Months: -1, Valid: true},
+			isExpectedEq(pgtype.Interval{Microseconds: 1000001, Valid: true}),
-		&pgtype.Interval{Months: -12, Valid: true},
+		},
-		&pgtype.Interval{Months: -13, Days: -15, Microseconds: -1000001, Valid: true},
+		{
-		&pgtype.Interval{},
+			pgtype.Interval{Microseconds: 123202800000000, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: 123202800000000, Valid: true}),
+		},
+		{
+			pgtype.Interval{Days: 1, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Days: 1, Valid: true}),
+		},
+		{
+			pgtype.Interval{Months: 1, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: 1, Valid: true}),
+		},
+		{
+			pgtype.Interval{Months: 12, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: 12, Valid: true}),
+		},
+		{
+			pgtype.Interval{Months: 13, Days: 15, Microseconds: 1000001, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: 13, Days: 15, Microseconds: 1000001, Valid: true}),
+		},
+		{
+			pgtype.Interval{Microseconds: -1, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: -1, Valid: true}),
+		},
+		{
+			pgtype.Interval{Microseconds: -1000000, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: -1000000, Valid: true}),
+		},
+		{
+			pgtype.Interval{Microseconds: -1000001, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: -1000001, Valid: true}),
+		},
+		{
+			pgtype.Interval{Microseconds: -123202800000000, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: -123202800000000, Valid: true}),
+		},
+		{
+			pgtype.Interval{Days: -1, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Days: -1, Valid: true}),
+		},
+		{
+			pgtype.Interval{Months: -1, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: -1, Valid: true}),
+		},
+		{
+			pgtype.Interval{Months: -12, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: -12, Valid: true}),
+		},
+		{
+			pgtype.Interval{Months: -13, Days: -15, Microseconds: -1000001, Valid: true},
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: -13, Days: -15, Microseconds: -1000001, Valid: true}),
+		},
+		{
+			"1 second",
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: 1000000, Valid: true}),
+		},
+		{
+			"1.000001 second",
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: 1000001, Valid: true}),
+		},
+		{
+			"34223 hours",
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Microseconds: 123202800000000, Valid: true}),
+		},
+		{
+			"1 day",
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Days: 1, Valid: true}),
+		},
+		{
+			"1 month",
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: 1, Valid: true}),
+		},
+		{
+			"1 year",
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: 12, Valid: true}),
+		},
+		{
+			"-13 mon",
+			new(pgtype.Interval),
+			isExpectedEq(pgtype.Interval{Months: -13, Valid: true}),
+		},
+		{time.Hour, new(time.Duration), isExpectedEq(time.Hour)},
+		{
+			pgtype.Interval{Months: 1, Days: 1, Valid: true},
+			new(time.Duration),
+			isExpectedEq(time.Duration(2678400000000000)),
+		},
+		{pgtype.Interval{}, new(pgtype.Interval), isExpectedEq(pgtype.Interval{})},
+		{nil, new(pgtype.Interval), isExpectedEq(pgtype.Interval{})},
 	})
 }
-
-func TestIntervalNormalize(t *testing.T) {
-	testutil.TestSuccessfulNormalize(t, []testutil.NormalizeTest{
-		{
-			SQL:   "select '1 second'::interval",
-			Value: &pgtype.Interval{Microseconds: 1000000, Valid: true},
-		},
-		{
-			SQL:   "select '1.000001 second'::interval",
-			Value: &pgtype.Interval{Microseconds: 1000001, Valid: true},
-		},
-		{
-			SQL:   "select '34223 hours'::interval",
-			Value: &pgtype.Interval{Microseconds: 123202800000000, Valid: true},
-		},
-		{
-			SQL:   "select '1 day'::interval",
-			Value: &pgtype.Interval{Days: 1, Valid: true},
-		},
-		{
-			SQL:   "select '1 month'::interval",
-			Value: &pgtype.Interval{Months: 1, Valid: true},
-		},
-		{
-			SQL:   "select '1 year'::interval",
-			Value: &pgtype.Interval{Months: 12, Valid: true},
-		},
-		{
-			SQL:   "select '-13 mon'::interval",
-			Value: &pgtype.Interval{Months: -13, Valid: true},
-		},
-	})
-}
-
-func TestIntervalLossyConversionToDuration(t *testing.T) {
-	interval := &pgtype.Interval{Months: 1, Days: 1, Valid: true}
-	var d time.Duration
-	err := interval.AssignTo(&d)
-	require.NoError(t, err)
-	assert.EqualValues(t, int64(2678400000000000), d.Nanoseconds())
-}

pgtype/pgtype.go

@@ -305,7 +305,7 @@ func NewConnInfo() *ConnInfo {
 	// ci.RegisterDataType(DataType{Value: &Int4range{}, Name: "int4range", OID: Int4rangeOID})
 	ci.RegisterDataType(DataType{Name: "int8", OID: Int8OID, Codec: Int8Codec{}})
 	// ci.RegisterDataType(DataType{Value: &Int8range{}, Name: "int8range", OID: Int8rangeOID})
-	ci.RegisterDataType(DataType{Value: &Interval{}, Name: "interval", OID: IntervalOID})
+	ci.RegisterDataType(DataType{Name: "interval", OID: IntervalOID, Codec: IntervalCodec{}})
 	ci.RegisterDataType(DataType{Value: &JSON{}, Name: "json", OID: JSONOID})
 	ci.RegisterDataType(DataType{Value: &JSONB{}, Name: "jsonb", OID: JSONBOID})
 	ci.RegisterDataType(DataType{Value: &JSONBArray{}, Name: "_jsonb", OID: JSONBArrayOID})
@@ -858,6 +858,8 @@ func tryWrapBuiltinTypeScanPlan(dst interface{}) (plan WrappedScanPlanNextSetter
 		return &wrapStringScanPlan{}, (*stringWrapper)(dst), true
 	case *time.Time:
 		return &wrapTimeScanPlan{}, (*timeWrapper)(dst), true
+	case *time.Duration:
+		return &wrapDurationScanPlan{}, (*durationWrapper)(dst), true
 	case *net.IPNet:
 		return &wrapNetIPNetScanPlan{}, (*netIPNetWrapper)(dst), true
 	case *net.IP:
@@ -1011,6 +1013,16 @@ func (plan *wrapTimeScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, s
 	return plan.next.Scan(ci, oid, formatCode, src, (*timeWrapper)(dst.(*time.Time)))
 }
 
+type wrapDurationScanPlan struct {
+	next ScanPlan
+}
+
+func (plan *wrapDurationScanPlan) SetNext(next ScanPlan) { plan.next = next }
+
+func (plan *wrapDurationScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error {
+	return plan.next.Scan(ci, oid, formatCode, src, (*durationWrapper)(dst.(*time.Duration)))
+}
+
 type wrapNetIPNetScanPlan struct {
 	next ScanPlan
 }
@@ -1143,8 +1155,10 @@ func (ci *ConnInfo) PlanScan(oid uint32, formatCode int16, dst interface{}) Scan
 		for _, f := range tryWrappers {
 			if wrapperPlan, nextDst, ok := f(dst); ok {
 				if nextPlan := ci.PlanScan(oid, formatCode, nextDst); nextPlan != nil {
-					wrapperPlan.SetNext(nextPlan)
+					if _, ok := nextPlan.(*scanPlanDataTypeAssignTo); !ok { // avoid fallthrough -- this will go away when old system removed.
-					return wrapperPlan
+						wrapperPlan.SetNext(nextPlan)
+						return wrapperPlan
+					}
 				}
 			}
 		}
@@ -1381,6 +1395,8 @@ func tryWrapBuiltinTypeEncodePlan(value interface{}) (plan WrappedEncodePlanNext
 		return &wrapStringEncodePlan{}, stringWrapper(value), true
 	case time.Time:
 		return &wrapTimeEncodePlan{}, timeWrapper(value), true
+	case time.Duration:
+		return &wrapDurationEncodePlan{}, durationWrapper(value), true
 	case net.IPNet:
 		return &wrapNetIPNetEncodePlan{}, netIPNetWrapper(value), true
 	case net.IP:
@@ -1534,6 +1550,16 @@ func (plan *wrapTimeEncodePlan) Encode(value interface{}, buf []byte) (newBuf []
 	return plan.next.Encode(timeWrapper(value.(time.Time)), buf)
 }
 
+type wrapDurationEncodePlan struct {
+	next EncodePlan
+}
+
+func (plan *wrapDurationEncodePlan) SetNext(next EncodePlan) { plan.next = next }
+
+func (plan *wrapDurationEncodePlan) Encode(value interface{}, buf []byte) (newBuf []byte, err error) {
+	return plan.next.Encode(durationWrapper(value.(time.Duration)), buf)
+}
+
 type wrapNetIPNetEncodePlan struct {
 	next EncodePlan
 }