diff --git a/pgtype/float4.go b/pgtype/float4.go index 36c46346..7699f656 100644 --- a/pgtype/float4.go +++ b/pgtype/float4.go @@ -15,198 +15,158 @@ type Float4 struct { Valid bool } -func (dst *Float4) Set(src interface{}) error { +// ScanFloat64 implements the Float64Scanner interface. +func (f *Float4) ScanFloat64(n Float8) error { + *f = Float4{Float: float32(n.Float), Valid: n.Valid} + return nil +} + +func (f Float4) Float64Value() (Float8, error) { + return Float8{Float: float64(f.Float), Valid: f.Valid}, nil +} + +// Scan implements the database/sql Scanner interface. +func (f *Float4) Scan(src interface{}) error { if src == nil { - *dst = Float4{} + *f = Float4{} return nil } - if value, ok := src.(interface{ Get() interface{} }); ok { - value2 := value.Get() - if value2 != value { - return dst.Set(value2) - } - } - - switch value := src.(type) { - case float32: - *dst = Float4{Float: value, Valid: true} + switch src := src.(type) { case float64: - *dst = Float4{Float: float32(value), Valid: true} - case int8: - *dst = Float4{Float: float32(value), Valid: true} - case uint8: - *dst = Float4{Float: float32(value), Valid: true} - case int16: - *dst = Float4{Float: float32(value), Valid: true} - case uint16: - *dst = Float4{Float: float32(value), Valid: true} - case int32: - f32 := float32(value) - if int32(f32) == value { - *dst = Float4{Float: f32, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float32", value) - } - case uint32: - f32 := float32(value) - if uint32(f32) == value { - *dst = Float4{Float: f32, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float32", value) - } - case int64: - f32 := float32(value) - if int64(f32) == value { - *dst = Float4{Float: f32, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float32", value) - } - case uint64: - f32 := float32(value) - if uint64(f32) == value { - *dst = Float4{Float: f32, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float32", value) - } - case int: - f32 := float32(value) - if int(f32) == value { - *dst = Float4{Float: f32, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float32", value) - } - case uint: - f32 := float32(value) - if uint(f32) == value { - *dst = Float4{Float: f32, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float32", value) - } + *f = Float4{Float: float32(src), Valid: true} + return nil case string: - num, err := strconv.ParseFloat(value, 32) + n, err := strconv.ParseFloat(string(src), 32) if err != nil { return err } - *dst = Float4{Float: float32(num), Valid: true} - case *float64: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) + *f = Float4{Float: float32(n), Valid: true} + return nil + } + + return fmt.Errorf("cannot scan %T", src) +} + +// Value implements the database/sql/driver Valuer interface. +func (f Float4) Value() (driver.Value, error) { + if !f.Valid { + return nil, nil + } + return float64(f.Float), nil +} + +type Float4Codec struct{} + +func (Float4Codec) FormatSupported(format int16) bool { + return format == TextFormatCode || format == BinaryFormatCode +} + +func (Float4Codec) PreferredFormat() int16 { + return BinaryFormatCode +} + +func (Float4Codec) PlanEncode(ci *ConnInfo, oid uint32, format int16, value interface{}) EncodePlan { + switch format { + case BinaryFormatCode: + switch value.(type) { + case float32: + return encodePlanFloat4CodecBinaryFloat32{} + case Float64Valuer: + return encodePlanFloat4CodecBinaryFloat64Valuer{} + case Int64Valuer: + return encodePlanFloat4CodecBinaryInt64Valuer{} } - case *float32: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) + case TextFormatCode: + switch value.(type) { + case float32: + return encodePlanTextFloat32{} + case Float64Valuer: + return encodePlanTextFloat64Valuer{} + case Int64Valuer: + return encodePlanTextInt64Valuer{} } - case *int8: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *uint8: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *int16: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *uint16: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *int32: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *uint32: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *int64: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *uint64: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *int: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *uint: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - case *string: - if value == nil { - *dst = Float4{} - } else { - return dst.Set(*value) - } - default: - if originalSrc, ok := underlyingNumberType(src); ok { - return dst.Set(originalSrc) - } - return fmt.Errorf("cannot convert %v to Float8", value) } return nil } -func (dst Float4) Get() interface{} { - if !dst.Valid { - return nil - } - return dst.Float +type encodePlanFloat4CodecBinaryFloat32 struct{} + +func (encodePlanFloat4CodecBinaryFloat32) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n := value.(float32) + return pgio.AppendUint32(buf, math.Float32bits(n)), nil } -func (src *Float4) AssignTo(dst interface{}) error { - return float64AssignTo(float64(src.Float), src.Valid, dst) +type encodePlanTextFloat32 struct{} + +func (encodePlanTextFloat32) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n := value.(float32) + return append(buf, strconv.FormatFloat(float64(n), 'f', -1, 32)...), nil } -func (dst *Float4) DecodeText(ci *ConnInfo, src []byte) error { - if src == nil { - *dst = Float4{} - return nil - } +type encodePlanFloat4CodecBinaryFloat64Valuer struct{} - n, err := strconv.ParseFloat(string(src), 32) +func (encodePlanFloat4CodecBinaryFloat64Valuer) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n, err := value.(Float64Valuer).Float64Value() if err != nil { - return err + return nil, err + } + + if !n.Valid { + return nil, nil + } + + return pgio.AppendUint32(buf, math.Float32bits(float32(n.Float))), nil +} + +type encodePlanFloat4CodecBinaryInt64Valuer struct{} + +func (encodePlanFloat4CodecBinaryInt64Valuer) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n, err := value.(Int64Valuer).Int64Value() + if err != nil { + return nil, err + } + + if !n.Valid { + return nil, nil + } + + f := float32(n.Int) + return pgio.AppendUint32(buf, math.Float32bits(f)), nil +} + +func (Float4Codec) PlanScan(ci *ConnInfo, oid uint32, format int16, target interface{}, actualTarget bool) ScanPlan { + + switch format { + case BinaryFormatCode: + switch target.(type) { + case *float32: + return scanPlanBinaryFloat4ToFloat32{} + case Float64Scanner: + return scanPlanBinaryFloat4ToFloat64Scanner{} + case Int64Scanner: + return scanPlanBinaryFloat4ToInt64Scanner{} + } + case TextFormatCode: + switch target.(type) { + case *float32: + return scanPlanTextAnyToFloat32{} + case Float64Scanner: + return scanPlanTextAnyToFloat64Scanner{} + case Int64Scanner: + return scanPlanTextAnyToInt64Scanner{} + } } - *dst = Float4{Float: float32(n), Valid: true} return nil } -func (dst *Float4) DecodeBinary(ci *ConnInfo, src []byte) error { +type scanPlanBinaryFloat4ToFloat32 struct{} + +func (scanPlanBinaryFloat4ToFloat32) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { if src == nil { - *dst = Float4{} - return nil + return fmt.Errorf("cannot scan null into %T", dst) } if len(src) != 4 { @@ -214,55 +174,92 @@ func (dst *Float4) DecodeBinary(ci *ConnInfo, src []byte) error { } n := int32(binary.BigEndian.Uint32(src)) + f := (dst).(*float32) + *f = math.Float32frombits(uint32(n)) - *dst = Float4{Float: math.Float32frombits(uint32(n)), Valid: true} return nil } -func (src Float4) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } +type scanPlanBinaryFloat4ToFloat64Scanner struct{} - buf = append(buf, strconv.FormatFloat(float64(src.Float), 'f', -1, 32)...) - return buf, nil -} +func (scanPlanBinaryFloat4ToFloat64Scanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + s := (dst).(Float64Scanner) -func (src Float4) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - buf = pgio.AppendUint32(buf, math.Float32bits(src.Float)) - return buf, nil -} - -// Scan implements the database/sql Scanner interface. -func (dst *Float4) Scan(src interface{}) error { if src == nil { - *dst = Float4{} - return nil + return s.ScanFloat64(Float8{}) } - switch src := src.(type) { - case float64: - *dst = Float4{Float: float32(src), Valid: true} - return nil - case string: - return dst.DecodeText(nil, []byte(src)) - case []byte: - srcCopy := make([]byte, len(src)) - copy(srcCopy, src) - return dst.DecodeText(nil, srcCopy) + if len(src) != 4 { + return fmt.Errorf("invalid length for float4: %v", len(src)) } - return fmt.Errorf("cannot scan %T", src) + n := int32(binary.BigEndian.Uint32(src)) + return s.ScanFloat64(Float8{Float: float64(math.Float32frombits(uint32(n))), Valid: true}) } -// Value implements the database/sql/driver Valuer interface. -func (src Float4) Value() (driver.Value, error) { - if !src.Valid { +type scanPlanBinaryFloat4ToInt64Scanner struct{} + +func (scanPlanBinaryFloat4ToInt64Scanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + s := (dst).(Int64Scanner) + + if src == nil { + return s.ScanInt64(Int8{}) + } + + if len(src) != 4 { + return fmt.Errorf("invalid length for float4: %v", len(src)) + } + + ui32 := int32(binary.BigEndian.Uint32(src)) + f32 := math.Float32frombits(uint32(ui32)) + i64 := int64(f32) + if f32 != float32(i64) { + return fmt.Errorf("cannot losslessly convert %v to int64", f32) + } + + return s.ScanInt64(Int8{Int: i64, Valid: true}) +} + +type scanPlanTextAnyToFloat32 struct{} + +func (scanPlanTextAnyToFloat32) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + if src == nil { + return fmt.Errorf("cannot scan null into %T", dst) + } + + n, err := strconv.ParseFloat(string(src), 32) + if err != nil { + return err + } + + f := (dst).(*float32) + *f = float32(n) + + return nil +} + +func (c Float4Codec) DecodeDatabaseSQLValue(ci *ConnInfo, oid uint32, format int16, src []byte) (driver.Value, error) { + if src == nil { return nil, nil } - return float64(src.Float), nil + + var n float64 + err := codecScan(c, ci, oid, format, src, &n) + if err != nil { + return nil, err + } + return n, nil +} + +func (c Float4Codec) DecodeValue(ci *ConnInfo, oid uint32, format int16, src []byte) (interface{}, error) { + if src == nil { + return nil, nil + } + + var n float32 + err := codecScan(c, ci, oid, format, src, &n) + if err != nil { + return nil, err + } + return n, nil } diff --git a/pgtype/float4_array.go b/pgtype/float4_array.go deleted file mode 100644 index dcf6c1f7..00000000 --- a/pgtype/float4_array.go +++ /dev/null @@ -1,504 +0,0 @@ -// Code generated by erb. DO NOT EDIT. - -package pgtype - -import ( - "database/sql/driver" - "encoding/binary" - "fmt" - "reflect" - - "github.com/jackc/pgio" -) - -type Float4Array struct { - Elements []Float4 - Dimensions []ArrayDimension - Valid bool -} - -func (dst *Float4Array) Set(src interface{}) error { - // untyped nil and typed nil interfaces are different - if src == nil { - *dst = Float4Array{} - return nil - } - - if value, ok := src.(interface{ Get() interface{} }); ok { - value2 := value.Get() - if value2 != value { - return dst.Set(value2) - } - } - - // Attempt to match to select common types: - switch value := src.(type) { - - case []float32: - if value == nil { - *dst = Float4Array{} - } else if len(value) == 0 { - *dst = Float4Array{Valid: true} - } 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}}, - Valid: true, - } - } - - case []*float32: - if value == nil { - *dst = Float4Array{} - } else if len(value) == 0 { - *dst = Float4Array{Valid: true} - } 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}}, - Valid: true, - } - } - - case []Float4: - if value == nil { - *dst = Float4Array{} - } else if len(value) == 0 { - *dst = Float4Array{Valid: true} - } else { - *dst = Float4Array{ - Elements: value, - Dimensions: []ArrayDimension{{Length: int32(len(value)), LowerBound: 1}}, - Valid: true, - } - } - default: - // 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 - reflectedValue := reflect.ValueOf(src) - if !reflectedValue.IsValid() || reflectedValue.IsZero() { - *dst = Float4Array{} - return nil - } - - dimensions, elementsLength, ok := findDimensionsFromValue(reflectedValue, nil, 0) - if !ok { - return fmt.Errorf("cannot find dimensions of %v for Float4Array", src) - } - if elementsLength == 0 { - *dst = Float4Array{Valid: true} - return nil - } - if len(dimensions) == 0 { - if originalSrc, ok := underlyingSliceType(src); ok { - return dst.Set(originalSrc) - } - return fmt.Errorf("cannot convert %v to Float4Array", src) - } - - *dst = Float4Array{ - Elements: make([]Float4, elementsLength), - Dimensions: dimensions, - Valid: true, - } - elementCount, err := dst.setRecursive(reflectedValue, 0, 0) - if err != nil { - // Maybe the target was one dimension too far, try again: - if len(dst.Dimensions) > 1 { - dst.Dimensions = dst.Dimensions[:len(dst.Dimensions)-1] - elementsLength = 0 - for _, dim := range dst.Dimensions { - if elementsLength == 0 { - elementsLength = int(dim.Length) - } else { - elementsLength *= int(dim.Length) - } - } - dst.Elements = make([]Float4, elementsLength) - elementCount, err = dst.setRecursive(reflectedValue, 0, 0) - if err != nil { - return err - } - } else { - return err - } - } - if elementCount != len(dst.Elements) { - return fmt.Errorf("cannot convert %v to Float4Array, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount) - } - } - - return nil -} - -func (dst *Float4Array) setRecursive(value reflect.Value, index, dimension int) (int, error) { - switch value.Kind() { - case reflect.Array: - fallthrough - case reflect.Slice: - if len(dst.Dimensions) == dimension { - break - } - - valueLen := value.Len() - if int32(valueLen) != dst.Dimensions[dimension].Length { - return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions") - } - for i := 0; i < valueLen; i++ { - var err error - index, err = dst.setRecursive(value.Index(i), index, dimension+1) - if err != nil { - return 0, err - } - } - - return index, nil - } - if !value.CanInterface() { - return 0, fmt.Errorf("cannot convert all values to Float4Array") - } - if err := dst.Elements[index].Set(value.Interface()); err != nil { - return 0, fmt.Errorf("%v in Float4Array", err) - } - index++ - - return index, nil -} - -func (dst Float4Array) Get() interface{} { - if !dst.Valid { - return nil - } - return dst -} - -func (src *Float4Array) AssignTo(dst interface{}) error { - if !src.Valid { - return NullAssignTo(dst) - } - - if len(src.Dimensions) <= 1 { - // Attempt to match to select common types: - switch v := dst.(type) { - - 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 *[]*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 - - } - } - - // 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 *Float4Array) assignToRecursive(value reflect.Value, index, dimension int) (int, error) { - switch kind := value.Kind(); kind { - case reflect.Array: - fallthrough - case reflect.Slice: - if len(src.Dimensions) == dimension { - break - } - - length := int(src.Dimensions[dimension].Length) - if reflect.Array == kind { - typ := value.Type() - if typ.Len() != length { - return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len()) - } - value.Set(reflect.New(typ).Elem()) - } else { - value.Set(reflect.MakeSlice(value.Type(), length, length)) - } - - var err error - for i := 0; i < length; i++ { - index, err = src.assignToRecursive(value.Index(i), index, dimension+1) - if err != nil { - return 0, err - } - } - - return index, nil - } - if len(src.Dimensions) != dimension { - return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension) - } - if !value.CanAddr() { - return 0, fmt.Errorf("cannot assign all values from Float4Array") - } - addr := value.Addr() - if !addr.CanInterface() { - return 0, fmt.Errorf("cannot assign all values from Float4Array") - } - if err := src.Elements[index].AssignTo(addr.Interface()); err != nil { - return 0, err - } - index++ - return index, nil -} - -func (dst *Float4Array) DecodeText(ci *ConnInfo, src []byte) error { - if src == nil { - *dst = Float4Array{} - return nil - } - - uta, err := ParseUntypedTextArray(string(src)) - if err != nil { - return err - } - - var elements []Float4 - - if len(uta.Elements) > 0 { - elements = make([]Float4, len(uta.Elements)) - - for i, s := range uta.Elements { - var elem Float4 - var elemSrc []byte - if s != "NULL" || uta.Quoted[i] { - elemSrc = []byte(s) - } - err = elem.DecodeText(ci, elemSrc) - if err != nil { - return err - } - - elements[i] = elem - } - } - - *dst = Float4Array{Elements: elements, Dimensions: uta.Dimensions, Valid: true} - - return nil -} - -func (dst *Float4Array) DecodeBinary(ci *ConnInfo, src []byte) error { - if src == nil { - *dst = Float4Array{} - return nil - } - - var arrayHeader ArrayHeader - rp, err := arrayHeader.DecodeBinary(ci, src) - if err != nil { - return err - } - - if len(arrayHeader.Dimensions) == 0 { - *dst = Float4Array{Dimensions: arrayHeader.Dimensions, Valid: true} - return nil - } - - elementCount := arrayHeader.Dimensions[0].Length - for _, d := range arrayHeader.Dimensions[1:] { - elementCount *= d.Length - } - - elements := make([]Float4, elementCount) - - for i := range elements { - elemLen := int(int32(binary.BigEndian.Uint32(src[rp:]))) - rp += 4 - var elemSrc []byte - if elemLen >= 0 { - elemSrc = src[rp : rp+elemLen] - rp += elemLen - } - err = elements[i].DecodeBinary(ci, elemSrc) - if err != nil { - return err - } - } - - *dst = Float4Array{Elements: elements, Dimensions: arrayHeader.Dimensions, Valid: true} - return nil -} - -func (src Float4Array) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - if len(src.Dimensions) == 0 { - return append(buf, '{', '}'), nil - } - - buf = EncodeTextArrayDimensions(buf, src.Dimensions) - - // dimElemCounts is the multiples of elements that each array lies on. For - // example, a single dimension array of length 4 would have a dimElemCounts of - // [4]. A multi-dimensional array of lengths [3,5,2] would have a - // dimElemCounts of [30,10,2]. This is used to simplify when to render a '{' - // or '}'. - dimElemCounts := make([]int, len(src.Dimensions)) - dimElemCounts[len(src.Dimensions)-1] = int(src.Dimensions[len(src.Dimensions)-1].Length) - for i := len(src.Dimensions) - 2; i > -1; i-- { - dimElemCounts[i] = int(src.Dimensions[i].Length) * dimElemCounts[i+1] - } - - inElemBuf := make([]byte, 0, 32) - for i, elem := range src.Elements { - if i > 0 { - buf = append(buf, ',') - } - - for _, dec := range dimElemCounts { - if i%dec == 0 { - buf = append(buf, '{') - } - } - - elemBuf, err := elem.EncodeText(ci, inElemBuf) - if err != nil { - return nil, err - } - if elemBuf == nil { - buf = append(buf, `NULL`...) - } else { - buf = append(buf, QuoteArrayElementIfNeeded(string(elemBuf))...) - } - - for _, dec := range dimElemCounts { - if (i+1)%dec == 0 { - buf = append(buf, '}') - } - } - } - - return buf, nil -} - -func (src Float4Array) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - arrayHeader := ArrayHeader{ - Dimensions: src.Dimensions, - } - - if dt, ok := ci.DataTypeForName("float4"); ok { - arrayHeader.ElementOID = int32(dt.OID) - } else { - return nil, fmt.Errorf("unable to find oid for type name %v", "float4") - } - - for i := range src.Elements { - if !src.Elements[i].Valid { - arrayHeader.ContainsNull = true - break - } - } - - buf = arrayHeader.EncodeBinary(ci, buf) - - for i := range src.Elements { - sp := len(buf) - buf = pgio.AppendInt32(buf, -1) - - elemBuf, err := src.Elements[i].EncodeBinary(ci, buf) - if err != nil { - return nil, err - } - if elemBuf != nil { - buf = elemBuf - pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4)) - } - } - - return buf, nil -} - -// Scan implements the database/sql Scanner interface. -func (dst *Float4Array) Scan(src interface{}) error { - if src == nil { - return dst.DecodeText(nil, nil) - } - - switch src := src.(type) { - case string: - return dst.DecodeText(nil, []byte(src)) - case []byte: - srcCopy := make([]byte, len(src)) - copy(srcCopy, src) - return dst.DecodeText(nil, srcCopy) - } - - return fmt.Errorf("cannot scan %T", src) -} - -// Value implements the database/sql/driver Valuer interface. -func (src Float4Array) Value() (driver.Value, error) { - buf, err := src.EncodeText(nil, nil) - if err != nil { - return nil, err - } - if buf == nil { - return nil, nil - } - - return string(buf), nil -} diff --git a/pgtype/float4_array_test.go b/pgtype/float4_array_test.go deleted file mode 100644 index ecd65206..00000000 --- a/pgtype/float4_array_test.go +++ /dev/null @@ -1,282 +0,0 @@ -package pgtype_test - -import ( - "reflect" - "testing" - - "github.com/jackc/pgx/v5/pgtype" - "github.com/jackc/pgx/v5/pgtype/testutil" -) - -func TestFloat4ArrayTranscode(t *testing.T) { - testutil.TestSuccessfulTranscode(t, "float4[]", []interface{}{ - &pgtype.Float4Array{ - Elements: nil, - Dimensions: nil, - Valid: true, - }, - &pgtype.Float4Array{ - Elements: []pgtype.Float4{ - {Float: 1, Valid: true}, - {}, - }, - Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}}, - Valid: true, - }, - &pgtype.Float4Array{}, - &pgtype.Float4Array{ - Elements: []pgtype.Float4{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {}, - {Float: 6, Valid: true}, - }, - Dimensions: []pgtype.ArrayDimension{{Length: 3, LowerBound: 1}, {Length: 2, LowerBound: 1}}, - Valid: true, - }, - &pgtype.Float4Array{ - Elements: []pgtype.Float4{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - }, - Dimensions: []pgtype.ArrayDimension{ - {Length: 2, LowerBound: 4}, - {Length: 2, LowerBound: 2}, - }, - Valid: true, - }, - }) -} - -func TestFloat4ArraySet(t *testing.T) { - successfulTests := []struct { - source interface{} - result pgtype.Float4Array - }{ - { - source: []float32{1}, - result: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: (([]float32)(nil)), - result: pgtype.Float4Array{}, - }, - { - source: [][]float32{{1}, {2}}, - result: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: [][][][]float32{{{{1, 2, 3}}}, {{{4, 5, 6}}}}, - result: pgtype.Float4Array{ - Elements: []pgtype.Float4{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {Float: 5, Valid: true}, - {Float: 6, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - }, - { - source: [2][1]float32{{1}, {2}}, - result: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: [2][1][1][3]float32{{{{1, 2, 3}}}, {{{4, 5, 6}}}}, - result: pgtype.Float4Array{ - Elements: []pgtype.Float4{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {Float: 5, Valid: true}, - {Float: 6, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - }, - } - - for i, tt := range successfulTests { - var r pgtype.Float4Array - err := r.Set(tt.source) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if !reflect.DeepEqual(r, tt.result) { - t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, r) - } - } -} - -func TestFloat4ArrayAssignTo(t *testing.T) { - var float32Slice []float32 - var namedFloat32Slice _float32Slice - var float32SliceDim2 [][]float32 - var float32SliceDim4 [][][][]float32 - var float32ArrayDim2 [2][1]float32 - var float32ArrayDim4 [2][1][1][3]float32 - - simpleTests := []struct { - src pgtype.Float4Array - dst interface{} - expected interface{} - }{ - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1.23, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &float32Slice, - expected: []float32{1.23}, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1.23, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &namedFloat32Slice, - expected: _float32Slice{1.23}, - }, - { - src: pgtype.Float4Array{}, - dst: &float32Slice, - expected: (([]float32)(nil)), - }, - { - src: pgtype.Float4Array{Valid: true}, - dst: &float32Slice, - expected: []float32{}, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - expected: [][]float32{{1}, {2}}, - dst: &float32SliceDim2, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {Float: 5, Valid: true}, - {Float: 6, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - expected: [][][][]float32{{{{1, 2, 3}}}, {{{4, 5, 6}}}}, - dst: &float32SliceDim4, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - expected: [2][1]float32{{1}, {2}}, - dst: &float32ArrayDim2, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {Float: 5, Valid: true}, - {Float: 6, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - expected: [2][1][1][3]float32{{{{1, 2, 3}}}, {{{4, 5, 6}}}}, - dst: &float32ArrayDim4, - }, - } - - for i, tt := range simpleTests { - err := tt.src.AssignTo(tt.dst) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if dst := reflect.ValueOf(tt.dst).Elem().Interface(); !reflect.DeepEqual(dst, tt.expected) { - t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst) - } - } - - errorTests := []struct { - src pgtype.Float4Array - dst interface{} - }{ - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &float32Slice, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}, {LowerBound: 1, Length: 2}}, - Valid: true}, - dst: &float32ArrayDim2, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}, {LowerBound: 1, Length: 2}}, - Valid: true}, - dst: &float32Slice, - }, - { - src: pgtype.Float4Array{ - Elements: []pgtype.Float4{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - dst: &float32ArrayDim4, - }, - } - - for i, tt := range errorTests { - err := tt.src.AssignTo(tt.dst) - if err == nil { - t.Errorf("%d: expected error but none was returned (%v -> %v)", i, tt.src, tt.dst) - } - } - -} diff --git a/pgtype/float4_test.go b/pgtype/float4_test.go index aab6e980..85b3b21d 100644 --- a/pgtype/float4_test.go +++ b/pgtype/float4_test.go @@ -1,149 +1,20 @@ package pgtype_test import ( - "reflect" "testing" "github.com/jackc/pgx/v5/pgtype" - "github.com/jackc/pgx/v5/pgtype/testutil" ) -func TestFloat4Transcode(t *testing.T) { - testutil.TestSuccessfulTranscode(t, "float4", []interface{}{ - &pgtype.Float4{Float: -1, Valid: true}, - &pgtype.Float4{Float: 0, Valid: true}, - &pgtype.Float4{Float: 0.00001, Valid: true}, - &pgtype.Float4{Float: 1, Valid: true}, - &pgtype.Float4{Float: 9999.99, Valid: true}, - &pgtype.Float4{Float: 0}, +func TestFloat4Codec(t *testing.T) { + testPgxCodec(t, "float4", []PgxTranscodeTestCase{ + {pgtype.Float4{Float: -1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: -1, Valid: true})}, + {pgtype.Float4{Float: 0, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: 0, Valid: true})}, + {pgtype.Float4{Float: 1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: 1, Valid: true})}, + {float32(0.00001), new(float32), isExpectedEq(float32(0.00001))}, + {float32(9999.99), new(float32), isExpectedEq(float32(9999.99))}, + {pgtype.Float4{}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{})}, + {int64(1), new(int64), isExpectedEq(int64(1))}, + {nil, new(*float32), isExpectedEq((*float32)(nil))}, }) } - -func TestFloat4Set(t *testing.T) { - successfulTests := []struct { - source interface{} - result pgtype.Float4 - }{ - {source: float32(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: float64(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: int8(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: int16(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: int32(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: int64(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: int8(-1), result: pgtype.Float4{Float: -1, Valid: true}}, - {source: int16(-1), result: pgtype.Float4{Float: -1, Valid: true}}, - {source: int32(-1), result: pgtype.Float4{Float: -1, Valid: true}}, - {source: int64(-1), result: pgtype.Float4{Float: -1, Valid: true}}, - {source: uint8(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: uint16(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: uint32(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: uint64(1), result: pgtype.Float4{Float: 1, Valid: true}}, - {source: "1", result: pgtype.Float4{Float: 1, Valid: true}}, - {source: _int8(1), result: pgtype.Float4{Float: 1, Valid: true}}, - } - - for i, tt := range successfulTests { - var r pgtype.Float4 - err := r.Set(tt.source) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if r != tt.result { - t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, r) - } - } -} - -func TestFloat4AssignTo(t *testing.T) { - var i8 int8 - var i16 int16 - var i32 int32 - var i64 int64 - var i int - var ui8 uint8 - var ui16 uint16 - var ui32 uint32 - var ui64 uint64 - var ui uint - var pi8 *int8 - var _i8 _int8 - var _pi8 *_int8 - var f32 float32 - var f64 float64 - var pf32 *float32 - var pf64 *float64 - - simpleTests := []struct { - src pgtype.Float4 - dst interface{} - expected interface{} - }{ - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &f32, expected: float32(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &f64, expected: float64(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &i16, expected: int16(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &i32, expected: int32(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &i64, expected: int64(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &i, expected: int(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &ui8, expected: uint8(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &ui16, expected: uint16(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &ui32, expected: uint32(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &ui64, expected: uint64(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &ui, expected: uint(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &_i8, expected: _int8(42)}, - {src: pgtype.Float4{Float: 0}, dst: &pi8, expected: ((*int8)(nil))}, - {src: pgtype.Float4{Float: 0}, dst: &_pi8, expected: ((*_int8)(nil))}, - } - - for i, tt := range simpleTests { - err := tt.src.AssignTo(tt.dst) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if dst := reflect.ValueOf(tt.dst).Elem().Interface(); dst != tt.expected { - t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst) - } - } - - pointerAllocTests := []struct { - src pgtype.Float4 - dst interface{} - expected interface{} - }{ - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &pf32, expected: float32(42)}, - {src: pgtype.Float4{Float: 42, Valid: true}, dst: &pf64, expected: float64(42)}, - } - - for i, tt := range pointerAllocTests { - err := tt.src.AssignTo(tt.dst) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if dst := reflect.ValueOf(tt.dst).Elem().Elem().Interface(); dst != tt.expected { - t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst) - } - } - - errorTests := []struct { - src pgtype.Float4 - dst interface{} - }{ - {src: pgtype.Float4{Float: 150, Valid: true}, dst: &i8}, - {src: pgtype.Float4{Float: 40000, Valid: true}, dst: &i16}, - {src: pgtype.Float4{Float: -1, Valid: true}, dst: &ui8}, - {src: pgtype.Float4{Float: -1, Valid: true}, dst: &ui16}, - {src: pgtype.Float4{Float: -1, Valid: true}, dst: &ui32}, - {src: pgtype.Float4{Float: -1, Valid: true}, dst: &ui64}, - {src: pgtype.Float4{Float: -1, Valid: true}, dst: &ui}, - {src: pgtype.Float4{Float: 0}, dst: &i32}, - } - - for i, tt := range errorTests { - err := tt.src.AssignTo(tt.dst) - if err == nil { - t.Errorf("%d: expected error but none was returned (%v -> %v)", i, tt.src, tt.dst) - } - } -} diff --git a/pgtype/float8.go b/pgtype/float8.go index 1038d283..86638ab1 100644 --- a/pgtype/float8.go +++ b/pgtype/float8.go @@ -10,178 +10,259 @@ import ( "github.com/jackc/pgio" ) +type Float64Scanner interface { + ScanFloat64(Float8) error +} + +type Float64Valuer interface { + Float64Value() (Float8, error) +} + type Float8 struct { Float float64 Valid bool } -func (dst *Float8) Set(src interface{}) error { +// ScanFloat64 implements the Float64Scanner interface. +func (f *Float8) ScanFloat64(n Float8) error { + *f = n + return nil +} + +func (f Float8) Float64Value() (Float8, error) { + return f, nil +} + +// Scan implements the database/sql Scanner interface. +func (f *Float8) Scan(src interface{}) error { if src == nil { - *dst = Float8{} + *f = Float8{} return nil } - if value, ok := src.(interface{ Get() interface{} }); ok { - value2 := value.Get() - if value2 != value { - return dst.Set(value2) - } - } - - switch value := src.(type) { - case float32: - *dst = Float8{Float: float64(value), Valid: true} + switch src := src.(type) { case float64: - *dst = Float8{Float: value, Valid: true} - case int8: - *dst = Float8{Float: float64(value), Valid: true} - case uint8: - *dst = Float8{Float: float64(value), Valid: true} - case int16: - *dst = Float8{Float: float64(value), Valid: true} - case uint16: - *dst = Float8{Float: float64(value), Valid: true} - case int32: - *dst = Float8{Float: float64(value), Valid: true} - case uint32: - *dst = Float8{Float: float64(value), Valid: true} - case int64: - f64 := float64(value) - if int64(f64) == value { - *dst = Float8{Float: f64, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float64", value) - } - case uint64: - f64 := float64(value) - if uint64(f64) == value { - *dst = Float8{Float: f64, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float64", value) - } - case int: - f64 := float64(value) - if int(f64) == value { - *dst = Float8{Float: f64, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float64", value) - } - case uint: - f64 := float64(value) - if uint(f64) == value { - *dst = Float8{Float: f64, Valid: true} - } else { - return fmt.Errorf("%v cannot be exactly represented as float64", value) - } + *f = Float8{Float: src, Valid: true} + return nil case string: - num, err := strconv.ParseFloat(value, 64) + n, err := strconv.ParseFloat(string(src), 64) if err != nil { return err } - *dst = Float8{Float: float64(num), Valid: true} - case *float64: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) + *f = Float8{Float: n, Valid: true} + return nil + } + + return fmt.Errorf("cannot scan %T", src) +} + +// Value implements the database/sql/driver Valuer interface. +func (f Float8) Value() (driver.Value, error) { + if !f.Valid { + return nil, nil + } + return f.Float, nil +} + +type Float8Codec struct{} + +func (Float8Codec) FormatSupported(format int16) bool { + return format == TextFormatCode || format == BinaryFormatCode +} + +func (Float8Codec) PreferredFormat() int16 { + return BinaryFormatCode +} + +func (Float8Codec) PlanEncode(ci *ConnInfo, oid uint32, format int16, value interface{}) EncodePlan { + switch format { + case BinaryFormatCode: + switch value.(type) { + case float64: + return encodePlanFloat8CodecBinaryFloat64{} + case Float64Valuer: + return encodePlanFloat8CodecBinaryFloat64Valuer{} + case Int64Valuer: + return encodePlanFloat8CodecBinaryInt64Valuer{} } - case *float32: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) + case TextFormatCode: + switch value.(type) { + case float64: + return encodePlanTextFloat64{} + case Float64Valuer: + return encodePlanTextFloat64Valuer{} + case Int64Valuer: + return encodePlanTextInt64Valuer{} } - case *int8: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *uint8: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *int16: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *uint16: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *int32: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *uint32: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *int64: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *uint64: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *int: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *uint: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - case *string: - if value == nil { - *dst = Float8{} - } else { - return dst.Set(*value) - } - default: - if originalSrc, ok := underlyingNumberType(src); ok { - return dst.Set(originalSrc) - } - return fmt.Errorf("cannot convert %v to Float8", value) } return nil } -func (dst Float8) Get() interface{} { - if !dst.Valid { - return nil +type encodePlanFloat8CodecBinaryFloat64 struct{} + +func (encodePlanFloat8CodecBinaryFloat64) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n := value.(float64) + return pgio.AppendUint64(buf, math.Float64bits(n)), nil +} + +type encodePlanTextFloat64 struct{} + +func (encodePlanTextFloat64) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n := value.(float64) + return append(buf, strconv.FormatFloat(n, 'f', -1, 64)...), nil +} + +type encodePlanFloat8CodecBinaryFloat64Valuer struct{} + +func (encodePlanFloat8CodecBinaryFloat64Valuer) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n, err := value.(Float64Valuer).Float64Value() + if err != nil { + return nil, err } - return dst.Float + + if !n.Valid { + return nil, nil + } + + return pgio.AppendUint64(buf, math.Float64bits(n.Float)), nil } -func (src *Float8) AssignTo(dst interface{}) error { - return float64AssignTo(src.Float, src.Valid, dst) +type encodePlanTextFloat64Valuer struct{} + +func (encodePlanTextFloat64Valuer) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n, err := value.(Float64Valuer).Float64Value() + if err != nil { + return nil, err + } + + if !n.Valid { + return nil, nil + } + + return append(buf, strconv.FormatFloat(n.Float, 'f', -1, 64)...), nil } -func (dst *Float8) DecodeText(ci *ConnInfo, src []byte) error { +type encodePlanFloat8CodecBinaryInt64Valuer struct{} + +func (encodePlanFloat8CodecBinaryInt64Valuer) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n, err := value.(Int64Valuer).Int64Value() + if err != nil { + return nil, err + } + + if !n.Valid { + return nil, nil + } + + f := float64(n.Int) + return pgio.AppendUint64(buf, math.Float64bits(f)), nil +} + +type encodePlanTextInt64Valuer struct{} + +func (encodePlanTextInt64Valuer) Encode(value interface{}, buf []byte) (newBuf []byte, err error) { + n, err := value.(Int64Valuer).Int64Value() + if err != nil { + return nil, err + } + + if !n.Valid { + return nil, nil + } + + return append(buf, strconv.FormatInt(n.Int, 10)...), nil +} + +func (Float8Codec) PlanScan(ci *ConnInfo, oid uint32, format int16, target interface{}, actualTarget bool) ScanPlan { + + switch format { + case BinaryFormatCode: + switch target.(type) { + case *float64: + return scanPlanBinaryFloat8ToFloat64{} + case Float64Scanner: + return scanPlanBinaryFloat8ToFloat64Scanner{} + case Int64Scanner: + return scanPlanBinaryFloat8ToInt64Scanner{} + } + case TextFormatCode: + switch target.(type) { + case *float64: + return scanPlanTextAnyToFloat64{} + case Float64Scanner: + return scanPlanTextAnyToFloat64Scanner{} + case Int64Scanner: + return scanPlanTextAnyToInt64Scanner{} + } + } + + return nil +} + +type scanPlanBinaryFloat8ToFloat64 struct{} + +func (scanPlanBinaryFloat8ToFloat64) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { if src == nil { - *dst = Float8{} - return nil + return fmt.Errorf("cannot scan null into %T", dst) + } + + if len(src) != 8 { + return fmt.Errorf("invalid length for float8: %v", len(src)) + } + + n := int64(binary.BigEndian.Uint64(src)) + f := (dst).(*float64) + *f = math.Float64frombits(uint64(n)) + + return nil +} + +type scanPlanBinaryFloat8ToFloat64Scanner struct{} + +func (scanPlanBinaryFloat8ToFloat64Scanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + s := (dst).(Float64Scanner) + + if src == nil { + return s.ScanFloat64(Float8{}) + } + + if len(src) != 8 { + return fmt.Errorf("invalid length for float8: %v", len(src)) + } + + n := int64(binary.BigEndian.Uint64(src)) + return s.ScanFloat64(Float8{Float: math.Float64frombits(uint64(n)), Valid: true}) +} + +type scanPlanBinaryFloat8ToInt64Scanner struct{} + +func (scanPlanBinaryFloat8ToInt64Scanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + s := (dst).(Int64Scanner) + + if src == nil { + return s.ScanInt64(Int8{}) + } + + if len(src) != 8 { + return fmt.Errorf("invalid length for float8: %v", len(src)) + } + + ui64 := int64(binary.BigEndian.Uint64(src)) + f64 := math.Float64frombits(uint64(ui64)) + i64 := int64(f64) + if f64 != float64(i64) { + return fmt.Errorf("cannot losslessly convert %v to int64", f64) + } + + return s.ScanInt64(Int8{Int: i64, Valid: true}) +} + +type scanPlanTextAnyToFloat64 struct{} + +func (scanPlanTextAnyToFloat64) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + if src == nil { + return fmt.Errorf("cannot scan null into %T", dst) } n, err := strconv.ParseFloat(string(src), 64) @@ -189,70 +270,42 @@ func (dst *Float8) DecodeText(ci *ConnInfo, src []byte) error { return err } - *dst = Float8{Float: n, Valid: true} + f := (dst).(*float64) + *f = n + return nil } -func (dst *Float8) DecodeBinary(ci *ConnInfo, src []byte) error { +type scanPlanTextAnyToFloat64Scanner struct{} + +func (scanPlanTextAnyToFloat64Scanner) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + s := (dst).(Float64Scanner) + if src == nil { - *dst = Float8{} - return nil + return s.ScanFloat64(Float8{}) } - if len(src) != 8 { - return fmt.Errorf("invalid length for float4: %v", len(src)) + n, err := strconv.ParseFloat(string(src), 64) + if err != nil { + return err } - n := int64(binary.BigEndian.Uint64(src)) - - *dst = Float8{Float: math.Float64frombits(uint64(n)), Valid: true} - return nil + return s.ScanFloat64(Float8{Float: n, Valid: true}) } -func (src Float8) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - buf = append(buf, strconv.FormatFloat(float64(src.Float), 'f', -1, 64)...) - return buf, nil +func (c Float8Codec) DecodeDatabaseSQLValue(ci *ConnInfo, oid uint32, format int16, src []byte) (driver.Value, error) { + return c.DecodeValue(ci, oid, format, src) } -func (src Float8) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - buf = pgio.AppendUint64(buf, math.Float64bits(src.Float)) - return buf, nil -} - -// Scan implements the database/sql Scanner interface. -func (dst *Float8) Scan(src interface{}) error { +func (c Float8Codec) DecodeValue(ci *ConnInfo, oid uint32, format int16, src []byte) (interface{}, error) { if src == nil { - *dst = Float8{} - return nil - } - - switch src := src.(type) { - case float64: - *dst = Float8{Float: src, Valid: true} - return nil - case string: - return dst.DecodeText(nil, []byte(src)) - case []byte: - srcCopy := make([]byte, len(src)) - copy(srcCopy, src) - return dst.DecodeText(nil, srcCopy) - } - - return fmt.Errorf("cannot scan %T", src) -} - -// Value implements the database/sql/driver Valuer interface. -func (src Float8) Value() (driver.Value, error) { - if !src.Valid { return nil, nil } - return src.Float, nil + + var n float64 + err := codecScan(c, ci, oid, format, src, &n) + if err != nil { + return nil, err + } + return n, nil } diff --git a/pgtype/float8_array.go b/pgtype/float8_array.go deleted file mode 100644 index 5e85e236..00000000 --- a/pgtype/float8_array.go +++ /dev/null @@ -1,504 +0,0 @@ -// Code generated by erb. DO NOT EDIT. - -package pgtype - -import ( - "database/sql/driver" - "encoding/binary" - "fmt" - "reflect" - - "github.com/jackc/pgio" -) - -type Float8Array struct { - Elements []Float8 - Dimensions []ArrayDimension - Valid bool -} - -func (dst *Float8Array) Set(src interface{}) error { - // untyped nil and typed nil interfaces are different - if src == nil { - *dst = Float8Array{} - return nil - } - - if value, ok := src.(interface{ Get() interface{} }); ok { - value2 := value.Get() - if value2 != value { - return dst.Set(value2) - } - } - - // Attempt to match to select common types: - switch value := src.(type) { - - case []float64: - if value == nil { - *dst = Float8Array{} - } else if len(value) == 0 { - *dst = Float8Array{Valid: true} - } 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}}, - Valid: true, - } - } - - case []*float64: - if value == nil { - *dst = Float8Array{} - } else if len(value) == 0 { - *dst = Float8Array{Valid: true} - } 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}}, - Valid: true, - } - } - - case []Float8: - if value == nil { - *dst = Float8Array{} - } else if len(value) == 0 { - *dst = Float8Array{Valid: true} - } else { - *dst = Float8Array{ - Elements: value, - Dimensions: []ArrayDimension{{Length: int32(len(value)), LowerBound: 1}}, - Valid: true, - } - } - default: - // 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 - reflectedValue := reflect.ValueOf(src) - if !reflectedValue.IsValid() || reflectedValue.IsZero() { - *dst = Float8Array{} - return nil - } - - dimensions, elementsLength, ok := findDimensionsFromValue(reflectedValue, nil, 0) - if !ok { - return fmt.Errorf("cannot find dimensions of %v for Float8Array", src) - } - if elementsLength == 0 { - *dst = Float8Array{Valid: true} - return nil - } - if len(dimensions) == 0 { - if originalSrc, ok := underlyingSliceType(src); ok { - return dst.Set(originalSrc) - } - return fmt.Errorf("cannot convert %v to Float8Array", src) - } - - *dst = Float8Array{ - Elements: make([]Float8, elementsLength), - Dimensions: dimensions, - Valid: true, - } - elementCount, err := dst.setRecursive(reflectedValue, 0, 0) - if err != nil { - // Maybe the target was one dimension too far, try again: - if len(dst.Dimensions) > 1 { - dst.Dimensions = dst.Dimensions[:len(dst.Dimensions)-1] - elementsLength = 0 - for _, dim := range dst.Dimensions { - if elementsLength == 0 { - elementsLength = int(dim.Length) - } else { - elementsLength *= int(dim.Length) - } - } - dst.Elements = make([]Float8, elementsLength) - elementCount, err = dst.setRecursive(reflectedValue, 0, 0) - if err != nil { - return err - } - } else { - return err - } - } - if elementCount != len(dst.Elements) { - return fmt.Errorf("cannot convert %v to Float8Array, expected %d dst.Elements, but got %d instead", src, len(dst.Elements), elementCount) - } - } - - return nil -} - -func (dst *Float8Array) setRecursive(value reflect.Value, index, dimension int) (int, error) { - switch value.Kind() { - case reflect.Array: - fallthrough - case reflect.Slice: - if len(dst.Dimensions) == dimension { - break - } - - valueLen := value.Len() - if int32(valueLen) != dst.Dimensions[dimension].Length { - return 0, fmt.Errorf("multidimensional arrays must have array expressions with matching dimensions") - } - for i := 0; i < valueLen; i++ { - var err error - index, err = dst.setRecursive(value.Index(i), index, dimension+1) - if err != nil { - return 0, err - } - } - - return index, nil - } - if !value.CanInterface() { - return 0, fmt.Errorf("cannot convert all values to Float8Array") - } - if err := dst.Elements[index].Set(value.Interface()); err != nil { - return 0, fmt.Errorf("%v in Float8Array", err) - } - index++ - - return index, nil -} - -func (dst Float8Array) Get() interface{} { - if !dst.Valid { - return nil - } - return dst -} - -func (src *Float8Array) AssignTo(dst interface{}) error { - if !src.Valid { - return NullAssignTo(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) { - switch kind := value.Kind(); kind { - case reflect.Array: - fallthrough - case reflect.Slice: - if len(src.Dimensions) == dimension { - break - } - - length := int(src.Dimensions[dimension].Length) - if reflect.Array == kind { - typ := value.Type() - if typ.Len() != length { - return 0, fmt.Errorf("expected size %d array, but %s has size %d array", length, typ, typ.Len()) - } - value.Set(reflect.New(typ).Elem()) - } else { - value.Set(reflect.MakeSlice(value.Type(), length, length)) - } - - var err error - for i := 0; i < length; i++ { - index, err = src.assignToRecursive(value.Index(i), index, dimension+1) - if err != nil { - return 0, err - } - } - - return index, nil - } - if len(src.Dimensions) != dimension { - return 0, fmt.Errorf("incorrect dimensions, expected %d, found %d", len(src.Dimensions), dimension) - } - if !value.CanAddr() { - return 0, fmt.Errorf("cannot assign all values from Float8Array") - } - addr := value.Addr() - if !addr.CanInterface() { - return 0, fmt.Errorf("cannot assign all values from Float8Array") - } - if err := src.Elements[index].AssignTo(addr.Interface()); err != nil { - return 0, err - } - index++ - return index, nil -} - -func (dst *Float8Array) DecodeText(ci *ConnInfo, src []byte) error { - if src == nil { - *dst = Float8Array{} - return nil - } - - uta, err := ParseUntypedTextArray(string(src)) - if err != nil { - return err - } - - var elements []Float8 - - if len(uta.Elements) > 0 { - elements = make([]Float8, len(uta.Elements)) - - for i, s := range uta.Elements { - var elem Float8 - var elemSrc []byte - if s != "NULL" || uta.Quoted[i] { - elemSrc = []byte(s) - } - err = elem.DecodeText(ci, elemSrc) - if err != nil { - return err - } - - elements[i] = elem - } - } - - *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{} - return nil - } - - var arrayHeader ArrayHeader - rp, err := arrayHeader.DecodeBinary(ci, src) - if err != nil { - return err - } - - if len(arrayHeader.Dimensions) == 0 { - *dst = Float8Array{Dimensions: arrayHeader.Dimensions, Valid: true} - return nil - } - - elementCount := arrayHeader.Dimensions[0].Length - for _, d := range arrayHeader.Dimensions[1:] { - elementCount *= d.Length - } - - elements := make([]Float8, elementCount) - - for i := range elements { - elemLen := int(int32(binary.BigEndian.Uint32(src[rp:]))) - rp += 4 - var elemSrc []byte - if elemLen >= 0 { - elemSrc = src[rp : rp+elemLen] - rp += elemLen - } - err = elements[i].DecodeBinary(ci, elemSrc) - if err != nil { - return err - } - } - - *dst = Float8Array{Elements: elements, Dimensions: arrayHeader.Dimensions, Valid: true} - return nil -} - -func (src Float8Array) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - if len(src.Dimensions) == 0 { - return append(buf, '{', '}'), nil - } - - buf = EncodeTextArrayDimensions(buf, src.Dimensions) - - // dimElemCounts is the multiples of elements that each array lies on. For - // example, a single dimension array of length 4 would have a dimElemCounts of - // [4]. A multi-dimensional array of lengths [3,5,2] would have a - // dimElemCounts of [30,10,2]. This is used to simplify when to render a '{' - // or '}'. - dimElemCounts := make([]int, len(src.Dimensions)) - dimElemCounts[len(src.Dimensions)-1] = int(src.Dimensions[len(src.Dimensions)-1].Length) - for i := len(src.Dimensions) - 2; i > -1; i-- { - dimElemCounts[i] = int(src.Dimensions[i].Length) * dimElemCounts[i+1] - } - - inElemBuf := make([]byte, 0, 32) - for i, elem := range src.Elements { - if i > 0 { - buf = append(buf, ',') - } - - for _, dec := range dimElemCounts { - if i%dec == 0 { - buf = append(buf, '{') - } - } - - elemBuf, err := elem.EncodeText(ci, inElemBuf) - if err != nil { - return nil, err - } - if elemBuf == nil { - buf = append(buf, `NULL`...) - } else { - buf = append(buf, QuoteArrayElementIfNeeded(string(elemBuf))...) - } - - for _, dec := range dimElemCounts { - if (i+1)%dec == 0 { - buf = append(buf, '}') - } - } - } - - return buf, nil -} - -func (src Float8Array) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) { - if !src.Valid { - return nil, nil - } - - arrayHeader := ArrayHeader{ - Dimensions: src.Dimensions, - } - - if dt, ok := ci.DataTypeForName("float8"); ok { - arrayHeader.ElementOID = int32(dt.OID) - } else { - return nil, fmt.Errorf("unable to find oid for type name %v", "float8") - } - - for i := range src.Elements { - if !src.Elements[i].Valid { - arrayHeader.ContainsNull = true - break - } - } - - buf = arrayHeader.EncodeBinary(ci, buf) - - for i := range src.Elements { - sp := len(buf) - buf = pgio.AppendInt32(buf, -1) - - elemBuf, err := src.Elements[i].EncodeBinary(ci, buf) - if err != nil { - return nil, err - } - if elemBuf != nil { - buf = elemBuf - pgio.SetInt32(buf[sp:], int32(len(buf[sp:])-4)) - } - } - - return buf, nil -} - -// Scan implements the database/sql Scanner interface. -func (dst *Float8Array) Scan(src interface{}) error { - if src == nil { - return dst.DecodeText(nil, nil) - } - - switch src := src.(type) { - case string: - return dst.DecodeText(nil, []byte(src)) - case []byte: - srcCopy := make([]byte, len(src)) - copy(srcCopy, src) - return dst.DecodeText(nil, srcCopy) - } - - return fmt.Errorf("cannot scan %T", src) -} - -// Value implements the database/sql/driver Valuer interface. -func (src Float8Array) Value() (driver.Value, error) { - buf, err := src.EncodeText(nil, nil) - if err != nil { - return nil, err - } - if buf == nil { - return nil, nil - } - - return string(buf), nil -} diff --git a/pgtype/float8_array_test.go b/pgtype/float8_array_test.go deleted file mode 100644 index 66a10784..00000000 --- a/pgtype/float8_array_test.go +++ /dev/null @@ -1,258 +0,0 @@ -package pgtype_test - -import ( - "reflect" - "testing" - - "github.com/jackc/pgx/v5/pgtype" - "github.com/jackc/pgx/v5/pgtype/testutil" -) - -func TestFloat8ArrayTranscode(t *testing.T) { - testutil.TestSuccessfulTranscode(t, "float8[]", []interface{}{ - &pgtype.Float8Array{ - Elements: nil, - Dimensions: nil, - Valid: true, - }, - &pgtype.Float8Array{ - Elements: []pgtype.Float8{ - {Float: 1, Valid: true}, - {}, - }, - Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}}, - Valid: true, - }, - &pgtype.Float8Array{}, - &pgtype.Float8Array{ - Elements: []pgtype.Float8{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {}, - {Float: 6, Valid: true}, - }, - Dimensions: []pgtype.ArrayDimension{{Length: 3, LowerBound: 1}, {Length: 2, LowerBound: 1}}, - Valid: true, - }, - &pgtype.Float8Array{ - Elements: []pgtype.Float8{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - }, - Dimensions: []pgtype.ArrayDimension{ - {Length: 2, LowerBound: 4}, - {Length: 2, LowerBound: 2}, - }, - Valid: true, - }, - }) -} - -func TestFloat8ArraySet(t *testing.T) { - successfulTests := []struct { - source interface{} - result pgtype.Float8Array - }{ - { - source: []float64{1}, - result: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: (([]float64)(nil)), - result: pgtype.Float8Array{}, - }, - { - source: [][]float64{{1}, {2}}, - result: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - }, - { - source: [][][][]float64{{{{1, 2, 3}}}, {{{4, 5, 6}}}}, - result: pgtype.Float8Array{ - Elements: []pgtype.Float8{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {Float: 5, Valid: true}, - {Float: 6, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - }, - } - - for i, tt := range successfulTests { - var r pgtype.Float8Array - err := r.Set(tt.source) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if !reflect.DeepEqual(r, tt.result) { - t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, r) - } - } -} - -func TestFloat8ArrayAssignTo(t *testing.T) { - var float64Slice []float64 - var namedFloat64Slice _float64Slice - var float64SliceDim2 [][]float64 - var float64SliceDim4 [][][][]float64 - var float64ArrayDim2 [2][1]float64 - var float64ArrayDim4 [2][1][1][3]float64 - - simpleTests := []struct { - src pgtype.Float8Array - dst interface{} - expected interface{} - }{ - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1.23, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &float64Slice, - expected: []float64{1.23}, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1.23, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &namedFloat64Slice, - expected: _float64Slice{1.23}, - }, - { - src: pgtype.Float8Array{}, - dst: &float64Slice, - expected: (([]float64)(nil)), - }, - { - src: pgtype.Float8Array{Valid: true}, - dst: &float64Slice, - expected: []float64{}, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - expected: [][]float64{{1}, {2}}, - dst: &float64SliceDim2, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {Float: 5, Valid: true}, - {Float: 6, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - expected: [][][][]float64{{{{1, 2, 3}}}, {{{4, 5, 6}}}}, - dst: &float64SliceDim4, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - expected: [2][1]float64{{1}, {2}}, - dst: &float64ArrayDim2, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{ - {Float: 1, Valid: true}, - {Float: 2, Valid: true}, - {Float: 3, Valid: true}, - {Float: 4, Valid: true}, - {Float: 5, Valid: true}, - {Float: 6, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{ - {LowerBound: 1, Length: 2}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 1}, - {LowerBound: 1, Length: 3}}, - Valid: true}, - expected: [2][1][1][3]float64{{{{1, 2, 3}}}, {{{4, 5, 6}}}}, - dst: &float64ArrayDim4, - }, - } - - for i, tt := range simpleTests { - err := tt.src.AssignTo(tt.dst) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if dst := reflect.ValueOf(tt.dst).Elem().Interface(); !reflect.DeepEqual(dst, tt.expected) { - t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst) - } - } - - errorTests := []struct { - src pgtype.Float8Array - dst interface{} - }{ - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}}, - Valid: true, - }, - dst: &float64Slice, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}, {LowerBound: 1, Length: 2}}, - Valid: true}, - dst: &float64ArrayDim2, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}, {LowerBound: 1, Length: 2}}, - Valid: true}, - dst: &float64Slice, - }, - { - src: pgtype.Float8Array{ - Elements: []pgtype.Float8{{Float: 1, Valid: true}, {Float: 2, Valid: true}}, - Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 2}, {LowerBound: 1, Length: 1}}, - Valid: true}, - dst: &float64ArrayDim4, - }, - } - - for i, tt := range errorTests { - err := tt.src.AssignTo(tt.dst) - if err == nil { - t.Errorf("%d: expected error but none was returned (%v -> %v)", i, tt.src, tt.dst) - } - } - -} diff --git a/pgtype/float8_test.go b/pgtype/float8_test.go index e7bd4444..3c7660b8 100644 --- a/pgtype/float8_test.go +++ b/pgtype/float8_test.go @@ -1,149 +1,20 @@ package pgtype_test import ( - "reflect" "testing" "github.com/jackc/pgx/v5/pgtype" - "github.com/jackc/pgx/v5/pgtype/testutil" ) -func TestFloat8Transcode(t *testing.T) { - testutil.TestSuccessfulTranscode(t, "float8", []interface{}{ - &pgtype.Float8{Float: -1, Valid: true}, - &pgtype.Float8{Float: 0, Valid: true}, - &pgtype.Float8{Float: 0.00001, Valid: true}, - &pgtype.Float8{Float: 1, Valid: true}, - &pgtype.Float8{Float: 9999.99, Valid: true}, - &pgtype.Float8{Float: 0}, +func TestFloat8Codec(t *testing.T) { + testPgxCodec(t, "float8", []PgxTranscodeTestCase{ + {pgtype.Float8{Float: -1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: -1, Valid: true})}, + {pgtype.Float8{Float: 0, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: 0, Valid: true})}, + {pgtype.Float8{Float: 1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: 1, Valid: true})}, + {float64(0.00001), new(float64), isExpectedEq(float64(0.00001))}, + {float64(9999.99), new(float64), isExpectedEq(float64(9999.99))}, + {pgtype.Float8{}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{})}, + {int64(1), new(int64), isExpectedEq(int64(1))}, + {nil, new(*float64), isExpectedEq((*float64)(nil))}, }) } - -func TestFloat8Set(t *testing.T) { - successfulTests := []struct { - source interface{} - result pgtype.Float8 - }{ - {source: float32(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: float64(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: int8(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: int16(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: int32(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: int64(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: int8(-1), result: pgtype.Float8{Float: -1, Valid: true}}, - {source: int16(-1), result: pgtype.Float8{Float: -1, Valid: true}}, - {source: int32(-1), result: pgtype.Float8{Float: -1, Valid: true}}, - {source: int64(-1), result: pgtype.Float8{Float: -1, Valid: true}}, - {source: uint8(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: uint16(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: uint32(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: uint64(1), result: pgtype.Float8{Float: 1, Valid: true}}, - {source: "1", result: pgtype.Float8{Float: 1, Valid: true}}, - {source: _int8(1), result: pgtype.Float8{Float: 1, Valid: true}}, - } - - for i, tt := range successfulTests { - var r pgtype.Float8 - err := r.Set(tt.source) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if r != tt.result { - t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, r) - } - } -} - -func TestFloat8AssignTo(t *testing.T) { - var i8 int8 - var i16 int16 - var i32 int32 - var i64 int64 - var i int - var ui8 uint8 - var ui16 uint16 - var ui32 uint32 - var ui64 uint64 - var ui uint - var pi8 *int8 - var _i8 _int8 - var _pi8 *_int8 - var f32 float32 - var f64 float64 - var pf32 *float32 - var pf64 *float64 - - simpleTests := []struct { - src pgtype.Float8 - dst interface{} - expected interface{} - }{ - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &f32, expected: float32(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &f64, expected: float64(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &i16, expected: int16(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &i32, expected: int32(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &i64, expected: int64(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &i, expected: int(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &ui8, expected: uint8(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &ui16, expected: uint16(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &ui32, expected: uint32(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &ui64, expected: uint64(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &ui, expected: uint(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &_i8, expected: _int8(42)}, - {src: pgtype.Float8{Float: 0}, dst: &pi8, expected: ((*int8)(nil))}, - {src: pgtype.Float8{Float: 0}, dst: &_pi8, expected: ((*_int8)(nil))}, - } - - for i, tt := range simpleTests { - err := tt.src.AssignTo(tt.dst) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if dst := reflect.ValueOf(tt.dst).Elem().Interface(); dst != tt.expected { - t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst) - } - } - - pointerAllocTests := []struct { - src pgtype.Float8 - dst interface{} - expected interface{} - }{ - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &pf32, expected: float32(42)}, - {src: pgtype.Float8{Float: 42, Valid: true}, dst: &pf64, expected: float64(42)}, - } - - for i, tt := range pointerAllocTests { - err := tt.src.AssignTo(tt.dst) - if err != nil { - t.Errorf("%d: %v", i, err) - } - - if dst := reflect.ValueOf(tt.dst).Elem().Elem().Interface(); dst != tt.expected { - t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst) - } - } - - errorTests := []struct { - src pgtype.Float8 - dst interface{} - }{ - {src: pgtype.Float8{Float: 150, Valid: true}, dst: &i8}, - {src: pgtype.Float8{Float: 40000, Valid: true}, dst: &i16}, - {src: pgtype.Float8{Float: -1, Valid: true}, dst: &ui8}, - {src: pgtype.Float8{Float: -1, Valid: true}, dst: &ui16}, - {src: pgtype.Float8{Float: -1, Valid: true}, dst: &ui32}, - {src: pgtype.Float8{Float: -1, Valid: true}, dst: &ui64}, - {src: pgtype.Float8{Float: -1, Valid: true}, dst: &ui}, - {src: pgtype.Float8{Float: 0}, dst: &i32}, - } - - for i, tt := range errorTests { - err := tt.src.AssignTo(tt.dst) - if err == nil { - t.Errorf("%d: expected error but none was returned (%v -> %v)", i, tt.src, tt.dst) - } - } -} diff --git a/pgtype/pgtype.go b/pgtype/pgtype.go index 89c7b348..cb351fbd 100644 --- a/pgtype/pgtype.go +++ b/pgtype/pgtype.go @@ -264,8 +264,8 @@ func NewConnInfo() *ConnInfo { ci.RegisterDataType(DataType{Name: "_bytea", OID: ByteaArrayOID, Codec: &ArrayCodec{ElementCodec: ByteaCodec{}, ElementOID: ByteaOID}}) ci.RegisterDataType(DataType{Name: "_cidr", OID: CIDRArrayOID, Codec: &ArrayCodec{ElementCodec: InetCodec{}, ElementOID: CIDROID}}) ci.RegisterDataType(DataType{Name: "_date", OID: DateArrayOID, Codec: &ArrayCodec{ElementCodec: DateCodec{}, ElementOID: DateOID}}) - ci.RegisterDataType(DataType{Value: &Float4Array{}, Name: "_float4", OID: Float4ArrayOID}) - ci.RegisterDataType(DataType{Value: &Float8Array{}, Name: "_float8", OID: Float8ArrayOID}) + ci.RegisterDataType(DataType{Name: "_float4", OID: Float4ArrayOID, Codec: &ArrayCodec{ElementCodec: Float4Codec{}, ElementOID: Float4OID}}) + ci.RegisterDataType(DataType{Name: "_float8", OID: Float8ArrayOID, Codec: &ArrayCodec{ElementCodec: Float8Codec{}, ElementOID: Float8OID}}) ci.RegisterDataType(DataType{Name: "_inet", OID: InetArrayOID, Codec: &ArrayCodec{ElementCodec: InetCodec{}, ElementOID: InetOID}}) ci.RegisterDataType(DataType{Name: "_int2", OID: Int2ArrayOID, Codec: &ArrayCodec{ElementCodec: Int2Codec{}, ElementOID: Int2OID}}) ci.RegisterDataType(DataType{Name: "_int4", OID: Int4ArrayOID, Codec: &ArrayCodec{ElementCodec: Int4Codec{}, ElementOID: Int4OID}}) @@ -297,8 +297,8 @@ func NewConnInfo() *ConnInfo { ci.RegisterDataType(DataType{Name: "circle", OID: CircleOID, Codec: CircleCodec{}}) ci.RegisterDataType(DataType{Name: "date", OID: DateOID, Codec: DateCodec{}}) // ci.RegisterDataType(DataType{Value: &Daterange{}, Name: "daterange", OID: DaterangeOID}) - ci.RegisterDataType(DataType{Value: &Float4{}, Name: "float4", OID: Float4OID}) - ci.RegisterDataType(DataType{Value: &Float8{}, Name: "float8", OID: Float8OID}) + ci.RegisterDataType(DataType{Name: "float4", OID: Float4OID, Codec: Float4Codec{}}) + ci.RegisterDataType(DataType{Name: "float8", OID: Float8OID, Codec: Float8Codec{}}) ci.RegisterDataType(DataType{Name: "inet", OID: InetOID, Codec: InetCodec{}}) ci.RegisterDataType(DataType{Name: "int2", OID: Int2OID, Codec: Int2Codec{}}) ci.RegisterDataType(DataType{Name: "int4", OID: Int4OID, Codec: Int4Codec{}}) @@ -824,6 +824,32 @@ type WrappedScanPlanNextSetter interface { func tryWrapBuiltinTypeScanPlan(dst interface{}) (plan WrappedScanPlanNextSetter, nextDst interface{}, ok bool) { switch dst := dst.(type) { + case *int8: + return &wrapInt8ScanPlan{}, (*int8Wrapper)(dst), true + case *int16: + return &wrapInt16ScanPlan{}, (*int16Wrapper)(dst), true + case *int32: + return &wrapInt32ScanPlan{}, (*int32Wrapper)(dst), true + case *int64: + return &wrapInt64ScanPlan{}, (*int64Wrapper)(dst), true + case *int: + return &wrapIntScanPlan{}, (*intWrapper)(dst), true + case *uint8: + return &wrapUint8ScanPlan{}, (*uint8Wrapper)(dst), true + case *uint16: + return &wrapUint16ScanPlan{}, (*uint16Wrapper)(dst), true + case *uint32: + return &wrapUint32ScanPlan{}, (*uint32Wrapper)(dst), true + case *uint64: + return &wrapUint64ScanPlan{}, (*uint64Wrapper)(dst), true + case *uint: + return &wrapUintScanPlan{}, (*uintWrapper)(dst), true + case *float32: + return &wrapFloat32ScanPlan{}, (*float32Wrapper)(dst), true + case *float64: + return &wrapFloat64ScanPlan{}, (*float64Wrapper)(dst), true + case *string: + return &wrapStringScanPlan{}, (*stringWrapper)(dst), true case *time.Time: return &wrapTimeScanPlan{}, (*timeWrapper)(dst), true case *net.IPNet: @@ -835,6 +861,136 @@ func tryWrapBuiltinTypeScanPlan(dst interface{}) (plan WrappedScanPlanNextSetter return nil, nil, false } +type wrapInt8ScanPlan struct { + next ScanPlan +} + +func (plan *wrapInt8ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapInt8ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*int8Wrapper)(dst.(*int8))) +} + +type wrapInt16ScanPlan struct { + next ScanPlan +} + +func (plan *wrapInt16ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapInt16ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*int16Wrapper)(dst.(*int16))) +} + +type wrapInt32ScanPlan struct { + next ScanPlan +} + +func (plan *wrapInt32ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapInt32ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*int32Wrapper)(dst.(*int32))) +} + +type wrapInt64ScanPlan struct { + next ScanPlan +} + +func (plan *wrapInt64ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapInt64ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*int64Wrapper)(dst.(*int64))) +} + +type wrapIntScanPlan struct { + next ScanPlan +} + +func (plan *wrapIntScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapIntScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*intWrapper)(dst.(*int))) +} + +type wrapUint8ScanPlan struct { + next ScanPlan +} + +func (plan *wrapUint8ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapUint8ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*uint8Wrapper)(dst.(*uint8))) +} + +type wrapUint16ScanPlan struct { + next ScanPlan +} + +func (plan *wrapUint16ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapUint16ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*uint16Wrapper)(dst.(*uint16))) +} + +type wrapUint32ScanPlan struct { + next ScanPlan +} + +func (plan *wrapUint32ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapUint32ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*uint32Wrapper)(dst.(*uint32))) +} + +type wrapUint64ScanPlan struct { + next ScanPlan +} + +func (plan *wrapUint64ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapUint64ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*uint64Wrapper)(dst.(*uint64))) +} + +type wrapUintScanPlan struct { + next ScanPlan +} + +func (plan *wrapUintScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapUintScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*uintWrapper)(dst.(*uint))) +} + +type wrapFloat32ScanPlan struct { + next ScanPlan +} + +func (plan *wrapFloat32ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapFloat32ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*float32Wrapper)(dst.(*float32))) +} + +type wrapFloat64ScanPlan struct { + next ScanPlan +} + +func (plan *wrapFloat64ScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapFloat64ScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*float64Wrapper)(dst.(*float64))) +} + +type wrapStringScanPlan struct { + next ScanPlan +} + +func (plan *wrapStringScanPlan) SetNext(next ScanPlan) { plan.next = next } + +func (plan *wrapStringScanPlan) Scan(ci *ConnInfo, oid uint32, formatCode int16, src []byte, dst interface{}) error { + return plan.next.Scan(ci, oid, formatCode, src, (*stringWrapper)(dst.(*string))) +} + type wrapTimeScanPlan struct { next ScanPlan } diff --git a/pgtype/zeronull/float8.go b/pgtype/zeronull/float8.go index a4efb1ed..1c29d331 100644 --- a/pgtype/zeronull/float8.go +++ b/pgtype/zeronull/float8.go @@ -8,68 +8,29 @@ import ( type Float8 float64 -func (dst *Float8) DecodeText(ci *pgtype.ConnInfo, src []byte) error { - var nullable pgtype.Float8 - err := nullable.DecodeText(ci, src) - if err != nil { - return err +// ScanFloat64 implements the Float64Scanner interface. +func (f *Float8) ScanFloat64(n pgtype.Float8) error { + if !n.Valid { + *f = 0 + return nil } - if nullable.Valid { - *dst = Float8(nullable.Float) - } else { - *dst = 0 - } + *f = Float8(n.Float) return nil } -func (dst *Float8) DecodeBinary(ci *pgtype.ConnInfo, src []byte) error { - var nullable pgtype.Float8 - err := nullable.DecodeBinary(ci, src) - if err != nil { - return err +func (f Float8) Float64Value() (pgtype.Float8, error) { + if f == 0 { + return pgtype.Float8{}, nil } - - if nullable.Valid { - *dst = Float8(nullable.Float) - } else { - *dst = 0 - } - - return nil -} - -func (src Float8) EncodeText(ci *pgtype.ConnInfo, buf []byte) ([]byte, error) { - if src == 0 { - return nil, nil - } - - nullable := pgtype.Float8{ - Float: float64(src), - Valid: true, - } - - return nullable.EncodeText(ci, buf) -} - -func (src Float8) EncodeBinary(ci *pgtype.ConnInfo, buf []byte) ([]byte, error) { - if src == 0 { - return nil, nil - } - - nullable := pgtype.Float8{ - Float: float64(src), - Valid: true, - } - - return nullable.EncodeBinary(ci, buf) + return pgtype.Float8{Float: float64(f), Valid: true}, nil } // Scan implements the database/sql Scanner interface. -func (dst *Float8) Scan(src interface{}) error { +func (f *Float8) Scan(src interface{}) error { if src == nil { - *dst = 0 + *f = 0 return nil } @@ -79,12 +40,15 @@ func (dst *Float8) Scan(src interface{}) error { return err } - *dst = Float8(nullable.Float) + *f = Float8(nullable.Float) return nil } // Value implements the database/sql/driver Valuer interface. -func (src Float8) Value() (driver.Value, error) { - return pgtype.EncodeValueText(src) +func (f Float8) Value() (driver.Value, error) { + if f == 0 { + return nil, nil + } + return float64(f), nil }