From 3105c6e7065650f46fee8585b6690687e5947d48 Mon Sep 17 00:00:00 2001 From: megaturbo Date: Wed, 17 Jun 2020 15:13:59 +0200 Subject: [PATCH 1/4] Add support for nullable types in Value.Get implementations --- bool.go | 12 ++++++++ date.go | 12 ++++++++ float4.go | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++ float8.go | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++ inet.go | 20 +++++++++++-- int2.go | 66 ++++++++++++++++++++++++++++++++++++++++++ int4.go | 66 ++++++++++++++++++++++++++++++++++++++++++ int8.go | 66 ++++++++++++++++++++++++++++++++++++++++++ macaddr.go | 12 ++++++++ numeric.go | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++ timestamp.go | 6 ++++ timestamptz.go | 6 ++++ uuid.go | 6 ++++ 13 files changed, 504 insertions(+), 2 deletions(-) diff --git a/bool.go b/bool.go index 8b03a1af..9ec5097f 100644 --- a/bool.go +++ b/bool.go @@ -35,6 +35,18 @@ func (dst *Bool) Set(src interface{}) error { return err } *dst = Bool{Bool: bb, Status: Present} + case *bool: + if value == nil { + *dst = Bool{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Bool{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingBoolType(src); ok { return dst.Set(originalSrc) diff --git a/date.go b/date.go index 37fb8302..59e225df 100644 --- a/date.go +++ b/date.go @@ -39,6 +39,18 @@ func (dst *Date) Set(src interface{}) error { *dst = Date{Time: value, Status: Present} case string: return dst.DecodeText(nil, []byte(value)) + case *time.Time: + if value == nil { + *dst = Date{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Date{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingTimeType(src); ok { return dst.Set(originalSrc) diff --git a/float4.go b/float4.go index e33dfc75..5faad54d 100644 --- a/float4.go +++ b/float4.go @@ -89,6 +89,84 @@ func (dst *Float4) Set(src interface{}) error { return err } *dst = Float4{Float: float32(num), Status: Present} + case *float64: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *float32: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *int8: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint8: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *int16: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint16: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *int32: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint32: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *int64: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint64: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *int: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Float4{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingNumberType(src); ok { return dst.Set(originalSrc) diff --git a/float8.go b/float8.go index 41d0fe70..d7412301 100644 --- a/float8.go +++ b/float8.go @@ -79,6 +79,84 @@ func (dst *Float8) Set(src interface{}) error { return err } *dst = Float8{Float: float64(num), Status: Present} + case *float64: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *float32: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *int8: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint8: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *int16: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint16: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *int32: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint32: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *int64: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint64: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *int: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Float8{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingNumberType(src); ok { return dst.Set(originalSrc) diff --git a/inet.go b/inet.go index 7ab78bdf..f3dce87b 100644 --- a/inet.go +++ b/inet.go @@ -37,8 +37,6 @@ func (dst *Inet) Set(src interface{}) error { switch value := src.(type) { case net.IPNet: *dst = Inet{IPNet: &value, Status: Present} - case *net.IPNet: - *dst = Inet{IPNet: value, Status: Present} case net.IP: bitCount := len(value) * 8 mask := net.CIDRMask(bitCount, bitCount) @@ -49,6 +47,24 @@ func (dst *Inet) Set(src interface{}) error { return err } *dst = Inet{IPNet: ipnet, Status: Present} + case *net.IPNet: + if value == nil { + *dst = Inet{Status: Null} + } else { + return dst.Set(*value) + } + case *net.IP: + if value == nil { + *dst = Inet{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Inet{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingPtrType(src); ok { return dst.Set(originalSrc) diff --git a/int2.go b/int2.go index 54bab272..67fa1acc 100644 --- a/int2.go +++ b/int2.go @@ -85,6 +85,72 @@ func (dst *Int2) Set(src interface{}) error { return err } *dst = Int2{Int: int16(num), Status: Present} + case *int8: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *uint8: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *int16: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *uint16: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *int32: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *uint32: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *int64: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *uint64: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *int: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *uint: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Int2{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingNumberType(src); ok { return dst.Set(originalSrc) diff --git a/int4.go b/int4.go index 66fe9155..c4ed6103 100644 --- a/int4.go +++ b/int4.go @@ -77,6 +77,72 @@ func (dst *Int4) Set(src interface{}) error { return err } *dst = Int4{Int: int32(num), Status: Present} + case *int8: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint8: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *int16: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint16: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *int32: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint32: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *int64: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint64: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *int: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *uint: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Int4{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingNumberType(src); ok { return dst.Set(originalSrc) diff --git a/int8.go b/int8.go index fd721142..445fef0d 100644 --- a/int8.go +++ b/int8.go @@ -68,6 +68,72 @@ func (dst *Int8) Set(src interface{}) error { return err } *dst = Int8{Int: num, Status: Present} + case *int8: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint8: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *int16: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint16: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *int32: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint32: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *int64: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint64: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *int: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *uint: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Int8{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingNumberType(src); ok { return dst.Set(originalSrc) diff --git a/macaddr.go b/macaddr.go index af0901b0..6cc14114 100644 --- a/macaddr.go +++ b/macaddr.go @@ -36,6 +36,18 @@ func (dst *Macaddr) Set(src interface{}) error { return err } *dst = Macaddr{Addr: addr, Status: Present} + case *net.HardwareAddr: + if value == nil { + *dst = Macaddr{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Macaddr{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingPtrType(src); ok { return dst.Set(originalSrc) diff --git a/numeric.go b/numeric.go index 37a81edf..f2b04006 100644 --- a/numeric.go +++ b/numeric.go @@ -115,6 +115,84 @@ func (dst *Numeric) Set(src interface{}) error { return err } *dst = Numeric{Int: num, Exp: exp, Status: Present} + case *float64: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *float32: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *int8: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *uint8: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *int16: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *uint16: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *int32: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *uint32: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *int64: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *uint64: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *int: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *uint: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } + case *string: + if value == nil { + *dst = Numeric{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingNumberType(src); ok { return dst.Set(originalSrc) diff --git a/timestamp.go b/timestamp.go index de059f7e..88cb7672 100644 --- a/timestamp.go +++ b/timestamp.go @@ -40,6 +40,12 @@ func (dst *Timestamp) Set(src interface{}) error { switch value := src.(type) { case time.Time: *dst = Timestamp{Time: time.Date(value.Year(), value.Month(), value.Day(), value.Hour(), value.Minute(), value.Second(), value.Nanosecond(), time.UTC), Status: Present} + case *time.Time: + if value == nil { + *dst = Timestamp{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingTimeType(src); ok { return dst.Set(originalSrc) diff --git a/timestamptz.go b/timestamptz.go index 100f44a5..25ea659d 100644 --- a/timestamptz.go +++ b/timestamptz.go @@ -42,6 +42,12 @@ func (dst *Timestamptz) Set(src interface{}) error { switch value := src.(type) { case time.Time: *dst = Timestamptz{Time: value, Status: Present} + case *time.Time: + if value == nil { + *dst = Timestamptz{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingTimeType(src); ok { return dst.Set(originalSrc) diff --git a/uuid.go b/uuid.go index bdbe17e4..634f6463 100644 --- a/uuid.go +++ b/uuid.go @@ -45,6 +45,12 @@ func (dst *UUID) Set(src interface{}) error { return err } *dst = UUID{Bytes: uuid, Status: Present} + case *string: + if value == nil { + *dst = UUID{Status: Null} + } else { + return dst.Set(*value) + } default: if originalSrc, ok := underlyingUUIDType(src); ok { return dst.Set(originalSrc) From 066bc77610f0e459a3c097be13de3730e1c687a7 Mon Sep 17 00:00:00 2001 From: megaturbo Date: Wed, 17 Jun 2020 15:17:17 +0200 Subject: [PATCH 2/4] 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) From bc07106f0e2f48fd1031ce2ba3c23e8778382b4e Mon Sep 17 00:00:00 2001 From: megaturbo Date: Wed, 17 Jun 2020 15:24:34 +0200 Subject: [PATCH 3/4] Add `Code generated` notice at the top of the file --- aclitem_array.go | 2 ++ bool_array.go | 2 ++ bpchar_array.go | 2 ++ bytea_array.go | 2 ++ cidr_array.go | 2 ++ date_array.go | 2 ++ enum_array.go | 2 ++ float4_array.go | 2 ++ float8_array.go | 2 ++ hstore_array.go | 2 ++ inet_array.go | 2 ++ int2_array.go | 2 ++ int4_array.go | 2 ++ int8_array.go | 2 ++ macaddr_array.go | 2 ++ numeric_array.go | 2 ++ text_array.go | 2 ++ timestamp_array.go | 2 ++ timestamptz_array.go | 2 ++ tstzrange_array.go | 2 ++ typed_array.go.erb | 2 ++ uuid_array.go | 2 ++ varchar_array.go | 2 ++ 23 files changed, 46 insertions(+) diff --git a/aclitem_array.go b/aclitem_array.go index 064436fd..2df0ccd4 100644 --- a/aclitem_array.go +++ b/aclitem_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/bool_array.go b/bool_array.go index d5f89629..a8c75a25 100644 --- a/bool_array.go +++ b/bool_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/bpchar_array.go b/bpchar_array.go index 10d0d0f7..ed6fe703 100644 --- a/bpchar_array.go +++ b/bpchar_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/bytea_array.go b/bytea_array.go index 6a45e4da..87d77f9e 100644 --- a/bytea_array.go +++ b/bytea_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/cidr_array.go b/cidr_array.go index 5231e208..a2e025cc 100644 --- a/cidr_array.go +++ b/cidr_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/date_array.go b/date_array.go index 51d00da1..fe185f67 100644 --- a/date_array.go +++ b/date_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/enum_array.go b/enum_array.go index 528cdb03..9312264c 100644 --- a/enum_array.go +++ b/enum_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/float4_array.go b/float4_array.go index bc9d4746..0e95c446 100644 --- a/float4_array.go +++ b/float4_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/float8_array.go b/float8_array.go index acc94b3f..240e88d6 100644 --- a/float8_array.go +++ b/float8_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/hstore_array.go b/hstore_array.go index 54909e42..b258cbdd 100644 --- a/hstore_array.go +++ b/hstore_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/inet_array.go b/inet_array.go index 6d9f11fb..ca4c1a02 100644 --- a/inet_array.go +++ b/inet_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/int2_array.go b/int2_array.go index 35f73fee..ad2bd094 100644 --- a/int2_array.go +++ b/int2_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/int4_array.go b/int4_array.go index 2ff32ee1..15565f64 100644 --- a/int4_array.go +++ b/int4_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/int8_array.go b/int8_array.go index 17968338..e8e8823a 100644 --- a/int8_array.go +++ b/int8_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/macaddr_array.go b/macaddr_array.go index 72a4e8d4..616d6f85 100644 --- a/macaddr_array.go +++ b/macaddr_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/numeric_array.go b/numeric_array.go index e808669c..e086ca7a 100644 --- a/numeric_array.go +++ b/numeric_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/text_array.go b/text_array.go index 969054f8..d1583557 100644 --- a/text_array.go +++ b/text_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/timestamp_array.go b/timestamp_array.go index 81fd85f8..3b2c3141 100644 --- a/timestamp_array.go +++ b/timestamp_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/timestamptz_array.go b/timestamptz_array.go index 48725e29..3328ec05 100644 --- a/timestamptz_array.go +++ b/timestamptz_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/tstzrange_array.go b/tstzrange_array.go index 2c365645..c19a9bfa 100644 --- a/tstzrange_array.go +++ b/tstzrange_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/typed_array.go.erb b/typed_array.go.erb index d8ae97dd..a3deea5b 100644 --- a/typed_array.go.erb +++ b/typed_array.go.erb @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/uuid_array.go b/uuid_array.go index 0c02977f..06d2d576 100644 --- a/uuid_array.go +++ b/uuid_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( diff --git a/varchar_array.go b/varchar_array.go index 5758ba62..32ca5941 100644 --- a/varchar_array.go +++ b/varchar_array.go @@ -1,3 +1,5 @@ +// Code generated by erb. DO NOT EDIT. + package pgtype import ( From 41a185b6112f3e3a1d0aa867d766f8f6c2db2af2 Mon Sep 17 00:00:00 2001 From: Jack Christensen Date: Sat, 20 Jun 2020 13:26:06 -0500 Subject: [PATCH 4/4] Allow converting intervals with months and days to duration It's a lossy conversion but so is numeric to float. fixes #42 --- interval.go | 8 ++++---- interval_test.go | 11 +++++++++++ 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/interval.go b/interval.go index 3a91c595..309e880c 100644 --- a/interval.go +++ b/interval.go @@ -16,6 +16,8 @@ const ( microsecondsPerSecond = 1000000 microsecondsPerMinute = 60 * microsecondsPerSecond microsecondsPerHour = 60 * microsecondsPerMinute + microsecondsPerDay = 24 * microsecondsPerHour + microsecondsPerMonth = 30 * microsecondsPerDay ) type Interval struct { @@ -67,10 +69,8 @@ func (src *Interval) AssignTo(dst interface{}) error { case Present: switch v := dst.(type) { case *time.Duration: - if src.Days > 0 || src.Months > 0 { - return errors.Errorf("interval with months or days cannot be decoded into %T", dst) - } - *v = time.Duration(src.Microseconds) * time.Microsecond + us := int64(src.Months)*microsecondsPerMonth + int64(src.Days)*microsecondsPerDay + src.Microseconds + *v = time.Duration(us) * time.Microsecond return nil default: if nextDst, retry := GetAssignToDstType(dst); retry { diff --git a/interval_test.go b/interval_test.go index 6a4787e0..1ee094d7 100644 --- a/interval_test.go +++ b/interval_test.go @@ -2,9 +2,12 @@ package pgtype_test import ( "testing" + "time" "github.com/jackc/pgtype" "github.com/jackc/pgtype/testutil" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestIntervalTranscode(t *testing.T) { @@ -61,3 +64,11 @@ func TestIntervalNormalize(t *testing.T) { }, }) } + +func TestIntervalLossyConversionToDuration(t *testing.T) { + interval := &pgtype.Interval{Months: 1, Days: 1, Status: pgtype.Present} + var d time.Duration + err := interval.AssignTo(&d) + require.NoError(t, err) + assert.EqualValues(t, int64(2678400000000000), d.Nanoseconds()) +}