How to reduce memory usage of []string?

This seems pretty inefficient to me:

for _, value := range strings.Split(line[23:], ";") {
    row.Values = append(row.Values, value)
}

You basically obtain a []string by calling the string.Split function, and then loop over that slice to append every string to another initially nil string slice.

Why not just do:

row.Values = strings.Split(line[23:], ";")

instead ?

Though I can't guarantee it, it might be possible that the loop causes each string to be copied, and therefore make your program use twice as memory as needed.

You are appending into a Row struct the values obtained by each iteration, which considering the huge file size is not a reasonable good approach. Why your are not processing the file in batches?

Looking at the Split function it returns a slice of substrings, so it's not necessary to range over the resulted slices and append them into the row.Values. You can assign the resulted values directly to row.Values, then append it to the rows slice.

func Split(s, sep string) []string

Split slices s into all substrings separated by sep and returns a slice of the substrings between those separators. If sep is empty, Split splits after each UTF-8 sequence. It is equivalent to SplitN with a count of -1.

row.Values = strings.Split(line[23:], ";")
rows = append(rows, row)

Seems to me it's about append() function. From language spec

If the capacity of s is not large enough to fit the additional values, append allocates a new, sufficiently large underlying array

Size of this newly allocated array can be sufficient enough to consume even more further appends. So to allocate precisely you should slice := make([]Row, 0, WithExpectedCapacity) and than assign slice[n]= instead of append(). If you can't do this, you at least can try reflection to compact

reflect.ValueOf(&slice).Elem().SetCap(len(slice))

Some tricky, but you can see https://play.golang.org/p/LslkOBCvII it works.