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
tsrange_array.go
+70 -83
View File
@@ -14,13 +14,13 @@ import (
type TsrangeArray struct {
Elements []Tsrange
Dimensions []ArrayDimension
Status Status
Valid bool
}
func (dst *TsrangeArray) Set(src interface{}) error {
// untyped nil and typed nil interfaces are different
if src == nil {
*dst = TsrangeArray{Status: Null}
*dst = TsrangeArray{}
return nil
}
@@ -36,14 +36,14 @@ func (dst *TsrangeArray) Set(src interface{}) error {
case []Tsrange:
if value == nil {
*dst = TsrangeArray{Status: Null}
*dst = TsrangeArray{}
} else if len(value) == 0 {
*dst = TsrangeArray{Status: Present}
*dst = TsrangeArray{Valid: true}
} else {
*dst = TsrangeArray{
Elements: value,
Dimensions: []ArrayDimension{{Length: int32(len(value)), LowerBound: 1}},
Status: Present,
Valid: true,
}
}
default:
@@ -52,7 +52,7 @@ func (dst *TsrangeArray) 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 = TsrangeArray{Status: Null}
*dst = TsrangeArray{}
return nil
}
@@ -61,7 +61,7 @@ func (dst *TsrangeArray) Set(src interface{}) error {
return fmt.Errorf("cannot find dimensions of %v for TsrangeArray", src)
}
if elementsLength == 0 {
*dst = TsrangeArray{Status: Present}
*dst = TsrangeArray{Valid: true}
return nil
}
if len(dimensions) == 0 {
@@ -74,7 +74,7 @@ func (dst *TsrangeArray) Set(src interface{}) error {
*dst = TsrangeArray{
Elements: make([]Tsrange, elementsLength),
Dimensions: dimensions,
Status: Present,
Valid: true,
}
elementCount, err := dst.setRecursive(reflectedValue, 0, 0)
if err != nil {
@@ -141,75 +141,68 @@ func (dst *TsrangeArray) setRecursive(value reflect.Value, index, dimension int)
}
func (dst TsrangeArray) Get() interface{} {
switch dst.Status {
case Present:
return dst
case Null:
if !dst.Valid {
return nil
default:
return dst.Status
}
return dst
}
func (src *TsrangeArray) 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 *[]Tsrange:
*v = make([]Tsrange, 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 *[]Tsrange:
*v = make([]Tsrange, 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 *TsrangeArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
@@ -261,7 +254,7 @@ func (src *TsrangeArray) assignToRecursive(value reflect.Value, index, dimension
func (dst *TsrangeArray) DecodeText(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = TsrangeArray{Status: Null}
*dst = TsrangeArray{}
return nil
}
@@ -290,14 +283,14 @@ func (dst *TsrangeArray) DecodeText(ci *ConnInfo, src []byte) error {
}
}
*dst = TsrangeArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
*dst = TsrangeArray{Elements: elements, Dimensions: uta.Dimensions, Valid: true}
return nil
}
func (dst *TsrangeArray) DecodeBinary(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = TsrangeArray{Status: Null}
*dst = TsrangeArray{}
return nil
}
@@ -308,7 +301,7 @@ func (dst *TsrangeArray) DecodeBinary(ci *ConnInfo, src []byte) error {
}
if len(arrayHeader.Dimensions) == 0 {
*dst = TsrangeArray{Dimensions: arrayHeader.Dimensions, Status: Present}
*dst = TsrangeArray{Dimensions: arrayHeader.Dimensions, Valid: true}
return nil
}
@@ -333,16 +326,13 @@ func (dst *TsrangeArray) DecodeBinary(ci *ConnInfo, src []byte) error {
}
}
*dst = TsrangeArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Status: Present}
*dst = TsrangeArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Valid: true}
return nil
}
func (src TsrangeArray) 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 {
@@ -395,11 +385,8 @@ func (src TsrangeArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
}
func (src TsrangeArray) 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{
@@ -413,7 +400,7 @@ func (src TsrangeArray) 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
}