From 1f7837d6d62471d72e2b2c15f8ed07cd0a43fda9 Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Wed, 22 Feb 2017 22:03:59 +0800 Subject: [PATCH] Refactor for issues loadattributes of a repository (#971) * refactor for issues loadattributes of a repository * refactors --- models/helper.go | 21 +++ models/issue.go | 66 +-------- models/issue_list.go | 320 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 343 insertions(+), 64 deletions(-) create mode 100644 models/helper.go create mode 100644 models/issue_list.go diff --git a/models/helper.go b/models/helper.go new file mode 100644 index 0000000000..93acadc989 --- /dev/null +++ b/models/helper.go @@ -0,0 +1,21 @@ +// Copyright 2017 The Gitea Authors. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package models + +func keysInt64(m map[int64]struct{}) []int64 { + var keys = make([]int64, 0, len(m)) + for k, _ := range m { + keys = append(keys, k) + } + return keys +} + +func valuesRepository(m map[int64]*Repository) []*Repository { + var values = make([]*Repository, 0, len(m)) + for _, v := range m { + values = append(values, v) + } + return values +} diff --git a/models/issue.go b/models/issue.go index b160004fd5..4677da401e 100644 --- a/models/issue.go +++ b/models/issue.go @@ -1128,11 +1128,8 @@ func Issues(opts *IssuesOptions) ([]*Issue, error) { return nil, fmt.Errorf("Find: %v", err) } - // FIXME: use IssueList to improve performance. - for i := range issues { - if err := issues[i].LoadAttributes(); err != nil { - return nil, fmt.Errorf("LoadAttributes [%d]: %v", issues[i].ID, err) - } + if err := IssueList(issues).LoadAttributes(); err != nil { + return nil, fmt.Errorf("LoadAttributes: %v", err) } return issues, nil @@ -1399,62 +1396,3 @@ func updateIssue(e Engine, issue *Issue) error { func UpdateIssue(issue *Issue) error { return updateIssue(x, issue) } - -// IssueList defines a list of issues -type IssueList []*Issue - -func (issues IssueList) getRepoIDs() []int64 { - repoIDs := make([]int64, 0, len(issues)) - for _, issue := range issues { - var has bool - for _, repoID := range repoIDs { - if repoID == issue.RepoID { - has = true - break - } - } - if !has { - repoIDs = append(repoIDs, issue.RepoID) - } - } - return repoIDs -} - -func (issues IssueList) loadRepositories(e Engine) ([]*Repository, error) { - if len(issues) == 0 { - return nil, nil - } - - repoIDs := issues.getRepoIDs() - rows, err := e. - Where("id > 0"). - In("id", repoIDs). - Rows(new(Repository)) - if err != nil { - return nil, fmt.Errorf("find repository: %v", err) - } - defer rows.Close() - - repositories := make([]*Repository, 0, len(repoIDs)) - repoMaps := make(map[int64]*Repository, len(repoIDs)) - for rows.Next() { - var repo Repository - err = rows.Scan(&repo) - if err != nil { - return nil, fmt.Errorf("find repository: %v", err) - } - - repositories = append(repositories, &repo) - repoMaps[repo.ID] = &repo - } - - for _, issue := range issues { - issue.Repo = repoMaps[issue.RepoID] - } - return repositories, nil -} - -// LoadRepositories loads issues' all repositories -func (issues IssueList) LoadRepositories() ([]*Repository, error) { - return issues.loadRepositories(x) -} diff --git a/models/issue_list.go b/models/issue_list.go new file mode 100644 index 0000000000..692243eff7 --- /dev/null +++ b/models/issue_list.go @@ -0,0 +1,320 @@ +// Copyright 2017 The Gitea Authors. All rights reserved. +// Use of this source code is governed by a MIT-style +// license that can be found in the LICENSE file. + +package models + +import "fmt" + +// IssueList defines a list of issues +type IssueList []*Issue + +func (issues IssueList) getRepoIDs() []int64 { + repoIDs := make(map[int64]struct{}, len(issues)) + for _, issue := range issues { + if _, ok := repoIDs[issue.RepoID]; !ok { + repoIDs[issue.RepoID] = struct{}{} + } + } + return keysInt64(repoIDs) +} + +func (issues IssueList) loadRepositories(e Engine) ([]*Repository, error) { + if len(issues) == 0 { + return nil, nil + } + + repoIDs := issues.getRepoIDs() + repoMaps := make(map[int64]*Repository, len(repoIDs)) + err := e. + In("id", repoIDs). + Find(&repoMaps) + if err != nil { + return nil, fmt.Errorf("find repository: %v", err) + } + + for _, issue := range issues { + issue.Repo = repoMaps[issue.RepoID] + } + return valuesRepository(repoMaps), nil +} + +// LoadRepositories loads issues' all repositories +func (issues IssueList) LoadRepositories() ([]*Repository, error) { + return issues.loadRepositories(x) +} + +func (issues IssueList) getPosterIDs() []int64 { + posterIDs := make(map[int64]struct{}, len(issues)) + for _, issue := range issues { + if _, ok := posterIDs[issue.PosterID]; !ok { + posterIDs[issue.PosterID] = struct{}{} + } + } + return keysInt64(posterIDs) +} + +func (issues IssueList) loadPosters(e Engine) error { + if len(issues) == 0 { + return nil + } + + postgerIDs := issues.getPosterIDs() + posterMaps := make(map[int64]*User, len(postgerIDs)) + err := e. + In("id", postgerIDs). + Find(&posterMaps) + if err != nil { + return err + } + + for _, issue := range issues { + issue.Poster = posterMaps[issue.PosterID] + } + return nil +} + +func (issues IssueList) getIssueIDs() []int64 { + var ids = make([]int64, 0, len(issues)) + for _, issue := range issues { + ids = append(ids, issue.ID) + } + return ids +} + +func (issues IssueList) loadLabels(e Engine) error { + if len(issues) == 0 { + return nil + } + + type LabelIssue struct { + Label *Label `xorm:"extends"` + IssueLabel *IssueLabel `xorm:"extends"` + } + + var issueLabels = make(map[int64][]*Label, len(issues)*3) + rows, err := e.Table("label"). + Join("LEFT", "issue_label", "issue_label.label_id = label.id"). + In("issue_label.issue_id", issues.getIssueIDs()). + Asc("label.name"). + Rows(new(LabelIssue)) + if err != nil { + return err + } + defer rows.Close() + + for rows.Next() { + var labelIssue LabelIssue + err = rows.Scan(&labelIssue) + if err != nil { + return err + } + issueLabels[labelIssue.IssueLabel.IssueID] = append(issueLabels[labelIssue.IssueLabel.IssueID], labelIssue.Label) + } + + for _, issue := range issues { + issue.Labels = issueLabels[issue.ID] + } + return nil +} + +func (issues IssueList) getMilestoneIDs() []int64 { + var ids = make(map[int64]struct{}, len(issues)) + for _, issue := range issues { + if _, ok := ids[issue.MilestoneID]; !ok { + ids[issue.MilestoneID] = struct{}{} + } + } + return keysInt64(ids) +} + +func (issues IssueList) loadMilestones(e Engine) error { + milestoneIDs := issues.getMilestoneIDs() + if len(milestoneIDs) == 0 { + return nil + } + + milestoneMaps := make(map[int64]*Milestone, len(milestoneIDs)) + err := e. + In("id", milestoneIDs). + Find(&milestoneMaps) + if err != nil { + return err + } + + for _, issue := range issues { + issue.Milestone = milestoneMaps[issue.MilestoneID] + } + return nil +} + +func (issues IssueList) getAssigneeIDs() []int64 { + var ids = make(map[int64]struct{}, len(issues)) + for _, issue := range issues { + if _, ok := ids[issue.AssigneeID]; !ok { + ids[issue.AssigneeID] = struct{}{} + } + } + return keysInt64(ids) +} + +func (issues IssueList) loadAssignees(e Engine) error { + assigneeIDs := issues.getAssigneeIDs() + if len(assigneeIDs) == 0 { + return nil + } + + assigneeMaps := make(map[int64]*User, len(assigneeIDs)) + err := e. + In("id", assigneeIDs). + Find(&assigneeMaps) + if err != nil { + return err + } + + for _, issue := range issues { + issue.Assignee = assigneeMaps[issue.AssigneeID] + } + return nil +} + +func (issues IssueList) getPullIssueIDs() []int64 { + var ids = make([]int64, 0, len(issues)) + for _, issue := range issues { + if issue.IsPull && issue.PullRequest == nil { + ids = append(ids, issue.ID) + } + } + return ids +} + +func (issues IssueList) loadPullRequests(e Engine) error { + issuesIDs := issues.getPullIssueIDs() + if len(issuesIDs) == 0 { + return nil + } + + pullRequestMaps := make(map[int64]*PullRequest, len(issuesIDs)) + rows, err := e. + In("issue_id", issuesIDs). + Rows(new(PullRequest)) + if err != nil { + return err + } + defer rows.Close() + + for rows.Next() { + var pr PullRequest + err = rows.Scan(&pr) + if err != nil { + return err + } + pullRequestMaps[pr.IssueID] = &pr + } + + for _, issue := range issues { + issue.PullRequest = pullRequestMaps[issue.ID] + } + return nil +} + +func (issues IssueList) loadAttachments(e Engine) (err error) { + if len(issues) == 0 { + return nil + } + + var attachments = make(map[int64][]*Attachment, len(issues)) + rows, err := e.Table("attachment"). + Join("INNER", "issue", "issue.id = attachment.issue_id"). + In("issue.id", issues.getIssueIDs()). + Rows(new(Attachment)) + if err != nil { + return err + } + defer rows.Close() + + for rows.Next() { + var attachment Attachment + err = rows.Scan(&attachment) + if err != nil { + return err + } + attachments[attachment.IssueID] = append(attachments[attachment.IssueID], &attachment) + } + + for _, issue := range issues { + issue.Attachments = attachments[issue.ID] + } + return nil +} + +func (issues IssueList) loadComments(e Engine) (err error) { + if len(issues) == 0 { + return nil + } + + var comments = make(map[int64][]*Comment, len(issues)) + rows, err := e.Table("comment"). + Join("INNER", "issue", "issue.id = comment.issue_id"). + In("issue.id", issues.getIssueIDs()). + Rows(new(Comment)) + if err != nil { + return err + } + defer rows.Close() + + for rows.Next() { + var comment Comment + err = rows.Scan(&comment) + if err != nil { + return err + } + comments[comment.IssueID] = append(comments[comment.IssueID], &comment) + } + + for _, issue := range issues { + issue.Comments = comments[issue.ID] + } + return nil +} + +func (issues IssueList) loadAttributes(e Engine) (err error) { + if _, err = issues.loadRepositories(e); err != nil { + return + } + + if err = issues.loadPosters(e); err != nil { + return + } + + if err = issues.loadLabels(e); err != nil { + return + } + + if err = issues.loadMilestones(e); err != nil { + return + } + + if err = issues.loadAssignees(e); err != nil { + return + } + + if err = issues.loadPullRequests(e); err != nil { + return + } + + if err = issues.loadAttachments(e); err != nil { + return + } + + if err = issues.loadComments(e); err != nil { + return + } + + return nil +} + +// LoadAttributes loads atrributes of the issues +func (issues IssueList) LoadAttributes() error { + return issues.loadAttributes(x) +}