Convert path to Codec

pgtype/path.go

@@ -11,33 +11,213 @@ import (
 	"github.com/jackc/pgio"
 )
 
+type PathScanner interface {
+	ScanPath(v Path) error
+}
+
+type PathValuer interface {
+	PathValue() (Path, error)
+}
+
 type Path struct {
 	P      []Vec2
 	Closed bool
 	Valid  bool
 }
 
-func (dst *Path) Set(src interface{}) error {
+func (path *Path) ScanPath(v Path) error {
-	return fmt.Errorf("cannot convert %v to Path", src)
+	*path = v
+	return nil
 }
 
-func (dst Path) Get() interface{} {
+func (path Path) PathValue() (Path, error) {
-	if !dst.Valid {
+	return path, nil
+}
+
+// Scan implements the database/sql Scanner interface.
+func (path *Path) Scan(src interface{}) error {
+	if src == nil {
+		*path = Path{}
 		return nil
 	}
-	return dst
+
+	switch src := src.(type) {
+	case string:
+		return scanPlanTextAnyToPathScanner{}.Scan(nil, 0, TextFormatCode, []byte(src), path)
+	}
+
+	return fmt.Errorf("cannot scan %T", src)
 }
 
-func (src *Path) AssignTo(dst interface{}) error {
+// Value implements the database/sql/driver Valuer interface.
-	return fmt.Errorf("cannot assign %v to %T", src, dst)
+func (path Path) Value() (driver.Value, error) {
+	if !path.Valid {
+		return nil, nil
+	}
+
+	buf, err := PathCodec{}.PlanEncode(nil, 0, TextFormatCode, path).Encode(path, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return string(buf), err
 }
 
-func (dst *Path) DecodeText(ci *ConnInfo, src []byte) error {
+type PathCodec struct{}
-	if src == nil {
+
-		*dst = Path{}
+func (PathCodec) FormatSupported(format int16) bool {
+	return format == TextFormatCode || format == BinaryFormatCode
+}
+
+func (PathCodec) PreferredFormat() int16 {
+	return BinaryFormatCode
+}
+
+func (PathCodec) PlanEncode(ci *ConnInfo, oid uint32, format int16, value interface{}) EncodePlan {
+	if _, ok := value.(PathValuer); !ok {
 		return nil
 	}
 
+	switch format {
+	case BinaryFormatCode:
+		return encodePlanPathCodecBinary{}
+	case TextFormatCode:
+		return encodePlanPathCodecText{}
+	}
+
+	return nil
+}
+
+type encodePlanPathCodecBinary struct{}
+
+func (encodePlanPathCodecBinary) Encode(value interface{}, buf []byte) (newBuf []byte, err error) {
+	path, err := value.(PathValuer).PathValue()
+	if err != nil {
+		return nil, err
+	}
+
+	if !path.Valid {
+		return nil, nil
+	}
+
+	var closeByte byte
+	if path.Closed {
+		closeByte = 1
+	}
+	buf = append(buf, closeByte)
+
+	buf = pgio.AppendInt32(buf, int32(len(path.P)))
+
+	for _, p := range path.P {
+		buf = pgio.AppendUint64(buf, math.Float64bits(p.X))
+		buf = pgio.AppendUint64(buf, math.Float64bits(p.Y))
+	}
+
+	return buf, nil
+}
+
+type encodePlanPathCodecText struct{}
+
+func (encodePlanPathCodecText) Encode(value interface{}, buf []byte) (newBuf []byte, err error) {
+	path, err := value.(PathValuer).PathValue()
+	if err != nil {
+		return nil, err
+	}
+
+	if !path.Valid {
+		return nil, nil
+	}
+
+	var startByte, endByte byte
+	if path.Closed {
+		startByte = '('
+		endByte = ')'
+	} else {
+		startByte = '['
+		endByte = ']'
+	}
+	buf = append(buf, startByte)
+
+	for i, p := range path.P {
+		if i > 0 {
+			buf = append(buf, ',')
+		}
+		buf = append(buf, fmt.Sprintf(`(%s,%s)`,
+			strconv.FormatFloat(p.X, 'f', -1, 64),
+			strconv.FormatFloat(p.Y, 'f', -1, 64),
+		)...)
+	}
+
+	buf = append(buf, endByte)
+
+	return buf, nil
+}
+
+func (PathCodec) PlanScan(ci *ConnInfo, oid uint32, format int16, target interface{}, actualTarget bool) ScanPlan {
+
+	switch format {
+	case BinaryFormatCode:
+		switch target.(type) {
+		case PathScanner:
+			return scanPlanBinaryPathToPathScanner{}
+		}
+	case TextFormatCode:
+		switch target.(type) {
+		case PathScanner:
+			return scanPlanTextAnyToPathScanner{}
+		}
+	}
+
+	return nil
+}
+
+type scanPlanBinaryPathToPathScanner struct{}
+
+func (scanPlanBinaryPathToPathScanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error {
+	scanner := (dst).(PathScanner)
+
+	if src == nil {
+		return scanner.ScanPath(Path{})
+	}
+
+	if len(src) < 5 {
+		return fmt.Errorf("invalid length for Path: %v", len(src))
+	}
+
+	closed := src[0] == 1
+	pointCount := int(binary.BigEndian.Uint32(src[1:]))
+
+	rp := 5
+
+	if 5+pointCount*16 != len(src) {
+		return fmt.Errorf("invalid length for Path with %d points: %v", pointCount, len(src))
+	}
+
+	points := make([]Vec2, pointCount)
+	for i := 0; i < len(points); i++ {
+		x := binary.BigEndian.Uint64(src[rp:])
+		rp += 8
+		y := binary.BigEndian.Uint64(src[rp:])
+		rp += 8
+		points[i] = Vec2{math.Float64frombits(x), math.Float64frombits(y)}
+	}
+
+	return scanner.ScanPath(Path{
+		P:      points,
+		Closed: closed,
+		Valid:  true,
+	})
+}
+
+type scanPlanTextAnyToPathScanner struct{}
+
+func (scanPlanTextAnyToPathScanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error {
+	scanner := (dst).(PathScanner)
+
+	if src == nil {
+		return scanner.ScanPath(Path{})
+	}
+
 	if len(src) < 7 {
 		return fmt.Errorf("invalid length for Path: %v", len(src))
 	}
@@ -71,115 +251,22 @@ func (dst *Path) DecodeText(ci *ConnInfo, src []byte) error {
 		}
 	}
 
-	*dst = Path{P: points, Closed: closed, Valid: true}
+	return scanner.ScanPath(Path{P: points, Closed: closed, Valid: true})
-	return nil
 }
 
-func (dst *Path) DecodeBinary(ci *ConnInfo, src []byte) error {
+func (c PathCodec) DecodeDatabaseSQLValue(ci *ConnInfo, oid uint32, format int16, src []byte) (driver.Value, error) {
+	return codecDecodeToTextFormat(c, ci, oid, format, src)
+}
+
+func (c PathCodec) DecodeValue(ci *ConnInfo, oid uint32, format int16, src []byte) (interface{}, error) {
 	if src == nil {
-		*dst = Path{}
-		return nil
-	}
-
-	if len(src) < 5 {
-		return fmt.Errorf("invalid length for Path: %v", len(src))
-	}
-
-	closed := src[0] == 1
-	pointCount := int(binary.BigEndian.Uint32(src[1:]))
-
-	rp := 5
-
-	if 5+pointCount*16 != len(src) {
-		return fmt.Errorf("invalid length for Path with %d points: %v", pointCount, len(src))
-	}
-
-	points := make([]Vec2, pointCount)
-	for i := 0; i < len(points); i++ {
-		x := binary.BigEndian.Uint64(src[rp:])
-		rp += 8
-		y := binary.BigEndian.Uint64(src[rp:])
-		rp += 8
-		points[i] = Vec2{math.Float64frombits(x), math.Float64frombits(y)}
-	}
-
-	*dst = Path{
-		P:      points,
-		Closed: closed,
-		Valid:  true,
-	}
-	return nil
-}
-
-func (src Path) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
-	if !src.Valid {
 		return nil, nil
 	}
 
-	var startByte, endByte byte
+	var path Path
-	if src.Closed {
+	err := codecScan(c, ci, oid, format, src, &path)
-		startByte = '('
+	if err != nil {
-		endByte = ')'
+		return nil, err
-	} else {
-		startByte = '['
-		endByte = ']'
 	}
-	buf = append(buf, startByte)
+	return path, nil
-
-	for i, p := range src.P {
-		if i > 0 {
-			buf = append(buf, ',')
-		}
-		buf = append(buf, fmt.Sprintf(`(%s,%s)`,
-			strconv.FormatFloat(p.X, 'f', -1, 64),
-			strconv.FormatFloat(p.Y, 'f', -1, 64),
-		)...)
-	}
-
-	return append(buf, endByte), nil
-}
-
-func (src Path) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
-	if !src.Valid {
-		return nil, nil
-	}
-
-	var closeByte byte
-	if src.Closed {
-		closeByte = 1
-	}
-	buf = append(buf, closeByte)
-
-	buf = pgio.AppendInt32(buf, int32(len(src.P)))
-
-	for _, p := range src.P {
-		buf = pgio.AppendUint64(buf, math.Float64bits(p.X))
-		buf = pgio.AppendUint64(buf, math.Float64bits(p.Y))
-	}
-
-	return buf, nil
-}
-
-// Scan implements the database/sql Scanner interface.
-func (dst *Path) Scan(src interface{}) error {
-	if src == nil {
-		*dst = Path{}
-		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 Path) Value() (driver.Value, error) {
-	return EncodeValueText(src)
 }

pgtype/path_test.go

@@ -4,26 +4,69 @@ import (
 	"testing"
 
 	"github.com/jackc/pgx/v5/pgtype"
-	"github.com/jackc/pgx/v5/pgtype/testutil"
 )
 
+func isExpectedEqPath(a interface{}) func(interface{}) bool {
+	return func(v interface{}) bool {
+		ap := a.(pgtype.Path)
+		vp := v.(pgtype.Path)
+
+		if !(ap.Valid == vp.Valid && ap.Closed == vp.Closed && len(ap.P) == len(vp.P)) {
+			return false
+		}
+
+		for i := range ap.P {
+			if ap.P[i] != vp.P[i] {
+				return false
+			}
+		}
+
+		return true
+	}
+}
+
 func TestPathTranscode(t *testing.T) {
-	testutil.TestSuccessfulTranscode(t, "path", []interface{}{
+	testPgxCodec(t, "path", []PgxTranscodeTestCase{
-		&pgtype.Path{
+		{
-			P:      []pgtype.Vec2{{3.14, 1.678901234}, {7.1, 5.234}},
+			pgtype.Path{
-			Closed: false,
+				P:      []pgtype.Vec2{{3.14, 1.678901234}, {7.1, 5.234}},
-			Valid:  true,
+				Closed: false,
+				Valid:  true,
+			},
+			new(pgtype.Path),
+			isExpectedEqPath(pgtype.Path{
+				P:      []pgtype.Vec2{{3.14, 1.678901234}, {7.1, 5.234}},
+				Closed: false,
+				Valid:  true,
+			}),
 		},
-		&pgtype.Path{
+		{
-			P:      []pgtype.Vec2{{3.14, 1.678}, {7.1, 5.234}, {23.1, 9.34}},
+			pgtype.Path{
-			Closed: true,
+				P:      []pgtype.Vec2{{3.14, 1.678}, {7.1, 5.234}, {23.1, 9.34}},
-			Valid:  true,
+				Closed: true,
+				Valid:  true,
+			},
+			new(pgtype.Path),
+			isExpectedEqPath(pgtype.Path{
+				P:      []pgtype.Vec2{{3.14, 1.678}, {7.1, 5.234}, {23.1, 9.34}},
+				Closed: true,
+				Valid:  true,
+			}),
 		},
-		&pgtype.Path{
+		{
-			P:      []pgtype.Vec2{{7.1, 1.678}, {-13.14, -5.234}},
+			pgtype.Path{
-			Closed: true,
+				P:      []pgtype.Vec2{{7.1, 1.678}, {-13.14, -5.234}},
-			Valid:  true,
+				Closed: true,
+				Valid:  true,
+			},
+			new(pgtype.Path),
+			isExpectedEqPath(pgtype.Path{
+				P:      []pgtype.Vec2{{7.1, 1.678}, {-13.14, -5.234}},
+				Closed: true,
+				Valid:  true,
+			}),
 		},
-		&pgtype.Path{},
+		{pgtype.Path{}, new(pgtype.Path), isExpectedEqPath(pgtype.Path{})},
+		{nil, new(pgtype.Path), isExpectedEqPath(pgtype.Path{})},
 	})
 }

pgtype/pgtype.go

@@ -322,7 +322,7 @@ func NewConnInfo() *ConnInfo {
 	ci.RegisterDataType(DataType{Value: &Numeric{}, Name: "numeric", OID: NumericOID})
 	// ci.RegisterDataType(DataType{Value: &Numrange{}, Name: "numrange", OID: NumrangeOID})
 	ci.RegisterDataType(DataType{Name: "oid", OID: OIDOID, Codec: Uint32Codec{}})
-	ci.RegisterDataType(DataType{Value: &Path{}, Name: "path", OID: PathOID})
+	ci.RegisterDataType(DataType{Name: "path", OID: PathOID, Codec: PathCodec{}})
 	ci.RegisterDataType(DataType{Name: "point", OID: PointOID, Codec: PointCodec{}})
 	ci.RegisterDataType(DataType{Value: &Polygon{}, Name: "polygon", OID: PolygonOID})
 	// ci.RegisterDataType(DataType{Value: &Record{}, Name: "record", OID: RecordOID})