我正在为位置和事件(发生在这些位置)运行联合 SQL 查询。在结果中，位置数据自然会按行复制，因为存在一对多关系:一个位置包含多个事件。

清理成倍增加的位置数据的最佳方法是什么？

继续使用单个 SQL 操作，最有意义的是在循环查询结果(行)时执行检查。

但是我似乎无法访问位置对象来检查预先存在的位置 ID。

编辑: 这是 SQL 输出。如您所见，位置数据自然会出现多次，因为它是跨事件共享的。最终这将作为 JSON 发送出去，带有嵌套结构，一个用于位置，一个用于事件。

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

JSON 输出。如您所见，位置数据成倍增加，形成更大的 JSON 文件。

   {
        "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
            }
        ]

    }

结构:

// 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"`
}

运行查询并循环遍历行的函数:

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
}

路由器调用的函数:

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

以 JSON 形式发送数据的函数(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)
}

更新:

回到使用 SQL 查询执行此操作，有哪些可能性？使用 GROUP BY？这是一个示例 SQL:

SELECT locations.id, locations.title, locations.latlng, events.id, events.title, events.locationid 从地点 在 locations.id = events.locationid 上左加入事件 GROUP BY locations.id, events.id

结果集仍然包含重复的位置数据，但已很好地分组和排序。

然后是子查询的可能性: http://www.w3resource.com/sql/subqueries/understanding-sql-subqueries.php但现在我正在运行多个 SQL 查询，这是我想避免的事情。

实际上，我不认为我可以像我一样在使用单个连接查询时避免重复的位置数据。如果不复制位置数据，我还能如何接收连接数据的结果集？让 SQL 服务器根据需要向我发送预制的 JSON 数据(位置和事件分开)？根据我的理解，最好在收到结果后再做这项工作。

最佳答案

我认为您可以将请求分为两部分:位置(SELECT * FROM locations)和事件(SELECT * FROM events)，然后将它们传递给 JSON 编码器。 这 2 个请求对于数据库来说将非常容易和快速地执行。接下来他们将更容易缓存中间结果。

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

请您澄清一下 - 为什么要避免多次查询？你想解决什么任务，有什么限制？有时一组简单的小查询比一个过于复杂的查询要好。

关于Go:在 SQL 连接结果后删除重复行，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44874566/