appview/pipelines: add limit to pipelines query #829

···

       
168
       
 
       


     

       
169
       
 
       
// this is a mega query, but the most useful one:

     

       
170
       
 
       
// get N pipelines, for each one get the latest status of its N workflows

     

       
171
       
-
       
func GetPipelineStatuses(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       
172
       
 
       
	var conditions []string

     

       
173
       
 
       
	var args []any

     

       
174
       
 
       
	for _, filter := range filters {

     
···

       
205
       
 
       
		join

     

       
206
       
 
       
			triggers t ON p.trigger_id = t.id

     

       
207
       
 
       
		%s

     

       
208
       
-
       
	`, whereClause)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
209
       
 
       


     

       
210
       
 
       
	rows, err := e.Query(query, args...)

     

       
211
       
 
       
	if err != nil {

     

···

       
168
       
 
       


     

       
169
       
 
       
// this is a mega query, but the most useful one:

     

       
170
       
 
       
// get N pipelines, for each one get the latest status of its N workflows

     

       
171
       
+
       
func GetPipelineStatuses(e Execer, limit int, filters ...filter) ([]models.Pipeline, error) {

     

       
172
       
 
       
	var conditions []string

     

       
173
       
 
       
	var args []any

     

       
174
       
 
       
	for _, filter := range filters {

     
···

       
205
       
 
       
		join

     

       
206
       
 
       
			triggers t ON p.trigger_id = t.id

     

       
207
       
 
       
		%s

     

       
208
       
+
       
		order by p.created desc

     

       
209
       
+
       
		limit %d

     

       
210
       
+
       
	`, whereClause, limit)

     

       
211
       
 
       


     

       
212
       
 
       
	rows, err := e.Query(query, args...)

     

       
213
       
 
       
	if err != nil {

     

···

       
82
       
 
       


     

       
83
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
84
       
 
       
		p.db,

     

       
0
       
 
       

     

       
85
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
86
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
87
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     
···

       
124
       
 
       


     

       
125
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
126
       
 
       
		p.db,

     

       
0
       
 
       

     

       
127
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
128
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
129
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     
···

       
193
       
 
       


     

       
194
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
195
       
 
       
		p.db,

     

       
0
       
 
       

     

       
196
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
197
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
198
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     

···

       
82
       
 
       


     

       
83
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
84
       
 
       
		p.db,

     

       
85
       
+
       
		30,

     

       
86
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
87
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
88
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     
···

       
125
       
 
       


     

       
126
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
127
       
 
       
		p.db,

     

       
128
       
+
       
		1,

     

       
129
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
130
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
131
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     
···

       
195
       
 
       


     

       
196
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
197
       
 
       
		p.db,

     

       
198
       
+
       
		1,

     

       
199
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
200
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
201
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     

···

       
178
       
 
       


     

       
179
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
180
       
 
       
		s.db,

     

       
0
       
 
       

     

       
181
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
182
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
183
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     
···

       
648
       
 
       
	repoInfo := f.RepoInfo(user)

     

       
649
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
650
       
 
       
		s.db,

     

       
0
       
 
       

     

       
651
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
652
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
653
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     

···

       
178
       
 
       


     

       
179
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
180
       
 
       
		s.db,

     

       
181
       
+
       
		len(shas),

     

       
182
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
183
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
184
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     
···

       
649
       
 
       
	repoInfo := f.RepoInfo(user)

     

       
650
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
651
       
 
       
		s.db,

     

       
652
       
+
       
		len(shas),

     

       
653
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
654
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
655
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     

···

       
1
       
 
       
package repo

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
-
       
	"crypto/rand"

     

       
5
       
-
       
	"math/big"

     

       
6
       
 
       
	"slices"

     

       
7
       
 
       
	"sort"

     

       
8
       
 
       
	"strings"

     
···

       
90
       
 
       
	return

     

       
91
       
 
       
}

     

       
92
       
 
       


     

       
93
       
-
       
func randomString(n int) string {

     

       
94
       
-
       
	const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

     

       
95
       
-
       
	result := make([]byte, n)

     

       
96
       
-
       


     

       
97
       
-
       
	for i := 0; i < n; i++ {

     

       
98
       
-
       
		n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))

     

       
99
       
-
       
		result[i] = letters[n.Int64()]

     

       
100
       
-
       
	}

     

       
101
       
-
       


     

       
102
       
-
       
	return string(result)

     

       
103
       
-
       
}

     

       
104
       
-
       


     

       
105
       
 
       
// grab pipelines from DB and munge that into a hashmap with commit sha as key

     

       
106
       
 
       
//

     

       
107
       
 
       
// golang is so blessed that it requires 35 lines of imperative code for this

     
···

       
118
       
 
       


     

       
119
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
120
       
 
       
		d,

     

       
0
       
 
       

     

       
121
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
122
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
123
       
 
       
		db.FilterEq("knot", repoInfo.Knot),

     

···

       
1
       
 
       
package repo

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4
       
 
       
	"slices"

     

       
5
       
 
       
	"sort"

     

       
6
       
 
       
	"strings"

     
···

       
88
       
 
       
	return

     

       
89
       
 
       
}

     

       
90
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
91
       
 
       
// grab pipelines from DB and munge that into a hashmap with commit sha as key

     

       
92
       
 
       
//

     

       
93
       
 
       
// golang is so blessed that it requires 35 lines of imperative code for this

     
···

       
104
       
 
       


     

       
105
       
 
       
	ps, err := db.GetPipelineStatuses(

     

       
106
       
 
       
		d,

     

       
107
       
+
       
		len(shas),

     

       
108
       
 
       
		db.FilterEq("repo_owner", repoInfo.OwnerDid),

     

       
109
       
 
       
		db.FilterEq("repo_name", repoInfo.Name),

     

       
110
       
 
       
		db.FilterEq("knot", repoInfo.Knot),