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: "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]}})
pgtype/range_codec.go
+24 -24
View File
@@ -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
}
pgtype/range_codec_test.go
+3 -3
View File
@@ -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,