Replace Status with Valid to conform to database/sql style

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

enum_array.go

@@ -11,13 +11,13 @@ import (
 type EnumArray struct {
 	Elements   []GenericText
 	Dimensions []ArrayDimension
-	Status     Status
+	Valid      bool
 }
 
 func (dst *EnumArray) Set(src interface{}) error {
 	// untyped nil and typed nil interfaces are different
 	if src == nil {
-		*dst = EnumArray{Status: Null}
+		*dst = EnumArray{}
 		return nil
 	}
 
@@ -33,9 +33,9 @@ func (dst *EnumArray) Set(src interface{}) error {
 
 	case []string:
 		if value == nil {
-			*dst = EnumArray{Status: Null}
+			*dst = EnumArray{}
 		} else if len(value) == 0 {
-			*dst = EnumArray{Status: Present}
+			*dst = EnumArray{Valid: true}
 		} else {
 			elements := make([]GenericText, len(value))
 			for i := range value {
@@ -46,15 +46,15 @@ func (dst *EnumArray) Set(src interface{}) error {
 			*dst = EnumArray{
 				Elements:   elements,
 				Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
-				Status:     Present,
+				Valid:      true,
 			}
 		}
 
 	case []*string:
 		if value == nil {
-			*dst = EnumArray{Status: Null}
+			*dst = EnumArray{}
 		} else if len(value) == 0 {
-			*dst = EnumArray{Status: Present}
+			*dst = EnumArray{Valid: true}
 		} else {
 			elements := make([]GenericText, len(value))
 			for i := range value {
@@ -65,20 +65,20 @@ func (dst *EnumArray) Set(src interface{}) error {
 			*dst = EnumArray{
 				Elements:   elements,
 				Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
-				Status:     Present,
+				Valid:      true,
 			}
 		}
 
 	case []GenericText:
 		if value == nil {
-			*dst = EnumArray{Status: Null}
+			*dst = EnumArray{}
 		} else if len(value) == 0 {
-			*dst = EnumArray{Status: Present}
+			*dst = EnumArray{Valid: true}
 		} else {
 			*dst = EnumArray{
 				Elements:   value,
 				Dimensions: []ArrayDimension{{Length: int32(len(value)), LowerBound: 1}},
-				Status:     Present,
+				Valid:      true,
 			}
 		}
 	default:
@@ -87,7 +87,7 @@ func (dst *EnumArray) 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 = EnumArray{Status: Null}
+			*dst = EnumArray{}
 			return nil
 		}
 
@@ -96,7 +96,7 @@ func (dst *EnumArray) Set(src interface{}) error {
 			return fmt.Errorf("cannot find dimensions of %v for EnumArray", src)
 		}
 		if elementsLength == 0 {
-			*dst = EnumArray{Status: Present}
+			*dst = EnumArray{Valid: true}
 			return nil
 		}
 		if len(dimensions) == 0 {
@@ -109,7 +109,7 @@ func (dst *EnumArray) Set(src interface{}) error {
 		*dst = EnumArray{
 			Elements:   make([]GenericText, elementsLength),
 			Dimensions: dimensions,
-			Status:     Present,
+			Valid:      true,
 		}
 		elementCount, err := dst.setRecursive(reflectedValue, 0, 0)
 		if err != nil {
@@ -176,84 +176,77 @@ func (dst *EnumArray) setRecursive(value reflect.Value, index, dimension int) (i
 }
 
 func (dst EnumArray) Get() interface{} {
-	switch dst.Status {
-	case Present:
-		return dst
-	case Null:
+	if !dst.Valid {
 		return nil
-	default:
-		return dst.Status
 	}
+	return dst
 }
 
 func (src *EnumArray) 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 *[]string:
-				*v = make([]string, len(src.Elements))
-				for i := range src.Elements {
-					if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil {
-						return err
-					}
-				}
-				return nil
-
-			case *[]*string:
-				*v = make([]*string, 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 *[]string:
+			*v = make([]string, len(src.Elements))
+			for i := range src.Elements {
+				if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil {
+					return err
+				}
+			}
+			return nil
+
+		case *[]*string:
+			*v = make([]*string, 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 *EnumArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
@@ -305,7 +298,7 @@ func (src *EnumArray) assignToRecursive(value reflect.Value, index, dimension in
 
 func (dst *EnumArray) DecodeText(ci *ConnInfo, src []byte) error {
 	if src == nil {
-		*dst = EnumArray{Status: Null}
+		*dst = EnumArray{}
 		return nil
 	}
 
@@ -334,17 +327,14 @@ func (dst *EnumArray) DecodeText(ci *ConnInfo, src []byte) error {
 		}
 	}
 
-	*dst = EnumArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
+	*dst = EnumArray{Elements: elements, Dimensions: uta.Dimensions, Valid: true}
 
 	return nil
 }
 
 func (src EnumArray) 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 {