How to avoid slice reference to the same memory block

I met a problem when query from Database and tried to insert into a slice(contains some map[string]interface{})
Even I already used make to create a new memory block, the slice seems always mapping to a same memory block.

type DBResult []map[string]interface{}

func ResultRows(rows *sql.Rows, limit int) (DBResult, error) {
    cols, err := rows.Columns()
    if err != nil {
        return nil, err
    }

    vals := make([]sql.RawBytes, len(cols))
    scanArgs := make([]interface{}, len(vals))
    for i := range vals {
        scanArgs[i] = &vals[i]
    }

    if limit > QUERY_HARD_LIMIT {
        limit = QUERY_HARD_LIMIT
    }

    res := make(DBResult, 0, limit)
    for rows.Next() {
        err = rows.Scan(scanArgs...)
        m := make(map[string]interface{})

        for i := range vals {
            m[cols[i]] = vals[i]
        }
        /* Append m to res */
        res = append(res, m)
        /* The value of m has been changed */
        fmt.Printf("lib: m:\n\n%s\n\n", m)
        /* When printing res, always mapping to the same memory block */
        fmt.Printf("lib: res:\n\n%s\n\n", res)
    }

    return res, err
}

The following is the result, you can find the contents of res are the same

>m = map[comment:first_comment id:0]
>
>res = [map[id:0 comment:first_comment]]
>
>m = map[id:1 comment:first_comment]
>
>res = [map[id:1 comment:first_comment] map[id:1 comment:first_comment]]
>
>m = map[id:2 comment:first_comment]
>
>res = [map[id:2 comment:first_comment] map[id:2 comment:first_comment] map[id:2 comment:first_comment]]

My expect of res = [map[id:0 comment:first_comment] map[id:1 comment:first_comment] map[id:2 comment:first_comment]]

Thanks for watching

according to the document of Rows (https://golang.org/pkg/database/sql/#Rows.Scan):

Scan copies the columns in the current row into the values pointed at by dest.

If an argument has type *[]byte, Scan saves in that argument a copy of the corresponding data. The copy is owned by the caller and can be modified and held indefinitely. The copy can be avoided by using an argument of type *RawBytes instead; see the documentation for RawBytes for restrictions on its use.

If an argument has type *interface{}, Scan copies the value provided by the underlying driver without conversion. If the value is of type []byte, a copy is made and the caller owns the result.

in your case, you use RawBytes as argument of Scan. That might be the problem you got. Try other type as argument of Scan function.