patch of appview/pipelines: add limit to pipelines query · round #0 · pull #829 · tangled.org/core

+4 -2

appview/db/pipeline.go

···

       168
       168
        
       

     

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

     

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

     

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

     

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

     

       172
       172
        
       	var conditions []string

     

       173
       173
        
       	var args []any

     

       174
       174
        
       	for _, filter := range filters {

     
···

       205
       205
        
       		join

     

       206
       206
        
       			triggers t ON p.trigger_id = t.id

     

       207
       207
        
       		%s

     

       208
       208
       -
       	`, whereClause)

     

       208
       208
       +
       		order by p.created desc

     

       209
       209
       +
       		limit %d

     

       210
       210
       +
       	`, whereClause, limit)

     

       209
       211
        
       

     

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

     

       211
       213
        
       	if err != nil {

+3

appview/pipelines/pipelines.go

···

       82
       82
        
       

     

       83
       83
        
       	ps, err := db.GetPipelineStatuses(

     

       84
       84
        
       		p.db,

     

       85
       85
       +
       		30,

     

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

     

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

     

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

     
···

       124
       125
        
       

     

       125
       126
        
       	ps, err := db.GetPipelineStatuses(

     

       126
       127
        
       		p.db,

     

       128
       128
       +
       		1,

     

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

     

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

     

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

     
···

       193
       195
        
       

     

       194
       196
        
       	ps, err := db.GetPipelineStatuses(

     

       195
       197
        
       		p.db,

     

       198
       198
       +
       		1,

     

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

     

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

     

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

+2

appview/pulls/pulls.go

···

       178
       178
        
       

     

       179
       179
        
       	ps, err := db.GetPipelineStatuses(

     

       180
       180
        
       		s.db,

     

       181
       181
       +
       		len(shas),

     

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

     

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

     

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

     
···

       648
       649
        
       	repoInfo := f.RepoInfo(user)

     

       649
       650
        
       	ps, err := db.GetPipelineStatuses(

     

       650
       651
        
       		s.db,

     

       652
       652
       +
       		len(shas),

     

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

     

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

     

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

+1 -14

appview/repo/repo_util.go

···

       1
       1
        
       package repo

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"crypto/rand"

     

       5
       5
       -
       	"math/big"

     

       6
       4
        
       	"slices"

     

       7
       5
        
       	"sort"

     

       8
       6
        
       	"strings"

     
···

       90
       88
        
       	return

     

       91
       89
        
       }

     

       92
       90
        
       

     

       93
       93
       -
       func randomString(n int) string {

     

       94
       94
       -
       	const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

     

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

     

       96
       96
       -
       

     

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

     

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

     

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

     

       100
       100
       -
       	}

     

       101
       101
       -
       

     

       102
       102
       -
       	return string(result)

     

       103
       103
       -
       }

     

       104
       104
       -
       

     

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

     

       106
       92
        
       //

     

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

     
···

       118
       104
        
       

     

       119
       105
        
       	ps, err := db.GetPipelineStatuses(

     

       120
       106
        
       		d,

     

       107
       107
       +
       		len(shas),

     

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

     

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

     

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