gopkg/pgx
2
0
Fork 0
Code Activity

Revert use generics for RangeCodec

Browse Source 
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.
This commit is contained in:
Jack Christensen
2022-04-16 10:39:12 -05:00
parent 8b483e4223
commit d4abe83edb
3 changed files with 33 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pgtype/pgtype.go
+6 -6
View File
@@ -263,12 +263,12 @@ func NewMap() *Map {
m.RegisterType(&Type{Name: "varchar", OID: VarcharOID, Codec: TextCodec{}}) m.RegisterType(&Type{Name: "varchar", OID: VarcharOID, Codec: TextCodec{}})
m.RegisterType(&Type{Name: "xid", OID: XIDOID, Codec: Uint32Codec{}}) 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: "daterange", OID: DaterangeOID, Codec: &RangeCodec{ElementType: m.oidToType[DateOID]}})
m.RegisterType(&Type{Name: "int4range", OID: Int4rangeOID, Codec: &RangeCodec[Int4]{ElementType: m.oidToType[Int4OID]}}) m.RegisterType(&Type{Name: "int4range", OID: Int4rangeOID, Codec: &RangeCodec{ElementType: m.oidToType[Int4OID]}})
m.RegisterType(&Type{Name: "int8range", OID: Int8rangeOID, Codec: &RangeCodec[Int8]{ElementType: m.oidToType[Int8OID]}}) m.RegisterType(&Type{Name: "int8range", OID: Int8rangeOID, Codec: &RangeCodec{ElementType: m.oidToType[Int8OID]}})
m.RegisterType(&Type{Name: "numrange", OID: NumrangeOID, Codec: &RangeCodec[Numeric]{ElementType: m.oidToType[NumericOID]}}) m.RegisterType(&Type{Name: "numrange", OID: NumrangeOID, Codec: &RangeCodec{ElementType: m.oidToType[NumericOID]}})
m.RegisterType(&Type{Name: "tsrange", OID: TsrangeOID, Codec: &RangeCodec[Timestamp]{ElementType: m.oidToType[TimestampOID]}}) m.RegisterType(&Type{Name: "tsrange", OID: TsrangeOID, Codec: &RangeCodec{ElementType: m.oidToType[TimestampOID]}})
m.RegisterType(&Type{Name: "tstzrange", OID: TstzrangeOID, Codec: &RangeCodec[Timestamptz]{ElementType: m.oidToType[TimestamptzOID]}}) 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: "_aclitem", OID: ACLItemArrayOID, Codec: &ArrayCodec{ElementType: m.oidToType[ACLItemOID]}})
m.RegisterType(&Type{Name: "_bit", OID: BitArrayOID, Codec: &ArrayCodec{ElementType: m.oidToType[BitOID]}}) m.RegisterType(&Type{Name: "_bit", OID: BitArrayOID, Codec: &ArrayCodec{ElementType: m.oidToType[BitOID]}})
pgtype/range_codec.go
+24 -24
View File
@@ -35,42 +35,42 @@ type RangeScanner interface {
} }
// RangeCodec is a codec for any range type. // RangeCodec is a codec for any range type.
type RangeCodec[T any] struct { type RangeCodec struct {
ElementType *Type ElementType *Type
} }
func (c *RangeCodec[T]) FormatSupported(format int16) bool { func (c *RangeCodec) FormatSupported(format int16) bool {
return c.ElementType.Codec.FormatSupported(format) return c.ElementType.Codec.FormatSupported(format)
} }
func (c *RangeCodec[T]) PreferredFormat() int16 { func (c *RangeCodec) PreferredFormat() int16 {
if c.FormatSupported(BinaryFormatCode) { if c.FormatSupported(BinaryFormatCode) {
return BinaryFormatCode return BinaryFormatCode
} }
return TextFormatCode 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 { if _, ok := value.(RangeValuer); !ok {
return nil return nil
} }
switch format { switch format {
case BinaryFormatCode: case BinaryFormatCode:
return &encodePlanRangeCodecRangeValuerToBinary[T]{rc: c, m: m} return &encodePlanRangeCodecRangeValuerToBinary{rc: c, m: m}
case TextFormatCode: case TextFormatCode:
return &encodePlanRangeCodecRangeValuerToText[T]{rc: c, m: m} return &encodePlanRangeCodecRangeValuerToText{rc: c, m: m}
} }
return nil return nil
} }
type encodePlanRangeCodecRangeValuerToBinary[T any] struct { type encodePlanRangeCodecRangeValuerToBinary struct {
rc *RangeCodec[T] rc *RangeCodec
m *Map 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) getter := value.(RangeValuer)
if getter.IsNull() { if getter.IsNull() {
@@ -156,12 +156,12 @@ func (plan *encodePlanRangeCodecRangeValuerToBinary[T]) Encode(value any, buf []
return buf, nil return buf, nil
} }
type encodePlanRangeCodecRangeValuerToText[T any] struct { type encodePlanRangeCodecRangeValuerToText struct {
rc *RangeCodec[T] rc *RangeCodec
m *Map 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) getter := value.(RangeValuer)
if getter.IsNull() { if getter.IsNull() {
@@ -234,29 +234,29 @@ func (plan *encodePlanRangeCodecRangeValuerToText[T]) Encode(value any, buf []by
return buf, nil 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 { switch format {
case BinaryFormatCode: case BinaryFormatCode:
switch target.(type) { switch target.(type) {
case RangeScanner: case RangeScanner:
return &scanPlanBinaryRangeToRangeScanner[T]{rc: c, m: m} return &scanPlanBinaryRangeToRangeScanner{rc: c, m: m}
} }
case TextFormatCode: case TextFormatCode:
switch target.(type) { switch target.(type) {
case RangeScanner: case RangeScanner:
return &scanPlanTextRangeToRangeScanner[T]{rc: c, m: m} return &scanPlanTextRangeToRangeScanner{rc: c, m: m}
} }
} }
return nil return nil
} }
type scanPlanBinaryRangeToRangeScanner[T any] struct { type scanPlanBinaryRangeToRangeScanner struct {
rc *RangeCodec[T] rc *RangeCodec
m *Map m *Map
} }
func (plan *scanPlanBinaryRangeToRangeScanner[T]) Scan(src []byte, target any) error { func (plan *scanPlanBinaryRangeToRangeScanner) Scan(src []byte, target any) error {
rangeScanner := (target).(RangeScanner) rangeScanner := (target).(RangeScanner)
if src == nil { if src == nil {
@@ -301,12 +301,12 @@ func (plan *scanPlanBinaryRangeToRangeScanner[T]) Scan(src []byte, target any) e
return rangeScanner.SetBoundTypes(ubr.LowerType, ubr.UpperType) return rangeScanner.SetBoundTypes(ubr.LowerType, ubr.UpperType)
} }
type scanPlanTextRangeToRangeScanner[T any] struct { type scanPlanTextRangeToRangeScanner struct {
rc *RangeCodec[T] rc *RangeCodec
m *Map m *Map
} }
func (plan *scanPlanTextRangeToRangeScanner[T]) Scan(src []byte, target any) error { func (plan *scanPlanTextRangeToRangeScanner) Scan(src []byte, target any) error {
rangeScanner := (target).(RangeScanner) rangeScanner := (target).(RangeScanner)
if src == nil { if src == nil {
@@ -351,7 +351,7 @@ func (plan *scanPlanTextRangeToRangeScanner[T]) Scan(src []byte, target any) err
return rangeScanner.SetBoundTypes(utr.LowerType, utr.UpperType) 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 { if src == nil {
return nil, 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 { if src == nil {
return nil, nil return nil, nil
} }
var r Range[T] var r Range[any]
err := c.PlanScan(m, oid, format, &r).Scan(src, &r) err := c.PlanScan(m, oid, format, &r).Scan(src, &r)
return r, err return r, err
} }
pgtype/range_codec_test.go
+3 -3
View File
@@ -136,9 +136,9 @@ func TestRangeCodecDecodeValue(t *testing.T) {
}{ }{
{ {
sql: `select '[1,5)'::int4range`, sql: `select '[1,5)'::int4range`,
expected: pgtype.Range[pgtype.Int4]{ expected: pgtype.Range[any]{
Lower: pgtype.Int4{Int32: 1, Valid: true}, Lower: int32(1),
Upper: pgtype.Int4{Int32: 5, Valid: true}, Upper: int32(5),
LowerType: pgtype.Inclusive, LowerType: pgtype.Inclusive,
UpperType: pgtype.Exclusive, UpperType: pgtype.Exclusive,
Valid: true, Valid: true,