Go: Removing duplicate rows after SQL join result

I’m running a joined SQL query for locations and events (occuring at the locations). In the results, naturally the location data is replicated per row, as there’s a one-to-many relationship: one location holds multiple events.

What’s an optimal approach to clean up the multiplied location data?

Staying with a single SQL operation, what makes the most sense is performing a check while looping through the query results (rows).

However I cannot seem to access the locations object to check for a pre-existing location ID.

Edit:
This is the SQL output. As you see, location data naturally occurs multiple times, because it's shared across events. Ultimately this will be sent out as JSON eventually, with nested structs, one for locations, one for events.

id 	title 		    latlng 				    id 	title 	        locationid 	
1 	Fox Thea... 	43.6640673,-79.4213863 	1 	Bob's Event		1
1 	Fox Thea... 	43.6640673,-79.4213863 	2 	Jill's Event 	1
2 	Wrigley ... 	43.6640673,-79.4213863 	3 	Mary's Event 	2
3 	Blues Bar 	    43.6640673,-79.4213863 	4 	John's Event 	3
1 	Fox Thea... 	43.6640673,-79.4213863 	5 	Monthly G... 	1
1 	Fox Thea... 	43.6640673,-79.4213863 	6 	A Special... 	1
1 	Fox Thea... 	43.6640673,-79.4213863 	7 	The Final... 	1

The JSON output. As you see location data is multiplied making for a larger JSON file.

   {
        "Locations": [
            {
                "ID": 1,
                "Title": "Fox Theatre",
                "Latlng": "43.6640673,-79.4213863",
            },
            {
                "ID": 1,
                "Title": "Fox Theatre",
                "Latlng": "43.6640673,-79.4213863",
            },
            {
                "ID": 2,
                "Title": "Wrigley Field",
                "Latlng": "43.6640673,-79.4213863",
            },
            {
                "ID": 3,
                "Title": "Blues Bar",
                "Latlng": "43.6640673,-79.4213863",
            },
            {
                "ID": 1,
                "Title": "Fox Theatre",
                "Latlng": "43.6640673,-79.4213863",
            },
            {
                "ID": 1,
                "Title": "Fox Theatre",
                "Latlng": "43.6640673,-79.4213863",
            },
            {
                "ID": 1,
                "Title": "Fox Theatre",
                "Latlng": "43.6640673,-79.4213863",
            }
        ],
        "Events": [
            {
                "ID": 1,
                "Title": "Bob's Event",
                "Location": 1
            },
            {
                "ID": 2,
                "Title": "Jill's Event",
                "Location": 1
            },
            {
                "ID": 3,
                "Title": "Mary's Event",
                "Location": 2
            },
            {
                "ID": 4,
                "Title": "John's Event",
                "Location": 3
            },
            {
                "ID": 5,
                "Title": "Monthly Gathering",
                "Location": 1
            },
            {
                "ID": 6,
                "Title": "A Special Event",
                "Location": 1
            },
            {
                "ID": 7,
                "Title": "The Final Contest",
                "Location": 1
            }
        ]
    
    }

Structs:

// Event type
type Event struct {
	ID int `schema:"id"`
	Title string `schema:"title"`
	LocationID int `schema:"locationid"`
}

// Location type
type Location struct {
	ID int `schema:"id"`
	Title string `schema:"title"`
	Latlng string `schema:"latlng"`
}

// LocationsEvents type
type LocationsEvents struct {
	Locations []Location `schema:"locations"`
	Events []Event `schema:"events"`
}

Function running the query and looping through rows:

func getLocationsEvents(db *sql.DB, start, count int) ([]Location, []Event, error) {

	var locations = []Location{}
	var events = []Event{}

	rows, err := db.Query("SELECT locations.id, locations.title, locations.latlng, events.id, events.title, events.locationid FROM locations LEFT JOIN events ON locations.id = events.locationid LIMIT ? OFFSET ?", count, start)
	if err != nil {
		return locations, events, err
	}
	defer rows.Close()

	for rows.Next() {
		var location Location
		var event Event

		err := rows.Scan(&location.ID, &location.Title, &location.Latlng, &event.ID, &event.Title, &event.LocationID);
		if err != nil {
				return locations, events, err
		}
		
    // Here I can print locations and see it getting longer with each loop iteration
	fmt.Println(locations)

	// How can I check if an ID exists in locations?
	// Ideally, if location.ID already exists in locations, then only append event, otherwise, append both the location and event

		locations = append(locations, location)
		events = append(events, event)
	}

	return locations, events, nil
}

Function called on by router:

func (a *App) getLocationsEventsJSON(w http.ResponseWriter, r *http.Request) {

count := 99
start := 0

    if count > 10 || count < 1 {
        count = 10
    }
    if start < 0 {
        start = 0
    }

    locations, events, err := getLocationsEvents(a.DB, start, count)
    if err != nil {
        respondWithError(w, http.StatusInternalServerError, err.Error())
        return
    }

	var locationsEvents LocationsEvents

	locationsEvents.Locations = locations
	locationsEvents.Events = events

    respondWithJSON(w, http.StatusOK, locationsEvents)
}

Function sending data out as JSON (part of REST API):

func respondWithJSON(w http.ResponseWriter, code int, payload interface{}) {
    response, _ := json.Marshal(payload)

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(code)
    w.Write(response)
}

UPDATE:

Reverting to doing this with the SQL query, what are the possibilities? Using GROUP BY? Here is an example SQL:

SELECT locations.id, locations.title, locations.latlng, events.id, events.title, events.locationid
FROM locations
LEFT JOIN events ON locations.id = events.locationid
GROUP BY locations.id, events.id

The result set still contains duplicated location data, however it's nicely grouped and sorted.

Then there's the possibility of sub-queries:
http://www.w3resource.com/sql/subqueries/understanding-sql-subqueries.php but now I'm running multiple SQL queries, something I wanted to avoid.

In reality I don't think I can avoid the duplicated location data when using a single join query like I am. How else would I receive a resultset of joined data, without having location data replicated? Having the SQL server send me pre-made JSON data as I need it (locations and events seperated)? From my understanding it's better doing that work after receiving results.

I think you can split your request in two: locations (SELECT * FROM locations) and events (SELECT * FROM events) and then pass them to JSON marshaller.
These 2 requests will be very easy and fast for database to perform. Next they will be easier to cache intermediate results.

> but now I'm running multiple SQL queries, something I wanted to avoid.

Could you pls clarify this moment - why do you want to avoid multiple queries? What task do you want to solve and what limitations have? Sometimes set of small easy queries are better than one overcomplicated.

If you are querying the database yourself, you should be able to avoid any duplicates in the first place.
In the end of your query add "GROUP BY {unique field}".

Example that should give a unique list of locations that are on you event list

SELECT location.* 
FROM location.ID, location.Title, location.Latlng
  INNER JOIN event ON event.ID=location.ID
GROUP BY location.ID