AssignTo pointer to pointer to slice and named types

fixes #69

aclitem_array.go

@@ -219,6 +219,11 @@ func (src *ACLItemArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -226,12 +231,6 @@ func (src *ACLItemArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

bool_array.go

@@ -221,6 +221,11 @@ func (src *BoolArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -228,12 +233,6 @@ func (src *BoolArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

bpchar_array.go

@@ -221,6 +221,11 @@ func (src *BPCharArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -228,12 +233,6 @@ func (src *BPCharArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

bytea_array.go

@@ -193,6 +193,11 @@ func (src *ByteaArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -200,12 +205,6 @@ func (src *ByteaArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

cidr_array.go

@@ -250,6 +250,11 @@ func (src *CIDRArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -257,12 +262,6 @@ func (src *CIDRArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

date_array.go

@@ -222,6 +222,11 @@ func (src *DateArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -229,12 +234,6 @@ func (src *DateArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

enum_array.go

@@ -219,6 +219,11 @@ func (src *EnumArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -226,12 +231,6 @@ func (src *EnumArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

float4_array.go

@@ -221,6 +221,11 @@ func (src *Float4Array) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -228,12 +233,6 @@ func (src *Float4Array) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

float8_array.go

@@ -221,6 +221,11 @@ func (src *Float8Array) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -228,12 +233,6 @@ func (src *Float8Array) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

hstore_array.go

@@ -193,6 +193,11 @@ func (src *HstoreArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -200,12 +205,6 @@ func (src *HstoreArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

inet_array.go

@@ -250,6 +250,11 @@ func (src *InetArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -257,12 +262,6 @@ func (src *InetArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

int2_array.go

@@ -613,6 +613,11 @@ func (src *Int2Array) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -620,12 +625,6 @@ func (src *Int2Array) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

int4_array.go

@@ -613,6 +613,11 @@ func (src *Int4Array) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -620,12 +625,6 @@ func (src *Int4Array) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

int8_array.go

@@ -613,6 +613,11 @@ func (src *Int8Array) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -620,12 +625,6 @@ func (src *Int8Array) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

jsonb_array.go

@@ -221,6 +221,11 @@ func (src *JSONBArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -228,12 +233,6 @@ func (src *JSONBArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

macaddr_array.go

@@ -222,6 +222,11 @@ func (src *MacaddrArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -229,12 +234,6 @@ func (src *MacaddrArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

numeric_array.go

@@ -389,6 +389,11 @@ func (src *NumericArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -396,12 +401,6 @@ func (src *NumericArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

text_array.go

@@ -221,6 +221,11 @@ func (src *TextArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -228,12 +233,6 @@ func (src *TextArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

timestamp_array.go

@@ -222,6 +222,11 @@ func (src *TimestampArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -229,12 +234,6 @@ func (src *TimestampArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

timestamptz_array.go

@@ -222,6 +222,11 @@ func (src *TimestamptzArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -229,12 +234,6 @@ func (src *TimestamptzArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

tstzrange_array.go

@@ -174,6 +174,11 @@ func (src *TstzrangeArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -181,12 +186,6 @@ func (src *TstzrangeArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

typed_array.go.erb

@@ -194,6 +194,11 @@ func (src *<%= pgtype_array_type %>) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -201,12 +206,6 @@ func (src *<%= pgtype_array_type %>) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

uuid_array.go

@@ -277,6 +277,11 @@ func (src *UUIDArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -284,12 +289,6 @@ func (src *UUIDArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {

varchar_array.go

@@ -221,6 +221,11 @@ func (src *VarcharArray) AssignTo(dst interface{}) error {
 			}
 		}
 
+		// 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
@@ -228,12 +233,6 @@ func (src *VarcharArray) AssignTo(dst interface{}) error {
 		if value.Kind() == reflect.Ptr {
 			value = value.Elem()
 		}
-		if !value.CanSet() {
-			if nextDst, retry := GetAssignToDstType(dst); retry {
-				return src.AssignTo(nextDst)
-			}
-			return errors.Errorf("unable to assign to %T", dst)
-		}
 
 		elementCount, err := src.assignToRecursive(value, 0, 0)
 		if err != nil {