From 97443487ce93a473d1ba1569f70ef8797904838e Mon Sep 17 00:00:00 2001 From: Jack Christensen Date: Thu, 20 Jan 2022 20:07:09 -0600 Subject: [PATCH] Convert macaddr to Codec --- pgtype/builtin_wrappers.go | 13 + pgtype/macaddr.go | 228 ++++++++-------- pgtype/macaddr_array.go | 505 ----------------------------------- pgtype/macaddr_array_test.go | 262 ------------------ pgtype/macaddr_test.go | 103 +++---- pgtype/pgtype.go | 2 +- 6 files changed, 164 insertions(+), 949 deletions(-) delete mode 100644 pgtype/macaddr_array.go delete mode 100644 pgtype/macaddr_array_test.go diff --git a/pgtype/builtin_wrappers.go b/pgtype/builtin_wrappers.go index 3c8d23fb..873afe53 100644 --- a/pgtype/builtin_wrappers.go +++ b/pgtype/builtin_wrappers.go @@ -299,6 +299,19 @@ type stringWrapper string func (w stringWrapper) SkipUnderlyingTypePlan() {} +func (w *stringWrapper) ScanText(v Text) error { + if !v.Valid { + return fmt.Errorf("cannot scan NULL into *string") + } + + *w = stringWrapper(v.String) + return nil +} + +func (w stringWrapper) TextValue() (Text, error) { + return Text{String: string(w), Valid: true}, nil +} + func (w *stringWrapper) ScanInt64(v Int8) error { if !v.Valid { return fmt.Errorf("cannot scan NULL into *string") diff --git a/pgtype/macaddr.go b/pgtype/macaddr.go index 8d6ab720..0ac003ae 100644 --- a/pgtype/macaddr.go +++ b/pgtype/macaddr.go @@ -2,92 +2,135 @@ package pgtype import ( "database/sql/driver" - "fmt" "net" ) -type Macaddr struct { - Addr net.HardwareAddr - Valid bool +type MacaddrCodec struct{} + +func (MacaddrCodec) FormatSupported(format int16) bool { + return format == TextFormatCode || format == BinaryFormatCode } -func (dst *Macaddr) Set(src interface{}) error { - if src == nil { - *dst = Macaddr{} - return nil - } +func (MacaddrCodec) PreferredFormat() int16 { + return BinaryFormatCode +} - if value, ok := src.(interface{ Get() interface{} }); ok { - value2 := value.Get() - if value2 != value { - return dst.Set(value2) - } - } +func (MacaddrCodec) PlanEncode(ci *ConnInfo, oid uint32, format int16, value interface{}) EncodePlan { + switch format { + case BinaryFormatCode: + switch value.(type) { + case net.HardwareAddr: + return encodePlanMacaddrCodecBinaryHardwareAddr{} + case TextValuer: + return encodePlanMacAddrCodecTextValuer{} - switch value := src.(type) { - case net.HardwareAddr: - addr := make(net.HardwareAddr, len(value)) - copy(addr, value) - *dst = Macaddr{Addr: addr, Valid: true} - case string: - addr, err := net.ParseMAC(value) - if err != nil { - return err } - *dst = Macaddr{Addr: addr, Valid: true} - case *net.HardwareAddr: - if value == nil { - *dst = Macaddr{} - } else { - return dst.Set(*value) + case TextFormatCode: + switch value.(type) { + case net.HardwareAddr: + return encodePlanMacaddrCodecTextHardwareAddr{} + case TextValuer: + return encodePlanTextCodecTextValuer{} } - case *string: - if value == nil { - *dst = Macaddr{} - } else { - return dst.Set(*value) - } - default: - if originalSrc, ok := underlyingPtrType(src); ok { - return dst.Set(originalSrc) - } - return fmt.Errorf("cannot convert %v to Macaddr", value) } return nil } -func (dst Macaddr) Get() interface{} { - if !dst.Valid { - return nil +type encodePlanMacaddrCodecBinaryHardwareAddr struct{} + +func (encodePlanMacaddrCodecBinaryHardwareAddr) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + addr := value.(net.HardwareAddr) + if addr == nil { + return nil, nil } - return dst.Addr + + return append(buf, addr...), nil } -func (src *Macaddr) AssignTo(dst interface{}) error { - if !src.Valid { - return NullAssignTo(dst) +type encodePlanMacAddrCodecTextValuer struct{} + +func (encodePlanMacAddrCodecTextValuer) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + t, err := value.(TextValuer).TextValue() + if err != nil { + return nil, err + } + if !t.Valid { + return nil, nil } - switch v := dst.(type) { - case *net.HardwareAddr: - *v = make(net.HardwareAddr, len(src.Addr)) - copy(*v, src.Addr) - return nil - case *string: - *v = src.Addr.String() - return nil - default: - if nextDst, retry := GetAssignToDstType(dst); retry { - return src.AssignTo(nextDst) + addr, err := net.ParseMAC(t.String) + if err != nil { + return nil, err + } + + return append(buf, addr...), nil +} + +type encodePlanMacaddrCodecTextHardwareAddr struct{} + +func (encodePlanMacaddrCodecTextHardwareAddr) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + addr := value.(net.HardwareAddr) + if addr == nil { + return nil, nil + } + + return append(buf, addr.String()...), nil +} + +func (MacaddrCodec) PlanScan(ci *ConnInfo, oid uint32, format int16, target interface{}, actualTarget bool) ScanPlan { + switch format { + case BinaryFormatCode: + switch target.(type) { + case *net.HardwareAddr: + return scanPlanBinaryMacaddrToHardwareAddr{} + case TextScanner: + return scanPlanBinaryMacaddrToTextScanner{} + } + case TextFormatCode: + switch target.(type) { + case *net.HardwareAddr: + return scanPlanTextMacaddrToHardwareAddr{} + case TextScanner: + return scanPlanTextAnyToTextScanner{} } - return fmt.Errorf("unable to assign to %T", dst) } + + return nil } -func (dst *Macaddr) DecodeText(ci *ConnInfo, src []byte) error { +type scanPlanBinaryMacaddrToHardwareAddr struct{} + +func (scanPlanBinaryMacaddrToHardwareAddr) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + dstBuf := dst.(*net.HardwareAddr) if src == nil { - *dst = Macaddr{} + *dstBuf = nil + return nil + } + + *dstBuf = make([]byte, len(src)) + copy(*dstBuf, src) + return nil +} + +type scanPlanBinaryMacaddrToTextScanner struct{} + +func (scanPlanBinaryMacaddrToTextScanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + scanner := (dst).(TextScanner) + if src == nil { + return scanner.ScanText(Text{}) + } + + return scanner.ScanText(Text{String: net.HardwareAddr(src).String(), Valid: true}) +} + +type scanPlanTextMacaddrToHardwareAddr struct{} + +func (scanPlanTextMacaddrToHardwareAddr) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + p := dst.(*net.HardwareAddr) + + if src == nil { + *p = nil return nil } @@ -96,65 +139,24 @@ func (dst *Macaddr) DecodeText(ci *ConnInfo, src []byte) error { return err } - *dst = Macaddr{Addr: addr, Valid: true} - return nil -} - -func (dst *Macaddr) DecodeBinary(ci *ConnInfo, src []byte) error { - if src == nil { - *dst = Macaddr{} - return nil - } - - if len(src) != 6 { - return fmt.Errorf("Received an invalid size for a macaddr: %d", len(src)) - } - - addr := make(net.HardwareAddr, 6) - copy(addr, src) - - *dst = Macaddr{Addr: addr, Valid: true} + *p = addr return nil } -func (src Macaddr) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - return append(buf, src.Addr.String()...), nil +func (c MacaddrCodec) DecodeDatabaseSQLValue(ci *ConnInfo, oid uint32, format int16, src []byte) (driver.Value, error) { + return codecDecodeToTextFormat(c, ci, oid, format, src) } -// EncodeBinary encodes src into w. -func (src Macaddr) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - return append(buf, src.Addr...), nil -} - -// Scan implements the database/sql Scanner interface. -func (dst *Macaddr) Scan(src interface{}) error { +func (c MacaddrCodec) DecodeValue(ci *ConnInfo, oid uint32, format int16, src []byte) (interface{}, error) { if src == nil { - *dst = Macaddr{} - return nil + return nil, 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) + var addr net.HardwareAddr + err := codecScan(c, ci, oid, format, src, &addr) + if err != nil { + return nil, err } - - return fmt.Errorf("cannot scan %T", src) -} - -// Value implements the database/sql/driver Valuer interface. -func (src Macaddr) Value() (driver.Value, error) { - return EncodeValueText(src) + return addr, nil } diff --git a/pgtype/macaddr_array.go b/pgtype/macaddr_array.go deleted file mode 100644 index 78a93a2d..00000000 --- a/pgtype/macaddr_array.go +++ /dev/null @@ -1,505 +0,0 @@ -// Code generated by erb. DO NOT EDIT. - -package pgtype - -import ( - "database/sql/driver" - "encoding/binary" - "fmt" - "net" - "reflect" - - "github.com/jackc/pgio" -) - -type MacaddrArray struct { - Elements []Macaddr - Dimensions []ArrayDimension - Valid bool -} - -func (dst *MacaddrArray) Set(src interface{}) error { - // untyped nil and typed nil interfaces are different - if src == nil { - *dst = MacaddrArray{} - return nil - } - - if value, ok := src.(interface{ Get() interface{} }); ok { - value2 := value.Get() - if value2 != value { - return dst.Set(value2) - } - } - - // Attempt to match to select common types: - switch value := src.(type) { - - case []net.HardwareAddr: - if value == nil { - *dst = MacaddrArray{} - } else if len(value) == 0 { - *dst = MacaddrArray{Valid: true} - } else { - elements := make([]Macaddr, len(value)) - for i := range value { - if err := elements[i].Set(value[i]); err != nil { - return err - } - } - *dst = MacaddrArray{ - Elements: elements, - Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, - Valid: true, - } - } - - case []*net.HardwareAddr: - if value == nil { - *dst = MacaddrArray{} - } else if len(value) == 0 { - *dst = MacaddrArray{Valid: true} - } else { - elements := make([]Macaddr, len(value)) - for i := range value { - if err := elements[i].Set(value[i]); err != nil { - return err - } - } - *dst = MacaddrArray{ - Elements: elements, - Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, - Valid: true, - } - } - - case []Macaddr: - if value == nil { - *dst = MacaddrArray{} - } else if len(value) == 0 { - *dst = MacaddrArray{Valid: true} - } else { - *dst = MacaddrArray{ - Elements: value, - Dimensions: []ArrayDimension{{Length: int32(len(value)), LowerBound: 1}}, - Valid: true, - } - } - default: - // Fallback to reflection if an optimised match was not found. - // The reflection is necessary for arrays and multidimensional slices, - // but it comes with a 20-50% performance penalty for large arrays/slices - reflectedValue := reflect.ValueOf(src) - if !reflectedValue.IsValid() || reflectedValue.IsZero() { - *dst = MacaddrArray{} - return nil - } - - dimensions, elementsLength, ok := findDimensionsFromValue(reflectedValue, nil, 0) - if !ok { - return fmt.Errorf("cannot find dimensions of %v for MacaddrArray", src) - } - if elementsLength == 0 { - *dst = MacaddrArray{Valid: true} - return nil - } - if len(dimensions) == 0 { - if originalSrc, ok := underlyingSliceType(src); ok { - return dst.Set(originalSrc) - } - return fmt.Errorf("cannot convert %v to MacaddrArray", src) - } - - *dst = MacaddrArray{ - Elements: make([]Macaddr, elementsLength), - Dimensions: dimensions, - Valid: true, - } - elementCount, err := dst.setRecursive(reflectedValue, 0, 0) - if err != nil { - // Maybe the target was one dimension too far, try again: - if len(dst.Dimensions) > 1 { - dst.Dimensions = dst.Dimensions[:len(dst.Dimensions)-1] - elementsLength = 0 - for _, dim := range dst.Dimensions { - if elementsLength == 0 { - elementsLength = int(dim.Length) - } else { - elementsLength *= int(dim.Length) - } - } - dst.Elements = make([]Macaddr, elementsLength) - elementCount, err = dst.setRecursive(reflectedValue, 0, 0) - if err != nil { - return err - } - } else { - return err - } - } - if elementCount != len(dst.Elements) { - return fmt.Errorf("cannot convert %v to MacaddrArray, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount) - } - } - - return nil -} - -func (dst *MacaddrArray) setRecursive(value reflect.Value, index, dimension int) (int, error) { - switch value.Kind() { - case reflect.Array: - fallthrough - case reflect.Slice: - if len(dst.Dimensions) == dimension { - break - } - - valueLen := value.Len() - if int32(valueLen) != dst.Dimensions[dimension].Length { - return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions") - } - for i := 0; i < valueLen; i++ { - var err error - index, err = dst.setRecursive(value.Index(i), index, dimension+1) - if err != nil { - return 0, err - } - } - - return index, nil - } - if !value.CanInterface() { - return 0, fmt.Errorf("cannot convert all values to MacaddrArray") - } - if err := dst.Elements[index].Set(value.Interface()); err != nil { - return 0, fmt.Errorf("%v in MacaddrArray", err) - } - index++ - - return index, nil -} - -func (dst MacaddrArray) Get() interface{} { - if !dst.Valid { - return nil - } - return dst -} - -func (src *MacaddrArray) AssignTo(dst interface{}) error { - if !src.Valid { - return NullAssignTo(dst) - } - - if len(src.Dimensions) <= 1 { - // Attempt to match to select common types: - switch v := dst.(type) { - - case *[]net.HardwareAddr: - *v = make([]net.HardwareAddr, len(src.Elements)) - for i := range src.Elements { - if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { - return err - } - } - return nil - - case *[]*net.HardwareAddr: - *v = make([]*net.HardwareAddr, len(src.Elements)) - for i := range src.Elements { - if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { - return err - } - } - return nil - - } - } - - // Try to convert to something AssignTo can use directly. - if nextDst, retry := GetAssignToDstType(dst); retry { - return src.AssignTo(nextDst) - } - - // Fallback to reflection if an optimised match was not found. - // The reflection is necessary for arrays and multidimensional slices, - // but it comes with a 20-50% performance penalty for large arrays/slices - value := reflect.ValueOf(dst) - if value.Kind() == reflect.Ptr { - value = value.Elem() - } - - switch value.Kind() { - case reflect.Array, reflect.Slice: - default: - return fmt.Errorf("cannot assign %T to %T", src, dst) - } - - if len(src.Elements) == 0 { - if value.Kind() == reflect.Slice { - value.Set(reflect.MakeSlice(value.Type(), 0, 0)) - return nil - } - } - - elementCount, err := src.assignToRecursive(value, 0, 0) - if err != nil { - return err - } - if elementCount != len(src.Elements) { - return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount) - } - - return nil -} - -func (src *MacaddrArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) { - switch kind := value.Kind(); kind { - case reflect.Array: - fallthrough - case reflect.Slice: - if len(src.Dimensions) == dimension { - break - } - - length := int(src.Dimensions[dimension].Length) - if reflect.Array == kind { - typ := value.Type() - if typ.Len() != length { - return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len()) - } - value.Set(reflect.New(typ).Elem()) - } else { - value.Set(reflect.MakeSlice(value.Type(), length, length)) - } - - var err error - for i := 0; i < length; i++ { - index, err = src.assignToRecursive(value.Index(i), index, dimension+1) - if err != nil { - return 0, err - } - } - - return index, nil - } - if len(src.Dimensions) != dimension { - return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension) - } - if !value.CanAddr() { - return 0, fmt.Errorf("cannot assign all values from MacaddrArray") - } - addr := value.Addr() - if !addr.CanInterface() { - return 0, fmt.Errorf("cannot assign all values from MacaddrArray") - } - if err := src.Elements[index].AssignTo(addr.Interface()); err != nil { - return 0, err - } - index++ - return index, nil -} - -func (dst *MacaddrArray) DecodeText(ci *ConnInfo, src []byte) error { - if src == nil { - *dst = MacaddrArray{} - return nil - } - - uta, err := ParseUntypedTextArray(string(src)) - if err != nil { - return err - } - - var elements []Macaddr - - if len(uta.Elements) > 0 { - elements = make([]Macaddr, len(uta.Elements)) - - for i, s := range uta.Elements { - var elem Macaddr - var elemSrc []byte - if s != "NULL" || uta.Quoted[i] { - elemSrc = []byte(s) - } - err = elem.DecodeText(ci, elemSrc) - if err != nil { - return err - } - - elements[i] = elem - } - } - - *dst = MacaddrArray{Elements: elements, Dimensions: uta.Dimensions, Valid: true} - - return nil -} - -func (dst *MacaddrArray) DecodeBinary(ci *ConnInfo, src []byte) error { - if src == nil { - *dst = MacaddrArray{} - return nil - } - - var arrayHeader ArrayHeader - rp, err := arrayHeader.DecodeBinary(ci, src) - if err != nil { - return err - } - - if len(arrayHeader.Dimensions) == 0 { - *dst = MacaddrArray{Dimensions: arrayHeader.Dimensions, Valid: true} - return nil - } - - elementCount := arrayHeader.Dimensions[0].Length - for _, d := range arrayHeader.Dimensions[1:] { - elementCount *= d.Length - } - - elements := make([]Macaddr, elementCount) - - for i := range elements { - elemLen := int(int32(binary.BigEndian.Uint32(src[rp:]))) - rp += 4 - var elemSrc []byte - if elemLen >= 0 { - elemSrc = src[rp : rp+elemLen] - rp += elemLen - } - err = elements[i].DecodeBinary(ci, elemSrc) - if err != nil { - return err - } - } - - *dst = MacaddrArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Valid: true} - return nil -} - -func (src MacaddrArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - if len(src.Dimensions) == 0 { - return append(buf, '{', '}'), nil - } - - buf = EncodeTextArrayDimensions(buf, src.Dimensions) - - // dimElemCounts is the multiples of elements that each array lies on. For - // example, a single dimension array of length 4 would have a dimElemCounts of - // [4]. A multi-dimensional array of lengths [3,5,2] would have a - // dimElemCounts of [30,10,2]. This is used to simplify when to render a '{' - // or '}'. - dimElemCounts := make([]int, len(src.Dimensions)) - dimElemCounts[len(src.Dimensions)-1] = int(src.Dimensions[len(src.Dimensions)-1].Length) - for i := len(src.Dimensions) - 2; i > -1; i-- { - dimElemCounts[i] = int(src.Dimensions[i].Length) * dimElemCounts[i+1] - } - - inElemBuf := make([]byte, 0, 32) - for i, elem := range src.Elements { - if i > 0 { - buf = append(buf, ',') - } - - for _, dec := range dimElemCounts { - if i%dec == 0 { - buf = append(buf, '{') - } - } - - elemBuf, err := elem.EncodeText(ci, inElemBuf) - if err != nil { - return nil, err - } - if elemBuf == nil { - buf = append(buf, `NULL`...) - } else { - buf = append(buf, QuoteArrayElementIfNeeded(string(elemBuf))...) - } - - for _, dec := range dimElemCounts { - if (i+1)%dec == 0 { - buf = append(buf, '}') - } - } - } - - return buf, nil -} - -func (src MacaddrArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - arrayHeader := ArrayHeader{ - Dimensions: src.Dimensions, - } - - if dt, ok := ci.DataTypeForName("macaddr"); ok { - arrayHeader.ElementOID = int32(dt.OID) - } else { - return nil, fmt.Errorf("unable to find oid for type name %v", "macaddr") - } - - for i := range src.Elements { - if !src.Elements[i].Valid { - arrayHeader.ContainsNull = true - break - } - } - - buf = arrayHeader.EncodeBinary(ci, buf) - - for i := range src.Elements { - sp := len(buf) - buf = pgio.AppendInt32(buf, -1) - - elemBuf, err := src.Elements[i].EncodeBinary(ci, buf) - if err != nil { - return nil, err - } - if elemBuf != nil { - buf = elemBuf - pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4)) - } - } - - return buf, nil -} - -// Scan implements the database/sql Scanner interface. -func (dst *MacaddrArray) Scan(src interface{}) error { - if src == nil { - return dst.DecodeText(nil, 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 MacaddrArray) Value() (driver.Value, error) { - buf, err := src.EncodeText(nil, nil) - if err != nil { - return nil, err - } - if buf == nil { - return nil, nil - } - - return string(buf), nil -} diff --git a/pgtype/macaddr_array_test.go b/pgtype/macaddr_array_test.go deleted file mode 100644 index ac76a052..00000000 --- a/pgtype/macaddr_array_test.go +++ /dev/null @@ -1,262 +0,0 @@ -package pgtype_test - -import ( - "net" - "reflect" - "testing" - - "github.com/jackc/pgx/v5/pgtype" - "github.com/jackc/pgx/v5/pgtype/testutil" -) - -func TestMacaddrArrayTranscode(t *testing.T) { - testutil.TestSuccessfulTranscode(t, "macaddr[]", []interface{}{ - &pgtype.MacaddrArray{ - Elements: nil, - Dimensions: nil, - Valid: true, - }, - &pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {}, - }, - Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}}, - Valid: true, - }, - &pgtype.MacaddrArray{}, - }) -} - -func TestMacaddrArraySet(t *testing.T) { - successfulTests := []struct { - source interface{} - result pgtype.MacaddrArray - }{ - { - source: []net.HardwareAddr{mustParseMacaddr(t, "01:23:45:67:89:ab")}, - result: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{{Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: (([]net.HardwareAddr)(nil)), - result: pgtype.MacaddrArray{}, - }, - { - source: [][]net.HardwareAddr{ - {mustParseMacaddr(t, "01:23:45:67:89:ab")}, - {mustParseMacaddr(t, "cd:ef:01:23:45:67")}}, - result: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: [][][][]net.HardwareAddr{ - {{{ - mustParseMacaddr(t, "01:23:45:67:89:ab"), - mustParseMacaddr(t, "cd:ef:01:23:45:67"), - mustParseMacaddr(t, "89:ab:cd:ef:01:23")}}}, - {{{ - mustParseMacaddr(t, "45:67:89:ab:cd:ef"), - mustParseMacaddr(t, "fe:dc:ba:98:76:54"), - mustParseMacaddr(t, "32:10:fe:dc:ba:98")}}}}, - result: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}, - {Addr: mustParseMacaddr(t, "89:ab:cd:ef:01:23"), Valid: true}, - {Addr: mustParseMacaddr(t, "45:67:89:ab:cd:ef"), Valid: true}, - {Addr: mustParseMacaddr(t, "fe:dc:ba:98:76:54"), Valid: true}, - {Addr: mustParseMacaddr(t, "32:10:fe:dc:ba:98"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - }, - { - source: [2][1]net.HardwareAddr{ - {mustParseMacaddr(t, "01:23:45:67:89:ab")}, - {mustParseMacaddr(t, "cd:ef:01:23:45:67")}}, - result: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: [2][1][1][3]net.HardwareAddr{ - {{{ - mustParseMacaddr(t, "01:23:45:67:89:ab"), - mustParseMacaddr(t, "cd:ef:01:23:45:67"), - mustParseMacaddr(t, "89:ab:cd:ef:01:23")}}}, - {{{ - mustParseMacaddr(t, "45:67:89:ab:cd:ef"), - mustParseMacaddr(t, "fe:dc:ba:98:76:54"), - mustParseMacaddr(t, "32:10:fe:dc:ba:98")}}}}, - result: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}, - {Addr: mustParseMacaddr(t, "89:ab:cd:ef:01:23"), Valid: true}, - {Addr: mustParseMacaddr(t, "45:67:89:ab:cd:ef"), Valid: true}, - {Addr: mustParseMacaddr(t, "fe:dc:ba:98:76:54"), Valid: true}, - {Addr: mustParseMacaddr(t, "32:10:fe:dc:ba:98"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - }, - } - - for i, tt := range successfulTests { - var r pgtype.MacaddrArray - err := r.Set(tt.source) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if !reflect.DeepEqual(r, tt.result) { - t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, r) - } - } -} - -func TestMacaddrArrayAssignTo(t *testing.T) { - var macaddrSlice []net.HardwareAddr - var macaddrSliceDim2 [][]net.HardwareAddr - var macaddrSliceDim4 [][][][]net.HardwareAddr - var macaddrArrayDim2 [2][1]net.HardwareAddr - var macaddrArrayDim4 [2][1][1][3]net.HardwareAddr - - simpleTests := []struct { - src pgtype.MacaddrArray - dst interface{} - expected interface{} - }{ - { - src: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{{Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &macaddrSlice, - expected: []net.HardwareAddr{mustParseMacaddr(t, "01:23:45:67:89:ab")}, - }, - { - src: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{{}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &macaddrSlice, - expected: []net.HardwareAddr{nil}, - }, - { - src: pgtype.MacaddrArray{}, - dst: &macaddrSlice, - expected: (([]net.HardwareAddr)(nil)), - }, - { - src: pgtype.MacaddrArray{Valid: true}, - dst: &macaddrSlice, - expected: []net.HardwareAddr{}, - }, - { - src: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - dst: &macaddrSliceDim2, - expected: [][]net.HardwareAddr{ - {mustParseMacaddr(t, "01:23:45:67:89:ab")}, - {mustParseMacaddr(t, "cd:ef:01:23:45:67")}}, - }, - { - src: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}, - {Addr: mustParseMacaddr(t, "89:ab:cd:ef:01:23"), Valid: true}, - {Addr: mustParseMacaddr(t, "45:67:89:ab:cd:ef"), Valid: true}, - {Addr: mustParseMacaddr(t, "fe:dc:ba:98:76:54"), Valid: true}, - {Addr: mustParseMacaddr(t, "32:10:fe:dc:ba:98"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - dst: &macaddrSliceDim4, - expected: [][][][]net.HardwareAddr{ - {{{ - mustParseMacaddr(t, "01:23:45:67:89:ab"), - mustParseMacaddr(t, "cd:ef:01:23:45:67"), - mustParseMacaddr(t, "89:ab:cd:ef:01:23")}}}, - {{{ - mustParseMacaddr(t, "45:67:89:ab:cd:ef"), - mustParseMacaddr(t, "fe:dc:ba:98:76:54"), - mustParseMacaddr(t, "32:10:fe:dc:ba:98")}}}}, - }, - { - src: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - dst: &macaddrArrayDim2, - expected: [2][1]net.HardwareAddr{ - {mustParseMacaddr(t, "01:23:45:67:89:ab")}, - {mustParseMacaddr(t, "cd:ef:01:23:45:67")}}, - }, - { - src: pgtype.MacaddrArray{ - Elements: []pgtype.Macaddr{ - {Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - {Addr: mustParseMacaddr(t, "cd:ef:01:23:45:67"), Valid: true}, - {Addr: mustParseMacaddr(t, "89:ab:cd:ef:01:23"), Valid: true}, - {Addr: mustParseMacaddr(t, "45:67:89:ab:cd:ef"), Valid: true}, - {Addr: mustParseMacaddr(t, "fe:dc:ba:98:76:54"), Valid: true}, - {Addr: mustParseMacaddr(t, "32:10:fe:dc:ba:98"), Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - dst: &macaddrArrayDim4, - expected: [2][1][1][3]net.HardwareAddr{ - {{{ - mustParseMacaddr(t, "01:23:45:67:89:ab"), - mustParseMacaddr(t, "cd:ef:01:23:45:67"), - mustParseMacaddr(t, "89:ab:cd:ef:01:23")}}}, - {{{ - mustParseMacaddr(t, "45:67:89:ab:cd:ef"), - mustParseMacaddr(t, "fe:dc:ba:98:76:54"), - mustParseMacaddr(t, "32:10:fe:dc:ba:98")}}}}, - }, - } - - for i, tt := range simpleTests { - err := tt.src.AssignTo(tt.dst) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if dst := reflect.ValueOf(tt.dst).Elem().Interface(); !reflect.DeepEqual(dst, tt.expected) { - t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst) - } - } -} diff --git a/pgtype/macaddr_test.go b/pgtype/macaddr_test.go index 5b9d8d88..3e59c580 100644 --- a/pgtype/macaddr_test.go +++ b/pgtype/macaddr_test.go @@ -3,76 +3,43 @@ package pgtype_test import ( "bytes" "net" - "reflect" "testing" - - "github.com/jackc/pgx/v5/pgtype" - "github.com/jackc/pgx/v5/pgtype/testutil" ) -func TestMacaddrTranscode(t *testing.T) { - testutil.TestSuccessfulTranscode(t, "macaddr", []interface{}{ - &pgtype.Macaddr{Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - &pgtype.Macaddr{}, +func isExpectedEqHardwareAddr(a interface{}) func(interface{}) bool { + return func(v interface{}) bool { + aa := a.(net.HardwareAddr) + vv := v.(net.HardwareAddr) + + if (aa == nil) != (vv == nil) { + return false + } + + if aa == nil { + return true + } + + return bytes.Compare(aa, vv) == 0 + } +} + +func TestMacaddrCodec(t *testing.T) { + testPgxCodec(t, "macaddr", []PgxTranscodeTestCase{ + { + mustParseMacaddr(t, "01:23:45:67:89:ab"), + new(net.HardwareAddr), + isExpectedEqHardwareAddr(mustParseMacaddr(t, "01:23:45:67:89:ab")), + }, + { + "01:23:45:67:89:ab", + new(net.HardwareAddr), + isExpectedEqHardwareAddr(mustParseMacaddr(t, "01:23:45:67:89:ab")), + }, + { + mustParseMacaddr(t, "01:23:45:67:89:ab"), + new(string), + isExpectedEq("01:23:45:67:89:ab"), + }, + {nil, new(*net.HardwareAddr), isExpectedEq((*net.HardwareAddr)(nil))}, }) } - -func TestMacaddrSet(t *testing.T) { - successfulTests := []struct { - source interface{} - result pgtype.Macaddr - }{ - { - source: mustParseMacaddr(t, "01:23:45:67:89:ab"), - result: pgtype.Macaddr{Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - }, - { - source: "01:23:45:67:89:ab", - result: pgtype.Macaddr{Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true}, - }, - } - - for i, tt := range successfulTests { - var r pgtype.Macaddr - err := r.Set(tt.source) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if !reflect.DeepEqual(r, tt.result) { - t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, r) - } - } -} - -func TestMacaddrAssignTo(t *testing.T) { - { - src := pgtype.Macaddr{Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true} - var dst net.HardwareAddr - expected := mustParseMacaddr(t, "01:23:45:67:89:ab") - - err := src.AssignTo(&dst) - if err != nil { - t.Error(err) - } - - if bytes.Compare([]byte(dst), []byte(expected)) != 0 { - t.Errorf("expected %v to assign %v, but result was %v", src, expected, dst) - } - } - - { - src := pgtype.Macaddr{Addr: mustParseMacaddr(t, "01:23:45:67:89:ab"), Valid: true} - var dst string - expected := "01:23:45:67:89:ab" - - err := src.AssignTo(&dst) - if err != nil { - t.Error(err) - } - - if dst != expected { - t.Errorf("expected %v to assign %v, but result was %v", src, expected, dst) - } - } -} diff --git a/pgtype/pgtype.go b/pgtype/pgtype.go index cb028677..0cc0c062 100644 --- a/pgtype/pgtype.go +++ b/pgtype/pgtype.go @@ -325,7 +325,7 @@ func NewConnInfo() *ConnInfo { ci.RegisterDataType(DataType{Name: "jsonb", OID: JSONBOID, Codec: JSONBCodec{}}) ci.RegisterDataType(DataType{Name: "line", OID: LineOID, Codec: LineCodec{}}) ci.RegisterDataType(DataType{Name: "lseg", OID: LsegOID, Codec: LsegCodec{}}) - ci.RegisterDataType(DataType{Value: &Macaddr{}, Name: "macaddr", OID: MacaddrOID}) + ci.RegisterDataType(DataType{Name: "macaddr", OID: MacaddrOID, Codec: MacaddrCodec{}}) ci.RegisterDataType(DataType{Name: "name", OID: NameOID, Codec: TextCodec{}}) ci.RegisterDataType(DataType{Value: &Numeric{}, Name: "numeric", OID: NumericOID}) // ci.RegisterDataType(DataType{Value: &Numrange{}, Name: "numrange", OID: NumrangeOID})