add NullType

null.go

@@ -0,0 +1,5 @@
+package xorm
+
+type NullType interface {
+	IsNil() bool
+}

null_bool.go

@@ -0,0 +1,90 @@
+package xorm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+type NullBool struct {
+	Bool  bool
+	Valid bool
+}
+
+func (nb NullBool) Ptr() *bool {
+	if !nb.Valid {
+		return nil
+	}
+	return &nb.Bool
+}
+
+func (nb NullBool) ValueOrZero() bool {
+	if !nb.Valid {
+		return false
+	}
+	return nb.Bool
+}
+
+func (nb NullBool) IsNil() bool {
+	return !nb.Valid
+}
+
+func (nb *NullBool) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case bool:
+		nb.Bool = x
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nb)
+	case nil:
+		nb.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullBool", reflect.TypeOf(v).Name())
+	}
+	nb.Valid = err == nil
+	return err
+}
+
+func (nb *NullBool) UnmarshalText(text []byte) error {
+	str := string(text)
+	switch str {
+	case "", "null":
+		nb.Valid = false
+		return nil
+	case "true":
+		nb.Bool = true
+	case "false":
+		nb.Bool = false
+	default:
+		nb.Valid = false
+		return errors.New("invalid input:" + str)
+	}
+	nb.Valid = true
+	return nil
+}
+
+func (nb NullBool) MarshalJSON() ([]byte, error) {
+	if !nb.Valid {
+		return []byte("null"), nil
+	}
+	if !nb.Bool {
+		return []byte("false"), nil
+	}
+	return []byte("true"), nil
+}
+
+func (nb NullBool) MarshalText() ([]byte, error) {
+	if !nb.Valid {
+		return []byte{}, nil
+	}
+	if !nb.Bool {
+		return []byte("false"), nil
+	}
+	return []byte("true"), nil
+}

null_float32.go

@@ -0,0 +1,100 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+)
+
+type NullFloat32 struct {
+	Float32 float32
+	Valid   bool
+}
+
+func (nf NullFloat32) Ptr() *float32 {
+	if !nf.Valid {
+		return nil
+	}
+	return &nf.Float32
+}
+
+func (nf NullFloat32) ValueOrZero() float32 {
+	if !nf.Valid {
+		return 0
+	}
+	return nf.Float32
+}
+
+func (nf NullFloat32) IsNil() bool {
+	return !nf.Valid
+}
+
+func (nf *NullFloat32) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		nf.Float32 = float32(x)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			nf.Valid = false
+			return nil
+		}
+		var f float64
+		f, err = strconv.ParseFloat(str, 32)
+		if err == nil {
+			nf.Float32 = float32(f)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nf)
+	case nil:
+		nf.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullFloat32", reflect.TypeOf(v).Name())
+	}
+	nf.Valid = err == nil
+	return err
+}
+
+func (nf *NullFloat32) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		nf.Valid = false
+		return nil
+	}
+	var err error
+	var f float64
+	f, err = strconv.ParseFloat(string(text), 32)
+	if err == nil {
+		nf.Float32 = float32(f)
+	}
+	nf.Valid = err == nil
+	return err
+}
+
+func (nf NullFloat32) MarshalJSON() ([]byte, error) {
+	if !nf.Valid {
+		return []byte("null"), nil
+	}
+	if math.IsInf(float64(nf.Float32), 0) || math.IsNaN(float64(nf.Float32)) {
+		return nil, &json.UnsupportedValueError{
+			Value: reflect.ValueOf(nf.Float32),
+			Str:   strconv.FormatFloat(float64(nf.Float32), 'g', -1, 32),
+		}
+	}
+	return []byte(strconv.FormatFloat(float64(nf.Float32), 'f', -1, 32)), nil
+}
+
+func (nf NullFloat32) MarshalText() ([]byte, error) {
+	if !nf.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatFloat(float64(nf.Float32), 'f', -1, 32)), nil
+}

null_float64.go

@@ -0,0 +1,92 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+)
+
+type NullFloat64 struct {
+	Float64 float64
+	Valid   bool
+}
+
+func (nf NullFloat64) Ptr() *float64 {
+	if !nf.Valid {
+		return nil
+	}
+	return &nf.Float64
+}
+
+func (nf NullFloat64) ValueOrZero() float64 {
+	if !nf.Valid {
+		return 0
+	}
+	return nf.Float64
+}
+
+func (nf NullFloat64) IsNil() bool {
+	return !nf.Valid
+}
+
+func (nf *NullFloat64) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		nf.Float64 = float64(x)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			nf.Valid = false
+			return nil
+		}
+		nf.Float64, err = strconv.ParseFloat(str, 64)
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nf)
+	case nil:
+		nf.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullFloat64", reflect.TypeOf(v).Name())
+	}
+	nf.Valid = err == nil
+	return err
+}
+
+func (nf *NullFloat64) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		nf.Valid = false
+		return nil
+	}
+	var err error
+	nf.Float64, err = strconv.ParseFloat(string(text), 64)
+	nf.Valid = err == nil
+	return err
+}
+
+func (nf NullFloat64) MarshalJSON() ([]byte, error) {
+	if !nf.Valid {
+		return []byte("null"), nil
+	}
+	if math.IsInf(nf.Float64, 0) || math.IsNaN(nf.Float64) {
+		return nil, &json.UnsupportedValueError{
+			Value: reflect.ValueOf(nf.Float64),
+			Str:   strconv.FormatFloat(nf.Float64, 'g', -1, 64),
+		}
+	}
+	return []byte(strconv.FormatFloat(nf.Float64, 'f', -1, 64)), nil
+}
+
+func (nf NullFloat64) MarshalText() ([]byte, error) {
+	if !nf.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatFloat(nf.Float64, 'f', -1, 64)), nil
+}

null_int.go

@@ -0,0 +1,85 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullInt struct {
+	Int   int
+	Valid bool
+}
+
+func (ni NullInt) Ptr() *int {
+	if !ni.Valid {
+		return nil
+	}
+	return &ni.Int
+}
+
+func (ni NullInt) ValueOrZero() int {
+	if !ni.Valid {
+		return 0
+	}
+	return ni.Int
+}
+
+func (ni NullInt) IsNil() bool {
+	return !ni.Valid
+}
+
+func (ni *NullInt) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &ni.Int)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			ni.Valid = false
+			return nil
+		}
+		ni.Int, err = strconv.Atoi(string(str))
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &ni)
+	case nil:
+		ni.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullInt", reflect.TypeOf(v).Name())
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni *NullInt) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		ni.Valid = false
+		return nil
+	}
+	var err error
+	ni.Int, err = strconv.Atoi(string(text))
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni NullInt) MarshalJSON() ([]byte, error) {
+	if !ni.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.Itoa(ni.Int)), nil
+}
+
+func (ni NullInt) MarshalText() ([]byte, error) {
+	if !ni.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.Itoa(ni.Int)), nil
+}

null_int16.go

@@ -0,0 +1,93 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullInt16 struct {
+	Int16 int16
+	Valid bool
+}
+
+func (ni NullInt16) Ptr() *int16 {
+	if !ni.Valid {
+		return nil
+	}
+	return &ni.Int16
+}
+
+func (ni NullInt16) ValueOrZero() int16 {
+	if !ni.Valid {
+		return 0
+	}
+	return ni.Int16
+}
+
+func (ni NullInt16) IsNil() bool {
+	return !ni.Valid
+}
+
+func (ni *NullInt16) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &ni.Int16)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			ni.Valid = false
+			return nil
+		}
+		var i int64
+		i, err = strconv.ParseInt(str, 10, 16)
+		if err == nil {
+			ni.Int16 = int16(i)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &ni)
+	case nil:
+		ni.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullInt16", reflect.TypeOf(v).Name())
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni *NullInt16) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		ni.Valid = false
+		return nil
+	}
+	var err error
+	var i int64
+	i, err = strconv.ParseInt(string(text), 10, 16)
+	if err == nil {
+		ni.Int16 = int16(i)
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni NullInt16) MarshalJSON() ([]byte, error) {
+	if !ni.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatInt(int64(ni.Int16), 10)), nil
+}
+
+func (ni NullInt16) MarshalText() ([]byte, error) {
+	if !ni.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatInt(int64(ni.Int16), 10)), nil
+}

null_int32.go

@@ -0,0 +1,93 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullInt32 struct {
+	Int32 int32
+	Valid bool
+}
+
+func (ni NullInt32) Ptr() *int32 {
+	if !ni.Valid {
+		return nil
+	}
+	return &ni.Int32
+}
+
+func (ni NullInt32) ValueOrZero() int32 {
+	if !ni.Valid {
+		return 0
+	}
+	return ni.Int32
+}
+
+func (ni NullInt32) IsNil() bool {
+	return !ni.Valid
+}
+
+func (ni *NullInt32) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &ni.Int32)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			ni.Valid = false
+			return nil
+		}
+		var i int64
+		i, err = strconv.ParseInt(str, 10, 32)
+		if err == nil {
+			ni.Int32 = int32(i)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &ni)
+	case nil:
+		ni.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullInt32", reflect.TypeOf(v).Name())
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni *NullInt32) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		ni.Valid = false
+		return nil
+	}
+	var err error
+	var i int64
+	i, err = strconv.ParseInt(string(text), 10, 32)
+	if err == nil {
+		ni.Int32 = int32(i)
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni NullInt32) MarshalJSON() ([]byte, error) {
+	if !ni.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatInt(int64(ni.Int32), 10)), nil
+}
+
+func (ni NullInt32) MarshalText() ([]byte, error) {
+	if !ni.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatInt(int64(ni.Int32), 10)), nil
+}

null_int64.go

@@ -0,0 +1,85 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullInt64 struct {
+	Int64 int64
+	Valid bool
+}
+
+func (ni NullInt64) Ptr() *int64 {
+	if !ni.Valid {
+		return nil
+	}
+	return &ni.Int64
+}
+
+func (ni NullInt64) ValueOrZero() int64 {
+	if !ni.Valid {
+		return 0
+	}
+	return ni.Int64
+}
+
+func (ni NullInt64) IsNil() bool {
+	return !ni.Valid
+}
+
+func (ni *NullInt64) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &ni.Int64)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			ni.Valid = false
+			return nil
+		}
+		ni.Int64, err = strconv.ParseInt(str, 10, 64)
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &ni)
+	case nil:
+		ni.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullInt64", reflect.TypeOf(v).Name())
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni *NullInt64) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		ni.Valid = false
+		return nil
+	}
+	var err error
+	ni.Int64, err = strconv.ParseInt(string(text), 10, 64)
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni NullInt64) MarshalJSON() ([]byte, error) {
+	if !ni.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatInt(ni.Int64, 10)), nil
+}
+
+func (ni NullInt64) MarshalText() ([]byte, error) {
+	if !ni.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatInt(ni.Int64, 10)), nil
+}

null_int8.go

@@ -0,0 +1,93 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullInt8 struct {
+	Int8  int8
+	Valid bool
+}
+
+func (ni NullInt8) Ptr() *int8 {
+	if !ni.Valid {
+		return nil
+	}
+	return &ni.Int8
+}
+
+func (ni NullInt8) ValueOrZero() int8 {
+	if !ni.Valid {
+		return 0
+	}
+	return ni.Int8
+}
+
+func (ni NullInt8) IsNil() bool {
+	return !ni.Valid
+}
+
+func (ni *NullInt8) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &ni.Int8)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			ni.Valid = false
+			return nil
+		}
+		var i int64
+		i, err = strconv.ParseInt(str, 10, 8)
+		if err == nil {
+			ni.Int8 = int8(i)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &ni)
+	case nil:
+		ni.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullInt8", reflect.TypeOf(v).Name())
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni *NullInt8) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		ni.Valid = false
+		return nil
+	}
+	var err error
+	var i int64
+	i, err = strconv.ParseInt(string(text), 10, 8)
+	if err == nil {
+		ni.Int8 = int8(i)
+	}
+	ni.Valid = err == nil
+	return err
+}
+
+func (ni NullInt8) MarshalJSON() ([]byte, error) {
+	if !ni.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatInt(int64(ni.Int8), 10)), nil
+}
+
+func (ni NullInt8) MarshalText() ([]byte, error) {
+	if !ni.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatInt(int64(ni.Int8), 10)), nil
+}

null_string.go

@@ -0,0 +1,71 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+)
+
+type NullString struct {
+	String string
+	Valid  bool
+}
+
+func (ns NullString) Ptr() *string {
+	if !ns.Valid {
+		return nil
+	}
+	return &ns.String
+}
+
+func (ns NullString) ValueOrZero() string {
+	if !ns.Valid {
+		return ""
+	}
+	return ns.String
+}
+
+func (ns NullString) IsNil() bool {
+	return !ns.Valid
+}
+
+func (ns *NullString) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case string:
+		ns.String = x
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &ns)
+	case nil:
+		ns.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullString", reflect.TypeOf(v).Name())
+	}
+	ns.Valid = err == nil
+	return err
+}
+
+func (ns NullString) MarshalJSON() ([]byte, error) {
+	if !ns.Valid {
+		return []byte("null"), nil
+	}
+	return json.Marshal(ns.String)
+}
+
+func (ns NullString) MarshalText() ([]byte, error) {
+	if !ns.Valid {
+		return []byte{}, nil
+	}
+	return []byte(ns.String), nil
+}
+
+func (ns *NullString) UnmarshalText(text []byte) error {
+	ns.String = string(text)
+	ns.Valid = ns.String != ""
+	return nil
+}

null_time.go

@@ -0,0 +1,28 @@
+package xorm
+
+import (
+	"time"
+)
+
+type NullTime struct {
+	Time  time.Time
+	Valid bool
+}
+
+func (nt NullTime) Ptr() *time.Time {
+	if !nt.Valid {
+		return nil
+	}
+	return &nt.Time
+}
+
+func (nt NullTime) ValueOrZero() time.Time {
+	if !nt.Valid {
+		return time.Time{}
+	}
+	return nt.Time
+}
+
+func (nt NullTime) IsNil() bool {
+	return !nt.Valid
+}

null_uint.go

@@ -0,0 +1,93 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullUint struct {
+	Uint  uint
+	Valid bool
+}
+
+func (nu NullUint) Ptr() *uint {
+	if !nu.Valid {
+		return nil
+	}
+	return &nu.Uint
+}
+
+func (nu NullUint) ValueOrZero() uint {
+	if !nu.Valid {
+		return 0
+	}
+	return nu.Uint
+}
+
+func (nu NullUint) IsNil() bool {
+	return !nu.Valid
+}
+
+func (nu *NullUint) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &nu.Uint)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			nu.Valid = false
+			return nil
+		}
+		var u uint64
+		u, err = strconv.ParseUint(str, 10, 0)
+		if err == nil {
+			nu.Uint = uint(u)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nu)
+	case nil:
+		nu.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullUint", reflect.TypeOf(v).Name())
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu *NullUint) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		nu.Valid = false
+		return nil
+	}
+	var err error
+	var u uint64
+	u, err = strconv.ParseUint(string(text), 10, 0)
+	if err == nil {
+		nu.Uint = uint(u)
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (ni NullUint) MarshalJSON() ([]byte, error) {
+	if !ni.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatUint(uint64(ni.Uint), 10)), nil
+}
+
+func (ni NullUint) MarshalText() ([]byte, error) {
+	if !ni.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatUint(uint64(ni.Uint), 10)), nil
+}

null_uint16.go

@@ -0,0 +1,93 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullUint16 struct {
+	Uint16 uint16
+	Valid  bool
+}
+
+func (nu NullUint16) Ptr() *uint16 {
+	if !nu.Valid {
+		return nil
+	}
+	return &nu.Uint16
+}
+
+func (nu NullUint16) ValueOrZero() uint16 {
+	if !nu.Valid {
+		return 0
+	}
+	return nu.Uint16
+}
+
+func (nu NullUint16) IsNil() bool {
+	return !nu.Valid
+}
+
+func (nu *NullUint16) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &nu.Uint16)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			nu.Valid = false
+			return nil
+		}
+		var u uint64
+		u, err = strconv.ParseUint(str, 10, 16)
+		if err == nil {
+			nu.Uint16 = uint16(u)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nu)
+	case nil:
+		nu.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullUint16", reflect.TypeOf(v).Name())
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu *NullUint16) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		nu.Valid = false
+		return nil
+	}
+	var err error
+	var u uint64
+	u, err = strconv.ParseUint(string(text), 10, 16)
+	if err == nil {
+		nu.Uint16 = uint16(u)
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu NullUint16) MarshalJSON() ([]byte, error) {
+	if !nu.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatUint(uint64(nu.Uint16), 10)), nil
+}
+
+func (nu NullUint16) MarshalText() ([]byte, error) {
+	if !nu.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatUint(uint64(nu.Uint16), 10)), nil
+}

null_uint32.go

@@ -0,0 +1,93 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullUint32 struct {
+	Uint32 uint32
+	Valid  bool
+}
+
+func (nu NullUint32) Ptr() *uint32 {
+	if !nu.Valid {
+		return nil
+	}
+	return &nu.Uint32
+}
+
+func (nu NullUint32) ValueOrZero() uint32 {
+	if !nu.Valid {
+		return 0
+	}
+	return nu.Uint32
+}
+
+func (nu NullUint32) IsNil() bool {
+	return !nu.Valid
+}
+
+func (nu *NullUint32) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &nu.Uint32)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			nu.Valid = false
+			return nil
+		}
+		var u uint64
+		u, err = strconv.ParseUint(str, 10, 32)
+		if err == nil {
+			nu.Uint32 = uint32(u)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nu)
+	case nil:
+		nu.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullUint32", reflect.TypeOf(v).Name())
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu *NullUint32) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		nu.Valid = false
+		return nil
+	}
+	var err error
+	var u uint64
+	u, err = strconv.ParseUint(string(text), 10, 32)
+	if err == nil {
+		nu.Uint32 = uint32(u)
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu NullUint32) MarshalJSON() ([]byte, error) {
+	if !nu.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatUint(uint64(nu.Uint32), 10)), nil
+}
+
+func (nu NullUint32) MarshalText() ([]byte, error) {
+	if !nu.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatUint(uint64(nu.Uint32), 10)), nil
+}

null_uint64.go

@@ -0,0 +1,85 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullUint64 struct {
+	Uint64 uint64
+	Valid  bool
+}
+
+func (nu NullUint64) Ptr() *uint64 {
+	if !nu.Valid {
+		return nil
+	}
+	return &nu.Uint64
+}
+
+func (nu NullUint64) ValueOrZero() uint64 {
+	if !nu.Valid {
+		return 0
+	}
+	return nu.Uint64
+}
+
+func (nu NullUint64) IsNil() bool {
+	return !nu.Valid
+}
+
+func (nu *NullUint64) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &nu.Uint64)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			nu.Valid = false
+			return nil
+		}
+		nu.Uint64, err = strconv.ParseUint(str, 10, 64)
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nu)
+	case nil:
+		nu.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullUint64", reflect.TypeOf(v).Name())
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu *NullUint64) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		nu.Valid = false
+		return nil
+	}
+	var err error
+	nu.Uint64, err = strconv.ParseUint(string(text), 10, 64)
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu NullUint64) MarshalJSON() ([]byte, error) {
+	if !nu.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatUint(nu.Uint64, 10)), nil
+}
+
+func (nu NullUint64) MarshalText() ([]byte, error) {
+	if !nu.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatUint(nu.Uint64, 10)), nil
+}

null_uint8.go

@@ -0,0 +1,93 @@
+package xorm
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+type NullUint8 struct {
+	Uint8 uint8
+	Valid bool
+}
+
+func (nu NullUint8) Ptr() *uint8 {
+	if !nu.Valid {
+		return nil
+	}
+	return &nu.Uint8
+}
+
+func (nu NullUint8) ValueOrZero() uint8 {
+	if !nu.Valid {
+		return 0
+	}
+	return nu.Uint8
+}
+
+func (nu NullUint8) IsNil() bool {
+	return !nu.Valid
+}
+
+func (nu *NullUint8) UnmarshalJSON(data []byte) error {
+	var err error
+	var v interface{}
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	switch x := v.(type) {
+	case float64:
+		err = json.Unmarshal(data, &nu.Uint8)
+	case string:
+		str := string(x)
+		if len(str) == 0 {
+			nu.Valid = false
+			return nil
+		}
+		var u uint64
+		u, err = strconv.ParseUint(str, 10, 8)
+		if err == nil {
+			nu.Uint8 = uint8(u)
+		}
+	case map[string]interface{}:
+		err = json.Unmarshal(data, &nu)
+	case nil:
+		nu.Valid = false
+		return nil
+	default:
+		err = fmt.Errorf("json: cannot unmarshal %v into Go value of type xorm.NullUint8", reflect.TypeOf(v).Name())
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu *NullUint8) UnmarshalText(text []byte) error {
+	str := string(text)
+	if str == "" || str == "null" {
+		nu.Valid = false
+		return nil
+	}
+	var err error
+	var u uint64
+	u, err = strconv.ParseUint(string(text), 10, 8)
+	if err == nil {
+		nu.Uint8 = uint8(u)
+	}
+	nu.Valid = err == nil
+	return err
+}
+
+func (nu NullUint8) MarshalJSON() ([]byte, error) {
+	if !nu.Valid {
+		return []byte("null"), nil
+	}
+	return []byte(strconv.FormatUint(uint64(nu.Uint8), 10)), nil
+}
+
+func (nu NullUint8) MarshalText() ([]byte, error) {
+	if !nu.Valid {
+		return []byte{}, nil
+	}
+	return []byte(strconv.FormatUint(uint64(nu.Uint8), 10)), nil
+}

value.go

@@ -1,352 +1,9 @@
 package xorm
 
-import (
-	"time"
-)
+import "time"
 
 type Value []byte
 
-type NullString struct {
-	String string
-	Valid  bool
-}
-
-func (ns NullString) Ptr() *string {
-	if !ns.Valid {
-		return nil
-	}
-	return &ns.String
-}
-
-func (ns NullString) ValueOrZero() string {
-	if !ns.Valid {
-		return ""
-	}
-	return ns.String
-}
-
-func (ns NullString) IsZero() bool {
-	return !ns.Valid
-}
-
-type NullBool struct {
-	Bool  bool
-	Valid bool
-}
-
-func (nb NullBool) Ptr() *bool {
-	if !nb.Valid {
-		return nil
-	}
-	return &nb.Bool
-}
-
-func (nb NullBool) ValueOrZero() bool {
-	if !nb.Valid {
-		return false
-	}
-	return nb.Bool
-}
-
-func (nb NullBool) IsZero() bool {
-	return !nb.Valid
-}
-
-type NullInt struct {
-	Int   int
-	Valid bool
-}
-
-func (ni NullInt) Ptr() *int {
-	if !ni.Valid {
-		return nil
-	}
-	return &ni.Int
-}
-
-func (ni NullInt) ValueOrZero() int {
-	if !ni.Valid {
-		return 0
-	}
-	return ni.Int
-}
-
-func (ni NullInt) IsZero() bool {
-	return !ni.Valid
-}
-
-type NullInt8 struct {
-	Int8  int8
-	Valid bool
-}
-
-func (ni NullInt8) Ptr() *int8 {
-	if !ni.Valid {
-		return nil
-	}
-	return &ni.Int8
-}
-
-func (ni NullInt8) ValueOrZero() int8 {
-	if !ni.Valid {
-		return 0
-	}
-	return ni.Int8
-}
-
-func (ni NullInt8) IsZero() bool {
-	return !ni.Valid
-}
-
-type NullInt16 struct {
-	Int16 int16
-	Valid bool
-}
-
-func (ni NullInt16) Ptr() *int16 {
-	if !ni.Valid {
-		return nil
-	}
-	return &ni.Int16
-}
-
-func (ni NullInt16) ValueOrZero() int16 {
-	if !ni.Valid {
-		return 0
-	}
-	return ni.Int16
-}
-
-func (ni NullInt16) IsZero() bool {
-	return !ni.Valid
-}
-
-type NullInt32 struct {
-	Int32 int32
-	Valid bool
-}
-
-func (ni NullInt32) Ptr() *int32 {
-	if !ni.Valid {
-		return nil
-	}
-	return &ni.Int32
-}
-
-func (ni NullInt32) ValueOrZero() int32 {
-	if !ni.Valid {
-		return 0
-	}
-	return ni.Int32
-}
-
-func (ni NullInt32) IsZero() bool {
-	return !ni.Valid
-}
-
-type NullInt64 struct {
-	Int64 int64
-	Valid bool
-}
-
-func (ni NullInt64) Ptr() *int64 {
-	if !ni.Valid {
-		return nil
-	}
-	return &ni.Int64
-}
-
-func (ni NullInt64) ValueOrZero() int64 {
-	if !ni.Valid {
-		return 0
-	}
-	return ni.Int64
-}
-
-func (ni NullInt64) IsZero() bool {
-	return !ni.Valid
-}
-
-type NullUint struct {
-	Uint  uint
-	Valid bool
-}
-
-func (nu NullUint) Ptr() *uint {
-	if !nu.Valid {
-		return nil
-	}
-	return &nu.Uint
-}
-
-func (nu NullUint) ValueOrZero() uint {
-	if !nu.Valid {
-		return 0
-	}
-	return nu.Uint
-}
-
-func (nu NullUint) IsZero() bool {
-	return !nu.Valid
-}
-
-type NullUint8 struct {
-	Uint8 uint8
-	Valid bool
-}
-
-func (nu NullUint8) Ptr() *uint8 {
-	if !nu.Valid {
-		return nil
-	}
-	return &nu.Uint8
-}
-
-func (nu NullUint8) ValueOrZero() uint8 {
-	if !nu.Valid {
-		return 0
-	}
-	return nu.Uint8
-}
-
-func (nu NullUint8) IsZero() bool {
-	return !nu.Valid
-}
-
-type NullUint16 struct {
-	Uint16 uint16
-	Valid  bool
-}
-
-func (nu NullUint16) Ptr() *uint16 {
-	if !nu.Valid {
-		return nil
-	}
-	return &nu.Uint16
-}
-
-func (nu NullUint16) ValueOrZero() uint16 {
-	if !nu.Valid {
-		return 0
-	}
-	return nu.Uint16
-}
-
-func (nu NullUint16) IsZero() bool {
-	return !nu.Valid
-}
-
-type NullUint32 struct {
-	Uint32 uint32
-	Valid  bool
-}
-
-func (nu NullUint32) Ptr() *uint32 {
-	if !nu.Valid {
-		return nil
-	}
-	return &nu.Uint32
-}
-
-func (nu NullUint32) ValueOrZero() uint32 {
-	if !nu.Valid {
-		return 0
-	}
-	return nu.Uint32
-}
-
-func (nu NullUint32) IsZero() bool {
-	return !nu.Valid
-}
-
-type NullUint64 struct {
-	Uint64 uint64
-	Valid  bool
-}
-
-func (nu NullUint64) Ptr() *uint64 {
-	if !nu.Valid {
-		return nil
-	}
-	return &nu.Uint64
-}
-
-func (nu NullUint64) ValueOrZero() uint64 {
-	if !nu.Valid {
-		return 0
-	}
-	return nu.Uint64
-}
-
-func (nu NullUint64) IsZero() bool {
-	return !nu.Valid
-}
-
-type NullFloat32 struct {
-	Float32 float32
-	Valid   bool
-}
-
-func (nf NullFloat32) Ptr() *float32 {
-	if !nf.Valid {
-		return nil
-	}
-	return &nf.Float32
-}
-
-func (nf NullFloat32) ValueOrZero() float32 {
-	if !nf.Valid {
-		return 0
-	}
-	return nf.Float32
-}
-
-func (nf NullFloat32) IsZero() bool {
-	return !nf.Valid
-}
-
-type NullFloat64 struct {
-	Float64 float64
-	Valid   bool
-}
-
-func (nf NullFloat64) Ptr() *float64 {
-	if !nf.Valid {
-		return nil
-	}
-	return &nf.Float64
-}
-
-func (nf NullFloat64) ValueOrZero() float64 {
-	if !nf.Valid {
-		return 0
-	}
-	return nf.Float64
-}
-
-func (nf NullFloat64) IsZero() bool {
-	return !nf.Valid
-}
-
-type NullTime struct {
-	Time  time.Time
-	Valid bool
-}
-
-func (nt NullTime) Ptr() *time.Time {
-	if !nt.Valid {
-		return nil
-	}
-	return &nt.Time
-}
-
-func (nt NullTime) ValueOrZero() time.Time {
-	if !nt.Valid {
-		return time.Time{}
-	}
-	return nt.Time
-}
-
 func (v Value) Bytes() []byte {
 	return []byte(v)
 }