Using LEFT JOIN on Golang and mapping to a struct - postgresql

Question

I have the following structs on Go:
type Struct1 struct {
ID int64 `db:id`
InternalID int64 `db:internal_id`
Structs2 []Struct2
}
type Struct2 struct {
ID int64 `db:id`
InternalID int64 `db:internal_id`
SomeText string `db:some_text`
}
The relation between this two is: There only can be one Struct1, connect to N Struct2 by the internal_id. So I am doing this query:
SELECT*
FROM struct1 st1
LEFT JOIN struct2 st2
ON
st1.internal_id = st2.internal_id
LIMIT 10
OFFSET (1 - 1) * 10;
By executing this query on Go, I wanna know if i can: Create an array of Struct1, by mapping correctly the array Struct2 on it. If it is possible, how can I do it? Thanks in advance.
I'm using Postgres and sqlx.

Answer 1

This is entirely dependent on the library/client you're using to connect to the database, however, I have never seen a library support what you're trying to do so I'll provide a custom implementation that you can do. Full disclosure, I did not test this but I hope it gives you the general idea and anyone should feel free to add edits.
package main
type Struct1 struct {
ID int64 `db:id`
InternalID int64 `db:internal_id`
Structs2 []Struct2
}
type Struct2 struct {
ID int64 `db:id`
InternalID int64 `db:internal_id`
SomeText string `db:some_text`
}
type Row struct {
Struct1
Struct2
}
func main() {
var rows []*Row
// decode the response into the rows variable using whatever SQL client you use
// We'll group the struct1s into a map, then iterate over all the rows, taking the
// struct2 contents off of rows we've already added to the map and then appending
// the struct2 to them. This effectively turns rows into one-to-many relationships
// between struct1 and struct2.
mapped := map[int64]*Struct1{}
for _, r := range rows {
// The key of the map is going to be the internal ID of struct1 (that's the ONE
// in the one-to-many relationship)
if _, ok := mapped[r.Struct1.InternalID]; ok {
// Make sure to initialize the key if this is the first row with struct1's
// internal ID.
mapped[r.Struct1.InternalID] = &r.Struct1
}
// Append the struct 2 (the MANY in the one-to-many relationship) to the struct1s
// array of struct2s.
mapped[r.Struct1.InternalID].Structs2 = append(mapped[r.Struct1.InternalID].Structs2, r.Struct2)
}
// Then convert it to a slice if needed
results := make([]*Struct1, len(mapped))
i := 0
for _, v := range mapped {
results[i] = v
i++
}
}