Best behavior on error during multipart stream - go

Question

I have implemented a CSV export endpoint that is grabbing data from a database, row by row, and writing each line to BodyWriter. This must happen line by line, because the implementation needs to be conscious of memory consumption...
Here is a naive pseudo implementation:
rows, err := db.Query(q)
if err != nil {
w.WriteHeader(http.StatusInternalServerError) // <-- location 0
return
}
for rows.Next() {
if err := rows.Err(); err != nil {
// <-- location 1
return
}
r := result{}
if err := rows.Scan(&r); err != nil {
// <-- location 2
return
}
stringSlice := convertToStringSlice(r)
err := w.Write([]byte(line))
if err != nil {
// <-- location 3
return
}
}
return // <-- location 4
In location 0 - there is only one call to BodyWriter.WriteHeader so no problem.
In location 4 - I've already implicitly called BodyWriter.WriteHeader by calling BodyWriter.Write. Once I return, the BodyWriter is probably released and that is how (I assume) how the connection is closed (client gets EOF?).
But what if an error occurs after I've already written a few lines, in position 1/2/3? How do I differentiate this from the situation when we return in location 4?
I want to somehow notify the client that something went wrong, but the 200 status was already sent...
It also seems that Golang standard http library manages the connection internally and does not expose an easy way to manually close the TCP connection.
What is the best way to handle this situation?

Answer 1

use the context package
so if the frontend close the request you are not endup reading data and processing data from your database for no use
func test3Handler(w http.ResponseWriter, r *http.Request) {
rows, err := db.QueryContext(r.Context(), q)
}
the *http.Request have a context that is active while the request is active so if it gets an error that 'the context is closed' which means that the frontend dropped the request in the middle of the request
you can't update the `w.WriteHeader(200)` or call `w.WriteHeader(200)` after writing to the body it needs to be called before writing to the body,
you will need to send the error in that row, also even it didn'
for rows.Next() {
res := result{}
if err := rows.Scan(&res); err != nil {
// <-- location 2
fmt.Fprintf(w, "cant read row from the db error %v\n", err)
return
}
stringSlice, err := convertToStringSlice(r)
if err != nil {
fmt.Fprintf(w, "cant process row %+v, error %v\n", res, stringSlice)
return
}
fmt.Fprintln(w, stringSlice)
}
if you do want to return a 500 on a scan error, scan all rows to memory and if there is an error return an 500 else return all rows
func csvHandler(w http.ResponseWriter, r *http.Request) {
rows, err := db.QueryContext(r.Context(), q)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
var list []*result
for rows.Next() {
res := &result{}
if err := rows.Scan(res); err != nil {
// <-- location 2
w.WriteHeader(http.StatusInternalServerError)
return
}
list = append(list, res)
}
csvEnc := csv.NewWriter(w)
for _, res := range list {
err = csvEnc.Write(convertToStringSlice(res)...)
}
if err != nil {
// <-- location 3
// handle response writing error
return
}
return
}
this solution is using more memory than the previous example