Convert Date to Codec

2022-01-10 21:02:20 -06:00
parent f4a9d84e32
commit b57e0c419b
6 changed files with 301 additions and 1122 deletions
@@ -10,10 +10,27 @@ import (
 	"github.com/jackc/pgio"
 )

+type DateScanner interface {
+	ScanDate(v Date) error
+}
+
+type DateValuer interface {
+	DateValue() (Date, error)
+}
+
 type Date struct {
 	Time             time.Time
-	Valid            bool
 	InfinityModifier InfinityModifier
+	Valid            bool
+}
+
+func (d *Date) ScanDate(v Date) error {
+	*d = v
+	return nil
+}
+
+func (d Date) DateValue() (Date, error) {
+	return d, nil
 }

 const (
@@ -21,166 +38,6 @@ const (
 	infinityDayOffset         = 2147483647
 )

-func (dst *Date) Set(src interface{}) error {
-	if src == nil {
-		*dst = Date{}
-		return nil
-	}
-
-	if value, ok := src.(interface{ Get() interface{} }); ok {
-		value2 := value.Get()
-		if value2 != value {
-			return dst.Set(value2)
-		}
-	}
-
-	switch value := src.(type) {
-	case time.Time:
-		*dst = Date{Time: value, Valid: true}
-	case string:
-		return dst.DecodeText(nil, []byte(value))
-	case *time.Time:
-		if value == nil {
-			*dst = Date{}
-		} else {
-			return dst.Set(*value)
-		}
-	case *string:
-		if value == nil {
-			*dst = Date{}
-		} else {
-			return dst.Set(*value)
-		}
-	default:
-		if originalSrc, ok := underlyingTimeType(src); ok {
-			return dst.Set(originalSrc)
-		}
-		return fmt.Errorf("cannot convert %v to Date", value)
-	}
-
-	return nil
-}
-
-func (dst Date) Get() interface{} {
-	if !dst.Valid {
-		return nil
-	}
-	if dst.InfinityModifier != None {
-		return dst.InfinityModifier
-	}
-	return dst.Time
-}
-
-func (src *Date) AssignTo(dst interface{}) error {
-	if !src.Valid {
-		return NullAssignTo(dst)
-	}
-
-	switch v := dst.(type) {
-	case *time.Time:
-		if src.InfinityModifier != None {
-			return fmt.Errorf("cannot assign %v to %T", src, dst)
-		}
-		*v = src.Time
-		return nil
-	default:
-		if nextDst, retry := GetAssignToDstType(dst); retry {
-			return src.AssignTo(nextDst)
-		}
-		return fmt.Errorf("unable to assign to %T", dst)
-	}
-}
-
-func (dst *Date) DecodeText(ci *ConnInfo, src []byte) error {
-	if src == nil {
-		*dst = Date{}
-		return nil
-	}
-
-	sbuf := string(src)
-	switch sbuf {
-	case "infinity":
-		*dst = Date{Valid: true, InfinityModifier: Infinity}
-	case "-infinity":
-		*dst = Date{Valid: true, InfinityModifier: -Infinity}
-	default:
-		t, err := time.ParseInLocation("2006-01-02", sbuf, time.UTC)
-		if err != nil {
-			return err
-		}
-
-		*dst = Date{Time: t, Valid: true}
-	}
-
-	return nil
-}
-
-func (dst *Date) DecodeBinary(ci *ConnInfo, src []byte) error {
-	if src == nil {
-		*dst = Date{}
-		return nil
-	}
-
-	if len(src) != 4 {
-		return fmt.Errorf("invalid length for date: %v", len(src))
-	}
-
-	dayOffset := int32(binary.BigEndian.Uint32(src))
-
-	switch dayOffset {
-	case infinityDayOffset:
-		*dst = Date{Valid: true, InfinityModifier: Infinity}
-	case negativeInfinityDayOffset:
-		*dst = Date{Valid: true, InfinityModifier: -Infinity}
-	default:
-		t := time.Date(2000, 1, int(1+dayOffset), 0, 0, 0, 0, time.UTC)
-		*dst = Date{Time: t, Valid: true}
-	}
-
-	return nil
-}
-
-func (src Date) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
-	if !src.Valid {
-		return nil, nil
-	}
-
-	var s string
-
-	switch src.InfinityModifier {
-	case None:
-		s = src.Time.Format("2006-01-02")
-	case Infinity:
-		s = "infinity"
-	case NegativeInfinity:
-		s = "-infinity"
-	}
-
-	return append(buf, s...), nil
-}
-
-func (src Date) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
-	if !src.Valid {
-		return nil, nil
-	}
-
-	var daysSinceDateEpoch int32
-	switch src.InfinityModifier {
-	case None:
-		tUnix := time.Date(src.Time.Year(), src.Time.Month(), src.Time.Day(), 0, 0, 0, 0, time.UTC).Unix()
-		dateEpoch := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC).Unix()
-
-		secSinceDateEpoch := tUnix - dateEpoch
-		daysSinceDateEpoch = int32(secSinceDateEpoch / 86400)
-	case Infinity:
-		daysSinceDateEpoch = infinityDayOffset
-	case NegativeInfinity:
-		daysSinceDateEpoch = negativeInfinityDayOffset
-	}
-
-	return pgio.AppendInt32(buf, daysSinceDateEpoch), nil
-}
-
 // Scan implements the database/sql Scanner interface.
 func (dst *Date) Scan(src interface{}) error {
 	if src == nil {
@@ -190,11 +47,7 @@ func (dst *Date) Scan(src interface{}) error {

 	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 scanPlanTextAnyToDateScanner{}.Scan(nil, 0, TextFormatCode, []byte(src), dst)
 	case time.Time:
 		*dst = Date{Time: src, Valid: true}
 		return nil
@@ -262,3 +115,181 @@ func (dst *Date) UnmarshalJSON(b []byte) error {

 	return nil
 }
+
+type DateCodec struct{}
+
+func (DateCodec) FormatSupported(format int16) bool {
+	return format == TextFormatCode || format == BinaryFormatCode
+}
+
+func (DateCodec) PreferredFormat() int16 {
+	return BinaryFormatCode
+}
+
+func (DateCodec) PlanEncode(ci *ConnInfo, oid uint32, format int16, value interface{}) EncodePlan {
+	if _, ok := value.(DateValuer); !ok {
+		return nil
+	}
+
+	switch format {
+	case BinaryFormatCode:
+		return encodePlanDateCodecBinary{}
+	case TextFormatCode:
+		return encodePlanDateCodecText{}
+	}
+
+	return nil
+}
+
+type encodePlanDateCodecBinary struct{}
+
+func (encodePlanDateCodecBinary) Encode(value interface{}, buf []byte) (newBuf []byte, err error) {
+	date, err := value.(DateValuer).DateValue()
+	if err != nil {
+		return nil, err
+	}
+
+	if !date.Valid {
+		return nil, nil
+	}
+
+	var daysSinceDateEpoch int32
+	switch date.InfinityModifier {
+	case None:
+		tUnix := time.Date(date.Time.Year(), date.Time.Month(), date.Time.Day(), 0, 0, 0, 0, time.UTC).Unix()
+		dateEpoch := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC).Unix()
+
+		secSinceDateEpoch := tUnix - dateEpoch
+		daysSinceDateEpoch = int32(secSinceDateEpoch / 86400)
+	case Infinity:
+		daysSinceDateEpoch = infinityDayOffset
+	case NegativeInfinity:
+		daysSinceDateEpoch = negativeInfinityDayOffset
+	}
+
+	return pgio.AppendInt32(buf, daysSinceDateEpoch), nil
+}
+
+type encodePlanDateCodecText struct{}
+
+func (encodePlanDateCodecText) Encode(value interface{}, buf []byte) (newBuf []byte, err error) {
+	date, err := value.(DateValuer).DateValue()
+	if err != nil {
+		return nil, err
+	}
+
+	if !date.Valid {
+		return nil, nil
+	}
+
+	var s string
+
+	switch date.InfinityModifier {
+	case None:
+		s = date.Time.Format("2006-01-02")
+	case Infinity:
+		s = "infinity"
+	case NegativeInfinity:
+		s = "-infinity"
+	}
+
+	return append(buf, s...), nil
+}
+
+func (DateCodec) PlanScan(ci *ConnInfo, oid uint32, format int16, target interface{}, actualTarget bool) ScanPlan {
+
+	switch format {
+	case BinaryFormatCode:
+		switch target.(type) {
+		case DateScanner:
+			return scanPlanBinaryDateToDateScanner{}
+		}
+	case TextFormatCode:
+		switch target.(type) {
+		case DateScanner:
+			return scanPlanTextAnyToDateScanner{}
+		}
+	}
+
+	return nil
+}
+
+type scanPlanBinaryDateToDateScanner struct{}
+
+func (scanPlanBinaryDateToDateScanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error {
+	scanner := (dst).(DateScanner)
+
+	if src == nil {
+		return scanner.ScanDate(Date{})
+	}
+
+	if len(src) != 4 {
+		return fmt.Errorf("invalid length for date: %v", len(src))
+	}
+
+	dayOffset := int32(binary.BigEndian.Uint32(src))
+
+	switch dayOffset {
+	case infinityDayOffset:
+		return scanner.ScanDate(Date{InfinityModifier: Infinity, Valid: true})
+	case negativeInfinityDayOffset:
+		return scanner.ScanDate(Date{InfinityModifier: -Infinity, Valid: true})
+	default:
+		t := time.Date(2000, 1, int(1+dayOffset), 0, 0, 0, 0, time.UTC)
+		return scanner.ScanDate(Date{Time: t, Valid: true})
+	}
+}
+
+type scanPlanTextAnyToDateScanner struct{}
+
+func (scanPlanTextAnyToDateScanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error {
+	scanner := (dst).(DateScanner)
+
+	if src == nil {
+		return scanner.ScanDate(Date{})
+	}
+
+	sbuf := string(src)
+	switch sbuf {
+	case "infinity":
+		return scanner.ScanDate(Date{InfinityModifier: Infinity, Valid: true})
+	case "-infinity":
+		return scanner.ScanDate(Date{InfinityModifier: -Infinity, Valid: true})
+	default:
+		t, err := time.ParseInLocation("2006-01-02", sbuf, time.UTC)
+		if err != nil {
+			return err
+		}
+
+		return scanner.ScanDate(Date{Time: t, Valid: true})
+	}
+}
+
+func (c DateCodec) DecodeDatabaseSQLValue(ci *ConnInfo, oid uint32, format int16, src []byte) (driver.Value, error) {
+	return codecDecodeToTextFormat(c, ci, oid, format, src)
+}
+
+func (c DateCodec) DecodeValue(ci *ConnInfo, oid uint32, format int16, src []byte) (interface{}, error) {
+	if src == nil {
+		return nil, nil
+	}
+
+	var date Date
+	err := codecScan(c, ci, oid, format, src, &date)
+	if err != nil {
+		return nil, err
+	}
+
+	if date.Valid {
+		switch date.InfinityModifier {
+		case None:
+			return date.Time, nil
+		case Infinity:
+			return "infinity", nil
+		case NegativeInfinity:
+			return "-infinity", nil
+		}
+	}
+
+	return nil, nil
+}