gopkg/pgx
2
0
Fork 0
Code Activity

pgtype Int2, Int4, and Int8 fields include bit size

Browse Source 
e.g. Instead of Int it is Int64. This matches the pattern set by the
database/sql types.
This commit is contained in:
Jack Christensen
2022-03-05 09:10:58 -06:00
parent 872a7a9315
commit d723a4ab6f
12 changed files with 206 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pgtype/builtin_wrappers.go
+60 -60
View File
@@ -18,19 +18,19 @@ func (w *int8Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *int8") return fmt.Errorf("cannot scan NULL into *int8")
} }
if v.Int < math.MinInt8 { if v.Int64 < math.MinInt8 {
return fmt.Errorf("%d is less than minimum value for int8", v.Int) return fmt.Errorf("%d is less than minimum value for int8", v.Int64)
} }
if v.Int > math.MaxInt8 { if v.Int64 > math.MaxInt8 {
return fmt.Errorf("%d is greater than maximum value for int8", v.Int) return fmt.Errorf("%d is greater than maximum value for int8", v.Int64)
} }
*w = int8Wrapper(v.Int) *w = int8Wrapper(v.Int64)
return nil return nil
} }
func (w int8Wrapper) Int64Value() (Int8, error) { func (w int8Wrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type int16Wrapper int16 type int16Wrapper int16
@@ -42,19 +42,19 @@ func (w *int16Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *int16") return fmt.Errorf("cannot scan NULL into *int16")
} }
if v.Int < math.MinInt16 { if v.Int64 < math.MinInt16 {
return fmt.Errorf("%d is less than minimum value for int16", v.Int) return fmt.Errorf("%d is less than minimum value for int16", v.Int64)
} }
if v.Int > math.MaxInt16 { if v.Int64 > math.MaxInt16 {
return fmt.Errorf("%d is greater than maximum value for int16", v.Int) return fmt.Errorf("%d is greater than maximum value for int16", v.Int64)
} }
*w = int16Wrapper(v.Int) *w = int16Wrapper(v.Int64)
return nil return nil
} }
func (w int16Wrapper) Int64Value() (Int8, error) { func (w int16Wrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type int32Wrapper int32 type int32Wrapper int32
@@ -66,19 +66,19 @@ func (w *int32Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *int32") return fmt.Errorf("cannot scan NULL into *int32")
} }
if v.Int < math.MinInt32 { if v.Int64 < math.MinInt32 {
return fmt.Errorf("%d is less than minimum value for int32", v.Int) return fmt.Errorf("%d is less than minimum value for int32", v.Int64)
} }
if v.Int > math.MaxInt32 { if v.Int64 > math.MaxInt32 {
return fmt.Errorf("%d is greater than maximum value for int32", v.Int) return fmt.Errorf("%d is greater than maximum value for int32", v.Int64)
} }
*w = int32Wrapper(v.Int) *w = int32Wrapper(v.Int64)
return nil return nil
} }
func (w int32Wrapper) Int64Value() (Int8, error) { func (w int32Wrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type int64Wrapper int64 type int64Wrapper int64
@@ -90,13 +90,13 @@ func (w *int64Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *int64") return fmt.Errorf("cannot scan NULL into *int64")
} }
*w = int64Wrapper(v.Int) *w = int64Wrapper(v.Int64)
return nil return nil
} }
func (w int64Wrapper) Int64Value() (Int8, error) { func (w int64Wrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type intWrapper int type intWrapper int
@@ -108,20 +108,20 @@ func (w *intWrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *int") return fmt.Errorf("cannot scan NULL into *int")
} }
if v.Int < math.MinInt { if v.Int64 < math.MinInt {
return fmt.Errorf("%d is less than minimum value for int", v.Int) return fmt.Errorf("%d is less than minimum value for int", v.Int64)
} }
if v.Int > math.MaxInt { if v.Int64 > math.MaxInt {
return fmt.Errorf("%d is greater than maximum value for int", v.Int) return fmt.Errorf("%d is greater than maximum value for int", v.Int64)
} }
*w = intWrapper(v.Int) *w = intWrapper(v.Int64)
return nil return nil
} }
func (w intWrapper) Int64Value() (Int8, error) { func (w intWrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type uint8Wrapper uint8 type uint8Wrapper uint8
@@ -133,19 +133,19 @@ func (w *uint8Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *uint8") return fmt.Errorf("cannot scan NULL into *uint8")
} }
if v.Int < 0 { if v.Int64 < 0 {
return fmt.Errorf("%d is less than minimum value for uint8", v.Int) return fmt.Errorf("%d is less than minimum value for uint8", v.Int64)
} }
if v.Int > math.MaxUint8 { if v.Int64 > math.MaxUint8 {
return fmt.Errorf("%d is greater than maximum value for uint8", v.Int) return fmt.Errorf("%d is greater than maximum value for uint8", v.Int64)
} }
*w = uint8Wrapper(v.Int) *w = uint8Wrapper(v.Int64)
return nil return nil
} }
func (w uint8Wrapper) Int64Value() (Int8, error) { func (w uint8Wrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type uint16Wrapper uint16 type uint16Wrapper uint16
@@ -157,19 +157,19 @@ func (w *uint16Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *uint16") return fmt.Errorf("cannot scan NULL into *uint16")
} }
if v.Int < 0 { if v.Int64 < 0 {
return fmt.Errorf("%d is less than minimum value for uint16", v.Int) return fmt.Errorf("%d is less than minimum value for uint16", v.Int64)
} }
if v.Int > math.MaxUint16 { if v.Int64 > math.MaxUint16 {
return fmt.Errorf("%d is greater than maximum value for uint16", v.Int) return fmt.Errorf("%d is greater than maximum value for uint16", v.Int64)
} }
*w = uint16Wrapper(v.Int) *w = uint16Wrapper(v.Int64)
return nil return nil
} }
func (w uint16Wrapper) Int64Value() (Int8, error) { func (w uint16Wrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type uint32Wrapper uint32 type uint32Wrapper uint32
@@ -181,19 +181,19 @@ func (w *uint32Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *uint32") return fmt.Errorf("cannot scan NULL into *uint32")
} }
if v.Int < 0 { if v.Int64 < 0 {
return fmt.Errorf("%d is less than minimum value for uint32", v.Int) return fmt.Errorf("%d is less than minimum value for uint32", v.Int64)
} }
if v.Int > math.MaxUint32 { if v.Int64 > math.MaxUint32 {
return fmt.Errorf("%d is greater than maximum value for uint32", v.Int) return fmt.Errorf("%d is greater than maximum value for uint32", v.Int64)
} }
*w = uint32Wrapper(v.Int) *w = uint32Wrapper(v.Int64)
return nil return nil
} }
func (w uint32Wrapper) Int64Value() (Int8, error) { func (w uint32Wrapper) Int64Value() (Int8, error) {
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type uint64Wrapper uint64 type uint64Wrapper uint64
@@ -205,11 +205,11 @@ func (w *uint64Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *uint64") return fmt.Errorf("cannot scan NULL into *uint64")
} }
if v.Int < 0 { if v.Int64 < 0 {
return fmt.Errorf("%d is less than minimum value for uint64", v.Int) return fmt.Errorf("%d is less than minimum value for uint64", v.Int64)
} }
*w = uint64Wrapper(v.Int) *w = uint64Wrapper(v.Int64)
return nil return nil
} }
@@ -219,7 +219,7 @@ func (w uint64Wrapper) Int64Value() (Int8, error) {
return Int8{}, fmt.Errorf("%d is greater than maximum value for int64", w) return Int8{}, fmt.Errorf("%d is greater than maximum value for int64", w)
} }
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type uintWrapper uint type uintWrapper uint
@@ -231,15 +231,15 @@ func (w *uintWrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *uint64") return fmt.Errorf("cannot scan NULL into *uint64")
} }
if v.Int < 0 { if v.Int64 < 0 {
return fmt.Errorf("%d is less than minimum value for uint64", v.Int) return fmt.Errorf("%d is less than minimum value for uint64", v.Int64)
} }
if uint64(v.Int) > math.MaxUint { if uint64(v.Int64) > math.MaxUint {
return fmt.Errorf("%d is greater than maximum value for uint", v.Int) return fmt.Errorf("%d is greater than maximum value for uint", v.Int64)
} }
*w = uintWrapper(v.Int) *w = uintWrapper(v.Int64)
return nil return nil
} }
@@ -249,7 +249,7 @@ func (w uintWrapper) Int64Value() (Int8, error) {
return Int8{}, fmt.Errorf("%d is greater than maximum value for int64", w) return Int8{}, fmt.Errorf("%d is greater than maximum value for int64", w)
} }
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
type float32Wrapper float32 type float32Wrapper float32
@@ -261,7 +261,7 @@ func (w *float32Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *float32") return fmt.Errorf("cannot scan NULL into *float32")
} }
*w = float32Wrapper(v.Int) *w = float32Wrapper(v.Int64)
return nil return nil
} }
@@ -271,7 +271,7 @@ func (w float32Wrapper) Int64Value() (Int8, error) {
return Int8{}, fmt.Errorf("%f is greater than maximum value for int64", w) return Int8{}, fmt.Errorf("%f is greater than maximum value for int64", w)
} }
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
func (w *float32Wrapper) ScanFloat64(v Float8) error { func (w *float32Wrapper) ScanFloat64(v Float8) error {
@@ -297,7 +297,7 @@ func (w *float64Wrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *float64") return fmt.Errorf("cannot scan NULL into *float64")
} }
*w = float64Wrapper(v.Int) *w = float64Wrapper(v.Int64)
return nil return nil
} }
@@ -307,7 +307,7 @@ func (w float64Wrapper) Int64Value() (Int8, error) {
return Int8{}, fmt.Errorf("%f is greater than maximum value for int64", w) return Int8{}, fmt.Errorf("%f is greater than maximum value for int64", w)
} }
return Int8{Int: int64(w), Valid: true}, nil return Int8{Int64: int64(w), Valid: true}, nil
} }
func (w *float64Wrapper) ScanFloat64(v Float8) error { func (w *float64Wrapper) ScanFloat64(v Float8) error {
@@ -346,7 +346,7 @@ func (w *stringWrapper) ScanInt64(v Int8) error {
return fmt.Errorf("cannot scan NULL into *string") return fmt.Errorf("cannot scan NULL into *string")
} }
*w = stringWrapper(strconv.FormatInt(v.Int, 10)) *w = stringWrapper(strconv.FormatInt(v.Int64, 10))
return nil return nil
} }
@@ -357,7 +357,7 @@ func (w stringWrapper) Int64Value() (Int8, error) {
return Int8{}, err return Int8{}, err
} }
return Int8{Int: int64(num), Valid: true}, nil return Int8{Int64: int64(num), Valid: true}, nil
} }
type timeWrapper time.Time type timeWrapper time.Time
pgtype/float4.go
+4 -4
View File
@@ -26,12 +26,12 @@ func (f Float4) Float64Value() (Float8, error) {
} }
func (f *Float4) ScanInt64(n Int8) error { func (f *Float4) ScanInt64(n Int8) error {
*f = Float4{Float: float32(n.Int), Valid: n.Valid} *f = Float4{Float: float32(n.Int64), Valid: n.Valid}
return nil return nil
} }
func (f Float4) Int64Value() (Int8, error) { func (f Float4) Int64Value() (Int8, error) {
return Int8{Int: int64(f.Float), Valid: f.Valid}, nil return Int8{Int64: int64(f.Float), Valid: f.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@@ -141,7 +141,7 @@ func (encodePlanFloat4CodecBinaryInt64Valuer) Encode(value interface{}, buf []by
return nil, nil return nil, nil
} }
f := float32(n.Int) f := float32(n.Int64)
return pgio.AppendUint32(buf, math.Float32bits(f)), nil return pgio.AppendUint32(buf, math.Float32bits(f)), nil
} }
@@ -226,7 +226,7 @@ func (scanPlanBinaryFloat4ToInt64Scanner) Scan(src []byte, dst interface{}) erro
return fmt.Errorf("cannot losslessly convert %v to int64", f32) return fmt.Errorf("cannot losslessly convert %v to int64", f32)
} }
return s.ScanInt64(Int8{Int: i64, Valid: true}) return s.ScanInt64(Int8{Int64: i64, Valid: true})
} }
type scanPlanTextAnyToFloat32 struct{} type scanPlanTextAnyToFloat32 struct{}
pgtype/float8.go
+5 -5
View File
@@ -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.Int), Valid: n.Valid} *f = Float8{Float: float64(n.Int64), Valid: n.Valid}
return nil return nil
} }
func (f Float8) Int64Value() (Int8, error) { func (f Float8) Int64Value() (Int8, error) {
return Int8{Int: int64(f.Float), Valid: f.Valid}, nil return Int8{Int64: int64(f.Float), Valid: f.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@@ -164,7 +164,7 @@ func (encodePlanFloat8CodecBinaryInt64Valuer) Encode(value interface{}, buf []by
return nil, nil return nil, nil
} }
f := float64(n.Int) f := float64(n.Int64)
return pgio.AppendUint64(buf, math.Float64bits(f)), nil return pgio.AppendUint64(buf, math.Float64bits(f)), nil
} }
@@ -180,7 +180,7 @@ func (encodePlanTextInt64Valuer) Encode(value interface{}, buf []byte) (newBuf [
return nil, nil return nil, nil
} }
return append(buf, strconv.FormatInt(n.Int, 10)...), nil return append(buf, strconv.FormatInt(n.Int64, 10)...), nil
} }
func (Float8Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan { func (Float8Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan {
@@ -264,7 +264,7 @@ func (scanPlanBinaryFloat8ToInt64Scanner) Scan(src []byte, dst interface{}) erro
return fmt.Errorf("cannot losslessly convert %v to int64", f64) return fmt.Errorf("cannot losslessly convert %v to int64", f64)
} }
return s.ScanInt64(Int8{Int: i64, Valid: true}) return s.ScanInt64(Int8{Int64: i64, Valid: true})
} }
type scanPlanTextAnyToFloat64 struct{} type scanPlanTextAnyToFloat64 struct{}
pgtype/int.go
+67 -67
View File
@@ -21,7 +21,7 @@ type Int64Valuer interface {
} }
type Int2 struct { type Int2 struct {
Int int16 Int16 int16
Valid bool Valid bool
} }
@@ -32,19 +32,19 @@ func (dst *Int2) ScanInt64(n Int8) error {
return nil return nil
} }
if n.Int < math.MinInt16 { if n.Int64 < math.MinInt16 {
return fmt.Errorf("%d is greater than maximum value for Int2", n.Int) return fmt.Errorf("%d is greater than maximum value for Int2", n.Int64)
} }
if n.Int > math.MaxInt16 { if n.Int64 > math.MaxInt16 {
return fmt.Errorf("%d is greater than maximum value for Int2", n.Int) return fmt.Errorf("%d is greater than maximum value for Int2", n.Int64)
} }
*dst = Int2{Int: int16(n.Int), Valid: true} *dst = Int2{Int16: int16(n.Int64), Valid: true}
return nil return nil
} }
func (n Int2) Int64Value() (Int8, error) { func (n Int2) Int64Value() (Int8, error) {
return Int8{Int: int64(n.Int), Valid: n.Valid}, nil return Int8{Int64: int64(n.Int16), Valid: n.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@@ -81,7 +81,7 @@ func (dst *Int2) Scan(src interface{}) error {
if n > math.MaxInt16 { if n > math.MaxInt16 {
return fmt.Errorf("%d is greater than maximum value for Int2", n) return fmt.Errorf("%d is greater than maximum value for Int2", n)
} }
*dst = Int2{Int: int16(n), Valid: true} *dst = Int2{Int16: int16(n), Valid: true}
return nil return nil
} }
@@ -91,14 +91,14 @@ func (src Int2) Value() (driver.Value, error) {
if !src.Valid { if !src.Valid {
return nil, nil return nil, nil
} }
return int64(src.Int), nil return int64(src.Int16), nil
} }
func (src Int2) MarshalJSON() ([]byte, error) { func (src Int2) MarshalJSON() ([]byte, error) {
if !src.Valid { if !src.Valid {
return []byte("null"), nil return []byte("null"), nil
} }
return []byte(strconv.FormatInt(int64(src.Int), 10)), nil return []byte(strconv.FormatInt(int64(src.Int16), 10)), nil
} }
func (dst *Int2) UnmarshalJSON(b []byte) error { func (dst *Int2) UnmarshalJSON(b []byte) error {
@@ -111,7 +111,7 @@ func (dst *Int2) UnmarshalJSON(b []byte) error {
if n == nil { if n == nil {
*dst = Int2{} *dst = Int2{}
} else { } else {
*dst = Int2{Int: *n, Valid: true} *dst = Int2{Int16: *n, Valid: true}
} }
return nil return nil
@@ -174,14 +174,14 @@ func (encodePlanInt2CodecBinaryInt64Valuer) Encode(value interface{}, buf []byte
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt16 { if n.Int64 > math.MaxInt16 {
return nil, fmt.Errorf("%d is greater than maximum value for int2", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int2", n.Int64)
} }
if n.Int < math.MinInt16 { if n.Int64 < math.MinInt16 {
return nil, fmt.Errorf("%d is less than minimum value for int2", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int2", n.Int64)
} }
return pgio.AppendInt16(buf, int16(n.Int)), nil return pgio.AppendInt16(buf, int16(n.Int64)), nil
} }
type encodePlanInt2CodecTextInt64Valuer struct{} type encodePlanInt2CodecTextInt64Valuer struct{}
@@ -196,14 +196,14 @@ func (encodePlanInt2CodecTextInt64Valuer) Encode(value interface{}, buf []byte)
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt16 { if n.Int64 > math.MaxInt16 {
return nil, fmt.Errorf("%d is greater than maximum value for int2", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int2", n.Int64)
} }
if n.Int < math.MinInt16 { if n.Int64 < math.MinInt16 {
return nil, fmt.Errorf("%d is less than minimum value for int2", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int2", n.Int64)
} }
return append(buf, strconv.FormatInt(n.Int, 10)...), nil return append(buf, strconv.FormatInt(n.Int64, 10)...), nil
} }
func (Int2Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan { func (Int2Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan {
@@ -554,11 +554,11 @@ func (scanPlanBinaryInt2ToInt64Scanner) Scan(src []byte, dst interface{}) error
n := int64(int16(binary.BigEndian.Uint16(src))) n := int64(int16(binary.BigEndian.Uint16(src)))
return s.ScanInt64(Int8{Int: n, Valid: true}) return s.ScanInt64(Int8{Int64: n, Valid: true})
} }
type Int4 struct { type Int4 struct {
Int int32 Int32 int32
Valid bool Valid bool
} }
@@ -569,19 +569,19 @@ func (dst *Int4) ScanInt64(n Int8) error {
return nil return nil
} }
if n.Int < math.MinInt32 { if n.Int64 < math.MinInt32 {
return fmt.Errorf("%d is greater than maximum value for Int4", n.Int) return fmt.Errorf("%d is greater than maximum value for Int4", n.Int64)
} }
if n.Int > math.MaxInt32 { if n.Int64 > math.MaxInt32 {
return fmt.Errorf("%d is greater than maximum value for Int4", n.Int) return fmt.Errorf("%d is greater than maximum value for Int4", n.Int64)
} }
*dst = Int4{Int: int32(n.Int), Valid: true} *dst = Int4{Int32: int32(n.Int64), Valid: true}
return nil return nil
} }
func (n Int4) Int64Value() (Int8, error) { func (n Int4) Int64Value() (Int8, error) {
return Int8{Int: int64(n.Int), Valid: n.Valid}, nil return Int8{Int64: int64(n.Int32), Valid: n.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@@ -618,7 +618,7 @@ func (dst *Int4) Scan(src interface{}) error {
if n > math.MaxInt32 { if n > math.MaxInt32 {
return fmt.Errorf("%d is greater than maximum value for Int4", n) return fmt.Errorf("%d is greater than maximum value for Int4", n)
} }
*dst = Int4{Int: int32(n), Valid: true} *dst = Int4{Int32: int32(n), Valid: true}
return nil return nil
} }
@@ -628,14 +628,14 @@ func (src Int4) Value() (driver.Value, error) {
if !src.Valid { if !src.Valid {
return nil, nil return nil, nil
} }
return int64(src.Int), nil return int64(src.Int32), nil
} }
func (src Int4) MarshalJSON() ([]byte, error) { func (src Int4) MarshalJSON() ([]byte, error) {
if !src.Valid { if !src.Valid {
return []byte("null"), nil return []byte("null"), nil
} }
return []byte(strconv.FormatInt(int64(src.Int), 10)), nil return []byte(strconv.FormatInt(int64(src.Int32), 10)), nil
} }
func (dst *Int4) UnmarshalJSON(b []byte) error { func (dst *Int4) UnmarshalJSON(b []byte) error {
@@ -648,7 +648,7 @@ func (dst *Int4) UnmarshalJSON(b []byte) error {
if n == nil { if n == nil {
*dst = Int4{} *dst = Int4{}
} else { } else {
*dst = Int4{Int: *n, Valid: true} *dst = Int4{Int32: *n, Valid: true}
} }
return nil return nil
@@ -711,14 +711,14 @@ func (encodePlanInt4CodecBinaryInt64Valuer) Encode(value interface{}, buf []byte
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt32 { if n.Int64 > math.MaxInt32 {
return nil, fmt.Errorf("%d is greater than maximum value for int4", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int4", n.Int64)
} }
if n.Int < math.MinInt32 { if n.Int64 < math.MinInt32 {
return nil, fmt.Errorf("%d is less than minimum value for int4", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int4", n.Int64)
} }
return pgio.AppendInt32(buf, int32(n.Int)), nil return pgio.AppendInt32(buf, int32(n.Int64)), nil
} }
type encodePlanInt4CodecTextInt64Valuer struct{} type encodePlanInt4CodecTextInt64Valuer struct{}
@@ -733,14 +733,14 @@ func (encodePlanInt4CodecTextInt64Valuer) Encode(value interface{}, buf []byte)
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt32 { if n.Int64 > math.MaxInt32 {
return nil, fmt.Errorf("%d is greater than maximum value for int4", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int4", n.Int64)
} }
if n.Int < math.MinInt32 { if n.Int64 < math.MinInt32 {
return nil, fmt.Errorf("%d is less than minimum value for int4", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int4", n.Int64)
} }
return append(buf, strconv.FormatInt(n.Int, 10)...), nil return append(buf, strconv.FormatInt(n.Int64, 10)...), nil
} }
func (Int4Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan { func (Int4Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan {
@@ -1102,11 +1102,11 @@ func (scanPlanBinaryInt4ToInt64Scanner) Scan(src []byte, dst interface{}) error
n := int64(int32(binary.BigEndian.Uint32(src))) n := int64(int32(binary.BigEndian.Uint32(src)))
return s.ScanInt64(Int8{Int: n, Valid: true}) return s.ScanInt64(Int8{Int64: n, Valid: true})
} }
type Int8 struct { type Int8 struct {
Int int64 Int64 int64
Valid bool Valid bool
} }
@@ -1117,19 +1117,19 @@ func (dst *Int8) ScanInt64(n Int8) error {
return nil return nil
} }
if n.Int < math.MinInt64 { if n.Int64 < math.MinInt64 {
return fmt.Errorf("%d is greater than maximum value for Int8", n.Int) return fmt.Errorf("%d is greater than maximum value for Int8", n.Int64)
} }
if n.Int > math.MaxInt64 { if n.Int64 > math.MaxInt64 {
return fmt.Errorf("%d is greater than maximum value for Int8", n.Int) return fmt.Errorf("%d is greater than maximum value for Int8", n.Int64)
} }
*dst = Int8{Int: int64(n.Int), Valid: true} *dst = Int8{Int64: int64(n.Int64), Valid: true}
return nil return nil
} }
func (n Int8) Int64Value() (Int8, error) { func (n Int8) Int64Value() (Int8, error) {
return Int8{Int: int64(n.Int), Valid: n.Valid}, nil return Int8{Int64: int64(n.Int64), Valid: n.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@@ -1166,7 +1166,7 @@ func (dst *Int8) Scan(src interface{}) error {
if n > math.MaxInt64 { if n > math.MaxInt64 {
return fmt.Errorf("%d is greater than maximum value for Int8", n) return fmt.Errorf("%d is greater than maximum value for Int8", n)
} }
*dst = Int8{Int: int64(n), Valid: true} *dst = Int8{Int64: int64(n), Valid: true}
return nil return nil
} }
@@ -1176,14 +1176,14 @@ func (src Int8) Value() (driver.Value, error) {
if !src.Valid { if !src.Valid {
return nil, nil return nil, nil
} }
return int64(src.Int), nil return int64(src.Int64), nil
} }
func (src Int8) MarshalJSON() ([]byte, error) { func (src Int8) MarshalJSON() ([]byte, error) {
if !src.Valid { if !src.Valid {
return []byte("null"), nil return []byte("null"), nil
} }
return []byte(strconv.FormatInt(int64(src.Int), 10)), nil return []byte(strconv.FormatInt(int64(src.Int64), 10)), nil
} }
func (dst *Int8) UnmarshalJSON(b []byte) error { func (dst *Int8) UnmarshalJSON(b []byte) error {
@@ -1196,7 +1196,7 @@ func (dst *Int8) UnmarshalJSON(b []byte) error {
if n == nil { if n == nil {
*dst = Int8{} *dst = Int8{}
} else { } else {
*dst = Int8{Int: *n, Valid: true} *dst = Int8{Int64: *n, Valid: true}
} }
return nil return nil
@@ -1259,14 +1259,14 @@ func (encodePlanInt8CodecBinaryInt64Valuer) Encode(value interface{}, buf []byte
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt64 { if n.Int64 > math.MaxInt64 {
return nil, fmt.Errorf("%d is greater than maximum value for int8", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int8", n.Int64)
} }
if n.Int < math.MinInt64 { if n.Int64 < math.MinInt64 {
return nil, fmt.Errorf("%d is less than minimum value for int8", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int8", n.Int64)
} }
return pgio.AppendInt64(buf, int64(n.Int)), nil return pgio.AppendInt64(buf, int64(n.Int64)), nil
} }
type encodePlanInt8CodecTextInt64Valuer struct{} type encodePlanInt8CodecTextInt64Valuer struct{}
@@ -1281,14 +1281,14 @@ func (encodePlanInt8CodecTextInt64Valuer) Encode(value interface{}, buf []byte)
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt64 { if n.Int64 > math.MaxInt64 {
return nil, fmt.Errorf("%d is greater than maximum value for int8", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int8", n.Int64)
} }
if n.Int < math.MinInt64 { if n.Int64 < math.MinInt64 {
return nil, fmt.Errorf("%d is less than minimum value for int8", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int8", n.Int64)
} }
return append(buf, strconv.FormatInt(n.Int, 10)...), nil return append(buf, strconv.FormatInt(n.Int64, 10)...), nil
} }
func (Int8Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan { func (Int8Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan {
@@ -1672,7 +1672,7 @@ func (scanPlanBinaryInt8ToInt64Scanner) Scan(src []byte, dst interface{}) error
n := int64(int64(binary.BigEndian.Uint64(src))) n := int64(int64(binary.BigEndian.Uint64(src)))
return s.ScanInt64(Int8{Int: n, Valid: true}) return s.ScanInt64(Int8{Int64: n, Valid: true})
} }
type scanPlanTextAnyToInt8 struct{} type scanPlanTextAnyToInt8 struct{}
@@ -1902,7 +1902,7 @@ func (scanPlanTextAnyToInt64Scanner) Scan(src []byte, dst interface{}) error {
return err return err
} }
err = s.ScanInt64(Int8{Int: n, Valid: true}) err = s.ScanInt64(Int8{Int64: n, Valid: true})
if err != nil { if err != nil {
return err return err
} }
pgtype/int.go.erb
+23 -23
View File
@@ -22,7 +22,7 @@ type Int64Valuer interface {
<% [2, 4, 8].each do |pg_byte_size| %> <% [2, 4, 8].each do |pg_byte_size| %>
<% pg_bit_size = pg_byte_size * 8 %> <% pg_bit_size = pg_byte_size * 8 %>
type Int<%= pg_byte_size %> struct { type Int<%= pg_byte_size %> struct {
Int int<%= pg_bit_size %> Int<%= pg_bit_size %> int<%= pg_bit_size %>
Valid bool Valid bool
} }
@@ -33,19 +33,19 @@ func (dst *Int<%= pg_byte_size %>) ScanInt64(n Int8) error {
return nil return nil
} }
if n.Int < math.MinInt<%= pg_bit_size %> { if n.Int64 < math.MinInt<%= pg_bit_size %> {
return fmt.Errorf("%d is greater than maximum value for Int<%= pg_byte_size %>", n.Int) return fmt.Errorf("%d is greater than maximum value for Int<%= pg_byte_size %>", n.Int64)
} }
if n.Int > math.MaxInt<%= pg_bit_size %> { if n.Int64 > math.MaxInt<%= pg_bit_size %> {
return fmt.Errorf("%d is greater than maximum value for Int<%= pg_byte_size %>", n.Int) return fmt.Errorf("%d is greater than maximum value for Int<%= pg_byte_size %>", n.Int64)
} }
*dst = Int<%= pg_byte_size %>{Int: int<%= pg_bit_size %>(n.Int), Valid: true} *dst = Int<%= pg_byte_size %>{Int<%= pg_bit_size %>: int<%= pg_bit_size %>(n.Int64), Valid: true}
return nil return nil
} }
func (n Int<%= pg_byte_size %>) Int64Value() (Int8, error) { func (n Int<%= pg_byte_size %>) Int64Value() (Int8, error) {
return Int8{Int: int64(n.Int), Valid: n.Valid}, nil return Int8{Int64: int64(n.Int<%= pg_bit_size %>), Valid: n.Valid}, nil
} }
// Scan implements the database/sql Scanner interface. // Scan implements the database/sql Scanner interface.
@@ -82,7 +82,7 @@ func (dst *Int<%= pg_byte_size %>) Scan(src interface{}) error {
if n > math.MaxInt<%= pg_bit_size %> { if n > math.MaxInt<%= pg_bit_size %> {
return fmt.Errorf("%d is greater than maximum value for Int<%= pg_byte_size %>", n) return fmt.Errorf("%d is greater than maximum value for Int<%= pg_byte_size %>", n)
} }
*dst = Int<%= pg_byte_size %>{Int: int<%= pg_bit_size %>(n), Valid: true} *dst = Int<%= pg_byte_size %>{Int<%= pg_bit_size %>: int<%= pg_bit_size %>(n), Valid: true}
return nil return nil
} }
@@ -92,14 +92,14 @@ func (src Int<%= pg_byte_size %>) Value() (driver.Value, error) {
if !src.Valid { if !src.Valid {
return nil, nil return nil, nil
} }
return int64(src.Int), nil return int64(src.Int<%= pg_bit_size %>), nil
} }
func (src Int<%= pg_byte_size %>) MarshalJSON() ([]byte, error) { func (src Int<%= pg_byte_size %>) MarshalJSON() ([]byte, error) {
if !src.Valid { if !src.Valid {
return []byte("null"), nil return []byte("null"), nil
} }
return []byte(strconv.FormatInt(int64(src.Int), 10)), nil return []byte(strconv.FormatInt(int64(src.Int<%= pg_bit_size %>), 10)), nil
} }
func (dst *Int<%= pg_byte_size %>) UnmarshalJSON(b []byte) error { func (dst *Int<%= pg_byte_size %>) UnmarshalJSON(b []byte) error {
@@ -112,7 +112,7 @@ func (dst *Int<%= pg_byte_size %>) UnmarshalJSON(b []byte) error {
if n == nil { if n == nil {
*dst = Int<%= pg_byte_size %>{} *dst = Int<%= pg_byte_size %>{}
} else { } else {
*dst = Int<%= pg_byte_size %>{Int: *n, Valid: true} *dst = Int<%= pg_byte_size %>{Int<%= pg_bit_size %>: *n, Valid: true}
} }
return nil return nil
@@ -175,14 +175,14 @@ func (encodePlanInt<%= pg_byte_size %>CodecBinaryInt64Valuer) Encode(value inter
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt<%= pg_bit_size %> { if n.Int64 > math.MaxInt<%= pg_bit_size %> {
return nil, fmt.Errorf("%d is greater than maximum value for int<%= pg_byte_size %>", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int<%= pg_byte_size %>", n.Int64)
} }
if n.Int < math.MinInt<%= pg_bit_size %> { if n.Int64 < math.MinInt<%= pg_bit_size %> {
return nil, fmt.Errorf("%d is less than minimum value for int<%= pg_byte_size %>", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int<%= pg_byte_size %>", n.Int64)
} }
return pgio.AppendInt<%= pg_bit_size %>(buf, int<%= pg_bit_size %>(n.Int)), nil return pgio.AppendInt<%= pg_bit_size %>(buf, int<%= pg_bit_size %>(n.Int64)), nil
} }
type encodePlanInt<%= pg_byte_size %>CodecTextInt64Valuer struct{} type encodePlanInt<%= pg_byte_size %>CodecTextInt64Valuer struct{}
@@ -197,14 +197,14 @@ func (encodePlanInt<%= pg_byte_size %>CodecTextInt64Valuer) Encode(value interfa
return nil, nil return nil, nil
} }
if n.Int > math.MaxInt<%= pg_bit_size %> { if n.Int64 > math.MaxInt<%= pg_bit_size %> {
return nil, fmt.Errorf("%d is greater than maximum value for int<%= pg_byte_size %>", n.Int) return nil, fmt.Errorf("%d is greater than maximum value for int<%= pg_byte_size %>", n.Int64)
} }
if n.Int < math.MinInt<%= pg_bit_size %> { if n.Int64 < math.MinInt<%= pg_bit_size %> {
return nil, fmt.Errorf("%d is less than minimum value for int<%= pg_byte_size %>", n.Int) return nil, fmt.Errorf("%d is less than minimum value for int<%= pg_byte_size %>", n.Int64)
} }
return append(buf, strconv.FormatInt(n.Int, 10)...), nil return append(buf, strconv.FormatInt(n.Int64, 10)...), nil
} }
func (Int<%= pg_byte_size %>Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan { func (Int<%= pg_byte_size %>Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan {
@@ -441,7 +441,7 @@ func (scanPlanBinaryInt<%= pg_byte_size %>ToInt64Scanner) Scan(src []byte, dst i
n := int64(int<%= pg_bit_size %>(binary.BigEndian.Uint<%= pg_bit_size %>(src))) n := int64(int<%= pg_bit_size %>(binary.BigEndian.Uint<%= pg_bit_size %>(src)))
return s.ScanInt64(Int8{Int: n, Valid: true}) return s.ScanInt64(Int8{Int64: n, Valid: true})
} }
<% end %> <% end %>
@@ -513,7 +513,7 @@ func (scanPlanTextAnyToInt64Scanner) Scan(src []byte, dst interface{}) error {
return err return err
} }
err = s.ScanInt64(Int8{Int: n, Valid: true}) err = s.ScanInt64(Int8{Int64: n, Valid: true})
if err != nil { if err != nil {
return err return err
} }
pgtype/int_test.go
+21 -21
View File
@@ -21,8 +21,8 @@ func TestInt2Codec(t *testing.T) {
{uint64(1), new(int16), isExpectedEq(int16(1))}, {uint64(1), new(int16), isExpectedEq(int16(1))},
{int(1), new(int16), isExpectedEq(int16(1))}, {int(1), new(int16), isExpectedEq(int16(1))},
{uint(1), new(int16), isExpectedEq(int16(1))}, {uint(1), new(int16), isExpectedEq(int16(1))},
{pgtype.Int2{Int: 1, Valid: true}, new(int16), isExpectedEq(int16(1))}, {pgtype.Int2{Int16: 1, Valid: true}, new(int16), isExpectedEq(int16(1))},
{int32(-1), new(pgtype.Int2), isExpectedEq(pgtype.Int2{Int: -1, Valid: true})}, {int32(-1), new(pgtype.Int2), isExpectedEq(pgtype.Int2{Int16: -1, Valid: true})},
{1, new(int8), isExpectedEq(int8(1))}, {1, new(int8), isExpectedEq(int8(1))},
{1, new(int16), isExpectedEq(int16(1))}, {1, new(int16), isExpectedEq(int16(1))},
{1, new(int32), isExpectedEq(int32(1))}, {1, new(int32), isExpectedEq(int32(1))},
@@ -43,7 +43,7 @@ func TestInt2Codec(t *testing.T) {
{0, new(int16), isExpectedEq(int16(0))}, {0, new(int16), isExpectedEq(int16(0))},
{1, new(int16), isExpectedEq(int16(1))}, {1, new(int16), isExpectedEq(int16(1))},
{math.MaxInt16, new(int16), isExpectedEq(int16(math.MaxInt16))}, {math.MaxInt16, new(int16), isExpectedEq(int16(math.MaxInt16))},
{1, new(pgtype.Int2), isExpectedEq(pgtype.Int2{Int: 1, Valid: true})}, {1, new(pgtype.Int2), isExpectedEq(pgtype.Int2{Int16: 1, Valid: true})},
{pgtype.Int2{}, new(pgtype.Int2), isExpectedEq(pgtype.Int2{})}, {pgtype.Int2{}, new(pgtype.Int2), isExpectedEq(pgtype.Int2{})},
{nil, new(*int16), isExpectedEq((*int16)(nil))}, {nil, new(*int16), isExpectedEq((*int16)(nil))},
}) })
@@ -54,8 +54,8 @@ func TestInt2MarshalJSON(t *testing.T) {
source pgtype.Int2 source pgtype.Int2
result string result string
}{ }{
{source: pgtype.Int2{Int: 0}, result: "null"}, {source: pgtype.Int2{Int16: 0}, result: "null"},
{source: pgtype.Int2{Int: 1, Valid: true}, result: "1"}, {source: pgtype.Int2{Int16: 1, Valid: true}, result: "1"},
} }
for i, tt := range successfulTests { for i, tt := range successfulTests {
r, err := tt.source.MarshalJSON() r, err := tt.source.MarshalJSON()
@@ -74,8 +74,8 @@ func TestInt2UnmarshalJSON(t *testing.T) {
source string source string
result pgtype.Int2 result pgtype.Int2
}{ }{
{source: "null", result: pgtype.Int2{Int: 0}}, {source: "null", result: pgtype.Int2{Int16: 0}},
{source: "1", result: pgtype.Int2{Int: 1, Valid: true}}, {source: "1", result: pgtype.Int2{Int16: 1, Valid: true}},
} }
for i, tt := range successfulTests { for i, tt := range successfulTests {
var r pgtype.Int2 var r pgtype.Int2
@@ -102,8 +102,8 @@ func TestInt4Codec(t *testing.T) {
{uint64(1), new(int32), isExpectedEq(int32(1))}, {uint64(1), new(int32), isExpectedEq(int32(1))},
{int(1), new(int32), isExpectedEq(int32(1))}, {int(1), new(int32), isExpectedEq(int32(1))},
{uint(1), new(int32), isExpectedEq(int32(1))}, {uint(1), new(int32), isExpectedEq(int32(1))},
{pgtype.Int4{Int: 1, Valid: true}, new(int32), isExpectedEq(int32(1))}, {pgtype.Int4{Int32: 1, Valid: true}, new(int32), isExpectedEq(int32(1))},
{int32(-1), new(pgtype.Int4), isExpectedEq(pgtype.Int4{Int: -1, Valid: true})}, {int32(-1), new(pgtype.Int4), isExpectedEq(pgtype.Int4{Int32: -1, Valid: true})},
{1, new(int8), isExpectedEq(int8(1))}, {1, new(int8), isExpectedEq(int8(1))},
{1, new(int16), isExpectedEq(int16(1))}, {1, new(int16), isExpectedEq(int16(1))},
{1, new(int32), isExpectedEq(int32(1))}, {1, new(int32), isExpectedEq(int32(1))},
@@ -124,7 +124,7 @@ func TestInt4Codec(t *testing.T) {
{0, new(int32), isExpectedEq(int32(0))}, {0, new(int32), isExpectedEq(int32(0))},
{1, new(int32), isExpectedEq(int32(1))}, {1, new(int32), isExpectedEq(int32(1))},
{math.MaxInt32, new(int32), isExpectedEq(int32(math.MaxInt32))}, {math.MaxInt32, new(int32), isExpectedEq(int32(math.MaxInt32))},
{1, new(pgtype.Int4), isExpectedEq(pgtype.Int4{Int: 1, Valid: true})}, {1, new(pgtype.Int4), isExpectedEq(pgtype.Int4{Int32: 1, Valid: true})},
{pgtype.Int4{}, new(pgtype.Int4), isExpectedEq(pgtype.Int4{})}, {pgtype.Int4{}, new(pgtype.Int4), isExpectedEq(pgtype.Int4{})},
{nil, new(*int32), isExpectedEq((*int32)(nil))}, {nil, new(*int32), isExpectedEq((*int32)(nil))},
}) })
@@ -135,8 +135,8 @@ func TestInt4MarshalJSON(t *testing.T) {
source pgtype.Int4 source pgtype.Int4
result string result string
}{ }{
{source: pgtype.Int4{Int: 0}, result: "null"}, {source: pgtype.Int4{Int32: 0}, result: "null"},
{source: pgtype.Int4{Int: 1, Valid: true}, result: "1"}, {source: pgtype.Int4{Int32: 1, Valid: true}, result: "1"},
} }
for i, tt := range successfulTests { for i, tt := range successfulTests {
r, err := tt.source.MarshalJSON() r, err := tt.source.MarshalJSON()
@@ -155,8 +155,8 @@ func TestInt4UnmarshalJSON(t *testing.T) {
source string source string
result pgtype.Int4 result pgtype.Int4
}{ }{
{source: "null", result: pgtype.Int4{Int: 0}}, {source: "null", result: pgtype.Int4{Int32: 0}},
{source: "1", result: pgtype.Int4{Int: 1, Valid: true}}, {source: "1", result: pgtype.Int4{Int32: 1, Valid: true}},
} }
for i, tt := range successfulTests { for i, tt := range successfulTests {
var r pgtype.Int4 var r pgtype.Int4
@@ -183,8 +183,8 @@ func TestInt8Codec(t *testing.T) {
{uint64(1), new(int64), isExpectedEq(int64(1))}, {uint64(1), new(int64), isExpectedEq(int64(1))},
{int(1), new(int64), isExpectedEq(int64(1))}, {int(1), new(int64), isExpectedEq(int64(1))},
{uint(1), new(int64), isExpectedEq(int64(1))}, {uint(1), new(int64), isExpectedEq(int64(1))},
{pgtype.Int8{Int: 1, Valid: true}, new(int64), isExpectedEq(int64(1))}, {pgtype.Int8{Int64: 1, Valid: true}, new(int64), isExpectedEq(int64(1))},
{int32(-1), new(pgtype.Int8), isExpectedEq(pgtype.Int8{Int: -1, Valid: true})}, {int32(-1), new(pgtype.Int8), isExpectedEq(pgtype.Int8{Int64: -1, Valid: true})},
{1, new(int8), isExpectedEq(int8(1))}, {1, new(int8), isExpectedEq(int8(1))},
{1, new(int16), isExpectedEq(int16(1))}, {1, new(int16), isExpectedEq(int16(1))},
{1, new(int32), isExpectedEq(int32(1))}, {1, new(int32), isExpectedEq(int32(1))},
@@ -205,7 +205,7 @@ func TestInt8Codec(t *testing.T) {
{0, new(int64), isExpectedEq(int64(0))}, {0, new(int64), isExpectedEq(int64(0))},
{1, new(int64), isExpectedEq(int64(1))}, {1, new(int64), isExpectedEq(int64(1))},
{math.MaxInt64, new(int64), isExpectedEq(int64(math.MaxInt64))}, {math.MaxInt64, new(int64), isExpectedEq(int64(math.MaxInt64))},
{1, new(pgtype.Int8), isExpectedEq(pgtype.Int8{Int: 1, Valid: true})}, {1, new(pgtype.Int8), isExpectedEq(pgtype.Int8{Int64: 1, Valid: true})},
{pgtype.Int8{}, new(pgtype.Int8), isExpectedEq(pgtype.Int8{})}, {pgtype.Int8{}, new(pgtype.Int8), isExpectedEq(pgtype.Int8{})},
{nil, new(*int64), isExpectedEq((*int64)(nil))}, {nil, new(*int64), isExpectedEq((*int64)(nil))},
}) })
@@ -216,8 +216,8 @@ func TestInt8MarshalJSON(t *testing.T) {
source pgtype.Int8 source pgtype.Int8
result string result string
}{ }{
{source: pgtype.Int8{Int: 0}, result: "null"}, {source: pgtype.Int8{Int64: 0}, result: "null"},
{source: pgtype.Int8{Int: 1, Valid: true}, result: "1"}, {source: pgtype.Int8{Int64: 1, Valid: true}, result: "1"},
} }
for i, tt := range successfulTests { for i, tt := range successfulTests {
r, err := tt.source.MarshalJSON() r, err := tt.source.MarshalJSON()
@@ -236,8 +236,8 @@ func TestInt8UnmarshalJSON(t *testing.T) {
source string source string
result pgtype.Int8 result pgtype.Int8
}{ }{
{source: "null", result: pgtype.Int8{Int: 0}}, {source: "null", result: pgtype.Int8{Int64: 0}},
{source: "1", result: pgtype.Int8{Int: 1, Valid: true}}, {source: "1", result: pgtype.Int8{Int64: 1, Valid: true}},
} }
for i, tt := range successfulTests { for i, tt := range successfulTests {
var r pgtype.Int8 var r pgtype.Int8
pgtype/numeric.go
+3 -3
View File
@@ -324,7 +324,7 @@ func (encodePlanNumericCodecBinaryInt64Valuer) Encode(value interface{}, buf []b
return nil, nil return nil, nil
} }
return encodeNumericBinary(Numeric{Int: big.NewInt(n.Int), Valid: true}, buf) return encodeNumericBinary(Numeric{Int: big.NewInt(n.Int64), Valid: true}, buf)
} }
func encodeNumericBinary(n Numeric, buf []byte) (newBuf []byte, err error) { func encodeNumericBinary(n Numeric, buf []byte) (newBuf []byte, err error) {
@@ -476,7 +476,7 @@ func (encodePlanNumericCodecTextInt64Valuer) Encode(value interface{}, buf []byt
return nil, nil return nil, nil
} }
return encodeNumericText(Numeric{Int: big.NewInt(n.Int), Valid: true}, buf) return encodeNumericText(Numeric{Int: big.NewInt(n.Int64), Valid: true}, buf)
} }
func encodeNumericText(n Numeric, buf []byte) (newBuf []byte, err error) { func encodeNumericText(n Numeric, buf []byte) (newBuf []byte, err error) {
@@ -682,7 +682,7 @@ func (scanPlanBinaryNumericToInt64Scanner) Scan(src []byte, dst interface{}) err
return fmt.Errorf("%v is out of range for int64", bigInt) return fmt.Errorf("%v is out of range for int64", bigInt)
} }
return scanner.ScanInt64(Int8{Int: bigInt.Int64(), Valid: true}) return scanner.ScanInt64(Int8{Int64: bigInt.Int64(), Valid: true})
} }
type scanPlanTextAnyToNumericScanner struct{} type scanPlanTextAnyToNumericScanner struct{}
pgtype/pgtype_test.go
+2 -2
View File
@@ -205,7 +205,7 @@ func BenchmarkTypeMapScanInt4IntoBinaryDecoder(b *testing.B) {
if err != nil { if err != nil {
b.Fatal(err) b.Fatal(err)
} }
if v != (pgtype.Int4{Int: 42, Valid: true}) { if v != (pgtype.Int4{Int32: 42, Valid: true}) {
b.Fatal("scan failed due to bad value") b.Fatal("scan failed due to bad value")
} }
} }
@@ -241,7 +241,7 @@ func BenchmarkScanPlanScanInt4IntoBinaryDecoder(b *testing.B) {
if err != nil { if err != nil {
b.Fatal(err) b.Fatal(err)
} }
if v != (pgtype.Int4{Int: 42, Valid: true}) { if v != (pgtype.Int4{Int32: 42, Valid: true}) {
b.Fatal("scan failed due to bad value") b.Fatal("scan failed due to bad value")
} }
} }
pgtype/range_codec_test.go
+7 -7
View File
@@ -19,15 +19,15 @@ func TestRangeCodecTranscode(t *testing.T) {
{ {
pgtype.Int4range{ pgtype.Int4range{
LowerType: pgtype.Inclusive, LowerType: pgtype.Inclusive,
Lower: pgtype.Int4{Int: 1, Valid: true}, Lower: pgtype.Int4{Int32: 1, Valid: true},
Upper: pgtype.Int4{Int: 5, Valid: true}, Upper: pgtype.Int4{Int32: 5, Valid: true},
UpperType: pgtype.Exclusive, Valid: true, UpperType: pgtype.Exclusive, Valid: true,
}, },
new(pgtype.Int4range), new(pgtype.Int4range),
isExpectedEq(pgtype.Int4range{ isExpectedEq(pgtype.Int4range{
LowerType: pgtype.Inclusive, LowerType: pgtype.Inclusive,
Lower: pgtype.Int4{Int: 1, Valid: true}, Lower: pgtype.Int4{Int32: 1, Valid: true},
Upper: pgtype.Int4{Int: 5, Valid: true}, Upper: pgtype.Int4{Int32: 5, Valid: true},
UpperType: pgtype.Exclusive, Valid: true, UpperType: pgtype.Exclusive, Valid: true,
}), }),
}, },
@@ -75,8 +75,8 @@ func TestRangeCodecScanRangeTwiceWithUnbounded(t *testing.T) {
require.Equal( require.Equal(
t, t,
pgtype.Int4range{ pgtype.Int4range{
Lower: pgtype.Int4{Int: 1, Valid: true}, Lower: pgtype.Int4{Int32: 1, Valid: true},
Upper: pgtype.Int4{Int: 5, Valid: true}, Upper: pgtype.Int4{Int32: 5, Valid: true},
LowerType: pgtype.Inclusive, LowerType: pgtype.Inclusive,
UpperType: pgtype.Exclusive, UpperType: pgtype.Exclusive,
Valid: true, Valid: true,
@@ -90,7 +90,7 @@ func TestRangeCodecScanRangeTwiceWithUnbounded(t *testing.T) {
require.Equal( require.Equal(
t, t,
pgtype.Int4range{ pgtype.Int4range{
Lower: pgtype.Int4{Int: 1, Valid: true}, Lower: pgtype.Int4{Int32: 1, Valid: true},
Upper: pgtype.Int4{}, Upper: pgtype.Int4{},
LowerType: pgtype.Inclusive, LowerType: pgtype.Inclusive,
UpperType: pgtype.Unbounded, UpperType: pgtype.Unbounded,
pgtype/uint32.go
+10 -10
View File
@@ -142,14 +142,14 @@ func (encodePlanUint32CodecBinaryInt64Valuer) Encode(value interface{}, buf []by
return nil, nil return nil, nil
} }
if v.Int < 0 { if v.Int64 < 0 {
return nil, fmt.Errorf("%d is less than minimum value for uint32", v.Int) return nil, fmt.Errorf("%d is less than minimum value for uint32", v.Int64)
} }
if v.Int > math.MaxUint32 { if v.Int64 > math.MaxUint32 {
return nil, fmt.Errorf("%d is greater than maximum value for uint32", v.Int) return nil, fmt.Errorf("%d is greater than maximum value for uint32", v.Int64)
} }
return pgio.AppendUint32(buf, uint32(v.Int)), nil return pgio.AppendUint32(buf, uint32(v.Int64)), nil
} }
type encodePlanUint32CodecTextUint32 struct{} type encodePlanUint32CodecTextUint32 struct{}
@@ -186,14 +186,14 @@ func (encodePlanUint32CodecTextInt64Valuer) Encode(value interface{}, buf []byte
return nil, nil return nil, nil
} }
if v.Int < 0 { if v.Int64 < 0 {
return nil, fmt.Errorf("%d is less than minimum value for uint32", v.Int) return nil, fmt.Errorf("%d is less than minimum value for uint32", v.Int64)
} }
if v.Int > math.MaxUint32 { if v.Int64 > math.MaxUint32 {
return nil, fmt.Errorf("%d is greater than maximum value for uint32", v.Int) return nil, fmt.Errorf("%d is greater than maximum value for uint32", v.Int64)
} }
return append(buf, strconv.FormatInt(v.Int, 10)...), nil return append(buf, strconv.FormatInt(v.Int64, 10)...), nil
} }
func (Uint32Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan { func (Uint32Codec) PlanScan(m *Map, oid uint32, format int16, target interface{}) ScanPlan {
pgtype/zeronull/int.go
+3 -3
View File
@@ -44,7 +44,7 @@ func (dst *Int2) Scan(src interface{}) error {
return err return err
} }
*dst = Int2(nullable.Int) *dst = Int2(nullable.Int16)
return nil return nil
} }
@@ -92,7 +92,7 @@ func (dst *Int4) Scan(src interface{}) error {
return err return err
} }
*dst = Int4(nullable.Int) *dst = Int4(nullable.Int32)
return nil return nil
} }
@@ -140,7 +140,7 @@ func (dst *Int8) Scan(src interface{}) error {
return err return err
} }
*dst = Int8(nullable.Int) *dst = Int8(nullable.Int64)
return nil return nil
} }
pgtype/zeronull/int.go.erb
+1 -1
View File
@@ -45,7 +45,7 @@ func (dst *Int<%= pg_byte_size %>) Scan(src interface{}) error {
return err return err
} }
*dst = Int<%= pg_byte_size %>(nullable.Int) *dst = Int<%= pg_byte_size %>(nullable.Int<%= pg_bit_size %>)
return nil return nil
} }