GOMODULES
/
pgx
mirror of https://github.com/jackc/pgx.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

pgtype Float4 and Float8 fields include bit size 

e.g. Instead of Float it is Float64. This matches the pattern set by the
database/sql types.
query-exec-mode
Jack Christensen 2022-03-05 09:20:03 -06:00
parent d723a4ab6f
commit 84a3d91322
9 changed files with 57 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pgtype/builtin_wrappers.go
View File

@ -279,13 +279,13 @@ func (w *float32Wrapper) ScanFloat64(v Float8) error {
return fmt.Errorf("cannot scan NULL into *float32") return fmt.Errorf("cannot scan NULL into *float32")
} }
*w = float32Wrapper(v.Float) *w = float32Wrapper(v.Float64)
return nil return nil
} }
func (w float32Wrapper) Float64Value() (Float8, error) { func (w float32Wrapper) Float64Value() (Float8, error) {
return Float8{Float: float64(w), Valid: true}, nil return Float8{Float64: float64(w), Valid: true}, nil
} }
type float64Wrapper float64 type float64Wrapper float64
@ -315,13 +315,13 @@ func (w *float64Wrapper) ScanFloat64(v Float8) error {
return fmt.Errorf("cannot scan NULL into *float64") return fmt.Errorf("cannot scan NULL into *float64")
} }
*w = float64Wrapper(v.Float) *w = float64Wrapper(v.Float64)
return nil return nil
} }
func (w float64Wrapper) Float64Value() (Float8, error) { func (w float64Wrapper) Float64Value() (Float8, error) {
return Float8{Float: float64(w), Valid: true}, nil return Float8{Float64: float64(w), Valid: true}, nil
} }
type stringWrapper string type stringWrapper string

22
pgtype/float4.go
View File

@ -11,27 +11,27 @@ import (
) )
type Float4 struct { type Float4 struct {
Float float32 Float32 float32
Valid bool Valid bool
} }
// ScanFloat64 implements the Float64Scanner interface. // ScanFloat64 implements the Float64Scanner interface.
func (f *Float4) ScanFloat64(n Float8) error { func (f *Float4) ScanFloat64(n Float8) error {
*f = Float4{Float: float32(n.Float), Valid: n.Valid} *f = Float4{Float32: float32(n.Float64), Valid: n.Valid}
return nil return nil
} }
func (f Float4) Float64Value() (Float8, error) { func (f Float4) Float64Value() (Float8, error) {
return Float8{Float: float64(f.Float), Valid: f.Valid}, nil return Float8{Float64: float64(f.Float32), Valid: f.Valid}, nil
} }
func (f *Float4) ScanInt64(n Int8) error { func (f *Float4) ScanInt64(n Int8) error {
*f = Float4{Float: float32(n.Int64), Valid: n.Valid} *f = Float4{Float32: float32(n.Int64), Valid: n.Valid}
return nil return nil
} }
func (f Float4) Int64Value() (Int8, error) { func (f Float4) Int64Value() (Int8, error) {
return Int8{Int64: int64(f.Float), Valid: f.Valid}, nil return Int8{Int64: int64(f.Float32), Valid: f.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@ -43,14 +43,14 @@ func (f *Float4) Scan(src interface{}) error {
switch src := src.(type) { switch src := src.(type) {
case float64: case float64:
*f = Float4{Float: float32(src), Valid: true} *f = Float4{Float32: float32(src), Valid: true}
return nil return nil
case string: case string:
n, err := strconv.ParseFloat(string(src), 32) n, err := strconv.ParseFloat(string(src), 32)
if err != nil { if err != nil {
return err return err
} }
*f = Float4{Float: float32(n), Valid: true} *f = Float4{Float32: float32(n), Valid: true}
return nil return nil
} }
@ -62,7 +62,7 @@ func (f Float4) Value() (driver.Value, error) {
if !f.Valid { if !f.Valid {
return nil, nil return nil, nil
} }
return float64(f.Float), nil return float64(f.Float32), nil
} }
type Float4Codec struct{} type Float4Codec struct{}
@ -126,7 +126,7 @@ func (encodePlanFloat4CodecBinaryFloat64Valuer) Encode(value interface{}, buf []
return nil, nil return nil, nil
} }
return pgio.AppendUint32(buf, math.Float32bits(float32(n.Float))), nil return pgio.AppendUint32(buf, math.Float32bits(float32(n.Float64))), nil
} }
type encodePlanFloat4CodecBinaryInt64Valuer struct{} type encodePlanFloat4CodecBinaryInt64Valuer struct{}
@ -203,7 +203,7 @@ func (scanPlanBinaryFloat4ToFloat64Scanner) Scan(src []byte, dst interface{}) er
} }
n := int32(binary.BigEndian.Uint32(src)) n := int32(binary.BigEndian.Uint32(src))
return s.ScanFloat64(Float8{Float: float64(math.Float32frombits(uint32(n))), Valid: true}) return s.ScanFloat64(Float8{Float64: float64(math.Float32frombits(uint32(n))), Valid: true})
} }
type scanPlanBinaryFloat4ToInt64Scanner struct{} type scanPlanBinaryFloat4ToInt64Scanner struct{}

6
pgtype/float4_test.go
View File

@ -9,9 +9,9 @@ import (
func TestFloat4Codec(t *testing.T) { func TestFloat4Codec(t *testing.T) {
testutil.RunTranscodeTests(t, "float4", []testutil.TranscodeTestCase{ testutil.RunTranscodeTests(t, "float4", []testutil.TranscodeTestCase{
{pgtype.Float4{Float: -1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: -1, Valid: true})}, {pgtype.Float4{Float32: -1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float32: -1, Valid: true})},
{pgtype.Float4{Float: 0, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: 0, Valid: true})}, {pgtype.Float4{Float32: 0, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float32: 0, Valid: true})},
{pgtype.Float4{Float: 1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float: 1, Valid: true})}, {pgtype.Float4{Float32: 1, Valid: true}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{Float32: 1, Valid: true})},
{float32(0.00001), new(float32), isExpectedEq(float32(0.00001))}, {float32(0.00001), new(float32), isExpectedEq(float32(0.00001))},
{float32(9999.99), new(float32), isExpectedEq(float32(9999.99))}, {float32(9999.99), new(float32), isExpectedEq(float32(9999.99))},
{pgtype.Float4{}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{})}, {pgtype.Float4{}, new(pgtype.Float4), isExpectedEq(pgtype.Float4{})},

22
pgtype/float8.go
View File

@ -19,8 +19,8 @@ type Float64Valuer interface {
} }
type Float8 struct { type Float8 struct {
Float float64 Float64 float64
Valid bool Valid bool
} }
// ScanFloat64 implements the Float64Scanner interface. // ScanFloat64 implements the Float64Scanner interface.
@ -34,12 +34,12 @@ func (f Float8) Float64Value() (Float8, error) {
} }
func (f *Float8) ScanInt64(n Int8) error { func (f *Float8) ScanInt64(n Int8) error {
*f = Float8{Float: float64(n.Int64), Valid: n.Valid} *f = Float8{Float64: float64(n.Int64), Valid: n.Valid}
return nil return nil
} }
func (f Float8) Int64Value() (Int8, error) { func (f Float8) Int64Value() (Int8, error) {
return Int8{Int64: int64(f.Float), Valid: f.Valid}, nil return Int8{Int64: int64(f.Float64), Valid: f.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@ -51,14 +51,14 @@ func (f *Float8) Scan(src interface{}) error {
switch src := src.(type) { switch src := src.(type) {
case float64: case float64:
*f = Float8{Float: src, Valid: true} *f = Float8{Float64: src, Valid: true}
return nil return nil
case string: case string:
n, err := strconv.ParseFloat(string(src), 64) n, err := strconv.ParseFloat(string(src), 64)
if err != nil { if err != nil {
return err return err
} }
*f = Float8{Float: n, Valid: true} *f = Float8{Float64: n, Valid: true}
return nil return nil
} }
@ -70,7 +70,7 @@ func (f Float8) Value() (driver.Value, error) {
if !f.Valid { if !f.Valid {
return nil, nil return nil, nil
} }
return f.Float, nil return f.Float64, nil
} }
type Float8Codec struct{} type Float8Codec struct{}
@ -134,7 +134,7 @@ func (encodePlanFloat8CodecBinaryFloat64Valuer) Encode(value interface{}, buf []
return nil, nil return nil, nil
} }
return pgio.AppendUint64(buf, math.Float64bits(n.Float)), nil return pgio.AppendUint64(buf, math.Float64bits(n.Float64)), nil
} }
type encodePlanTextFloat64Valuer struct{} type encodePlanTextFloat64Valuer struct{}
@ -149,7 +149,7 @@ func (encodePlanTextFloat64Valuer) Encode(value interface{}, buf []byte) (newBuf
return nil, nil return nil, nil
} }
return append(buf, strconv.FormatFloat(n.Float, 'f', -1, 64)...), nil return append(buf, strconv.FormatFloat(n.Float64, 'f', -1, 64)...), nil
} }
type encodePlanFloat8CodecBinaryInt64Valuer struct{} type encodePlanFloat8CodecBinaryInt64Valuer struct{}
@ -241,7 +241,7 @@ func (scanPlanBinaryFloat8ToFloat64Scanner) Scan(src []byte, dst interface{}) er
} }
n := int64(binary.BigEndian.Uint64(src)) n := int64(binary.BigEndian.Uint64(src))
return s.ScanFloat64(Float8{Float: math.Float64frombits(uint64(n)), Valid: true}) return s.ScanFloat64(Float8{Float64: math.Float64frombits(uint64(n)), Valid: true})
} }
type scanPlanBinaryFloat8ToInt64Scanner struct{} type scanPlanBinaryFloat8ToInt64Scanner struct{}
@ -299,7 +299,7 @@ func (scanPlanTextAnyToFloat64Scanner) Scan(src []byte, dst interface{}) error {
return err return err
} }
return s.ScanFloat64(Float8{Float: n, Valid: true}) return s.ScanFloat64(Float8{Float64: n, Valid: true})
} }
func (c Float8Codec) DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, src []byte) (driver.Value, error) { func (c Float8Codec) DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, src []byte) (driver.Value, error) {

6
pgtype/float8_test.go
View File

@ -9,9 +9,9 @@ import (
func TestFloat8Codec(t *testing.T) { func TestFloat8Codec(t *testing.T) {
testutil.RunTranscodeTests(t, "float8", []testutil.TranscodeTestCase{ testutil.RunTranscodeTests(t, "float8", []testutil.TranscodeTestCase{
{pgtype.Float8{Float: -1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: -1, Valid: true})}, {pgtype.Float8{Float64: -1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float64: -1, Valid: true})},
{pgtype.Float8{Float: 0, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: 0, Valid: true})}, {pgtype.Float8{Float64: 0, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float64: 0, Valid: true})},
{pgtype.Float8{Float: 1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float: 1, Valid: true})}, {pgtype.Float8{Float64: 1, Valid: true}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{Float64: 1, Valid: true})},
{float64(0.00001), new(float64), isExpectedEq(float64(0.00001))}, {float64(0.00001), new(float64), isExpectedEq(float64(0.00001))},
{float64(9999.99), new(float64), isExpectedEq(float64(9999.99))}, {float64(9999.99), new(float64), isExpectedEq(float64(9999.99))},
{pgtype.Float8{}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{})}, {pgtype.Float8{}, new(pgtype.Float8), isExpectedEq(pgtype.Float8{})},

24
pgtype/numeric.go
View File

@ -84,11 +84,11 @@ func (n Numeric) Float64Value() (Float8, error) {
if !n.Valid { if !n.Valid {
return Float8{}, nil return Float8{}, nil
} else if n.NaN { } else if n.NaN {
return Float8{Float: math.NaN(), Valid: true}, nil return Float8{Float64: math.NaN(), Valid: true}, nil
} else if n.InfinityModifier == Infinity { } else if n.InfinityModifier == Infinity {
return Float8{Float: math.Inf(1), Valid: true}, nil return Float8{Float64: math.Inf(1), Valid: true}, nil
} else if n.InfinityModifier == NegativeInfinity { } else if n.InfinityModifier == NegativeInfinity {
return Float8{Float: math.Inf(-1), Valid: true}, nil return Float8{Float64: math.Inf(-1), Valid: true}, nil
} }
buf := make([]byte, 0, 32) buf := make([]byte, 0, 32)
@ -106,7 +106,7 @@ func (n Numeric) Float64Value() (Float8, error) {
return Float8{}, err return Float8{}, err
} }
return Float8{Float: f, Valid: true}, nil return Float8{Float64: f, Valid: true}, nil
} }
func (n *Numeric) toBigInt() (*big.Int, error) { func (n *Numeric) toBigInt() (*big.Int, error) {
@ -297,14 +297,14 @@ func (encodePlanNumericCodecBinaryFloat64Valuer) Encode(value interface{}, buf [
return nil, nil return nil, nil
} }
if math.IsNaN(n.Float) { if math.IsNaN(n.Float64) {
return encodeNumericBinary(Numeric{NaN: true, Valid: true}, buf) return encodeNumericBinary(Numeric{NaN: true, Valid: true}, buf)
} else if math.IsInf(n.Float, 1) { } else if math.IsInf(n.Float64, 1) {
return encodeNumericBinary(Numeric{InfinityModifier: Infinity, Valid: true}, buf) return encodeNumericBinary(Numeric{InfinityModifier: Infinity, Valid: true}, buf)
} else if math.IsInf(n.Float, -1) { } else if math.IsInf(n.Float64, -1) {
return encodeNumericBinary(Numeric{InfinityModifier: NegativeInfinity, Valid: true}, buf) return encodeNumericBinary(Numeric{InfinityModifier: NegativeInfinity, Valid: true}, buf)
} }
num, exp, err := parseNumericString(strconv.FormatFloat(n.Float, 'f', -1, 64)) num, exp, err := parseNumericString(strconv.FormatFloat(n.Float64, 'f', -1, 64))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -449,14 +449,14 @@ func (encodePlanNumericCodecTextFloat64Valuer) Encode(value interface{}, buf []b
return nil, nil return nil, nil
} }
if math.IsNaN(n.Float) { if math.IsNaN(n.Float64) {
return encodeNumericBinary(Numeric{NaN: true, Valid: true}, buf) return encodeNumericBinary(Numeric{NaN: true, Valid: true}, buf)
} else if math.IsInf(n.Float, 1) { } else if math.IsInf(n.Float64, 1) {
return encodeNumericBinary(Numeric{InfinityModifier: Infinity, Valid: true}, buf) return encodeNumericBinary(Numeric{InfinityModifier: Infinity, Valid: true}, buf)
} else if math.IsInf(n.Float, -1) { } else if math.IsInf(n.Float64, -1) {
return encodeNumericBinary(Numeric{InfinityModifier: NegativeInfinity, Valid: true}, buf) return encodeNumericBinary(Numeric{InfinityModifier: NegativeInfinity, Valid: true}, buf)
} }
num, exp, err := parseNumericString(strconv.FormatFloat(n.Float, 'f', -1, 64)) num, exp, err := parseNumericString(strconv.FormatFloat(n.Float64, 'f', -1, 64))
if err != nil { if err != nil {
return nil, err return nil, err
} }

12
pgtype/numeric_test.go
View File

@ -123,11 +123,11 @@ func TestNumericFloat64Valuer(t *testing.T) {
n pgtype.Numeric n pgtype.Numeric
f pgtype.Float8 f pgtype.Float8
}{ }{
{mustParseNumeric(t, "1"), pgtype.Float8{Float: 1, Valid: true}}, {mustParseNumeric(t, "1"), pgtype.Float8{Float64: 1, Valid: true}},
{mustParseNumeric(t, "0.0000000000000000001"), pgtype.Float8{Float: 0.0000000000000000001, Valid: true}}, {mustParseNumeric(t, "0.0000000000000000001"), pgtype.Float8{Float64: 0.0000000000000000001, Valid: true}},
{mustParseNumeric(t, "-99999999999"), pgtype.Float8{Float: -99999999999, Valid: true}}, {mustParseNumeric(t, "-99999999999"), pgtype.Float8{Float64: -99999999999, Valid: true}},
{pgtype.Numeric{InfinityModifier: pgtype.Infinity, Valid: true}, pgtype.Float8{Float: math.Inf(1), Valid: true}}, {pgtype.Numeric{InfinityModifier: pgtype.Infinity, Valid: true}, pgtype.Float8{Float64: math.Inf(1), Valid: true}},
{pgtype.Numeric{InfinityModifier: pgtype.NegativeInfinity, Valid: true}, pgtype.Float8{Float: math.Inf(-1), Valid: true}}, {pgtype.Numeric{InfinityModifier: pgtype.NegativeInfinity, Valid: true}, pgtype.Float8{Float64: math.Inf(-1), Valid: true}},
{pgtype.Numeric{Valid: true}, pgtype.Float8{Valid: true}}, {pgtype.Numeric{Valid: true}, pgtype.Float8{Valid: true}},
{pgtype.Numeric{}, pgtype.Float8{}}, {pgtype.Numeric{}, pgtype.Float8{}},
} { } {
@ -138,7 +138,7 @@ func TestNumericFloat64Valuer(t *testing.T) {
f, err := pgtype.Numeric{NaN: true, Valid: true}.Float64Value() f, err := pgtype.Numeric{NaN: true, Valid: true}.Float64Value()
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, math.IsNaN(f.Float)) assert.True(t, math.IsNaN(f.Float64))
assert.True(t, f.Valid) assert.True(t, f.Valid)
} }

8
pgtype/range_codec_test.go
View File

@ -46,15 +46,15 @@ func TestRangeCodecTranscodeCompatibleRangeElementTypes(t *testing.T) {
{ {
pgtype.Float8range{ pgtype.Float8range{
LowerType: pgtype.Inclusive, LowerType: pgtype.Inclusive,
Lower: pgtype.Float8{Float: 1, Valid: true}, Lower: pgtype.Float8{Float64: 1, Valid: true},
Upper: pgtype.Float8{Float: 5, Valid: true}, Upper: pgtype.Float8{Float64: 5, Valid: true},
UpperType: pgtype.Exclusive, Valid: true, UpperType: pgtype.Exclusive, Valid: true,
}, },
new(pgtype.Float8range), new(pgtype.Float8range),
isExpectedEq(pgtype.Float8range{ isExpectedEq(pgtype.Float8range{
LowerType: pgtype.Inclusive, LowerType: pgtype.Inclusive,
Lower: pgtype.Float8{Float: 1, Valid: true}, Lower: pgtype.Float8{Float64: 1, Valid: true},
Upper: pgtype.Float8{Float: 5, Valid: true}, Upper: pgtype.Float8{Float64: 5, Valid: true},
UpperType: pgtype.Exclusive, Valid: true, UpperType: pgtype.Exclusive, Valid: true,
}), }),
}, },

6
pgtype/zeronull/float8.go
View File

@ -17,7 +17,7 @@ func (f *Float8) ScanFloat64(n pgtype.Float8) error {
return nil return nil
} }
*f = Float8(n.Float) *f = Float8(n.Float64)
return nil return nil
} }
@ -26,7 +26,7 @@ func (f Float8) Float64Value() (pgtype.Float8, error) {
if f == 0 { if f == 0 {
return pgtype.Float8{}, nil return pgtype.Float8{}, nil
} }
return pgtype.Float8{Float: float64(f), Valid: true}, nil return pgtype.Float8{Float64: float64(f), Valid: true}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@ -42,7 +42,7 @@ func (f *Float8) Scan(src interface{}) error {
return err return err
} }
*f = Float8(nullable.Float) *f = Float8(nullable.Float64)
return nil return nil
} }