From 230c242665bc1fae568ad872563a1621160c1c95 Mon Sep 17 00:00:00 2001 From: xormplus Date: Sat, 23 Jun 2018 13:11:52 +0800 Subject: [PATCH] add NullType --- null.go | 5 + null_bool.go | 90 +++++++++++++ null_float32.go | 100 ++++++++++++++ null_float64.go | 92 +++++++++++++ null_int.go | 85 ++++++++++++ null_int16.go | 93 +++++++++++++ null_int32.go | 93 +++++++++++++ null_int64.go | 85 ++++++++++++ null_int8.go | 93 +++++++++++++ null_string.go | 71 ++++++++++ null_time.go | 28 ++++ null_uint.go | 93 +++++++++++++ null_uint16.go | 93 +++++++++++++ null_uint32.go | 93 +++++++++++++ null_uint64.go | 85 ++++++++++++ null_uint8.go | 93 +++++++++++++ value.go | 345 +----------------------------------------------- 17 files changed, 1293 insertions(+), 344 deletions(-) create mode 100644 null.go create mode 100644 null_bool.go create mode 100644 null_float32.go create mode 100644 null_float64.go create mode 100644 null_int.go create mode 100644 null_int16.go create mode 100644 null_int32.go create mode 100644 null_int64.go create mode 100644 null_int8.go create mode 100644 null_string.go create mode 100644 null_time.go create mode 100644 null_uint.go create mode 100644 null_uint16.go create mode 100644 null_uint32.go create mode 100644 null_uint64.go create mode 100644 null_uint8.go diff --git a/null.go b/null.go new file mode 100644 index 0000000..99de1e0 --- /dev/null +++ b/null.go @@ -0,0 +1,5 @@ +package xorm + +type NullType interface { + IsNil() bool +} diff --git a/null_bool.go b/null_bool.go new file mode 100644 index 0000000..4c74c48 --- /dev/null +++ b/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 +} diff --git a/null_float32.go b/null_float32.go new file mode 100644 index 0000000..060c595 --- /dev/null +++ b/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 +} diff --git a/null_float64.go b/null_float64.go new file mode 100644 index 0000000..3fd43bd --- /dev/null +++ b/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 +} diff --git a/null_int.go b/null_int.go new file mode 100644 index 0000000..a3f8d5c --- /dev/null +++ b/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 +} diff --git a/null_int16.go b/null_int16.go new file mode 100644 index 0000000..0fe3584 --- /dev/null +++ b/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 +} diff --git a/null_int32.go b/null_int32.go new file mode 100644 index 0000000..a0b393b --- /dev/null +++ b/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 +} diff --git a/null_int64.go b/null_int64.go new file mode 100644 index 0000000..d17f7ce --- /dev/null +++ b/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 +} diff --git a/null_int8.go b/null_int8.go new file mode 100644 index 0000000..230fce0 --- /dev/null +++ b/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 +} diff --git a/null_string.go b/null_string.go new file mode 100644 index 0000000..d80501d --- /dev/null +++ b/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 +} diff --git a/null_time.go b/null_time.go new file mode 100644 index 0000000..168cbe2 --- /dev/null +++ b/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 +} diff --git a/null_uint.go b/null_uint.go new file mode 100644 index 0000000..bf2efda --- /dev/null +++ b/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 +} diff --git a/null_uint16.go b/null_uint16.go new file mode 100644 index 0000000..407afe4 --- /dev/null +++ b/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 +} diff --git a/null_uint32.go b/null_uint32.go new file mode 100644 index 0000000..3161af8 --- /dev/null +++ b/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 +} diff --git a/null_uint64.go b/null_uint64.go new file mode 100644 index 0000000..31c3999 --- /dev/null +++ b/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 +} diff --git a/null_uint8.go b/null_uint8.go new file mode 100644 index 0000000..9109403 --- /dev/null +++ b/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 +} diff --git a/value.go b/value.go index 1514100..47deaa8 100644 --- a/value.go +++ b/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) }