From d4abe83edb3f2793ee889afb5b4f955f8c677652 Mon Sep 17 00:00:00 2001 From: Jack Christensen Date: Sat, 16 Apr 2022 10:39:12 -0500 Subject: [PATCH] Revert use generics for RangeCodec Reverted almost all of 976b1e0. Still may consider a way to get DecodeValue to be strongly typed but that feature isn't worth the complications of generics. Especially in that applying this style to ArrayCodec would make Conn.LoadType impossible for arrays. --- pgtype/pgtype.go | 12 +++++----- pgtype/range_codec.go | 48 +++++++++++++++++++------------------- pgtype/range_codec_test.go | 6 ++--- 3 files changed, 33 insertions(+), 33 deletions(-) diff --git a/pgtype/pgtype.go b/pgtype/pgtype.go index 78ed341e..e35299e5 100644 --- a/pgtype/pgtype.go +++ b/pgtype/pgtype.go @@ -263,12 +263,12 @@ func NewMap() *Map { m.RegisterType(&Type{Name: "varchar", OID: VarcharOID, Codec: TextCodec{}}) m.RegisterType(&Type{Name: "xid", OID: XIDOID, Codec: Uint32Codec{}}) - m.RegisterType(&Type{Name: "daterange", OID: DaterangeOID, Codec: &RangeCodec[Date]{ElementType: m.oidToType[DateOID]}}) - m.RegisterType(&Type{Name: "int4range", OID: Int4rangeOID, Codec: &RangeCodec[Int4]{ElementType: m.oidToType[Int4OID]}}) - m.RegisterType(&Type{Name: "int8range", OID: Int8rangeOID, Codec: &RangeCodec[Int8]{ElementType: m.oidToType[Int8OID]}}) - m.RegisterType(&Type{Name: "numrange", OID: NumrangeOID, Codec: &RangeCodec[Numeric]{ElementType: m.oidToType[NumericOID]}}) - m.RegisterType(&Type{Name: "tsrange", OID: TsrangeOID, Codec: &RangeCodec[Timestamp]{ElementType: m.oidToType[TimestampOID]}}) - m.RegisterType(&Type{Name: "tstzrange", OID: TstzrangeOID, Codec: &RangeCodec[Timestamptz]{ElementType: m.oidToType[TimestamptzOID]}}) + m.RegisterType(&Type{Name: "daterange", OID: DaterangeOID, Codec: &RangeCodec{ElementType: m.oidToType[DateOID]}}) + m.RegisterType(&Type{Name: "int4range", OID: Int4rangeOID, Codec: &RangeCodec{ElementType: m.oidToType[Int4OID]}}) + m.RegisterType(&Type{Name: "int8range", OID: Int8rangeOID, Codec: &RangeCodec{ElementType: m.oidToType[Int8OID]}}) + m.RegisterType(&Type{Name: "numrange", OID: NumrangeOID, Codec: &RangeCodec{ElementType: m.oidToType[NumericOID]}}) + m.RegisterType(&Type{Name: "tsrange", OID: TsrangeOID, Codec: &RangeCodec{ElementType: m.oidToType[TimestampOID]}}) + m.RegisterType(&Type{Name: "tstzrange", OID: TstzrangeOID, Codec: &RangeCodec{ElementType: m.oidToType[TimestamptzOID]}}) m.RegisterType(&Type{Name: "_aclitem", OID: ACLItemArrayOID, Codec: &ArrayCodec{ElementType: m.oidToType[ACLItemOID]}}) m.RegisterType(&Type{Name: "_bit", OID: BitArrayOID, Codec: &ArrayCodec{ElementType: m.oidToType[BitOID]}}) diff --git a/pgtype/range_codec.go b/pgtype/range_codec.go index 49a39a47..d50bd3cb 100644 --- a/pgtype/range_codec.go +++ b/pgtype/range_codec.go @@ -35,42 +35,42 @@ type RangeScanner interface { } // RangeCodec is a codec for any range type. -type RangeCodec[T any] struct { +type RangeCodec struct { ElementType *Type } -func (c *RangeCodec[T]) FormatSupported(format int16) bool { +func (c *RangeCodec) FormatSupported(format int16) bool { return c.ElementType.Codec.FormatSupported(format) } -func (c *RangeCodec[T]) PreferredFormat() int16 { +func (c *RangeCodec) PreferredFormat() int16 { if c.FormatSupported(BinaryFormatCode) { return BinaryFormatCode } return TextFormatCode } -func (c *RangeCodec[T]) PlanEncode(m *Map, oid uint32, format int16, value any) EncodePlan { +func (c *RangeCodec) PlanEncode(m *Map, oid uint32, format int16, value any) EncodePlan { if _, ok := value.(RangeValuer); !ok { return nil } switch format { case BinaryFormatCode: - return &encodePlanRangeCodecRangeValuerToBinary[T]{rc: c, m: m} + return &encodePlanRangeCodecRangeValuerToBinary{rc: c, m: m} case TextFormatCode: - return &encodePlanRangeCodecRangeValuerToText[T]{rc: c, m: m} + return &encodePlanRangeCodecRangeValuerToText{rc: c, m: m} } return nil } -type encodePlanRangeCodecRangeValuerToBinary[T any] struct { - rc *RangeCodec[T] +type encodePlanRangeCodecRangeValuerToBinary struct { + rc *RangeCodec m *Map } -func (plan *encodePlanRangeCodecRangeValuerToBinary[T]) Encode(value any, buf []byte) (newBuf []byte, err error) { +func (plan *encodePlanRangeCodecRangeValuerToBinary) Encode(value any, buf []byte) (newBuf []byte, err error) { getter := value.(RangeValuer) if getter.IsNull() { @@ -156,12 +156,12 @@ func (plan *encodePlanRangeCodecRangeValuerToBinary[T]) Encode(value any, buf [] return buf, nil } -type encodePlanRangeCodecRangeValuerToText[T any] struct { - rc *RangeCodec[T] +type encodePlanRangeCodecRangeValuerToText struct { + rc *RangeCodec m *Map } -func (plan *encodePlanRangeCodecRangeValuerToText[T]) Encode(value any, buf []byte) (newBuf []byte, err error) { +func (plan *encodePlanRangeCodecRangeValuerToText) Encode(value any, buf []byte) (newBuf []byte, err error) { getter := value.(RangeValuer) if getter.IsNull() { @@ -234,29 +234,29 @@ func (plan *encodePlanRangeCodecRangeValuerToText[T]) Encode(value any, buf []by return buf, nil } -func (c *RangeCodec[T]) PlanScan(m *Map, oid uint32, format int16, target any) ScanPlan { +func (c *RangeCodec) PlanScan(m *Map, oid uint32, format int16, target any) ScanPlan { switch format { case BinaryFormatCode: switch target.(type) { case RangeScanner: - return &scanPlanBinaryRangeToRangeScanner[T]{rc: c, m: m} + return &scanPlanBinaryRangeToRangeScanner{rc: c, m: m} } case TextFormatCode: switch target.(type) { case RangeScanner: - return &scanPlanTextRangeToRangeScanner[T]{rc: c, m: m} + return &scanPlanTextRangeToRangeScanner{rc: c, m: m} } } return nil } -type scanPlanBinaryRangeToRangeScanner[T any] struct { - rc *RangeCodec[T] +type scanPlanBinaryRangeToRangeScanner struct { + rc *RangeCodec m *Map } -func (plan *scanPlanBinaryRangeToRangeScanner[T]) Scan(src []byte, target any) error { +func (plan *scanPlanBinaryRangeToRangeScanner) Scan(src []byte, target any) error { rangeScanner := (target).(RangeScanner) if src == nil { @@ -301,12 +301,12 @@ func (plan *scanPlanBinaryRangeToRangeScanner[T]) Scan(src []byte, target any) e return rangeScanner.SetBoundTypes(ubr.LowerType, ubr.UpperType) } -type scanPlanTextRangeToRangeScanner[T any] struct { - rc *RangeCodec[T] +type scanPlanTextRangeToRangeScanner struct { + rc *RangeCodec m *Map } -func (plan *scanPlanTextRangeToRangeScanner[T]) Scan(src []byte, target any) error { +func (plan *scanPlanTextRangeToRangeScanner) Scan(src []byte, target any) error { rangeScanner := (target).(RangeScanner) if src == nil { @@ -351,7 +351,7 @@ func (plan *scanPlanTextRangeToRangeScanner[T]) Scan(src []byte, target any) err return rangeScanner.SetBoundTypes(utr.LowerType, utr.UpperType) } -func (c *RangeCodec[T]) DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, src []byte) (driver.Value, error) { +func (c *RangeCodec) DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, src []byte) (driver.Value, error) { if src == nil { return nil, nil } @@ -368,12 +368,12 @@ func (c *RangeCodec[T]) DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, } } -func (c *RangeCodec[T]) DecodeValue(m *Map, oid uint32, format int16, src []byte) (any, error) { +func (c *RangeCodec) DecodeValue(m *Map, oid uint32, format int16, src []byte) (any, error) { if src == nil { return nil, nil } - var r Range[T] + var r Range[any] err := c.PlanScan(m, oid, format, &r).Scan(src, &r) return r, err } diff --git a/pgtype/range_codec_test.go b/pgtype/range_codec_test.go index 23e93105..c0628747 100644 --- a/pgtype/range_codec_test.go +++ b/pgtype/range_codec_test.go @@ -136,9 +136,9 @@ func TestRangeCodecDecodeValue(t *testing.T) { }{ { sql: `select '[1,5)'::int4range`, - expected: pgtype.Range[pgtype.Int4]{ - Lower: pgtype.Int4{Int32: 1, Valid: true}, - Upper: pgtype.Int4{Int32: 5, Valid: true}, + expected: pgtype.Range[any]{ + Lower: int32(1), + Upper: int32(5), LowerType: pgtype.Inclusive, UpperType: pgtype.Exclusive, Valid: true,