Using LEFT JOIN on Golang and mapping to a struct

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.

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++
	}
}