zero: add Equal and ValueOrZero methods

Author: guregu

zero/bool.go

@@ -38,6 +38,11 @@ func BoolFromPtr(b *bool) Bool {
 	return NewBool(*b, true)
 }
 
+// ValueOrZero returns the inner value if valid, otherwise false.
+func (b Bool) ValueOrZero() bool {
+	return b.Valid && b.Bool
+}
+
 // UnmarshalJSON implements json.Unmarshaler.
 // "false" will be considered a null Bool.
 // It also supports unmarshalling a sql.NullBool.
@@ -119,3 +124,8 @@ func (b Bool) Ptr() *bool {
 func (b Bool) IsZero() bool {
 	return !b.Valid || !b.Bool
 }
+
+// Equal returns true if both booleans are true and valid, or if both booleans are either false or invalid.
+func (b Bool) Equal(other Bool) bool {
+	return b.ValueOrZero() == other.ValueOrZero()
+}

zero/bool_test.go

@@ -171,6 +171,48 @@ func TestBoolScan(t *testing.T) {
 	assertNullBool(t, null, "scanned null")
 }
 
+func TestBoolValueOrZero(t *testing.T) {
+	valid := NewBool(true, true)
+	if valid.ValueOrZero() != true {
+		t.Error("unexpected ValueOrZero", valid.ValueOrZero())
+	}
+
+	invalid := NewBool(true, false)
+	if invalid.ValueOrZero() != false {
+		t.Error("unexpected ValueOrZero", invalid.ValueOrZero())
+	}
+}
+
+func TestBoolEqual(t *testing.T) {
+	b1 := NewBool(true, false)
+	b2 := NewBool(true, false)
+	assertBoolEqualIsTrue(t, b1, b2)
+
+	b1 = NewBool(true, false)
+	b2 = NewBool(false, false)
+	assertBoolEqualIsTrue(t, b1, b2)
+
+	b1 = NewBool(true, true)
+	b2 = NewBool(true, true)
+	assertBoolEqualIsTrue(t, b1, b2)
+
+	b1 = NewBool(true, false)
+	b2 = NewBool(false, true)
+	assertBoolEqualIsTrue(t, b1, b2)
+
+	b1 = NewBool(true, true)
+	b2 = NewBool(true, false)
+	assertBoolEqualIsFalse(t, b1, b2)
+
+	b1 = NewBool(true, false)
+	b2 = NewBool(true, true)
+	assertBoolEqualIsFalse(t, b1, b2)
+
+	b1 = NewBool(true, true)
+	b2 = NewBool(false, true)
+	assertBoolEqualIsFalse(t, b1, b2)
+}
+
 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)
@@ -185,3 +227,17 @@ func assertNullBool(t *testing.T, b Bool, from string) {
 		t.Error(from, "is valid, but should be invalid")
 	}
 }
+
+func assertBoolEqualIsTrue(t *testing.T, a, b Bool) {
+	t.Helper()
+	if !a.Equal(b) {
+		t.Errorf("Equal() of Bool{%t, Valid:%t} and Bool{%t, Valid:%t} should return true", a.Bool, a.Valid, b.Bool, b.Valid)
+	}
+}
+
+func assertBoolEqualIsFalse(t *testing.T, a, b Bool) {
+	t.Helper()
+	if a.Equal(b) {
+		t.Errorf("Equal() of Bool{%t, Valid:%t} and Bool{%t, Valid:%t} should return false", a.Bool, a.Valid, b.Bool, b.Valid)
+	}
+}

zero/float.go

@@ -39,6 +39,14 @@ func FloatFromPtr(f *float64) Float {
 	return NewFloat(*f, true)
 }
 
+// ValueOrZero returns the inner value if valid, otherwise zero.
+func (f Float) ValueOrZero() float64 {
+	if !f.Valid {
+		return 0
+	}
+	return f.Float64
+}
+
 // UnmarshalJSON implements json.Unmarshaler.
 // It supports number and null input.
 // 0 will be considered a null Float.
@@ -130,3 +138,12 @@ func (f Float) Ptr() *float64 {
 func (f Float) IsZero() bool {
 	return !f.Valid || f.Float64 == 0
 }
+
+// Equal returns true if both floats have the same value or are both either null or zero.
+// Warning: calculations using floating point numbers can result in different ways
+// the numbers are stored in memory. Therefore, this function is not suitable to
+// compare the result of a calculation. Use this method only to check if the value
+// has changed in comparison to some previous value.
+func (f Float) Equal(other Float) bool {
+	return f.ValueOrZero() == other.ValueOrZero()
+}

zero/float_test.go

@@ -191,6 +191,48 @@ func TestFloatInfNaN(t *testing.T) {
 	}
 }
 
+func TestFloatValueOrZero(t *testing.T) {
+	valid := NewFloat(1.2345, true)
+	if valid.ValueOrZero() != 1.2345 {
+		t.Error("unexpected ValueOrZero", valid.ValueOrZero())
+	}
+
+	invalid := NewFloat(1.2345, false)
+	if invalid.ValueOrZero() != 0 {
+		t.Error("unexpected ValueOrZero", invalid.ValueOrZero())
+	}
+}
+
+func TestFloatEqual(t *testing.T) {
+	f1 := NewFloat(10, false)
+	f2 := NewFloat(10, false)
+	assertFloatEqualIsTrue(t, f1, f2)
+
+	f1 = NewFloat(10, false)
+	f2 = NewFloat(20, false)
+	assertFloatEqualIsTrue(t, f1, f2)
+
+	f1 = NewFloat(10, true)
+	f2 = NewFloat(10, true)
+	assertFloatEqualIsTrue(t, f1, f2)
+
+	f1 = NewFloat(10, false)
+	f2 = NewFloat(0, true)
+	assertFloatEqualIsTrue(t, f1, f2)
+
+	f1 = NewFloat(10, true)
+	f2 = NewFloat(10, false)
+	assertFloatEqualIsFalse(t, f1, f2)
+
+	f1 = NewFloat(10, false)
+	f2 = NewFloat(10, true)
+	assertFloatEqualIsFalse(t, f1, f2)
+
+	f1 = NewFloat(10, true)
+	f2 = NewFloat(20, true)
+	assertFloatEqualIsFalse(t, f1, f2)
+}
+
 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)
@@ -205,3 +247,17 @@ func assertNullFloat(t *testing.T, f Float, from string) {
 		t.Error(from, "is valid, but should be invalid")
 	}
 }
+
+func assertFloatEqualIsTrue(t *testing.T, a, b Float) {
+	t.Helper()
+	if !a.Equal(b) {
+		t.Errorf("Equal() of Float{%v, Valid:%t} and Float{%v, Valid:%t} should return true", a.Float64, a.Valid, b.Float64, b.Valid)
+	}
+}
+
+func assertFloatEqualIsFalse(t *testing.T, a, b Float) {
+	t.Helper()
+	if a.Equal(b) {
+		t.Errorf("Equal() of Float{%v, Valid:%t} and Float{%v, Valid:%t} should return false", a.Float64, a.Valid, b.Float64, b.Valid)
+	}
+}

zero/int.go

@@ -39,6 +39,14 @@ func IntFromPtr(i *int64) Int {
 	return n
 }
 
+// ValueOrZero returns the inner value if valid, otherwise zero.
+func (i Int) ValueOrZero() int64 {
+	if !i.Valid {
+		return 0
+	}
+	return i.Int64
+}
+
 // UnmarshalJSON implements json.Unmarshaler.
 // It supports number and null input.
 // 0 will be considered a null Int.
@@ -125,3 +133,8 @@ func (i Int) Ptr() *int64 {
 func (i Int) IsZero() bool {
 	return !i.Valid || i.Int64 == 0
 }
+
+// Equal returns true if both ints have the same value or are both either null or zero.
+func (i Int) Equal(other Int) bool {
+	return i.ValueOrZero() == other.ValueOrZero()
+}

zero/int_test.go

@@ -202,6 +202,48 @@ func TestIntSetValid(t *testing.T) {
 	assertInt(t, change, "SetValid()")
 }
 
+func TestIntValueOrZero(t *testing.T) {
+	valid := NewInt(12345, true)
+	if valid.ValueOrZero() != 12345 {
+		t.Error("unexpected ValueOrZero", valid.ValueOrZero())
+	}
+
+	invalid := NewInt(12345, false)
+	if invalid.ValueOrZero() != 0 {
+		t.Error("unexpected ValueOrZero", invalid.ValueOrZero())
+	}
+}
+
+func TestIntEqual(t *testing.T) {
+	int1 := NewInt(10, false)
+	int2 := NewInt(10, false)
+	assertIntEqualIsTrue(t, int1, int2)
+
+	int1 = NewInt(10, false)
+	int2 = NewInt(20, false)
+	assertIntEqualIsTrue(t, int1, int2)
+
+	int1 = NewInt(10, true)
+	int2 = NewInt(10, true)
+	assertIntEqualIsTrue(t, int1, int2)
+
+	int1 = NewInt(0, true)
+	int2 = NewInt(10, false)
+	assertIntEqualIsTrue(t, int1, int2)
+
+	int1 = NewInt(10, true)
+	int2 = NewInt(10, false)
+	assertIntEqualIsFalse(t, int1, int2)
+
+	int1 = NewInt(10, false)
+	int2 = NewInt(10, true)
+	assertIntEqualIsFalse(t, int1, int2)
+
+	int1 = NewInt(10, true)
+	int2 = NewInt(20, true)
+	assertIntEqualIsFalse(t, int1, int2)
+}
+
 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)
@@ -216,3 +258,17 @@ func assertNullInt(t *testing.T, i Int, from string) {
 		t.Error(from, "is valid, but should be invalid")
 	}
 }
+
+func assertIntEqualIsTrue(t *testing.T, a, b Int) {
+	t.Helper()
+	if !a.Equal(b) {
+		t.Errorf("Equal() of Int{%v, Valid:%t} and Int{%v, Valid:%t} should return true", a.Int64, a.Valid, b.Int64, b.Valid)
+	}
+}
+
+func assertIntEqualIsFalse(t *testing.T, a, b Int) {
+	t.Helper()
+	if a.Equal(b) {
+		t.Errorf("Equal() of Int{%v, Valid:%t} and Int{%v, Valid:%t} should return false", a.Int64, a.Valid, b.Int64, b.Valid)
+	}
+}

zero/string.go

@@ -42,6 +42,14 @@ func StringFromPtr(s *string) String {
 	return NewString(*s, *s != "")
 }
 
+// ValueOrZero returns the inner value if valid, otherwise zero.
+func (s String) ValueOrZero() string {
+	if !s.Valid {
+		return ""
+	}
+	return s.String
+}
+
 // UnmarshalJSON implements json.Unmarshaler.
 // It supports string and null input. Blank string input produces a null String.
 // It also supports unmarshalling a sql.NullString.
@@ -101,3 +109,8 @@ func (s String) Ptr() *string {
 func (s String) IsZero() bool {
 	return !s.Valid || s.String == ""
 }
+
+// Equal returns true if both strings have the same value or are both either null or empty.
+func (s String) Equal(other String) bool {
+	return s.ValueOrZero() == other.ValueOrZero()
+}

zero/string_test.go

@@ -161,6 +161,48 @@ func TestStringSetValid(t *testing.T) {
 	assertStr(t, change, "SetValid()")
 }
 
+func TestStringValueOrZero(t *testing.T) {
+	valid := NewString("test", true)
+	if valid.ValueOrZero() != "test" {
+		t.Error("unexpected ValueOrZero", valid.ValueOrZero())
+	}
+
+	invalid := NewString("test", false)
+	if invalid.ValueOrZero() != "" {
+		t.Error("unexpected ValueOrZero", invalid.ValueOrZero())
+	}
+}
+
+func TestStringEqual(t *testing.T) {
+	str1 := NewString("foo", false)
+	str2 := NewString("foo", false)
+	assertStringEqualIsTrue(t, str1, str2)
+
+	str1 = NewString("foo", false)
+	str2 = NewString("bar", false)
+	assertStringEqualIsTrue(t, str1, str2)
+
+	str1 = NewString("foo", true)
+	str2 = NewString("foo", true)
+	assertStringEqualIsTrue(t, str1, str2)
+
+	str1 = NewString("", true)
+	str2 = NewString("foo", false)
+	assertStringEqualIsTrue(t, str1, str2)
+
+	str1 = NewString("foo", true)
+	str2 = NewString("foo", false)
+	assertStringEqualIsFalse(t, str1, str2)
+
+	str1 = NewString("foo", false)
+	str2 = NewString("foo", true)
+	assertStringEqualIsFalse(t, str1, str2)
+
+	str1 = NewString("foo", true)
+	str2 = NewString("bar", true)
+	assertStringEqualIsFalse(t, str1, str2)
+}
+
 func maybePanic(err error) {
 	if err != nil {
 		panic(err)
@@ -187,3 +229,17 @@ func assertJSONEquals(t *testing.T, data []byte, cmp string, from string) {
 		t.Errorf("bad %s data: %s ≠ %s\n", from, data, cmp)
 	}
 }
+
+func assertStringEqualIsTrue(t *testing.T, a, b String) {
+	t.Helper()
+	if !a.Equal(b) {
+		t.Errorf("Equal() of String{\"%v\", Valid:%t} and String{\"%v\", Valid:%t} should return true", a.String, a.Valid, b.String, b.Valid)
+	}
+}
+
+func assertStringEqualIsFalse(t *testing.T, a, b String) {
+	t.Helper()
+	if a.Equal(b) {
+		t.Errorf("Equal() of String{\"%v\", Valid:%t} and String{\"%v\", Valid:%t} should return false", a.String, a.Valid, b.String, b.Valid)
+	}
+}

zero/time.go

@@ -63,6 +63,14 @@ func TimeFromPtr(t *time.Time) Time {
 	return TimeFrom(*t)
 }
 
+// ValueOrZero returns the inner value if valid, otherwise zero.
+func (t Time) ValueOrZero() time.Time {
+	if !t.Valid {
+		return time.Time{}
+	}
+	return t.Time
+}
+
 // MarshalJSON implements json.Marshaler.
 // It will encode the zero value of time.Time
 // if this time is invalid.
@@ -148,3 +156,17 @@ func (t Time) Ptr() *time.Time {
 func (t Time) IsZero() bool {
 	return !t.Valid || t.Time.IsZero()
 }
+
+// Equal returns true if both Time objects encode the same time or are both are either null or zero.
+// Two times can be equal even if they are in different locations.
+// For example, 6:00 +0200 CEST and 4:00 UTC are Equal.
+func (t Time) Equal(other Time) bool {
+	return t.ValueOrZero().Equal(other.ValueOrZero())
+}
+
+// ExactEqual returns true if both Time objects are equal or both are either null or zero.
+// ExactEqual returns false for times that are in different locations or
+// have a different monotonic clock reading.
+func (t Time) ExactEqual(other Time) bool {
+	return t.ValueOrZero() == other.ValueOrZero()
+}