remove nuller pkg
This commit is contained in:
Greg
parent
406494f0f8
commit
49f7d361d6
8 changed files with 0 additions and 1117 deletions
123
nuller/bool.go
123
nuller/bool.go
|
|
@ -1,123 +0,0 @@
|
|||
package nuller
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
)
|
||||
|
||||
// Bool is an even nuller nullable bool.
|
||||
// It does not consider false values to be null.
|
||||
// It will decode to null, not false, if null.
|
||||
type Bool struct {
|
||||
sql.NullBool
|
||||
}
|
||||
|
||||
// NewBool creates a new Bool
|
||||
func NewBool(b bool, valid bool) Bool {
|
||||
return Bool{
|
||||
NullBool: sql.NullBool{
|
||||
Bool: b,
|
||||
Valid: valid,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// BoolFrom creates a new Bool that will always be valid.
|
||||
func BoolFrom(b bool) Bool {
|
||||
return NewBool(b, true)
|
||||
}
|
||||
|
||||
// BoolFromPtr creates a new String that be null if f is nil.
|
||||
func BoolFromPtr(b *bool) Bool {
|
||||
if b == nil {
|
||||
return NewBool(false, false)
|
||||
}
|
||||
return NewBool(*b, true)
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements json.Unmarshaler.
|
||||
// It supports number and null input.
|
||||
// 0 will not be considered a null Bool.
|
||||
// It also supports unmarshalling a sql.NullBool.
|
||||
func (b *Bool) UnmarshalJSON(data []byte) error {
|
||||
var err error
|
||||
var v interface{}
|
||||
json.Unmarshal(data, &v)
|
||||
switch x := v.(type) {
|
||||
case bool:
|
||||
b.Bool = x
|
||||
case map[string]interface{}:
|
||||
err = json.Unmarshal(data, &b.NullBool)
|
||||
case nil:
|
||||
b.Valid = false
|
||||
return nil
|
||||
}
|
||||
b.Valid = err == nil
|
||||
return err
|
||||
}
|
||||
|
||||
// UnmarshalText implements encoding.TextUnmarshaler.
|
||||
// It will unmarshal to a null Bool if the input is a blank or not an integer.
|
||||
// It will return an error if the input is not an integer, blank, or "null".
|
||||
func (b *Bool) UnmarshalText(text []byte) error {
|
||||
str := string(text)
|
||||
switch str {
|
||||
case "", "null":
|
||||
b.Valid = false
|
||||
return nil
|
||||
case "true":
|
||||
b.Bool = true
|
||||
case "false":
|
||||
b.Bool = false
|
||||
default:
|
||||
b.Valid = false
|
||||
return errors.New("invalid input:" + str)
|
||||
}
|
||||
b.Valid = true
|
||||
return nil
|
||||
}
|
||||
|
||||
// MarshalJSON implements json.Marshaler.
|
||||
// It will encode null if this Bool is null.
|
||||
func (b Bool) MarshalJSON() ([]byte, error) {
|
||||
if !b.Valid {
|
||||
return []byte("null"), nil
|
||||
}
|
||||
if !b.Bool {
|
||||
return []byte("false"), nil
|
||||
}
|
||||
return []byte("true"), nil
|
||||
}
|
||||
|
||||
// MarshalText implements encoding.TextMarshaler.
|
||||
// It will encode a blank string if this Bool is null.
|
||||
func (b Bool) MarshalText() ([]byte, error) {
|
||||
if !b.Valid {
|
||||
return []byte{}, nil
|
||||
}
|
||||
if !b.Bool {
|
||||
return []byte("false"), nil
|
||||
}
|
||||
return []byte("true"), nil
|
||||
}
|
||||
|
||||
// SetValid changes this Bool's value and also sets it to be non-null.
|
||||
func (b *Bool) SetValid(v bool) {
|
||||
b.Bool = v
|
||||
b.Valid = true
|
||||
}
|
||||
|
||||
// Ptr returns a pointer to this Bool's value, or a nil pointer if this Bool is null.
|
||||
func (b Bool) Ptr() *bool {
|
||||
if !b.Valid {
|
||||
return nil
|
||||
}
|
||||
return &b.Bool
|
||||
}
|
||||
|
||||
// IsZero returns true for invalid Bools, for future omitempty support (Go 1.4?)
|
||||
// A non-null Bool with a 0 value will not be considered zero.
|
||||
func (b Bool) IsZero() bool {
|
||||
return !b.Valid
|
||||
}
|
||||
|
|
@ -1,188 +0,0 @@
|
|||
package nuller
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var (
|
||||
boolJSON = []byte(`true`)
|
||||
falseJSON = []byte(`false`)
|
||||
nullBoolJSON = []byte(`{"Bool":true,"Valid":true}`)
|
||||
)
|
||||
|
||||
func TestBoolFrom(t *testing.T) {
|
||||
b := BoolFrom(true)
|
||||
assertBool(t, b, "BoolFrom()")
|
||||
|
||||
zero := BoolFrom(false)
|
||||
if !zero.Valid {
|
||||
t.Error("BoolFrom(false)", "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBoolFromPtr(t *testing.T) {
|
||||
n := true
|
||||
bptr := &n
|
||||
b := BoolFromPtr(bptr)
|
||||
assertBool(t, b, "BoolFromPtr()")
|
||||
|
||||
null := BoolFromPtr(nil)
|
||||
assertNullBool(t, null, "BoolFromPtr(nil)")
|
||||
}
|
||||
|
||||
func TestUnmarshalBool(t *testing.T) {
|
||||
var b Bool
|
||||
err := json.Unmarshal(boolJSON, &b)
|
||||
maybePanic(err)
|
||||
assertBool(t, b, "bool json")
|
||||
|
||||
var nb Bool
|
||||
err = json.Unmarshal(nullBoolJSON, &nb)
|
||||
maybePanic(err)
|
||||
assertBool(t, nb, "sq.NullBool json")
|
||||
|
||||
var null Bool
|
||||
err = json.Unmarshal(nullJSON, &null)
|
||||
maybePanic(err)
|
||||
assertNullBool(t, null, "null json")
|
||||
}
|
||||
|
||||
func TestTextUnmarshalBool(t *testing.T) {
|
||||
var b Bool
|
||||
err := b.UnmarshalText([]byte("true"))
|
||||
maybePanic(err)
|
||||
assertBool(t, b, "UnmarshalText() bool")
|
||||
|
||||
var zero Bool
|
||||
err = zero.UnmarshalText([]byte("false"))
|
||||
maybePanic(err)
|
||||
assertFalseBool(t, zero, "UnmarshalText() false")
|
||||
|
||||
var blank Bool
|
||||
err = blank.UnmarshalText([]byte(""))
|
||||
maybePanic(err)
|
||||
assertNullBool(t, blank, "UnmarshalText() empty bool")
|
||||
|
||||
var null Bool
|
||||
err = null.UnmarshalText([]byte("null"))
|
||||
maybePanic(err)
|
||||
assertNullBool(t, null, `UnmarshalText() "null"`)
|
||||
|
||||
var invalid Bool
|
||||
err = invalid.UnmarshalText([]byte(":D"))
|
||||
if err == nil {
|
||||
panic("err should not be nil")
|
||||
}
|
||||
assertNullBool(t, invalid, "invalid json")
|
||||
}
|
||||
|
||||
func TestMarshalBool(t *testing.T) {
|
||||
b := BoolFrom(true)
|
||||
data, err := json.Marshal(b)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "true", "non-empty json marshal")
|
||||
|
||||
zero := NewBool(false, true)
|
||||
data, err = json.Marshal(zero)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "false", "zero json marshal")
|
||||
|
||||
// invalid values should be encoded as null
|
||||
null := NewBool(false, false)
|
||||
data, err = json.Marshal(null)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "null", "null json marshal")
|
||||
}
|
||||
|
||||
func TestMarshalBoolText(t *testing.T) {
|
||||
b := BoolFrom(true)
|
||||
data, err := b.MarshalText()
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "true", "non-empty text marshal")
|
||||
|
||||
zero := NewBool(false, true)
|
||||
data, err = zero.MarshalText()
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "false", "zero text marshal")
|
||||
|
||||
// invalid values should be encoded as null
|
||||
null := NewBool(false, false)
|
||||
data, err = null.MarshalText()
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "", "null text marshal")
|
||||
}
|
||||
|
||||
func TestBoolPointer(t *testing.T) {
|
||||
b := BoolFrom(true)
|
||||
ptr := b.Ptr()
|
||||
if *ptr != true {
|
||||
t.Errorf("bad %s bool: %#v ≠ %s\n", "pointer", ptr, true)
|
||||
}
|
||||
|
||||
null := NewBool(false, false)
|
||||
ptr = null.Ptr()
|
||||
if ptr != nil {
|
||||
t.Errorf("bad %s bool: %#v ≠ %s\n", "nil pointer", ptr, "nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBoolIsZero(t *testing.T) {
|
||||
b := BoolFrom(true)
|
||||
if b.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
|
||||
null := NewBool(false, false)
|
||||
if !null.IsZero() {
|
||||
t.Errorf("IsZero() should be true")
|
||||
}
|
||||
|
||||
zero := NewBool(false, true)
|
||||
if zero.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBoolSetValid(t *testing.T) {
|
||||
change := NewBool(false, false)
|
||||
assertNullBool(t, change, "SetValid()")
|
||||
change.SetValid(true)
|
||||
assertBool(t, change, "SetValid()")
|
||||
}
|
||||
|
||||
func TestBoolScan(t *testing.T) {
|
||||
var b Bool
|
||||
err := b.Scan(true)
|
||||
maybePanic(err)
|
||||
assertBool(t, b, "scanned bool")
|
||||
|
||||
var null Bool
|
||||
err = null.Scan(nil)
|
||||
maybePanic(err)
|
||||
assertNullBool(t, null, "scanned null")
|
||||
}
|
||||
|
||||
func assertBool(t *testing.T, b Bool, from string) {
|
||||
if b.Bool != true {
|
||||
t.Errorf("bad %s bool: %v ≠ %v\n", from, b.Bool, true)
|
||||
}
|
||||
if !b.Valid {
|
||||
t.Error(from, "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func assertFalseBool(t *testing.T, b Bool, from string) {
|
||||
if b.Bool != false {
|
||||
t.Errorf("bad %s bool: %v ≠ %v\n", from, b.Bool, false)
|
||||
}
|
||||
if !b.Valid {
|
||||
t.Error(from, "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func assertNullBool(t *testing.T, b Bool, from string) {
|
||||
if b.Valid {
|
||||
t.Error(from, "is valid, but should be invalid")
|
||||
}
|
||||
}
|
||||
111
nuller/float.go
111
nuller/float.go
|
|
@ -1,111 +0,0 @@
|
|||
package nuller
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// Float is an even nuller nullable float64.
|
||||
// It does not consider zero values to be null.
|
||||
// It will decode to null, not zero, if null.
|
||||
type Float struct {
|
||||
sql.NullFloat64
|
||||
}
|
||||
|
||||
// NewFloat creates a new Float
|
||||
func NewFloat(f float64, valid bool) Float {
|
||||
return Float{
|
||||
NullFloat64: sql.NullFloat64{
|
||||
Float64: f,
|
||||
Valid: valid,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// FloatFrom creates a new Float that will always be valid.
|
||||
func FloatFrom(f float64) Float {
|
||||
return NewFloat(f, true)
|
||||
}
|
||||
|
||||
// FloatFromPtr creates a new String that be null if f is nil.
|
||||
func FloatFromPtr(f *float64) Float {
|
||||
if f == nil {
|
||||
return NewFloat(0, false)
|
||||
}
|
||||
return NewFloat(*f, true)
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements json.Unmarshaler.
|
||||
// It supports number and null input.
|
||||
// 0 will not be considered a null Float.
|
||||
// It also supports unmarshalling a sql.NullFloat64.
|
||||
func (f *Float) UnmarshalJSON(data []byte) error {
|
||||
var err error
|
||||
var v interface{}
|
||||
json.Unmarshal(data, &v)
|
||||
switch x := v.(type) {
|
||||
case float64:
|
||||
f.Float64 = float64(x)
|
||||
case map[string]interface{}:
|
||||
err = json.Unmarshal(data, &f.NullFloat64)
|
||||
case nil:
|
||||
f.Valid = false
|
||||
return nil
|
||||
}
|
||||
f.Valid = err == nil
|
||||
return err
|
||||
}
|
||||
|
||||
// UnmarshalText implements encoding.TextUnmarshaler.
|
||||
// It will unmarshal to a null Float if the input is a blank or not an integer.
|
||||
// It will return an error if the input is not an integer, blank, or "null".
|
||||
func (f *Float) UnmarshalText(text []byte) error {
|
||||
str := string(text)
|
||||
if str == "" || str == "null" {
|
||||
f.Valid = false
|
||||
return nil
|
||||
}
|
||||
var err error
|
||||
f.Float64, err = strconv.ParseFloat(string(text), 64)
|
||||
f.Valid = err == nil
|
||||
return err
|
||||
}
|
||||
|
||||
// MarshalJSON implements json.Marshaler.
|
||||
// It will encode null if this Float is null.
|
||||
func (f Float) MarshalJSON() ([]byte, error) {
|
||||
if !f.Valid {
|
||||
return []byte("null"), nil
|
||||
}
|
||||
return []byte(strconv.FormatFloat(f.Float64, 'f', -1, 64)), nil
|
||||
}
|
||||
|
||||
// MarshalText implements encoding.TextMarshaler.
|
||||
// It will encode a blank string if this Float is null.
|
||||
func (f Float) MarshalText() ([]byte, error) {
|
||||
if !f.Valid {
|
||||
return []byte{}, nil
|
||||
}
|
||||
return []byte(strconv.FormatFloat(f.Float64, 'f', -1, 64)), nil
|
||||
}
|
||||
|
||||
// SetValid changes this Float's value and also sets it to be non-null.
|
||||
func (f *Float) SetValid(n float64) {
|
||||
f.Float64 = n
|
||||
f.Valid = true
|
||||
}
|
||||
|
||||
// Ptr returns a pointer to this Float's value, or a nil pointer if this Float is null.
|
||||
func (f Float) Ptr() *float64 {
|
||||
if !f.Valid {
|
||||
return nil
|
||||
}
|
||||
return &f.Float64
|
||||
}
|
||||
|
||||
// IsZero returns true for invalid Floats, for future omitempty support (Go 1.4?)
|
||||
// A non-null Float with a 0 value will not be considered zero.
|
||||
func (f Float) IsZero() bool {
|
||||
return !f.Valid
|
||||
}
|
||||
|
|
@ -1,156 +0,0 @@
|
|||
package nuller
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var (
|
||||
floatJSON = []byte(`1.2345`)
|
||||
nullFloatJSON = []byte(`{"Float64":1.2345,"Valid":true}`)
|
||||
)
|
||||
|
||||
func TestFloatFrom(t *testing.T) {
|
||||
f := FloatFrom(1.2345)
|
||||
assertFloat(t, f, "FloatFrom()")
|
||||
|
||||
zero := FloatFrom(0)
|
||||
if !zero.Valid {
|
||||
t.Error("FloatFrom(0)", "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFloatFromPtr(t *testing.T) {
|
||||
n := float64(1.2345)
|
||||
iptr := &n
|
||||
f := FloatFromPtr(iptr)
|
||||
assertFloat(t, f, "FloatFromPtr()")
|
||||
|
||||
null := FloatFromPtr(nil)
|
||||
assertNullFloat(t, null, "FloatFromPtr(nil)")
|
||||
}
|
||||
|
||||
func TestUnmarshalFloat(t *testing.T) {
|
||||
var f Float
|
||||
err := json.Unmarshal(floatJSON, &f)
|
||||
maybePanic(err)
|
||||
assertFloat(t, f, "float json")
|
||||
|
||||
var nf Float
|
||||
err = json.Unmarshal(nullFloatJSON, &nf)
|
||||
maybePanic(err)
|
||||
assertFloat(t, nf, "sq.NullFloat64 json")
|
||||
|
||||
var null Float
|
||||
err = json.Unmarshal(nullJSON, &null)
|
||||
maybePanic(err)
|
||||
assertNullFloat(t, null, "null json")
|
||||
}
|
||||
|
||||
func TestTextUnmarshalFloat(t *testing.T) {
|
||||
var f Float
|
||||
err := f.UnmarshalText([]byte("1.2345"))
|
||||
maybePanic(err)
|
||||
assertFloat(t, f, "UnmarshalText() float")
|
||||
|
||||
var blank Float
|
||||
err = blank.UnmarshalText([]byte(""))
|
||||
maybePanic(err)
|
||||
assertNullFloat(t, blank, "UnmarshalText() empty float")
|
||||
|
||||
var null Float
|
||||
err = null.UnmarshalText([]byte("null"))
|
||||
maybePanic(err)
|
||||
assertNullFloat(t, null, `UnmarshalText() "null"`)
|
||||
}
|
||||
|
||||
func TestMarshalFloat(t *testing.T) {
|
||||
f := FloatFrom(1.2345)
|
||||
data, err := json.Marshal(f)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "1.2345", "non-empty json marshal")
|
||||
|
||||
// invalid values should be encoded as null
|
||||
null := NewFloat(0, false)
|
||||
data, err = json.Marshal(null)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "null", "null json marshal")
|
||||
}
|
||||
|
||||
func TestMarshalFloatText(t *testing.T) {
|
||||
f := FloatFrom(1.2345)
|
||||
data, err := f.MarshalText()
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "1.2345", "non-empty text marshal")
|
||||
|
||||
// invalid values should be encoded as null
|
||||
null := NewFloat(0, false)
|
||||
data, err = null.MarshalText()
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "", "null text marshal")
|
||||
}
|
||||
|
||||
func TestFloatPointer(t *testing.T) {
|
||||
f := FloatFrom(1.2345)
|
||||
ptr := f.Ptr()
|
||||
if *ptr != 1.2345 {
|
||||
t.Errorf("bad %s float: %#v ≠ %s\n", "pointer", ptr, 1.2345)
|
||||
}
|
||||
|
||||
null := NewFloat(0, false)
|
||||
ptr = null.Ptr()
|
||||
if ptr != nil {
|
||||
t.Errorf("bad %s float: %#v ≠ %s\n", "nil pointer", ptr, "nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFloatIsZero(t *testing.T) {
|
||||
f := FloatFrom(1.2345)
|
||||
if f.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
|
||||
null := NewFloat(0, false)
|
||||
if !null.IsZero() {
|
||||
t.Errorf("IsZero() should be true")
|
||||
}
|
||||
|
||||
zero := NewFloat(0, true)
|
||||
if zero.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFloatSetValid(t *testing.T) {
|
||||
change := NewFloat(0, false)
|
||||
assertNullFloat(t, change, "SetValid()")
|
||||
change.SetValid(1.2345)
|
||||
assertFloat(t, change, "SetValid()")
|
||||
}
|
||||
|
||||
func TestFloatScan(t *testing.T) {
|
||||
var f Float
|
||||
err := f.Scan(1.2345)
|
||||
maybePanic(err)
|
||||
assertFloat(t, f, "scanned float")
|
||||
|
||||
var null Float
|
||||
err = null.Scan(nil)
|
||||
maybePanic(err)
|
||||
assertNullFloat(t, null, "scanned null")
|
||||
}
|
||||
|
||||
func assertFloat(t *testing.T, f Float, from string) {
|
||||
if f.Float64 != 1.2345 {
|
||||
t.Errorf("bad %s float: %f ≠ %f\n", from, f.Float64, 1.2345)
|
||||
}
|
||||
if !f.Valid {
|
||||
t.Error(from, "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func assertNullFloat(t *testing.T, f Float, from string) {
|
||||
if f.Valid {
|
||||
t.Error(from, "is valid, but should be invalid")
|
||||
}
|
||||
}
|
||||
111
nuller/int.go
111
nuller/int.go
|
|
@ -1,111 +0,0 @@
|
|||
package nuller
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// Int is an even nuller nullable int64.
|
||||
// It does not consider zero values to be null.
|
||||
// It will decode to null, not zero, if null.
|
||||
type Int struct {
|
||||
sql.NullInt64
|
||||
}
|
||||
|
||||
// NewInt creates a new Int
|
||||
func NewInt(i int64, valid bool) Int {
|
||||
return Int{
|
||||
NullInt64: sql.NullInt64{
|
||||
Int64: i,
|
||||
Valid: valid,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// IntFrom creates a new Int that will always be valid.
|
||||
func IntFrom(i int64) Int {
|
||||
return NewInt(i, true)
|
||||
}
|
||||
|
||||
// IntFromPtr creates a new String that be null if i is nil.
|
||||
func IntFromPtr(i *int64) Int {
|
||||
if i == nil {
|
||||
return NewInt(0, false)
|
||||
}
|
||||
return NewInt(*i, true)
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements json.Unmarshaler.
|
||||
// It supports number and null input.
|
||||
// 0 will not be considered a null Int.
|
||||
// It also supports unmarshalling a sql.NullInt64.
|
||||
func (i *Int) UnmarshalJSON(data []byte) error {
|
||||
var err error
|
||||
var v interface{}
|
||||
json.Unmarshal(data, &v)
|
||||
switch x := v.(type) {
|
||||
case float64:
|
||||
i.Int64 = int64(x)
|
||||
case map[string]interface{}:
|
||||
err = json.Unmarshal(data, &i.NullInt64)
|
||||
case nil:
|
||||
i.Valid = false
|
||||
return nil
|
||||
}
|
||||
i.Valid = err == nil
|
||||
return err
|
||||
}
|
||||
|
||||
// UnmarshalText implements encoding.TextUnmarshaler.
|
||||
// It will unmarshal to a null Int if the input is a blank or not an integer.
|
||||
// It will return an error if the input is not an integer, blank, or "null".
|
||||
func (i *Int) UnmarshalText(text []byte) error {
|
||||
str := string(text)
|
||||
if str == "" || str == "null" {
|
||||
i.Valid = false
|
||||
return nil
|
||||
}
|
||||
var err error
|
||||
i.Int64, err = strconv.ParseInt(string(text), 10, 64)
|
||||
i.Valid = err == nil
|
||||
return err
|
||||
}
|
||||
|
||||
// MarshalJSON implements json.Marshaler.
|
||||
// It will encode null if this Int is null.
|
||||
func (i Int) MarshalJSON() ([]byte, error) {
|
||||
if !i.Valid {
|
||||
return []byte("null"), nil
|
||||
}
|
||||
return []byte(strconv.FormatInt(i.Int64, 10)), nil
|
||||
}
|
||||
|
||||
// MarshalText implements encoding.TextMarshaler.
|
||||
// It will encode a blank string if this Int is null.
|
||||
func (i Int) MarshalText() ([]byte, error) {
|
||||
if !i.Valid {
|
||||
return []byte{}, nil
|
||||
}
|
||||
return []byte(strconv.FormatInt(i.Int64, 10)), nil
|
||||
}
|
||||
|
||||
// SetValid changes this Int's value and also sets it to be non-null.
|
||||
func (i *Int) SetValid(n int64) {
|
||||
i.Int64 = n
|
||||
i.Valid = true
|
||||
}
|
||||
|
||||
// Ptr returns a pointer to this Int's value, or a nil pointer if this Int is null.
|
||||
func (i Int) Ptr() *int64 {
|
||||
if !i.Valid {
|
||||
return nil
|
||||
}
|
||||
return &i.Int64
|
||||
}
|
||||
|
||||
// IsZero returns true for invalid Ints, for future omitempty support (Go 1.4?)
|
||||
// A non-null Int with a 0 value will not be considered zero.
|
||||
func (i Int) IsZero() bool {
|
||||
return !i.Valid
|
||||
}
|
||||
|
|
@ -1,156 +0,0 @@
|
|||
package nuller
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var (
|
||||
intJSON = []byte(`12345`)
|
||||
nullIntJSON = []byte(`{"Int64":12345,"Valid":true}`)
|
||||
)
|
||||
|
||||
func TestIntFrom(t *testing.T) {
|
||||
i := IntFrom(12345)
|
||||
assertInt(t, i, "IntFrom()")
|
||||
|
||||
zero := IntFrom(0)
|
||||
if !zero.Valid {
|
||||
t.Error("IntFrom(0)", "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntFromPtr(t *testing.T) {
|
||||
n := int64(12345)
|
||||
iptr := &n
|
||||
i := IntFromPtr(iptr)
|
||||
assertInt(t, i, "IntFromPtr()")
|
||||
|
||||
null := IntFromPtr(nil)
|
||||
assertNullInt(t, null, "IntFromPtr(nil)")
|
||||
}
|
||||
|
||||
func TestUnmarshalInt(t *testing.T) {
|
||||
var i Int
|
||||
err := json.Unmarshal(intJSON, &i)
|
||||
maybePanic(err)
|
||||
assertInt(t, i, "int json")
|
||||
|
||||
var ni Int
|
||||
err = json.Unmarshal(nullIntJSON, &ni)
|
||||
maybePanic(err)
|
||||
assertInt(t, ni, "sq.NullInt64 json")
|
||||
|
||||
var null Int
|
||||
err = json.Unmarshal(nullJSON, &null)
|
||||
maybePanic(err)
|
||||
assertNullInt(t, null, "null json")
|
||||
}
|
||||
|
||||
func TestTextUnmarshalInt(t *testing.T) {
|
||||
var i Int
|
||||
err := i.UnmarshalText([]byte("12345"))
|
||||
maybePanic(err)
|
||||
assertInt(t, i, "UnmarshalText() int")
|
||||
|
||||
var blank Int
|
||||
err = blank.UnmarshalText([]byte(""))
|
||||
maybePanic(err)
|
||||
assertNullInt(t, blank, "UnmarshalText() empty int")
|
||||
|
||||
var null Int
|
||||
err = null.UnmarshalText([]byte("null"))
|
||||
maybePanic(err)
|
||||
assertNullInt(t, null, `UnmarshalText() "null"`)
|
||||
}
|
||||
|
||||
func TestMarshalInt(t *testing.T) {
|
||||
i := IntFrom(12345)
|
||||
data, err := json.Marshal(i)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "12345", "non-empty json marshal")
|
||||
|
||||
// invalid values should be encoded as null
|
||||
null := NewInt(0, false)
|
||||
data, err = json.Marshal(null)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "null", "null json marshal")
|
||||
}
|
||||
|
||||
func TestMarshalIntText(t *testing.T) {
|
||||
i := IntFrom(12345)
|
||||
data, err := i.MarshalText()
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "12345", "non-empty text marshal")
|
||||
|
||||
// invalid values should be encoded as null
|
||||
null := NewInt(0, false)
|
||||
data, err = null.MarshalText()
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, "", "null text marshal")
|
||||
}
|
||||
|
||||
func TestIntPointer(t *testing.T) {
|
||||
i := IntFrom(12345)
|
||||
ptr := i.Ptr()
|
||||
if *ptr != 12345 {
|
||||
t.Errorf("bad %s int: %#v ≠ %s\n", "pointer", ptr, 12345)
|
||||
}
|
||||
|
||||
null := NewInt(0, false)
|
||||
ptr = null.Ptr()
|
||||
if ptr != nil {
|
||||
t.Errorf("bad %s int: %#v ≠ %s\n", "nil pointer", ptr, "nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntIsZero(t *testing.T) {
|
||||
i := IntFrom(12345)
|
||||
if i.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
|
||||
null := NewInt(0, false)
|
||||
if !null.IsZero() {
|
||||
t.Errorf("IsZero() should be true")
|
||||
}
|
||||
|
||||
zero := NewInt(0, true)
|
||||
if zero.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntSetValid(t *testing.T) {
|
||||
change := NewInt(0, false)
|
||||
assertNullInt(t, change, "SetValid()")
|
||||
change.SetValid(12345)
|
||||
assertInt(t, change, "SetValid()")
|
||||
}
|
||||
|
||||
func TestIntScan(t *testing.T) {
|
||||
var i Int
|
||||
err := i.Scan(12345)
|
||||
maybePanic(err)
|
||||
assertInt(t, i, "scanned int")
|
||||
|
||||
var null Int
|
||||
err = null.Scan(nil)
|
||||
maybePanic(err)
|
||||
assertNullInt(t, null, "scanned null")
|
||||
}
|
||||
|
||||
func assertInt(t *testing.T, i Int, from string) {
|
||||
if i.Int64 != 12345 {
|
||||
t.Errorf("bad %s int: %d ≠ %d\n", from, i.Int64, 12345)
|
||||
}
|
||||
if !i.Valid {
|
||||
t.Error(from, "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func assertNullInt(t *testing.T, i Int, from string) {
|
||||
if i.Valid {
|
||||
t.Error(from, "is valid, but should be invalid")
|
||||
}
|
||||
}
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
// Package nuller contains types that consider zero input and null input as separate values.
|
||||
// Types in this package will always encode to their null value if null.
|
||||
package nuller
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"encoding/json"
|
||||
)
|
||||
|
||||
// String is an even nuller nullable string.
|
||||
type String struct {
|
||||
sql.NullString
|
||||
}
|
||||
|
||||
// StringFrom creates a new String that will never be blank.
|
||||
func StringFrom(s string) String {
|
||||
return NewString(s, true)
|
||||
}
|
||||
|
||||
// StringFromPtr creates a new String that be null if s is nil.
|
||||
func StringFromPtr(s *string) String {
|
||||
if s == nil {
|
||||
return NewString("", false)
|
||||
}
|
||||
return NewString(*s, true)
|
||||
}
|
||||
|
||||
// NewString creates a new String
|
||||
func NewString(s string, valid bool) String {
|
||||
return String{
|
||||
NullString: sql.NullString{
|
||||
String: s,
|
||||
Valid: valid,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements json.Unmarshaler.
|
||||
// It supports string and null input. Blank string input produces a null String.
|
||||
// It also supports unmarshalling a sql.NullString.
|
||||
func (s *String) UnmarshalJSON(data []byte) error {
|
||||
var err error
|
||||
var v interface{}
|
||||
json.Unmarshal(data, &v)
|
||||
switch x := v.(type) {
|
||||
case string:
|
||||
s.String = x
|
||||
case map[string]interface{}:
|
||||
err = json.Unmarshal(data, &s.NullString)
|
||||
case nil:
|
||||
s.Valid = false
|
||||
return nil
|
||||
}
|
||||
s.Valid = (err == nil) && (s.String != "")
|
||||
return err
|
||||
}
|
||||
|
||||
// MarshalJSON implements json.Marshaler.
|
||||
// It will encode null if this String is null.
|
||||
func (s String) MarshalJSON() ([]byte, error) {
|
||||
if !s.Valid {
|
||||
return []byte("null"), nil
|
||||
}
|
||||
return json.Marshal(s.String)
|
||||
}
|
||||
|
||||
// UnmarshalText implements encoding.TextUnmarshaler.
|
||||
// It will unmarshal to a null String if the input is a blank string.
|
||||
func (s *String) UnmarshalText(text []byte) error {
|
||||
s.String = string(text)
|
||||
s.Valid = s.String != ""
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetValid changes this String's value and also sets it to be non-null.
|
||||
func (s *String) SetValid(v string) {
|
||||
s.String = v
|
||||
s.Valid = true
|
||||
}
|
||||
|
||||
// Ptr returns a pointer to this String's value, or a nil pointer if this String is null.
|
||||
func (s String) Ptr() *string {
|
||||
if !s.Valid {
|
||||
return nil
|
||||
}
|
||||
return &s.String
|
||||
}
|
||||
|
||||
// IsZero returns true for null or empty strings, for future omitempty support. (Go 1.4?)
|
||||
// Will return false s if blank but non-null.
|
||||
func (s String) IsZero() bool {
|
||||
return !s.Valid
|
||||
}
|
||||
|
|
@ -1,179 +0,0 @@
|
|||
package nuller
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
)
|
||||
|
||||
var (
|
||||
stringJSON = []byte(`"test"`)
|
||||
blankStringJSON = []byte(`""`)
|
||||
nullStringJSON = []byte(`{"String":"test","Valid":true}`)
|
||||
nullJSON = []byte(`null`)
|
||||
)
|
||||
|
||||
type stringInStruct struct {
|
||||
Test String `json:"test,omitempty"`
|
||||
}
|
||||
|
||||
func TestStringFrom(t *testing.T) {
|
||||
str := StringFrom("test")
|
||||
assertStr(t, str, "StringFrom() string")
|
||||
|
||||
zero := StringFrom("")
|
||||
if !zero.Valid {
|
||||
t.Error("StringFrom(0)", "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStringFromPtr(t *testing.T) {
|
||||
s := "test"
|
||||
sptr := &s
|
||||
str := StringFromPtr(sptr)
|
||||
assertStr(t, str, "StringFromPtr() string")
|
||||
|
||||
null := StringFromPtr(nil)
|
||||
assertNullStr(t, null, "StringFromPtr(nil)")
|
||||
}
|
||||
|
||||
func TestUnmarshalString(t *testing.T) {
|
||||
var str String
|
||||
err := json.Unmarshal(stringJSON, &str)
|
||||
maybePanic(err)
|
||||
assertStr(t, str, "string json")
|
||||
|
||||
var ns String
|
||||
err = json.Unmarshal(nullStringJSON, &ns)
|
||||
maybePanic(err)
|
||||
assertStr(t, ns, "sql.NullString json")
|
||||
|
||||
var blank String
|
||||
err = json.Unmarshal(blankStringJSON, &blank)
|
||||
maybePanic(err)
|
||||
assertNullStr(t, blank, "blank string json")
|
||||
|
||||
var null String
|
||||
err = json.Unmarshal(nullJSON, &null)
|
||||
maybePanic(err)
|
||||
assertNullStr(t, null, "null json")
|
||||
}
|
||||
|
||||
func TestTextUnmarshalString(t *testing.T) {
|
||||
var str String
|
||||
err := str.UnmarshalText([]byte("test"))
|
||||
maybePanic(err)
|
||||
assertStr(t, str, "UnmarshalText() string")
|
||||
|
||||
var null String
|
||||
err = null.UnmarshalText([]byte(""))
|
||||
maybePanic(err)
|
||||
assertNullStr(t, null, "UnmarshalText() empty string")
|
||||
}
|
||||
|
||||
func TestMarshalString(t *testing.T) {
|
||||
str := StringFrom("test")
|
||||
data, err := json.Marshal(str)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, `"test"`, "non-empty json marshal")
|
||||
|
||||
// empty values should be encoded as an empty string
|
||||
zero := StringFrom("")
|
||||
data, err = json.Marshal(zero)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, `""`, "empty json marshal")
|
||||
|
||||
null := StringFromPtr(nil)
|
||||
data, err = json.Marshal(null)
|
||||
maybePanic(err)
|
||||
assertJSONEquals(t, data, `null`, "null json marshal")
|
||||
}
|
||||
|
||||
// Tests omitempty... broken until Go 1.4
|
||||
// func TestMarshalStringInStruct(t *testing.T) {
|
||||
// obj := stringInStruct{Test: StringFrom("")}
|
||||
// data, err := json.Marshal(obj)
|
||||
// maybePanic(err)
|
||||
// assertJSONEquals(t, data, `{}`, "null string in struct")
|
||||
// }
|
||||
|
||||
func TestStringPointer(t *testing.T) {
|
||||
str := StringFrom("test")
|
||||
ptr := str.Ptr()
|
||||
if *ptr != "test" {
|
||||
t.Errorf("bad %s string: %#v ≠ %s\n", "pointer", ptr, "test")
|
||||
}
|
||||
|
||||
null := NewString("", false)
|
||||
ptr = null.Ptr()
|
||||
if ptr != nil {
|
||||
t.Errorf("bad %s string: %#v ≠ %s\n", "nil pointer", ptr, "nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStringIsZero(t *testing.T) {
|
||||
str := StringFrom("test")
|
||||
if str.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
|
||||
blank := StringFrom("")
|
||||
if blank.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
|
||||
empty := NewString("", true)
|
||||
if empty.IsZero() {
|
||||
t.Errorf("IsZero() should be false")
|
||||
}
|
||||
|
||||
null := StringFromPtr(nil)
|
||||
if !null.IsZero() {
|
||||
t.Errorf("IsZero() should be true")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStringSetValid(t *testing.T) {
|
||||
change := NewString("", false)
|
||||
assertNullStr(t, change, "SetValid()")
|
||||
change.SetValid("test")
|
||||
assertStr(t, change, "SetValid()")
|
||||
}
|
||||
|
||||
func TestStringScan(t *testing.T) {
|
||||
var str String
|
||||
err := str.Scan("test")
|
||||
maybePanic(err)
|
||||
assertStr(t, str, "scanned string")
|
||||
|
||||
var null String
|
||||
err = null.Scan(nil)
|
||||
maybePanic(err)
|
||||
assertNullStr(t, null, "scanned null")
|
||||
}
|
||||
|
||||
func maybePanic(err error) {
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
func assertStr(t *testing.T, s String, from string) {
|
||||
if s.String != "test" {
|
||||
t.Errorf("bad %s string: %s ≠ %s\n", from, s.String, "test")
|
||||
}
|
||||
if !s.Valid {
|
||||
t.Error(from, "is invalid, but should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func assertNullStr(t *testing.T, s String, from string) {
|
||||
if s.Valid {
|
||||
t.Error(from, "is valid, but should be invalid")
|
||||
}
|
||||
}
|
||||
|
||||
func assertJSONEquals(t *testing.T, data []byte, cmp string, from string) {
|
||||
if string(data) != cmp {
|
||||
t.Errorf("bad %s data: %s ≠ %s\n", from, data, cmp)
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue