Go SQL scanned rows getting overwritten

I'm trying to read all the rows from a table on a SQL server and store them in string slices to use for later. The issue I'm running into is that the previously scanned rows are getting overwritten every time I scan a new row, even though I've converted all the mutable byte slices to immutable strings and saved the result slices to another slice. Here is the code I'm using:

rawResult := make([]interface{}, len(cols)) // holds anything that could be in a row
result := make([]string, len(cols)) // will hold all row elements as strings
var results [][]string // will hold all the result string slices
dest := make([]interface{}, len(cols)) // temporary, to pass into scan
for i, _ := range rawResult {
    dest[i] = &rawResult[i] // fill dest with pointers to rawResult to pass into scan
}
for rows.Next() { // for each row
    err = rows.Scan(dest...) // scan the row
    if err != nil {
        log.Fatal("Failed to scan row", err)
    }
    for i, raw := range rawResult { // for each scanned byte slice in a row
        switch rawtype := raw.(type){ // determine type, convert to string
        case int64:
            result[i] = strconv.FormatInt(raw.(int64), 10)
        case float64:
            result[i] = strconv.FormatFloat(raw.(float64), 'f', -1, 64)
        case bool:
            result[i] = strconv.FormatBool(raw.(bool))
        case []byte:
            result[i] = string(raw.([]byte))
        case string:
            result[i] = raw.(string)
        case time.Time:
            result[i] = raw.(time.Time).String()
        case nil:
            result[i] = ""
        default: // shouldn't actually be reachable since all types have been covered
            log.Fatal("Unexpected type %T", rawtype)
        }
    }
    results = append(results, result) // append the result to our slice of results
}

I'm sure this has something to do with the way Go handles variables and memory, but I can't seem to fix it. Can somebody explain what I'm not understanding?

You should create new slice for each data row. Notice, that a slice has a pointer to underlying array, so every slice you added into results have same pointer on actual data array. That's why you have faced with that behaviour.

When you create a slice using func make() it return a type (Not a pointer to type). But it does not allocate new memory each time a element is reassigned. Hence

result := make([]string, 5)

will have fix memory to contain 5 strings. when a element is reassigned, it occupies same memory as before hence overriding the old value.

Hopefully following example make things clear.

http://play.golang.org/p/3w2NtEHRuu

Hence in your program you are changing the content of the same memory and appending it again and again. To solve this problem you should create your result slice inside the loop.

Move result := make([]string, len(cols)) into your for loop that loops over the available rows.