gopkg/pgx
2
0
Fork 0
Code Activity

Replace Status with Valid to conform to database/sql style

Browse Source 
https://github.com/jackc/pgx/issues/1060
This commit is contained in:
Jack Christensen
2021-08-26 22:46:13 -05:00
parent 37044f47f5
commit 11d351dd75
156 changed files with 6909 additions and 7894 deletions
Download Patch File Download Diff File Expand all files Collapse all files
float8_array.go
+85 -98
View File
@@ -14,13 +14,13 @@ import (
type Float8Array struct {
Elements []Float8
Dimensions []ArrayDimension
Status Status
Valid bool
}
func (dst *Float8Array) Set(src interface{}) error {
// untyped nil and typed nil interfaces are different
if src == nil {
*dst = Float8Array{Status: Null}
*dst = Float8Array{}
return nil
}
@@ -36,9 +36,9 @@ func (dst *Float8Array) Set(src interface{}) error {
case []float64:
if value == nil {
*dst = Float8Array{Status: Null}
*dst = Float8Array{}
} else if len(value) == 0 {
*dst = Float8Array{Status: Present}
*dst = Float8Array{Valid: true}
} else {
elements := make([]Float8, len(value))
for i := range value {
@@ -49,15 +49,15 @@ func (dst *Float8Array) Set(src interface{}) error {
*dst = Float8Array{
Elements: elements,
Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
Status: Present,
Valid: true,
}
}
case []*float64:
if value == nil {
*dst = Float8Array{Status: Null}
*dst = Float8Array{}
} else if len(value) == 0 {
*dst = Float8Array{Status: Present}
*dst = Float8Array{Valid: true}
} else {
elements := make([]Float8, len(value))
for i := range value {
@@ -68,20 +68,20 @@ func (dst *Float8Array) Set(src interface{}) error {
*dst = Float8Array{
Elements: elements,
Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
Status: Present,
Valid: true,
}
}
case []Float8:
if value == nil {
*dst = Float8Array{Status: Null}
*dst = Float8Array{}
} else if len(value) == 0 {
*dst = Float8Array{Status: Present}
*dst = Float8Array{Valid: true}
} else {
*dst = Float8Array{
Elements: value,
Dimensions: []ArrayDimension{{Length: int32(len(value)), LowerBound: 1}},
Status: Present,
Valid: true,
}
}
default:
@@ -90,7 +90,7 @@ func (dst *Float8Array) Set(src interface{}) error {
// but it comes with a 20-50% performance penalty for large arrays/slices
reflectedValue := reflect.ValueOf(src)
if !reflectedValue.IsValid() || reflectedValue.IsZero() {
*dst = Float8Array{Status: Null}
*dst = Float8Array{}
return nil
}
@@ -99,7 +99,7 @@ func (dst *Float8Array) Set(src interface{}) error {
return fmt.Errorf("cannot find dimensions of %v for Float8Array", src)
}
if elementsLength == 0 {
*dst = Float8Array{Status: Present}
*dst = Float8Array{Valid: true}
return nil
}
if len(dimensions) == 0 {
@@ -112,7 +112,7 @@ func (dst *Float8Array) Set(src interface{}) error {
*dst = Float8Array{
Elements: make([]Float8, elementsLength),
Dimensions: dimensions,
Status: Present,
Valid: true,
}
elementCount, err := dst.setRecursive(reflectedValue, 0, 0)
if err != nil {
@@ -179,84 +179,77 @@ func (dst *Float8Array) setRecursive(value reflect.Value, index, dimension int)
}
func (dst Float8Array) Get() interface{} {
switch dst.Status {
case Present:
return dst
case Null:
if !dst.Valid {
return nil
default:
return dst.Status
}
return dst
}
func (src *Float8Array) AssignTo(dst interface{}) error {
switch src.Status {
case Present:
if len(src.Dimensions) <= 1 {
// Attempt to match to select common types:
switch v := dst.(type) {
case *[]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 *[]*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
}
}
// Try to convert to something AssignTo can use directly.
if nextDst, retry := GetAssignToDstType(dst); retry {
return src.AssignTo(nextDst)
}
// Fallback to reflection if an optimised match was not found.
// The reflection is necessary for arrays and multidimensional slices,
// but it comes with a 20-50% performance penalty for large arrays/slices
value := reflect.ValueOf(dst)
if value.Kind() == reflect.Ptr {
value = value.Elem()
}
switch value.Kind() {
case reflect.Array, reflect.Slice:
default:
return fmt.Errorf("cannot assign %T to %T", src, dst)
}
if len(src.Elements) == 0 {
if value.Kind() == reflect.Slice {
value.Set(reflect.MakeSlice(value.Type(), 0, 0))
return nil
}
}
elementCount, err := src.assignToRecursive(value, 0, 0)
if err != nil {
return err
}
if elementCount != len(src.Elements) {
return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
}
return nil
case Null:
if !src.Valid {
return NullAssignTo(dst)
}
return fmt.Errorf("cannot decode %#v into %T", src, dst)
if len(src.Dimensions) <= 1 {
// Attempt to match to select common types:
switch v := dst.(type) {
case *[]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 *[]*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
}
}
// Try to convert to something AssignTo can use directly.
if nextDst, retry := GetAssignToDstType(dst); retry {
return src.AssignTo(nextDst)
}
// Fallback to reflection if an optimised match was not found.
// The reflection is necessary for arrays and multidimensional slices,
// but it comes with a 20-50% performance penalty for large arrays/slices
value := reflect.ValueOf(dst)
if value.Kind() == reflect.Ptr {
value = value.Elem()
}
switch value.Kind() {
case reflect.Array, reflect.Slice:
default:
return fmt.Errorf("cannot assign %T to %T", src, dst)
}
if len(src.Elements) == 0 {
if value.Kind() == reflect.Slice {
value.Set(reflect.MakeSlice(value.Type(), 0, 0))
return nil
}
}
elementCount, err := src.assignToRecursive(value, 0, 0)
if err != nil {
return err
}
if elementCount != len(src.Elements) {
return fmt.Errorf("cannot assign %v, needed to assign %d elements, but only assigned %d", dst, len(src.Elements), elementCount)
}
return nil
}
func (src *Float8Array) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
@@ -308,7 +301,7 @@ func (src *Float8Array) assignToRecursive(value reflect.Value, index, dimension
func (dst *Float8Array) DecodeText(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = Float8Array{Status: Null}
*dst = Float8Array{}
return nil
}
@@ -337,14 +330,14 @@ func (dst *Float8Array) DecodeText(ci *ConnInfo, src []byte) error {
}
}
*dst = Float8Array{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
*dst = Float8Array{Elements: elements, Dimensions: uta.Dimensions, Valid: true}
return nil
}
func (dst *Float8Array) DecodeBinary(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = Float8Array{Status: Null}
*dst = Float8Array{}
return nil
}
@@ -355,7 +348,7 @@ func (dst *Float8Array) DecodeBinary(ci *ConnInfo, src []byte) error {
}
if len(arrayHeader.Dimensions) == 0 {
*dst = Float8Array{Dimensions: arrayHeader.Dimensions, Status: Present}
*dst = Float8Array{Dimensions: arrayHeader.Dimensions, Valid: true}
return nil
}
@@ -380,16 +373,13 @@ func (dst *Float8Array) DecodeBinary(ci *ConnInfo, src []byte) error {
}
}
*dst = Float8Array{Elements: elements, Dimensions: arrayHeader.Dimensions, Status: Present}
*dst = Float8Array{Elements: elements, Dimensions: arrayHeader.Dimensions, Valid: true}
return nil
}
func (src Float8Array) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
switch src.Status {
case Null:
if !src.Valid {
return nil, nil
case Undefined:
return nil, errUndefined
}
if len(src.Dimensions) == 0 {
@@ -442,11 +432,8 @@ func (src Float8Array) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
}
func (src Float8Array) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
switch src.Status {
case Null:
if !src.Valid {
return nil, nil
case Undefined:
return nil, errUndefined
}
arrayHeader := ArrayHeader{
@@ -460,7 +447,7 @@ func (src Float8Array) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
}
for i := range src.Elements {
if src.Elements[i].Status == Null {
if !src.Elements[i].Valid {
arrayHeader.ContainsNull = true
break
}