add Floats and Bools

README.md

@@ -1,7 +1,7 @@
 ## null [![GoDoc](https://godoc.org/github.com/guregu/null?status.svg)](https://godoc.org/github.com/guregu/null) [![Coverage](http://gocover.io/_badge/github.com/guregu/null)](http://gocover.io/github.com/guregu/null)
 null is a library with opinions on how to deal with nullable SQL and JSON values
 
-There are two packages, `null`, and `nuller`. 
+There are two packages: `null` and `nuller`. 
 
 Types in `null` are treated like zero values in Go: blank string input will produce a null `null.String`, and null Strings will JSON encode to `""`. If you need zero and null treated the same, use these.
 
@@ -19,6 +19,16 @@ A nullable int64.
 
 Will marshal to 0 if null. Blank string or 0 input produces a null Int. In other words, null values and empty values are considered equivalent. Can unmarshal from `sql.NullInt64` JSON input. 
 
+#### null.Float
+A nullable float64.
+
+Will marshal to 0 if null. Blank string or 0 input produces a null Float. In other words, null values and empty values are considered equivalent. Can unmarshal from `sql.NullFloat64` JSON input. 
+
+#### null.Bool
+A nullable bool.
+
+Will marshal to false if null. Blank string or false input produces a null Float. In other words, null values and empty values are considered equivalent. Can unmarshal from `sql.NullBool` JSON input. 
+
 #### nuller.String
 An even nuller nullable string. 
 
@@ -29,6 +39,16 @@ An even nuller nullable int64.
 
 Unlike `null.Int`, `nuller.Int` will marshal to null if null. Zero input will not produce a null Int. Can unmarshal from `sql.NullInt64` JSON input. 
 
+#### nuller.Float
+An even nuller nullable float64. 
+
+Unlike `null.Float`, `nuller.Float` will marshal to null if null. Zero input will not produce a null Float. Can unmarshal from `sql.NullFloat64` JSON input. 
+
+#### nuller.Bool
+An even nuller nullable float64. 
+
+Unlike `null.Bool`, `nuller.Bool` will marshal to null if null. False input will not produce a null Bool. Can unmarshal from `sql.NullBool` JSON input. 
+
 ### Bugs
 `json`'s `",omitempty"` struct tag does not work correctly right now. It will never omit a null or empty String. This should be [fixed in Go 1.4](https://code.google.com/p/go/issues/detail?id=4357).
 

bool.go

@@ -0,0 +1,107 @@
+package null
+
+import (
+	"database/sql"
+	"encoding/json"
+	"errors"
+)
+
+// Bool is a nullable bool.
+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 be null if false.
+func BoolFrom(b bool) Bool {
+	return NewBool(b, b)
+}
+
+// BoolFromPtr creates a new Bool that be null if b is nil.
+func BoolFromPtr(b *bool) Bool {
+	if b == nil {
+		return NewBool(false, false)
+	}
+	return NewBool(*b, true)
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+// "false" will 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) && b.Bool
+	return err
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+// It will unmarshal to a null Bool if the input is a false or not a bool.
+// It will return an error if the input is not a float, 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 = b.Bool
+	return nil
+}
+
+// MarshalJSON implements json.Marshaler.
+// It will encode null if this Bool is null.
+func (b Bool) MarshalJSON() ([]byte, error) {
+	if !b.Valid || !b.Bool {
+		return []byte("false"), nil
+	}
+	return []byte("true"), nil
+}
+
+// MarshalText implements encoding.TextMarshaler.
+// It will encode a zero if this Bool is null.
+func (b Bool) MarshalText() ([]byte, error) {
+	if !b.Valid || !b.Bool {
+		return []byte("false"), nil
+	}
+	return []byte("true"), nil
+}
+
+// Ptr returns a poBooler to this Bool's value, or a nil poBooler if this Bool is null.
+func (b Bool) Ptr() *bool {
+	if !b.Valid {
+		return nil
+	}
+	return &b.Bool
+}
+
+// IsZero returns true for null or zero Bools, for future omitempty support (Go 1.4?)
+func (b Bool) IsZero() bool {
+	return !b.Valid || !b.Bool
+}

bool_test.go

@@ -0,0 +1,160 @@
+package null
+
+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 valid, but should be invalid")
+	}
+}
+
+func TestBoolFromPtr(t *testing.T) {
+	v := true
+	bptr := &v
+	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, "float json")
+
+	var nb Bool
+	err = json.Unmarshal(nullBoolJSON, &nb)
+	maybePanic(err)
+	assertBool(t, nb, "sql.NullBool json")
+
+	var zero Bool
+	err = json.Unmarshal(falseJSON, &zero)
+	maybePanic(err)
+	assertNullBool(t, zero, "zero 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(boolJSON)
+	maybePanic(err)
+	assertBool(t, b, "UnmarshalText() bool")
+
+	var zero Bool
+	err = zero.UnmarshalText(falseJSON)
+	maybePanic(err)
+	assertNullBool(t, zero, "UnmarshalText() zero bool")
+
+	var blank Bool
+	err = blank.UnmarshalText([]byte(""))
+	maybePanic(err)
+	assertNullBool(t, blank, "UnmarshalText() empty bool")
+
+	var null Bool
+	err = null.UnmarshalText(nullJSON)
+	maybePanic(err)
+	assertNullBool(t, null, `UnmarshalText() "null"`)
+}
+
+func TestMarshalBool(t *testing.T) {
+	b := BoolFrom(true)
+	data, err := json.Marshal(b)
+	maybePanic(err)
+	assertJSONEquals(t, data, "true", "non-empty json marshal")
+
+	// invalid values should be encoded as false
+	null := NewBool(false, false)
+	data, err = json.Marshal(null)
+	maybePanic(err)
+	assertJSONEquals(t, data, "false", "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")
+
+	// invalid values should be encoded as zero
+	null := NewBool(false, false)
+	data, err = null.MarshalText()
+	maybePanic(err)
+	assertJSONEquals(t, data, "false", "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 true")
+	}
+}
+
+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: %d ≠ %d\n", from, b.Bool, true)
+	}
+	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")
+	}
+}

float.go

@@ -0,0 +1,104 @@
+package null
+
+import (
+	"database/sql"
+	"encoding/json"
+	"strconv"
+)
+
+// Float is a nullable float64.
+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 be null if zero.
+func FloatFrom(f float64) Float {
+	return NewFloat(f, f != 0)
+}
+
+// FloatFromPtr creates a new Float 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 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 = x
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &f.NullFloat64)
+	case nil:
+		f.Valid = false
+		return nil
+	}
+	f.Valid = (err == nil) && (f.Float64 != 0)
+	return err
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+// It will unmarshal to a null Float if the input is a blank, zero, or not a float.
+// It will return an error if the input is not a float, 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) && (f.Float64 != 0)
+	return err
+}
+
+// MarshalJSON implements json.Marshaler.
+// It will encode null if this Float is null.
+func (f Float) MarshalJSON() ([]byte, error) {
+	n := f.Float64
+	if !f.Valid {
+		n = 0
+	}
+	return []byte(strconv.FormatFloat(n, 'f', -1, 64)), nil
+}
+
+// MarshalText implements encoding.TextMarshaler.
+// It will encode a zero if this Float is null.
+func (f Float) MarshalText() ([]byte, error) {
+	n := f.Float64
+	if !f.Valid {
+		n = 0
+	}
+	return []byte(strconv.FormatFloat(n, 'f', -1, 64)), nil
+}
+
+// Ptr returns a poFloater to this Float's value, or a nil poFloater if this Float is null.
+func (f Float) Ptr() *float64 {
+	if !f.Valid {
+		return nil
+	}
+	return &f.Float64
+}
+
+// IsZero returns true for null or zero Floats, for future omitempty support (Go 1.4?)
+func (f Float) IsZero() bool {
+	return !f.Valid || f.Float64 == 0
+}

float_test.go

@@ -0,0 +1,159 @@
+package null
+
+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 valid, but should be invalid")
+	}
+}
+
+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, "sql.NullFloat64 json")
+
+	var zero Float
+	err = json.Unmarshal(zeroJSON, &zero)
+	maybePanic(err)
+	assertNullFloat(t, zero, "zero 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 zero Float
+	err = zero.UnmarshalText([]byte("0"))
+	maybePanic(err)
+	assertNullFloat(t, zero, "UnmarshalText() zero 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 0
+	null := NewFloat(0, false)
+	data, err = json.Marshal(null)
+	maybePanic(err)
+	assertJSONEquals(t, data, "0", "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 zero
+	null := NewFloat(0, false)
+	data, err = null.MarshalText()
+	maybePanic(err)
+	assertJSONEquals(t, data, "0", "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 true")
+	}
+}
+
+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")
+	}
+}

int.go

@@ -72,7 +72,7 @@ func (i *Int) UnmarshalText(text []byte) error {
 }
 
 // MarshalJSON implements json.Marshaler.
-// It will encode null if this Int is null.
+// It will encode 0 if this Int is null.
 func (i Int) MarshalJSON() ([]byte, error) {
 	n := i.Int64
 	if !i.Valid {

int_test.go

@@ -40,7 +40,7 @@ func TestUnmarshalInt(t *testing.T) {
 	var ni Int
 	err = json.Unmarshal(nullIntJSON, &ni)
 	maybePanic(err)
-	assertInt(t, ni, "sq.NullInt64 json")
+	assertInt(t, ni, "sql.NullInt64 json")
 
 	var zero Int
 	err = json.Unmarshal(zeroJSON, &zero)

nuller/bool.go

@@ -0,0 +1,117 @@
+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
+}
+
+// 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
+}

nuller/bool_test.go

@@ -0,0 +1,150 @@
+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 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"`)
+}
+
+func TestMarshalBool(t *testing.T) {
+	b := BoolFrom(true)
+	data, err := json.Marshal(b)
+	maybePanic(err)
+	assertJSONEquals(t, data, "true", "non-empty 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")
+
+	// 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 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 assertNullBool(t *testing.T, b Bool, from string) {
+	if b.Valid {
+		t.Error(from, "is valid, but should be invalid")
+	}
+}

nuller/float.go

@@ -0,0 +1,105 @@
+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
+}
+
+// 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
+}

nuller/float_test.go

@@ -0,0 +1,149 @@
+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 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")
+	}
+}

nuller/int.go

@@ -33,8 +33,7 @@ func IntFromPtr(i *int64) Int {
 	if i == nil {
 		return NewInt(0, false)
 	}
-	n := NewInt(*i, true)
+	return NewInt(*i, true)
-	return n
 }
 
 // UnmarshalJSON implements json.Unmarshaler.

nuller/string.go

@@ -22,8 +22,7 @@ func StringFromPtr(s *string) String {
 	if s == nil {
 		return NewString("", false)
 	}
-	str := NewString(*s, true)
+	return NewString(*s, true)
-	return str
 }
 
 // NewString creates a new String
@@ -82,7 +81,7 @@ func (s String) Ptr() *string {
 }
 
 // IsZero returns true for null or empty strings, for future omitempty support. (Go 1.4?)
-// Will return false s is blank but non-null.
+// Will return false s if blank but non-null.
 func (s String) IsZero() bool {
 	return !s.Valid
 }

string.go

@@ -35,8 +35,7 @@ func StringFromPtr(s *string) String {
 	if s == nil {
 		return NewString("", false)
 	}
-	str := NewString(*s, *s != "")
+	return NewString(*s, *s != "")
-	return str
 }
 
 // UnmarshalJSON implements json.Unmarshaler.