type FlatDetails struct {
 Id. String
 Flat Flat
 Users []User
}

-- name: GetFlatWithUsers :one
SELECT
 sqlc.embed(f),
 sqlc.group(
 sqlc.embed(u)
 )
FROM
 flats f
JOIN 
 user_flats uf ON f.id = uf.flat_id
JOIN 
 users u ON uf.username = u.username
WHERE 
 f.id = $1;

package sql
import (
	"context"
)
const getFlatWithUsers = `-- name: GetFlatWithUsers :one
SELECT
 f.id, f.name,
 u.username, u.email
FROM
 flats f
JOIN
 user_flats uf ON f.id = uf.flat_id
JOIN
 users u ON uf.username = u.username
WHERE
 f.id = 1ドル
`
type GetFlatWithUsersGroup struct {
	Flat Flat
	Users []User
}
func (data GetAllFlatsWithUsersGroup) HashCode() (string, error) {
	// Imagine we have a proper hashcode generation algorithm
	return fmt.Sprintf("%v", data), nil
}
func (q *Queries) GetFlatWithUsers(ctx context.Context, id int32) (GetFlatWithUsersGroup, error) {
	group := GetFlatWithUsersGroup{}
	rows, err := q.db.Query(ctx, getFlatWithUsers, id)
	if err != nil {
		return group, err
	}
	defer rows.Close()
	hashCode := map[string]bool{}
	for rows.Next() {
		var i GetFlatWithUsersGroup
		var j User
		if err := rows.Scan(
			&i.Flat.ID,
			&i.Flat.Name,
			&j.Username,
			&j.Email,
		); err != nil {
			return group, err
		}
		h, err := i.HashCode()
		if err != nil {
			return group, err
		}
		if len(hashCode) == 0 {
			group = i
			hashCode[h] = true
		}
		if _, ok := hashCode[h]; ok {
			group.Users = append(group.Users, j)
		}
	}
	if err := rows.Err(); err != nil {
		return group, err
	}
	return group, nil
}

package sql
import (
	"context"
)
const getAllFlatsWithUsers = `-- name: GetAllFlatsWithUsersGroup :many
SELECT
 f.id, f.name,
 u.username, u.email
FROM
 flats f
JOIN
 user_flats uf ON f.id = uf.flat_id
JOIN
 users u ON uf.username = u.username
`
type GetAllFlatsWithUsersGroup struct {
	Flat Flat
	Users []User
}
func (data GetAllFlatsWithUsersGroup) HashCode() (string, error) {
	// Imagine we have a proper hashcode generation algorithm
	return fmt.Sprintf("%v", data), nil
}
func (q *Queries) GetAllFlatsWithUsers(ctx context.Context) ([]GetAllFlatsWithUsersGroup, error) {
	rows, err := q.db.Query(ctx, getAllFlatsWithUsers)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := map[string]GetAllFlatsWithUsersGroup{}
	for rows.Next() {
		var i GetAllFlatsWithUsersGroup
		var j User
		if err := rows.Scan(
			&i.Flat.ID,
			&i.Flat.Name,
			&j.Username,
			&j.Email,
		); err != nil {
			return nil, err
		}
		hashCode, err := i.HashCode()
		if err != nil {
			return nil, err
		}
		if item, ok := items[hashCode]; ok {
			item.Users = append(item.Users, j)
		} else {
			items[hashCode] = i
			i.Users = []User{j}
		}
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	groups := make([]GetAllFlatsWithUsersGroup, 0, len(items))
	for _, item := range items {
		groups = append(groups, item)
	}
	return groups, nil
}