problems unmarshaling JSON to struct; panic: interface conversion: interface {} is string, not []uint8

[yuphing-ong]

I did some testing, and I can unmarshal a string which is a JSON array of tuples, into a custom struct. But trying to write a custom Scanner doesn't work. Test code as follows:

package main

import (
        "encoding/json"
        "fmt"
)

type JsonType struct {
        Col1 string `json:"c1"`
        Col2    string `json:"c2"`
}

type JsonTypes []JsonType

func (m *JsonTypes) Scan(value interface{}) error {
        return json.Unmarshal(value.([]byte), m)
}


func main() {
        value := `[{"c1":"aaa1","c2":"aaa2"}, {"c1":"bbb1","c2":"bbb2"}]`
        var dest JsonTypes
        if err := json.Unmarshal([]byte(value), &dest); err != nil {
                fmt.Println("ERROR:", err)
        }
        for idx, r := range dest {
                fmt.Printf("idx=%v, c1=%v, c2=%v\n", idx, r.Col1, r.Col2)
        }
        var dest2 JsonTypes
        dest2.Scan(value)
}

go run test.go
idx=0, c1=aaa1, c2=aaa2
idx=1, c1=bbb1, c2=bbb2
panic: interface conversion: interface {} is string, not []uint8

goroutine 1 [running]:
main.(*JsonTypes).Scan(...)
        /test.go:16
main.main()
        /test.go:30 +0x217
exit status 2

[yuphing-ong]

oh, I realised if I convert to []byte first the Scan works, i.e.
dest2.Scan([]byte(value))

But this same custom Scan doesn't seem to work when I use it with go-jet to parse a JSON result. I am generating the json string as the result of:
json_stmt := sql.Raw((select json_group_array(json_object('c1', testtable2.col1, 'c2', testtable2.col2))) as "testtable1.JsonCol")

and using that within a stmt, e.g.:

stmt := sql.SELECT(
	Testtable1.AllColumns,
	json_stmt,
	)

Is the SQL result not a []byte already?

[yuphing-ong]

my current workaround is to change the scanner to:

func (m *JsonTypes) Scan(value interface{}) error {
        value2 := value.(string)
        return json.Unmarshal([]byte(value2), m)
}

[houten11]

I think that value type depends on the driver used. To be safe you can handle both cases, for string and []byte:

func (m *JsonTypes) Scan(value interface{}) error {
	var byteArray []byte

	switch v := value.(type) {
	case string:
		byteArray = []byte(v)
	case []byte:
		byteArray = v
	default:
		return errors.New("invalid type")
	}

	return json.Unmarshal(byteArray, m)
}