Adds checks for zero length arrays.

Assigning values from nil or zero length elements or dimensions now return immediately as there are no values to assign.

aclitem_array.go

@@ -190,6 +190,10 @@ func (dst ACLItemArray) Get() interface{} {
 func (src *ACLItemArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

aclitem_array_test.go

@@ -189,6 +189,11 @@ func TestACLItemArrayAssignTo(t *testing.T) {
 			dst:      &stringSlice,
 			expected: (([]string)(nil)),
 		},
+		{
+			src:      pgtype.ACLItemArray{Status: pgtype.Present},
+			dst:      &stringSlice,
+			expected: (([]string)(nil)),
+		},
 		{
 			src: pgtype.ACLItemArray{
 				Elements: []pgtype.ACLItem{

bool_array.go

@@ -192,6 +192,10 @@ func (dst BoolArray) Get() interface{} {
 func (src *BoolArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

bool_array_test.go

@@ -168,6 +168,11 @@ func TestBoolArrayAssignTo(t *testing.T) {
 			dst:      &boolSlice,
 			expected: (([]bool)(nil)),
 		},
+		{
+			src:      pgtype.BoolArray{Status: pgtype.Present},
+			dst:      &boolSlice,
+			expected: (([]bool)(nil)),
+		},
 		{
 			src: pgtype.BoolArray{
 				Elements:   []pgtype.Bool{{Bool: true, Status: pgtype.Present}, {Bool: false, Status: pgtype.Present}},

bpchar_array.go

@@ -192,6 +192,10 @@ func (dst BPCharArray) Get() interface{} {
 func (src *BPCharArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

bytea_array.go

@@ -173,6 +173,10 @@ func (dst ByteaArray) Get() interface{} {
 func (src *ByteaArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

bytea_array_test.go

@@ -157,6 +157,11 @@ func TestByteaArrayAssignTo(t *testing.T) {
 			dst:      &byteByteSlice,
 			expected: (([][]byte)(nil)),
 		},
+		{
+			src:      pgtype.ByteaArray{Status: pgtype.Present},
+			dst:      &byteByteSlice,
+			expected: (([][]byte)(nil)),
+		},
 		{
 			src: pgtype.ByteaArray{
 				Elements:   []pgtype.Bytea{{Bytes: []byte{1}, Status: pgtype.Present}, {Bytes: []byte{2}, Status: pgtype.Present}},

cidr_array.go

@@ -212,6 +212,10 @@ func (dst CIDRArray) Get() interface{} {
 func (src *CIDRArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

cidr_array_test.go

@@ -217,11 +217,21 @@ func TestCIDRArrayAssignTo(t *testing.T) {
 			dst:      &ipnetSlice,
 			expected: (([]*net.IPNet)(nil)),
 		},
+		{
+			src:      pgtype.CIDRArray{Status: pgtype.Present},
+			dst:      &ipnetSlice,
+			expected: (([]*net.IPNet)(nil)),
+		},
 		{
 			src:      pgtype.CIDRArray{Status: pgtype.Null},
 			dst:      &ipSlice,
 			expected: (([]net.IP)(nil)),
 		},
+		{
+			src:      pgtype.CIDRArray{Status: pgtype.Present},
+			dst:      &ipSlice,
+			expected: (([]net.IP)(nil)),
+		},
 		{
 			src: pgtype.CIDRArray{
 				Elements: []pgtype.CIDR{

date_array.go

@@ -193,6 +193,10 @@ func (dst DateArray) Get() interface{} {
 func (src *DateArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

date_array_test.go

@@ -182,6 +182,11 @@ func TestDateArrayAssignTo(t *testing.T) {
 			dst:      &timeSlice,
 			expected: (([]time.Time)(nil)),
 		},
+		{
+			src:      pgtype.DateArray{Status: pgtype.Present},
+			dst:      &timeSlice,
+			expected: (([]time.Time)(nil)),
+		},
 		{
 			src: pgtype.DateArray{
 				Elements: []pgtype.Date{

enum_array.go

@@ -190,6 +190,10 @@ func (dst EnumArray) Get() interface{} {
 func (src *EnumArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

enum_array_test.go

@@ -167,6 +167,11 @@ func TestEnumArrayArrayAssignTo(t *testing.T) {
 			dst:      &stringSlice,
 			expected: (([]string)(nil)),
 		},
+		{
+			src:      pgtype.EnumArray{Status: pgtype.Present},
+			dst:      &stringSlice,
+			expected: (([]string)(nil)),
+		},
 		{
 			src: pgtype.EnumArray{
 				Elements:   []pgtype.GenericText{{String: "foo", Status: pgtype.Present}, {String: "bar", Status: pgtype.Present}},

float4_array.go

@@ -192,6 +192,10 @@ func (dst Float4Array) Get() interface{} {
 func (src *Float4Array) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

float4_array_test.go

@@ -167,6 +167,11 @@ func TestFloat4ArrayAssignTo(t *testing.T) {
 			dst:      &float32Slice,
 			expected: (([]float32)(nil)),
 		},
+		{
+			src:      pgtype.Float4Array{Status: pgtype.Present},
+			dst:      &float32Slice,
+			expected: (([]float32)(nil)),
+		},
 		{
 			src: pgtype.Float4Array{
 				Elements:   []pgtype.Float4{{Float: 1, Status: pgtype.Present}, {Float: 2, Status: pgtype.Present}},

float8_array.go

@@ -192,6 +192,10 @@ func (dst Float8Array) Get() interface{} {
 func (src *Float8Array) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

float8_array_test.go

@@ -143,6 +143,11 @@ func TestFloat8ArrayAssignTo(t *testing.T) {
 			dst:      &float64Slice,
 			expected: (([]float64)(nil)),
 		},
+		{
+			src:      pgtype.Float8Array{Status: pgtype.Present},
+			dst:      &float64Slice,
+			expected: (([]float64)(nil)),
+		},
 		{
 			src: pgtype.Float8Array{
 				Elements:   []pgtype.Float8{{Float: 1, Status: pgtype.Present}, {Float: 2, Status: pgtype.Present}},

hstore_array.go

@@ -173,6 +173,10 @@ func (dst HstoreArray) Get() interface{} {
 func (src *HstoreArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

hstore_array_test.go

@@ -302,6 +302,9 @@ func TestHstoreArrayAssignTo(t *testing.T) {
 		{
 			src: pgtype.HstoreArray{Status: pgtype.Null}, dst: &hstoreSlice, expected: (([]map[string]string)(nil)),
 		},
+		{
+			src: pgtype.HstoreArray{Status: pgtype.Present}, dst: &hstoreSlice, expected: (([]map[string]string)(nil)),
+		},
 		{
 			src: pgtype.HstoreArray{
 				Elements: []pgtype.Hstore{

inet_array.go

@@ -212,6 +212,10 @@ func (dst InetArray) Get() interface{} {
 func (src *InetArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

inet_array_test.go

@@ -217,11 +217,21 @@ func TestInetArrayAssignTo(t *testing.T) {
 			dst:      &ipnetSlice,
 			expected: (([]*net.IPNet)(nil)),
 		},
+		{
+			src:      pgtype.InetArray{Status: pgtype.Present},
+			dst:      &ipnetSlice,
+			expected: (([]*net.IPNet)(nil)),
+		},
 		{
 			src:      pgtype.InetArray{Status: pgtype.Null},
 			dst:      &ipSlice,
 			expected: (([]net.IP)(nil)),
 		},
+		{
+			src:      pgtype.InetArray{Status: pgtype.Present},
+			dst:      &ipSlice,
+			expected: (([]net.IP)(nil)),
+		},
 		{
 			src: pgtype.InetArray{
 				Elements: []pgtype.Inet{

int2_array.go

@@ -458,6 +458,10 @@ func (dst Int2Array) Get() interface{} {
 func (src *Int2Array) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

int2_array_test.go

@@ -219,6 +219,11 @@ func TestInt2ArrayAssignTo(t *testing.T) {
 			dst:      &int16Slice,
 			expected: (([]int16)(nil)),
 		},
+		{
+			src:      pgtype.Int2Array{Status: pgtype.Present},
+			dst:      &int16Slice,
+			expected: (([]int16)(nil)),
+		},
 		{
 			src: pgtype.Int2Array{
 				Elements:   []pgtype.Int2{{Int: 1, Status: pgtype.Present}, {Int: 2, Status: pgtype.Present}},

int4_array.go

@@ -458,6 +458,10 @@ func (dst Int4Array) Get() interface{} {
 func (src *Int4Array) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

int4_array_test.go

@@ -233,6 +233,11 @@ func TestInt4ArrayAssignTo(t *testing.T) {
 			dst:      &int32Slice,
 			expected: (([]int32)(nil)),
 		},
+		{
+			src:      pgtype.Int4Array{Status: pgtype.Present},
+			dst:      &int32Slice,
+			expected: (([]int32)(nil)),
+		},
 		{
 			src: pgtype.Int4Array{
 				Elements:   []pgtype.Int4{{Int: 1, Status: pgtype.Present}, {Int: 2, Status: pgtype.Present}},

int8_array.go

@@ -458,6 +458,10 @@ func (dst Int8Array) Get() interface{} {
 func (src *Int8Array) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

int8_array_test.go

@@ -226,6 +226,11 @@ func TestInt8ArrayAssignTo(t *testing.T) {
 			dst:      &int64Slice,
 			expected: (([]int64)(nil)),
 		},
+		{
+			src:      pgtype.Int8Array{Status: pgtype.Present},
+			dst:      &int64Slice,
+			expected: (([]int64)(nil)),
+		},
 		{
 			src: pgtype.Int8Array{
 				Elements:   []pgtype.Int8{{Int: 1, Status: pgtype.Present}, {Int: 2, Status: pgtype.Present}},

jsonb_array.go

@@ -192,6 +192,10 @@ func (dst JSONBArray) Get() interface{} {
 func (src *JSONBArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

macaddr_array.go

@@ -193,6 +193,10 @@ func (dst MacaddrArray) Get() interface{} {
 func (src *MacaddrArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

macaddr_array_test.go

@@ -166,6 +166,11 @@ func TestMacaddrArrayAssignTo(t *testing.T) {
 			dst:      &macaddrSlice,
 			expected: (([]net.HardwareAddr)(nil)),
 		},
+		{
+			src:      pgtype.MacaddrArray{Status: pgtype.Present},
+			dst:      &macaddrSlice,
+			expected: (([]net.HardwareAddr)(nil)),
+		},
 		{
 			src: pgtype.MacaddrArray{
 				Elements: []pgtype.Macaddr{

numeric_array.go

@@ -306,6 +306,10 @@ func (dst NumericArray) Get() interface{} {
 func (src *NumericArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

numeric_array_test.go

@@ -190,6 +190,11 @@ func TestNumericArrayAssignTo(t *testing.T) {
 			dst:      &float32Slice,
 			expected: (([]float32)(nil)),
 		},
+		{
+			src:      pgtype.NumericArray{Status: pgtype.Present},
+			dst:      &float32Slice,
+			expected: (([]float32)(nil)),
+		},
 		{
 			src: pgtype.NumericArray{
 				Elements:   []pgtype.Numeric{{Int: big.NewInt(1), Status: pgtype.Present}, {Int: big.NewInt(2), Status: pgtype.Present}},

text_array.go

@@ -192,6 +192,10 @@ func (dst TextArray) Get() interface{} {
 func (src *TextArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

text_array_test.go

@@ -168,6 +168,11 @@ func TestTextArrayAssignTo(t *testing.T) {
 			dst:      &stringSlice,
 			expected: (([]string)(nil)),
 		},
+		{
+			src:      pgtype.TextArray{Status: pgtype.Present},
+			dst:      &stringSlice,
+			expected: (([]string)(nil)),
+		},
 		{
 			src: pgtype.TextArray{
 				Elements:   []pgtype.Text{{String: "foo", Status: pgtype.Present}, {String: "bar", Status: pgtype.Present}},

timestamp_array.go

@@ -193,6 +193,10 @@ func (dst TimestampArray) Get() interface{} {
 func (src *TimestampArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

timestamp_array_test.go

@@ -162,6 +162,11 @@ func TestTimestampArrayAssignTo(t *testing.T) {
 			dst:      &timeSlice,
 			expected: (([]time.Time)(nil)),
 		},
+		{
+			src:      pgtype.TimestampArray{Status: pgtype.Present},
+			dst:      &timeSlice,
+			expected: (([]time.Time)(nil)),
+		},
 		{
 			src: pgtype.TimestampArray{
 				Elements: []pgtype.Timestamp{

timestamptz_array.go

@@ -193,6 +193,10 @@ func (dst TimestamptzArray) Get() interface{} {
 func (src *TimestamptzArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

timestamptz_array_test.go

@@ -198,6 +198,11 @@ func TestTimestamptzArrayAssignTo(t *testing.T) {
 			dst:      &timeSlice,
 			expected: (([]time.Time)(nil)),
 		},
+		{
+			src:      pgtype.TimestamptzArray{Status: pgtype.Present},
+			dst:      &timeSlice,
+			expected: (([]time.Time)(nil)),
+		},
 		{
 			src: pgtype.TimestamptzArray{
 				Elements: []pgtype.Timestamptz{

tstzrange_array.go

@@ -154,6 +154,10 @@ func (dst TstzrangeArray) Get() interface{} {
 func (src *TstzrangeArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

typed_array.go.erb

@@ -174,6 +174,10 @@ func (dst <%= pgtype_array_type %>) Get() interface{} {
 func (src *<%= pgtype_array_type %>) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1{
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

uuid_array.go

@@ -230,6 +230,10 @@ func (dst UUIDArray) Get() interface{} {
 func (src *UUIDArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

uuid_array_test.go

@@ -214,6 +214,7 @@ func TestUUIDArrayAssignTo(t *testing.T) {
 	var byteArraySlice [][16]byte
 	var byteSliceSlice [][]byte
 	var stringSlice []string
+	var byteSlice []byte
 	var byteArraySliceDim2 [][][16]byte
 	var stringSliceDim4 [][][][]string
 	var byteArrayDim2 [2][1][16]byte
@@ -252,6 +253,16 @@ func TestUUIDArrayAssignTo(t *testing.T) {
 			dst:      &byteSliceSlice,
 			expected: ([][]byte)(nil),
 		},
+		{
+			src:      pgtype.UUIDArray{Status: pgtype.Present},
+			dst:      &byteSlice,
+			expected: ([]byte)(nil),
+		},
+		{
+			src:      pgtype.UUIDArray{Status: pgtype.Present},
+			dst:      &stringSlice,
+			expected: (([]string)(nil)),
+		},
 		{
 			src: pgtype.UUIDArray{
 				Elements:   []pgtype.UUID{{Bytes: [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, Status: pgtype.Present}},

varchar_array.go

@@ -192,6 +192,10 @@ func (dst VarcharArray) Get() interface{} {
 func (src *VarcharArray) AssignTo(dst interface{}) error {
 	switch src.Status {
 	case Present:
+		if len(src.Elements) == 0 || len(src.Dimensions) == 0 {
+			// No values to assign
+			return nil
+		}
 		if len(src.Dimensions) <= 1 {
 			// Attempt to match to select common types:
 			switch v := dst.(type) {

varchar_array_test.go

@@ -168,6 +168,11 @@ func TestVarcharArrayAssignTo(t *testing.T) {
 			dst:      &stringSlice,
 			expected: (([]string)(nil)),
 		},
+		{
+			src:      pgtype.VarcharArray{Status: pgtype.Present},
+			dst:      &stringSlice,
+			expected: (([]string)(nil)),
+		},
 		{
 			src: pgtype.VarcharArray{
 				Elements:   []pgtype.Varchar{{String: "foo", Status: pgtype.Present}, {String: "bar", Status: pgtype.Present}},