sql.NullInt64 to JSON - mysql

Question

I have a database schema where Age is optional. But when in Go, via my RestFUL interface, I output the data as JSON, I get a very ugly response like {"ID":1,"Name":"John","age":{"Int64":0,"Valid":false}}
for age. I expected a null value to be omitted. What am I missing?
// CREATE TABLE users (
// id INT AUTO_INCREMENT PRIMARY KEY,
// name VARCHAR(50) NOT NULL,
// age INT
// );
// Age is optional
type user struct {
ID int `db:"id"`
Name string `db:"name"`
Age sql.NullInt64 `db:"age" json:"age,omitempty"`
}
func main() {
u := user{ID: 1, Name: "John"}
j, _ := json.Marshal(u)
fmt.Printf("%s", j)
}
// Expected: {"ID":1,"Name":"John"} since age is NULL/empty
https://play.golang.org/p/PS1-4Gw9h5u

Answer 1

sql.NullInt64 exists because SQL's null cannot be represented as Go's int. It's a third state that cannot be represented by any int value.
One solution to that would be to represent such SQL values as *int, but that would require an allocation for cases where the value is not null in the database, and allocations are bad for performance.
Designers of SQL package came up with NullInt64 solution that encodes the third state of null as an additional Valid boolean. It's not a good solution but it's the best we can get.
I'm not sure if it's possible to write JSON marshaller for NullInt64 that would work as you expect.
There's still the "third state" problem when marshalling to JSON. With ,omitempty a 0 int would also be omitted so how can you tell 0 from "not exists"/null?
Either way they didn't write custom marshaller for NullInt64 so it just encodes as the struct that it is.
You can create an alias type for NullInt64, write a JSON marshaller to encode the way you want to JSON (you need an alias because you can't add methods to types from other packages). You would also need to cast between your NullInt64 and sql.NullInt64.

Answer 2

You can use custom type for null int64.
This type works as you expected.
Usage example:
package main
import (
"encoding/json"
"database/sql/driver"
"fmt"
"strconv"
)
type user struct {
ID int `db:"id"`
Name string `db:"name"`
// pointer needed to omitempty work, otherwise output will be "age": null
Age *NullInt64 `db:"age" json:"age,omitempty"`
}
func main() {
u := user{ID: 1, Name: "John"}
j, _ := json.Marshal(u)
fmt.Printf("%s\n", j)
}
// Output:
// {"ID":1,"Name":"John"}
type NullInt64 struct {
Val int64
IsValid bool
}
func NewNullInt64(val interface{}) NullInt64 {
ni := NullInt64{}
ni.Set(val)
return ni
}
func (ni *NullInt64) Scan(value interface{}) error {
ni.Val, ni.IsValid = value.(int64)
return nil
}
func (ni NullInt64) Value() (driver.Value, error) {
if !ni.IsValid {
return nil, nil
}
return ni.Val, nil
}
func (ni *NullInt64) Set(val interface{}) {
ni.Val, ni.IsValid = val.(int64)
}
func (ni NullInt64) MarshalJSON() ([]byte, error) {
if !ni.IsValid {
return []byte(`null`), nil
}
return []byte(strconv.FormatInt(ni.Val, 10)), nil
}
func (ni *NullInt64) UnmarshalJSON(data []byte) error {
if data == nil || string(data) == `null` {
ni.IsValid = false
return nil
}
val, err := strconv.ParseInt(string(data), 10, 64)
if err != nil {
ni.IsValid = false
return err
}
ni.Val = val
ni.IsValid = true
return nil
}
func (ni NullInt64) String() string {
if !ni.IsValid {
return `<nil>`
}
return strconv.FormatInt(ni.Val, 10)
}