From 066bc77610f0e459a3c097be13de3730e1c687a7 Mon Sep 17 00:00:00 2001 From: megaturbo Date: Wed, 17 Jun 2020 15:17:17 +0200 Subject: [PATCH] Add support for slice of nullable types in array types --- aclitem_array.go | 28 ++++++ bool_array.go | 28 ++++++ bpchar_array.go | 28 ++++++ cidr_array.go | 28 ++++++ date_array.go | 28 ++++++ enum_array.go | 28 ++++++ float4_array.go | 28 ++++++ float8_array.go | 28 ++++++ inet_array.go | 28 ++++++ int2_array.go | 224 +++++++++++++++++++++++++++++++++++++++++++ int4_array.go | 224 +++++++++++++++++++++++++++++++++++++++++++ int8_array.go | 224 +++++++++++++++++++++++++++++++++++++++++++ macaddr_array.go | 28 ++++++ numeric_array.go | 112 ++++++++++++++++++++++ text_array.go | 28 ++++++ timestamp_array.go | 28 ++++++ timestamptz_array.go | 28 ++++++ typed_array_gen.sh | 38 ++++---- uuid_array.go | 28 ++++++ varchar_array.go | 28 ++++++ 20 files changed, 1223 insertions(+), 19 deletions(-) diff --git a/aclitem_array.go b/aclitem_array.go index 1d3de130..064436fd 100644 --- a/aclitem_array.go +++ b/aclitem_array.go @@ -47,6 +47,25 @@ func (dst *ACLItemArray) Set(src interface{}) error { } } + case []*string: + if value == nil { + *dst = ACLItemArray{Status: Null} + } else if len(value) == 0 { + *dst = ACLItemArray{Status: Present} + } else { + elements := make([]ACLItem, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = ACLItemArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []ACLItem: if value == nil { *dst = ACLItemArray{Status: Null} @@ -94,6 +113,15 @@ func (src *ACLItemArray) AssignTo(dst interface{}) error { } 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 + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/bool_array.go b/bool_array.go index c1af1e1f..d5f89629 100644 --- a/bool_array.go +++ b/bool_array.go @@ -49,6 +49,25 @@ func (dst *BoolArray) Set(src interface{}) error { } } + case []*bool: + if value == nil { + *dst = BoolArray{Status: Null} + } else if len(value) == 0 { + *dst = BoolArray{Status: Present} + } else { + elements := make([]Bool, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = BoolArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Bool: if value == nil { *dst = BoolArray{Status: Null} @@ -96,6 +115,15 @@ func (src *BoolArray) AssignTo(dst interface{}) error { } return nil + case *[]*bool: + *v = make([]*bool, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/bpchar_array.go b/bpchar_array.go index b6eeabd7..10d0d0f7 100644 --- a/bpchar_array.go +++ b/bpchar_array.go @@ -49,6 +49,25 @@ func (dst *BPCharArray) Set(src interface{}) error { } } + case []*string: + if value == nil { + *dst = BPCharArray{Status: Null} + } else if len(value) == 0 { + *dst = BPCharArray{Status: Present} + } else { + elements := make([]BPChar, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = BPCharArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []BPChar: if value == nil { *dst = BPCharArray{Status: Null} @@ -96,6 +115,15 @@ func (src *BPCharArray) AssignTo(dst interface{}) error { } 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 + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/cidr_array.go b/cidr_array.go index 4f3097a0..5231e208 100644 --- a/cidr_array.go +++ b/cidr_array.go @@ -69,6 +69,25 @@ func (dst *CIDRArray) Set(src interface{}) error { } } + case []*net.IP: + if value == nil { + *dst = CIDRArray{Status: Null} + } else if len(value) == 0 { + *dst = CIDRArray{Status: Present} + } else { + elements := make([]CIDR, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = CIDRArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []CIDR: if value == nil { *dst = CIDRArray{Status: Null} @@ -125,6 +144,15 @@ func (src *CIDRArray) AssignTo(dst interface{}) error { } return nil + case *[]*net.IP: + *v = make([]*net.IP, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/date_array.go b/date_array.go index 644e78fe..51d00da1 100644 --- a/date_array.go +++ b/date_array.go @@ -50,6 +50,25 @@ func (dst *DateArray) Set(src interface{}) error { } } + case []*time.Time: + if value == nil { + *dst = DateArray{Status: Null} + } else if len(value) == 0 { + *dst = DateArray{Status: Present} + } else { + elements := make([]Date, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = DateArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Date: if value == nil { *dst = DateArray{Status: Null} @@ -97,6 +116,15 @@ func (src *DateArray) AssignTo(dst interface{}) error { } return nil + case *[]*time.Time: + *v = make([]*time.Time, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/enum_array.go b/enum_array.go index a31916dc..528cdb03 100644 --- a/enum_array.go +++ b/enum_array.go @@ -47,6 +47,25 @@ func (dst *EnumArray) Set(src interface{}) error { } } + case []*string: + if value == nil { + *dst = EnumArray{Status: Null} + } else if len(value) == 0 { + *dst = EnumArray{Status: Present} + } else { + elements := make([]GenericText, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = EnumArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []GenericText: if value == nil { *dst = EnumArray{Status: Null} @@ -94,6 +113,15 @@ func (src *EnumArray) AssignTo(dst interface{}) error { } 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 + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/float4_array.go b/float4_array.go index ccd718a1..bc9d4746 100644 --- a/float4_array.go +++ b/float4_array.go @@ -49,6 +49,25 @@ func (dst *Float4Array) Set(src interface{}) error { } } + case []*float32: + if value == nil { + *dst = Float4Array{Status: Null} + } else if len(value) == 0 { + *dst = Float4Array{Status: Present} + } else { + elements := make([]Float4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Float4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Float4: if value == nil { *dst = Float4Array{Status: Null} @@ -96,6 +115,15 @@ func (src *Float4Array) AssignTo(dst interface{}) error { } return nil + case *[]*float32: + *v = make([]*float32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/float8_array.go b/float8_array.go index 740e8558..acc94b3f 100644 --- a/float8_array.go +++ b/float8_array.go @@ -49,6 +49,25 @@ func (dst *Float8Array) Set(src interface{}) error { } } + case []*float64: + if value == nil { + *dst = Float8Array{Status: Null} + } else if len(value) == 0 { + *dst = Float8Array{Status: Present} + } else { + elements := make([]Float8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Float8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Float8: if value == nil { *dst = Float8Array{Status: Null} @@ -96,6 +115,15 @@ func (src *Float8Array) AssignTo(dst interface{}) error { } return nil + case *[]*float64: + *v = make([]*float64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/inet_array.go b/inet_array.go index a663d51d..6d9f11fb 100644 --- a/inet_array.go +++ b/inet_array.go @@ -69,6 +69,25 @@ func (dst *InetArray) Set(src interface{}) error { } } + case []*net.IP: + if value == nil { + *dst = InetArray{Status: Null} + } else if len(value) == 0 { + *dst = InetArray{Status: Present} + } else { + elements := make([]Inet, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = InetArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Inet: if value == nil { *dst = InetArray{Status: Null} @@ -125,6 +144,15 @@ func (src *InetArray) AssignTo(dst interface{}) error { } return nil + case *[]*net.IP: + *v = make([]*net.IP, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/int2_array.go b/int2_array.go index 98552171..35f73fee 100644 --- a/int2_array.go +++ b/int2_array.go @@ -49,6 +49,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*int16: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint16: if value == nil { *dst = Int2Array{Status: Null} @@ -68,6 +87,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*uint16: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int32: if value == nil { *dst = Int2Array{Status: Null} @@ -87,6 +125,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*int32: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint32: if value == nil { *dst = Int2Array{Status: Null} @@ -106,6 +163,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*uint32: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int64: if value == nil { *dst = Int2Array{Status: Null} @@ -125,6 +201,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*int64: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint64: if value == nil { *dst = Int2Array{Status: Null} @@ -144,6 +239,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*uint64: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int: if value == nil { *dst = Int2Array{Status: Null} @@ -163,6 +277,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*int: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint: if value == nil { *dst = Int2Array{Status: Null} @@ -182,6 +315,25 @@ func (dst *Int2Array) Set(src interface{}) error { } } + case []*uint: + if value == nil { + *dst = Int2Array{Status: Null} + } else if len(value) == 0 { + *dst = Int2Array{Status: Present} + } else { + elements := make([]Int2, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int2Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Int2: if value == nil { *dst = Int2Array{Status: Null} @@ -229,6 +381,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*int16: + *v = make([]*int16, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint16: *v = make([]uint16, len(src.Elements)) for i := range src.Elements { @@ -238,6 +399,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint16: + *v = make([]*uint16, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int32: *v = make([]int32, len(src.Elements)) for i := range src.Elements { @@ -247,6 +417,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*int32: + *v = make([]*int32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint32: *v = make([]uint32, len(src.Elements)) for i := range src.Elements { @@ -256,6 +435,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint32: + *v = make([]*uint32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int64: *v = make([]int64, len(src.Elements)) for i := range src.Elements { @@ -265,6 +453,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*int64: + *v = make([]*int64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint64: *v = make([]uint64, len(src.Elements)) for i := range src.Elements { @@ -274,6 +471,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint64: + *v = make([]*uint64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int: *v = make([]int, len(src.Elements)) for i := range src.Elements { @@ -283,6 +489,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*int: + *v = make([]*int, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint: *v = make([]uint, len(src.Elements)) for i := range src.Elements { @@ -292,6 +507,15 @@ func (src *Int2Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint: + *v = make([]*uint, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/int4_array.go b/int4_array.go index a52ab437..2ff32ee1 100644 --- a/int4_array.go +++ b/int4_array.go @@ -49,6 +49,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*int16: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint16: if value == nil { *dst = Int4Array{Status: Null} @@ -68,6 +87,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*uint16: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int32: if value == nil { *dst = Int4Array{Status: Null} @@ -87,6 +125,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*int32: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint32: if value == nil { *dst = Int4Array{Status: Null} @@ -106,6 +163,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*uint32: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int64: if value == nil { *dst = Int4Array{Status: Null} @@ -125,6 +201,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*int64: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint64: if value == nil { *dst = Int4Array{Status: Null} @@ -144,6 +239,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*uint64: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int: if value == nil { *dst = Int4Array{Status: Null} @@ -163,6 +277,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*int: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint: if value == nil { *dst = Int4Array{Status: Null} @@ -182,6 +315,25 @@ func (dst *Int4Array) Set(src interface{}) error { } } + case []*uint: + if value == nil { + *dst = Int4Array{Status: Null} + } else if len(value) == 0 { + *dst = Int4Array{Status: Present} + } else { + elements := make([]Int4, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int4Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Int4: if value == nil { *dst = Int4Array{Status: Null} @@ -229,6 +381,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*int16: + *v = make([]*int16, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint16: *v = make([]uint16, len(src.Elements)) for i := range src.Elements { @@ -238,6 +399,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint16: + *v = make([]*uint16, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int32: *v = make([]int32, len(src.Elements)) for i := range src.Elements { @@ -247,6 +417,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*int32: + *v = make([]*int32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint32: *v = make([]uint32, len(src.Elements)) for i := range src.Elements { @@ -256,6 +435,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint32: + *v = make([]*uint32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int64: *v = make([]int64, len(src.Elements)) for i := range src.Elements { @@ -265,6 +453,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*int64: + *v = make([]*int64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint64: *v = make([]uint64, len(src.Elements)) for i := range src.Elements { @@ -274,6 +471,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint64: + *v = make([]*uint64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int: *v = make([]int, len(src.Elements)) for i := range src.Elements { @@ -283,6 +489,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*int: + *v = make([]*int, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint: *v = make([]uint, len(src.Elements)) for i := range src.Elements { @@ -292,6 +507,15 @@ func (src *Int4Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint: + *v = make([]*uint, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/int8_array.go b/int8_array.go index f6d577f0..17968338 100644 --- a/int8_array.go +++ b/int8_array.go @@ -49,6 +49,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*int16: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint16: if value == nil { *dst = Int8Array{Status: Null} @@ -68,6 +87,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*uint16: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int32: if value == nil { *dst = Int8Array{Status: Null} @@ -87,6 +125,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*int32: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint32: if value == nil { *dst = Int8Array{Status: Null} @@ -106,6 +163,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*uint32: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int64: if value == nil { *dst = Int8Array{Status: Null} @@ -125,6 +201,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*int64: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint64: if value == nil { *dst = Int8Array{Status: Null} @@ -144,6 +239,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*uint64: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int: if value == nil { *dst = Int8Array{Status: Null} @@ -163,6 +277,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*int: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint: if value == nil { *dst = Int8Array{Status: Null} @@ -182,6 +315,25 @@ func (dst *Int8Array) Set(src interface{}) error { } } + case []*uint: + if value == nil { + *dst = Int8Array{Status: Null} + } else if len(value) == 0 { + *dst = Int8Array{Status: Present} + } else { + elements := make([]Int8, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = Int8Array{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Int8: if value == nil { *dst = Int8Array{Status: Null} @@ -229,6 +381,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*int16: + *v = make([]*int16, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint16: *v = make([]uint16, len(src.Elements)) for i := range src.Elements { @@ -238,6 +399,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint16: + *v = make([]*uint16, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int32: *v = make([]int32, len(src.Elements)) for i := range src.Elements { @@ -247,6 +417,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*int32: + *v = make([]*int32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint32: *v = make([]uint32, len(src.Elements)) for i := range src.Elements { @@ -256,6 +435,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint32: + *v = make([]*uint32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int64: *v = make([]int64, len(src.Elements)) for i := range src.Elements { @@ -265,6 +453,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*int64: + *v = make([]*int64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint64: *v = make([]uint64, len(src.Elements)) for i := range src.Elements { @@ -274,6 +471,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint64: + *v = make([]*uint64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int: *v = make([]int, len(src.Elements)) for i := range src.Elements { @@ -283,6 +489,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*int: + *v = make([]*int, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint: *v = make([]uint, len(src.Elements)) for i := range src.Elements { @@ -292,6 +507,15 @@ func (src *Int8Array) AssignTo(dst interface{}) error { } return nil + case *[]*uint: + *v = make([]*uint, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/macaddr_array.go b/macaddr_array.go index 97b13537..72a4e8d4 100644 --- a/macaddr_array.go +++ b/macaddr_array.go @@ -50,6 +50,25 @@ func (dst *MacaddrArray) Set(src interface{}) error { } } + case []*net.HardwareAddr: + if value == nil { + *dst = MacaddrArray{Status: Null} + } else if len(value) == 0 { + *dst = MacaddrArray{Status: Present} + } 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}}, + Status: Present, + } + } + case []Macaddr: if value == nil { *dst = MacaddrArray{Status: Null} @@ -97,6 +116,15 @@ func (src *MacaddrArray) AssignTo(dst interface{}) error { } 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 + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/numeric_array.go b/numeric_array.go index 3cec9fea..e808669c 100644 --- a/numeric_array.go +++ b/numeric_array.go @@ -49,6 +49,25 @@ func (dst *NumericArray) Set(src interface{}) error { } } + case []*float32: + if value == nil { + *dst = NumericArray{Status: Null} + } else if len(value) == 0 { + *dst = NumericArray{Status: Present} + } else { + elements := make([]Numeric, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = NumericArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []float64: if value == nil { *dst = NumericArray{Status: Null} @@ -68,6 +87,25 @@ func (dst *NumericArray) Set(src interface{}) error { } } + case []*float64: + if value == nil { + *dst = NumericArray{Status: Null} + } else if len(value) == 0 { + *dst = NumericArray{Status: Present} + } else { + elements := make([]Numeric, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = NumericArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []int64: if value == nil { *dst = NumericArray{Status: Null} @@ -87,6 +125,25 @@ func (dst *NumericArray) Set(src interface{}) error { } } + case []*int64: + if value == nil { + *dst = NumericArray{Status: Null} + } else if len(value) == 0 { + *dst = NumericArray{Status: Present} + } else { + elements := make([]Numeric, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = NumericArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []uint64: if value == nil { *dst = NumericArray{Status: Null} @@ -106,6 +163,25 @@ func (dst *NumericArray) Set(src interface{}) error { } } + case []*uint64: + if value == nil { + *dst = NumericArray{Status: Null} + } else if len(value) == 0 { + *dst = NumericArray{Status: Present} + } else { + elements := make([]Numeric, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = NumericArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Numeric: if value == nil { *dst = NumericArray{Status: Null} @@ -153,6 +229,15 @@ func (src *NumericArray) AssignTo(dst interface{}) error { } return nil + case *[]*float32: + *v = make([]*float32, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]float64: *v = make([]float64, len(src.Elements)) for i := range src.Elements { @@ -162,6 +247,15 @@ func (src *NumericArray) AssignTo(dst interface{}) error { } return nil + case *[]*float64: + *v = make([]*float64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]int64: *v = make([]int64, len(src.Elements)) for i := range src.Elements { @@ -171,6 +265,15 @@ func (src *NumericArray) AssignTo(dst interface{}) error { } return nil + case *[]*int64: + *v = make([]*int64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + case *[]uint64: *v = make([]uint64, len(src.Elements)) for i := range src.Elements { @@ -180,6 +283,15 @@ func (src *NumericArray) AssignTo(dst interface{}) error { } return nil + case *[]*uint64: + *v = make([]*uint64, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/text_array.go b/text_array.go index 2130af84..969054f8 100644 --- a/text_array.go +++ b/text_array.go @@ -49,6 +49,25 @@ func (dst *TextArray) Set(src interface{}) error { } } + case []*string: + if value == nil { + *dst = TextArray{Status: Null} + } else if len(value) == 0 { + *dst = TextArray{Status: Present} + } else { + elements := make([]Text, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = TextArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Text: if value == nil { *dst = TextArray{Status: Null} @@ -96,6 +115,15 @@ func (src *TextArray) AssignTo(dst interface{}) error { } 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 + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/timestamp_array.go b/timestamp_array.go index 49ac98fd..81fd85f8 100644 --- a/timestamp_array.go +++ b/timestamp_array.go @@ -50,6 +50,25 @@ func (dst *TimestampArray) Set(src interface{}) error { } } + case []*time.Time: + if value == nil { + *dst = TimestampArray{Status: Null} + } else if len(value) == 0 { + *dst = TimestampArray{Status: Present} + } else { + elements := make([]Timestamp, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = TimestampArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Timestamp: if value == nil { *dst = TimestampArray{Status: Null} @@ -97,6 +116,15 @@ func (src *TimestampArray) AssignTo(dst interface{}) error { } return nil + case *[]*time.Time: + *v = make([]*time.Time, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/timestamptz_array.go b/timestamptz_array.go index 2e26692b..48725e29 100644 --- a/timestamptz_array.go +++ b/timestamptz_array.go @@ -50,6 +50,25 @@ func (dst *TimestamptzArray) Set(src interface{}) error { } } + case []*time.Time: + if value == nil { + *dst = TimestamptzArray{Status: Null} + } else if len(value) == 0 { + *dst = TimestamptzArray{Status: Present} + } else { + elements := make([]Timestamptz, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = TimestamptzArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Timestamptz: if value == nil { *dst = TimestamptzArray{Status: Null} @@ -97,6 +116,15 @@ func (src *TimestamptzArray) AssignTo(dst interface{}) error { } return nil + case *[]*time.Time: + *v = make([]*time.Time, len(src.Elements)) + for i := range src.Elements { + if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil { + return err + } + } + return nil + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/typed_array_gen.sh b/typed_array_gen.sh index 6fd49264..b96dc381 100755 --- a/typed_array_gen.sh +++ b/typed_array_gen.sh @@ -1,26 +1,26 @@ -erb pgtype_array_type=Int2Array pgtype_element_type=Int2 go_array_types=[]int16,[]uint16,[]int32,[]uint32,[]int64,[]uint64,[]int,[]uint element_type_name=int2 text_null=NULL binary_format=true typed_array.go.erb > int2_array.go -erb pgtype_array_type=Int4Array pgtype_element_type=Int4 go_array_types=[]int16,[]uint16,[]int32,[]uint32,[]int64,[]uint64,[]int,[]uint element_type_name=int4 text_null=NULL binary_format=true typed_array.go.erb > int4_array.go -erb pgtype_array_type=Int8Array pgtype_element_type=Int8 go_array_types=[]int16,[]uint16,[]int32,[]uint32,[]int64,[]uint64,[]int,[]uint element_type_name=int8 text_null=NULL binary_format=true typed_array.go.erb > int8_array.go -erb pgtype_array_type=BoolArray pgtype_element_type=Bool go_array_types=[]bool element_type_name=bool text_null=NULL binary_format=true typed_array.go.erb > bool_array.go -erb pgtype_array_type=DateArray pgtype_element_type=Date go_array_types=[]time.Time element_type_name=date text_null=NULL binary_format=true typed_array.go.erb > date_array.go -erb pgtype_array_type=TimestamptzArray pgtype_element_type=Timestamptz go_array_types=[]time.Time element_type_name=timestamptz text_null=NULL binary_format=true typed_array.go.erb > timestamptz_array.go +erb pgtype_array_type=Int2Array pgtype_element_type=Int2 go_array_types=[]int16,[]*int16,[]uint16,[]*uint16,[]int32,[]*int32,[]uint32,[]*uint32,[]int64,[]*int64,[]uint64,[]*uint64,[]int,[]*int,[]uint,[]*uint element_type_name=int2 text_null=NULL binary_format=true typed_array.go.erb > int2_array.go +erb pgtype_array_type=Int4Array pgtype_element_type=Int4 go_array_types=[]int16,[]*int16,[]uint16,[]*uint16,[]int32,[]*int32,[]uint32,[]*uint32,[]int64,[]*int64,[]uint64,[]*uint64,[]int,[]*int,[]uint,[]*uint element_type_name=int4 text_null=NULL binary_format=true typed_array.go.erb > int4_array.go +erb pgtype_array_type=Int8Array pgtype_element_type=Int8 go_array_types=[]int16,[]*int16,[]uint16,[]*uint16,[]int32,[]*int32,[]uint32,[]*uint32,[]int64,[]*int64,[]uint64,[]*uint64,[]int,[]*int,[]uint,[]*uint element_type_name=int8 text_null=NULL binary_format=true typed_array.go.erb > int8_array.go +erb pgtype_array_type=BoolArray pgtype_element_type=Bool go_array_types=[]bool,[]*bool element_type_name=bool text_null=NULL binary_format=true typed_array.go.erb > bool_array.go +erb pgtype_array_type=DateArray pgtype_element_type=Date go_array_types=[]time.Time,[]*time.Time element_type_name=date text_null=NULL binary_format=true typed_array.go.erb > date_array.go +erb pgtype_array_type=TimestamptzArray pgtype_element_type=Timestamptz go_array_types=[]time.Time,[]*time.Time element_type_name=timestamptz text_null=NULL binary_format=true typed_array.go.erb > timestamptz_array.go erb pgtype_array_type=TstzrangeArray pgtype_element_type=Tstzrange go_array_types=[]Tstzrange element_type_name=tstzrange text_null=NULL binary_format=true typed_array.go.erb > tstzrange_array.go -erb pgtype_array_type=TimestampArray pgtype_element_type=Timestamp go_array_types=[]time.Time element_type_name=timestamp text_null=NULL binary_format=true typed_array.go.erb > timestamp_array.go -erb pgtype_array_type=Float4Array pgtype_element_type=Float4 go_array_types=[]float32 element_type_name=float4 text_null=NULL binary_format=true typed_array.go.erb > float4_array.go -erb pgtype_array_type=Float8Array pgtype_element_type=Float8 go_array_types=[]float64 element_type_name=float8 text_null=NULL binary_format=true typed_array.go.erb > float8_array.go -erb pgtype_array_type=InetArray pgtype_element_type=Inet go_array_types=[]*net.IPNet,[]net.IP element_type_name=inet text_null=NULL binary_format=true typed_array.go.erb > inet_array.go -erb pgtype_array_type=MacaddrArray pgtype_element_type=Macaddr go_array_types=[]net.HardwareAddr element_type_name=macaddr text_null=NULL binary_format=true typed_array.go.erb > macaddr_array.go -erb pgtype_array_type=CIDRArray pgtype_element_type=CIDR go_array_types=[]*net.IPNet,[]net.IP element_type_name=cidr text_null=NULL binary_format=true typed_array.go.erb > cidr_array.go -erb pgtype_array_type=TextArray pgtype_element_type=Text go_array_types=[]string element_type_name=text text_null=NULL binary_format=true typed_array.go.erb > text_array.go -erb pgtype_array_type=VarcharArray pgtype_element_type=Varchar go_array_types=[]string element_type_name=varchar text_null=NULL binary_format=true typed_array.go.erb > varchar_array.go -erb pgtype_array_type=BPCharArray pgtype_element_type=BPChar go_array_types=[]string element_type_name=bpchar text_null=NULL binary_format=true typed_array.go.erb > bpchar_array.go +erb pgtype_array_type=TimestampArray pgtype_element_type=Timestamp go_array_types=[]time.Time,[]*time.Time element_type_name=timestamp text_null=NULL binary_format=true typed_array.go.erb > timestamp_array.go +erb pgtype_array_type=Float4Array pgtype_element_type=Float4 go_array_types=[]float32,[]*float32 element_type_name=float4 text_null=NULL binary_format=true typed_array.go.erb > float4_array.go +erb pgtype_array_type=Float8Array pgtype_element_type=Float8 go_array_types=[]float64,[]*float64 element_type_name=float8 text_null=NULL binary_format=true typed_array.go.erb > float8_array.go +erb pgtype_array_type=InetArray pgtype_element_type=Inet go_array_types=[]*net.IPNet,[]net.IP,[]*net.IP element_type_name=inet text_null=NULL binary_format=true typed_array.go.erb > inet_array.go +erb pgtype_array_type=MacaddrArray pgtype_element_type=Macaddr go_array_types=[]net.HardwareAddr,[]*net.HardwareAddr element_type_name=macaddr text_null=NULL binary_format=true typed_array.go.erb > macaddr_array.go +erb pgtype_array_type=CIDRArray pgtype_element_type=CIDR go_array_types=[]*net.IPNet,[]net.IP,[]*net.IP element_type_name=cidr text_null=NULL binary_format=true typed_array.go.erb > cidr_array.go +erb pgtype_array_type=TextArray pgtype_element_type=Text go_array_types=[]string,[]*string element_type_name=text text_null=NULL binary_format=true typed_array.go.erb > text_array.go +erb pgtype_array_type=VarcharArray pgtype_element_type=Varchar go_array_types=[]string,[]*string element_type_name=varchar text_null=NULL binary_format=true typed_array.go.erb > varchar_array.go +erb pgtype_array_type=BPCharArray pgtype_element_type=BPChar go_array_types=[]string,[]*string element_type_name=bpchar text_null=NULL binary_format=true typed_array.go.erb > bpchar_array.go erb pgtype_array_type=ByteaArray pgtype_element_type=Bytea go_array_types=[][]byte element_type_name=bytea text_null=NULL binary_format=true typed_array.go.erb > bytea_array.go -erb pgtype_array_type=ACLItemArray pgtype_element_type=ACLItem go_array_types=[]string element_type_name=aclitem text_null=NULL binary_format=false typed_array.go.erb > aclitem_array.go +erb pgtype_array_type=ACLItemArray pgtype_element_type=ACLItem go_array_types=[]string,[]*string element_type_name=aclitem text_null=NULL binary_format=false typed_array.go.erb > aclitem_array.go erb pgtype_array_type=HstoreArray pgtype_element_type=Hstore go_array_types=[]map[string]string element_type_name=hstore text_null=NULL binary_format=true typed_array.go.erb > hstore_array.go -erb pgtype_array_type=NumericArray pgtype_element_type=Numeric go_array_types=[]float32,[]float64,[]int64,[]uint64 element_type_name=numeric text_null=NULL binary_format=true typed_array.go.erb > numeric_array.go -erb pgtype_array_type=UUIDArray pgtype_element_type=UUID go_array_types=[][16]byte,[][]byte,[]string element_type_name=uuid text_null=NULL binary_format=true typed_array.go.erb > uuid_array.go +erb pgtype_array_type=NumericArray pgtype_element_type=Numeric go_array_types=[]float32,[]*float32,[]float64,[]*float64,[]int64,[]*int64,[]uint64,[]*uint64 element_type_name=numeric text_null=NULL binary_format=true typed_array.go.erb > numeric_array.go +erb pgtype_array_type=UUIDArray pgtype_element_type=UUID go_array_types=[][16]byte,[][]byte,[]string,[]*string element_type_name=uuid text_null=NULL binary_format=true typed_array.go.erb > uuid_array.go # While the binary format is theoretically possible it is only practical to use the text format. -erb pgtype_array_type=EnumArray pgtype_element_type=GenericText go_array_types=[]string text_null=NULL binary_format=false typed_array.go.erb > enum_array.go +erb pgtype_array_type=EnumArray pgtype_element_type=GenericText go_array_types=[]string,[]*string text_null=NULL binary_format=false typed_array.go.erb > enum_array.go goimports -w *_array.go diff --git a/uuid_array.go b/uuid_array.go index 4cd65017..0c02977f 100644 --- a/uuid_array.go +++ b/uuid_array.go @@ -87,6 +87,25 @@ func (dst *UUIDArray) Set(src interface{}) error { } } + case []*string: + if value == nil { + *dst = UUIDArray{Status: Null} + } else if len(value) == 0 { + *dst = UUIDArray{Status: Present} + } else { + elements := make([]UUID, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = UUIDArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []UUID: if value == nil { *dst = UUIDArray{Status: Null} @@ -152,6 +171,15 @@ func (src *UUIDArray) AssignTo(dst interface{}) error { } 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 + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst) diff --git a/varchar_array.go b/varchar_array.go index b13f29ce..5758ba62 100644 --- a/varchar_array.go +++ b/varchar_array.go @@ -49,6 +49,25 @@ func (dst *VarcharArray) Set(src interface{}) error { } } + case []*string: + if value == nil { + *dst = VarcharArray{Status: Null} + } else if len(value) == 0 { + *dst = VarcharArray{Status: Present} + } else { + elements := make([]Varchar, len(value)) + for i := range value { + if err := elements[i].Set(value[i]); err != nil { + return err + } + } + *dst = VarcharArray{ + Elements: elements, + Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}}, + Status: Present, + } + } + case []Varchar: if value == nil { *dst = VarcharArray{Status: Null} @@ -96,6 +115,15 @@ func (src *VarcharArray) AssignTo(dst interface{}) error { } 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 + default: if nextDst, retry := GetAssignToDstType(dst); retry { return src.AssignTo(nextDst)