Replace Status with Valid to conform to database/sql style

https://github.com/jackc/pgx/issues/1060

macaddr_array.go

@@ -15,13 +15,13 @@ import (
 type MacaddrArray struct {
 	Elements   []Macaddr
 	Dimensions []ArrayDimension
-	Status     Status
+	Valid      bool
 }
 
 func (dst *MacaddrArray) Set(src interface{}) error {
 	// untyped nil and typed nil interfaces are different
 	if src == nil {
-		*dst = MacaddrArray{Status: Null}
+		*dst = MacaddrArray{}
 		return nil
 	}
 
@@ -37,9 +37,9 @@ func (dst *MacaddrArray) Set(src interface{}) error {
 
 	case []net.HardwareAddr:
 		if value == nil {
-			*dst = MacaddrArray{Status: Null}
+			*dst = MacaddrArray{}
 		} else if len(value) == 0 {
-			*dst = MacaddrArray{Status: Present}
+			*dst = MacaddrArray{Valid: true}
 		} else {
 			elements := make([]Macaddr, len(value))
 			for i := range value {
@@ -50,15 +50,15 @@ func (dst *MacaddrArray) Set(src interface{}) error {
 			*dst = MacaddrArray{
 				Elements:   elements,
 				Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
-				Status:     Present,
+				Valid:      true,
 			}
 		}
 
 	case []*net.HardwareAddr:
 		if value == nil {
-			*dst = MacaddrArray{Status: Null}
+			*dst = MacaddrArray{}
 		} else if len(value) == 0 {
-			*dst = MacaddrArray{Status: Present}
+			*dst = MacaddrArray{Valid: true}
 		} else {
 			elements := make([]Macaddr, len(value))
 			for i := range value {
@@ -69,20 +69,20 @@ func (dst *MacaddrArray) Set(src interface{}) error {
 			*dst = MacaddrArray{
 				Elements:   elements,
 				Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
-				Status:     Present,
+				Valid:      true,
 			}
 		}
 
 	case []Macaddr:
 		if value == nil {
-			*dst = MacaddrArray{Status: Null}
+			*dst = MacaddrArray{}
 		} else if len(value) == 0 {
-			*dst = MacaddrArray{Status: Present}
+			*dst = MacaddrArray{Valid: true}
 		} else {
 			*dst = MacaddrArray{
 				Elements:   value,
 				Dimensions: []ArrayDimension{{Length: int32(len(value)), LowerBound: 1}},
-				Status:     Present,
+				Valid:      true,
 			}
 		}
 	default:
@@ -91,7 +91,7 @@ func (dst *MacaddrArray) Set(src interface{}) error {
 		// but it comes with a 20-50% performance penalty for large arrays/slices
 		reflectedValue := reflect.ValueOf(src)
 		if !reflectedValue.IsValid() || reflectedValue.IsZero() {
-			*dst = MacaddrArray{Status: Null}
+			*dst = MacaddrArray{}
 			return nil
 		}
 
@@ -100,7 +100,7 @@ func (dst *MacaddrArray) Set(src interface{}) error {
 			return fmt.Errorf("cannot find dimensions of %v for MacaddrArray", src)
 		}
 		if elementsLength == 0 {
-			*dst = MacaddrArray{Status: Present}
+			*dst = MacaddrArray{Valid: true}
 			return nil
 		}
 		if len(dimensions) == 0 {
@@ -113,7 +113,7 @@ func (dst *MacaddrArray) Set(src interface{}) error {
 		*dst = MacaddrArray{
 			Elements:   make([]Macaddr, elementsLength),
 			Dimensions: dimensions,
-			Status:     Present,
+			Valid:      true,
 		}
 		elementCount, err := dst.setRecursive(reflectedValue, 0, 0)
 		if err != nil {
@@ -180,84 +180,77 @@ func (dst *MacaddrArray) setRecursive(value reflect.Value, index, dimension int)
 }
 
 func (dst MacaddrArray) Get() interface{} {
-	switch dst.Status {
-	case Present:
-		return dst
-	case Null:
+	if !dst.Valid {
 		return nil
-	default:
-		return dst.Status
 	}
+	return dst
 }
 
 func (src *MacaddrArray) AssignTo(dst interface{}) error {
-	switch src.Status {
-	case Present:
-		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
-	case Null:
+	if !src.Valid {
 		return NullAssignTo(dst)
 	}
 
-	return fmt.Errorf("cannot decode %#v into %T", src, 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) {
@@ -309,7 +302,7 @@ func (src *MacaddrArray) assignToRecursive(value reflect.Value, index, dimension
 
 func (dst *MacaddrArray) DecodeText(ci *ConnInfo, src []byte) error {
 	if src == nil {
-		*dst = MacaddrArray{Status: Null}
+		*dst = MacaddrArray{}
 		return nil
 	}
 
@@ -338,14 +331,14 @@ func (dst *MacaddrArray) DecodeText(ci *ConnInfo, src []byte) error {
 		}
 	}
 
-	*dst = MacaddrArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
+	*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{Status: Null}
+		*dst = MacaddrArray{}
 		return nil
 	}
 
@@ -356,7 +349,7 @@ func (dst *MacaddrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
 	}
 
 	if len(arrayHeader.Dimensions) == 0 {
-		*dst = MacaddrArray{Dimensions: arrayHeader.Dimensions, Status: Present}
+		*dst = MacaddrArray{Dimensions: arrayHeader.Dimensions, Valid: true}
 		return nil
 	}
 
@@ -381,16 +374,13 @@ func (dst *MacaddrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
 		}
 	}
 
-	*dst = MacaddrArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Status: Present}
+	*dst = MacaddrArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Valid: true}
 	return nil
 }
 
 func (src MacaddrArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
-	switch src.Status {
-	case Null:
+	if !src.Valid {
 		return nil, nil
-	case Undefined:
-		return nil, errUndefined
 	}
 
 	if len(src.Dimensions) == 0 {
@@ -443,11 +433,8 @@ func (src MacaddrArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
 }
 
 func (src MacaddrArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
-	switch src.Status {
-	case Null:
+	if !src.Valid {
 		return nil, nil
-	case Undefined:
-		return nil, errUndefined
 	}
 
 	arrayHeader := ArrayHeader{
@@ -461,7 +448,7 @@ func (src MacaddrArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
 	}
 
 	for i := range src.Elements {
-		if src.Elements[i].Status == Null {
+		if !src.Elements[i].Valid {
 			arrayHeader.ContainsNull = true
 			break
 		}