back round 0 view raw

appview/db: add db helpers to count entries #542

merged

opened by

oppi.li 3 months ago targeting master from push-mvmrzuxwmzvs

Signed-off-by: oppiliappan me@oppi.li

options

unified split

Changed files

+79 -68

appview

follow.go

repos.go

star.go

strings.go

+4 -4

appview/db/follow.go

···

       56
       56
        
       }

     

       57
       57
        
       

     

       58
       58
        
       type FollowStats struct {

     

       59
       59
       -
       	Followers int

     

       60
       60
       -
       	Following int

     

       59
       59
       +
       	Followers int64

     

       60
       60
       +
       	Following int64

     

       61
       61
        
       }

     

       62
       62
        
       

     

       63
       63
        
       func GetFollowerFollowingCount(e Execer, did string) (FollowStats, error) {

     

       64
       64
       -
       	followers, following := 0, 0

     

       64
       64
       +
       	var followers, following int64

     

       65
       65
        
       	err := e.QueryRow(

     

       66
       66
        
       		`SELECT

     

       67
       67
        
       		COUNT(CASE WHEN subject_did = ? THEN 1 END) AS followers,

     
···

       122
       122
        
       

     

       123
       123
        
       	for rows.Next() {

     

       124
       124
        
       		var did string

     

       125
       125
       -
       		var followers, following int

     

       125
       125
       +
       		var followers, following int64

     

       126
       126
        
       		if err := rows.Scan(&did, &followers, &following); err != nil {

     

       127
       127
        
       			return nil, err

     

       128
       128
        
       		}

+25 -64

appview/db/repos.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"database/sql"

     

       5
       5
       +
       	"errors"

     

       5
       6
        
       	"fmt"

     

       6
       7
        
       	"log"

     

       7
       8
        
       	"slices"

     
···

       38
       39
        
       	return p

     

       39
       40
        
       }

     

       40
       41
        
       

     

       41
       41
       -
       func GetAllRepos(e Execer, limit int) ([]Repo, error) {

     

       42
       42
       -
       	var repos []Repo

     

       43
       43
       -
       

     

       44
       44
       -
       	rows, err := e.Query(

     

       45
       45
       -
       		`select did, name, knot, rkey, description, created, source

     

       46
       46
       -
       		from repos

     

       47
       47
       -
       		order by created desc

     

       48
       48
       -
       		limit ?

     

       49
       49
       -
       		`,

     

       50
       50
       -
       		limit,

     

       51
       51
       -
       	)

     

       52
       52
       -
       	if err != nil {

     

       53
       53
       -
       		return nil, err

     

       54
       54
       -
       	}

     

       55
       55
       -
       	defer rows.Close()

     

       56
       56
       -
       

     

       57
       57
       -
       	for rows.Next() {

     

       58
       58
       -
       		var repo Repo

     

       59
       59
       -
       		err := scanRepo(

     

       60
       60
       -
       			rows, &repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &repo.Description, &repo.Created, &repo.Source,

     

       61
       61
       -
       		)

     

       62
       62
       -
       		if err != nil {

     

       63
       63
       -
       			return nil, err

     

       64
       64
       -
       		}

     

       65
       65
       -
       		repos = append(repos, repo)

     

       66
       66
       -
       	}

     

       67
       67
       -
       

     

       68
       68
       -
       	if err := rows.Err(); err != nil {

     

       69
       69
       -
       		return nil, err

     

       70
       70
       -
       	}

     

       71
       71
       -
       

     

       72
       72
       -
       	return repos, nil

     

       73
       73
       -
       }

     

       74
       74
       -
       

     

       75
       42
        
       func GetRepos(e Execer, limit int, filters ...filter) ([]Repo, error) {

     

       76
       43
        
       	repoMap := make(map[syntax.ATURI]*Repo)

     

       77
       44
        
       

     
···

       318
       285
        
       	return repos, nil

     

       319
       286
        
       }

     

       320
       287
        
       

     

       288
       288
       +
       func CountRepos(e Execer, filters ...filter) (int64, error) {

     

       289
       289
       +
       	var conditions []string

     

       290
       290
       +
       	var args []any

     

       291
       291
       +
       	for _, filter := range filters {

     

       292
       292
       +
       		conditions = append(conditions, filter.Condition())

     

       293
       293
       +
       		args = append(args, filter.Arg()...)

     

       294
       294
       +
       	}

     

       295
       295
       +
       

     

       296
       296
       +
       	whereClause := ""

     

       297
       297
       +
       	if conditions != nil {

     

       298
       298
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       299
       299
       +
       	}

     

       300
       300
       +
       

     

       301
       301
       +
       	repoQuery := fmt.Sprintf(`select count(1) from repos %s`, whereClause)

     

       302
       302
       +
       	var count int64

     

       303
       303
       +
       	err := e.QueryRow(repoQuery, args...).Scan(&count)

     

       304
       304
       +
       

     

       305
       305
       +
       	if !errors.Is(err, sql.ErrNoRows) && err != nil {

     

       306
       306
       +
       		return 0, err

     

       307
       307
       +
       	}

     

       308
       308
       +
       

     

       309
       309
       +
       	return count, nil

     

       310
       310
       +
       }

     

       311
       311
       +
       

     

       321
       312
        
       func GetAllReposByDid(e Execer, did string) ([]Repo, error) {

     

       322
       313
        
       	var repos []Repo

     

       323
       314
        
       

     
···

       570
       561
        
       	IssueCount IssueCount

     

       571
       562
        
       	PullCount  PullCount

     

       572
       563
        
       }

     

       573
       573
       -
       

     

       574
       574
       -
       func scanRepo(rows *sql.Rows, did, name, knot, rkey, description *string, created *time.Time, source *string) error {

     

       575
       575
       -
       	var createdAt string

     

       576
       576
       -
       	var nullableDescription sql.NullString

     

       577
       577
       -
       	var nullableSource sql.NullString

     

       578
       578
       -
       	if err := rows.Scan(did, name, knot, rkey, &nullableDescription, &createdAt, &nullableSource); err != nil {

     

       579
       579
       -
       		return err

     

       580
       580
       -
       	}

     

       581
       581
       -
       

     

       582
       582
       -
       	if nullableDescription.Valid {

     

       583
       583
       -
       		*description = nullableDescription.String

     

       584
       584
       -
       	} else {

     

       585
       585
       -
       		*description = ""

     

       586
       586
       -
       	}

     

       587
       587
       -
       

     

       588
       588
       -
       	createdAtTime, err := time.Parse(time.RFC3339, createdAt)

     

       589
       589
       -
       	if err != nil {

     

       590
       590
       -
       		*created = time.Now()

     

       591
       591
       -
       	} else {

     

       592
       592
       -
       		*created = createdAtTime

     

       593
       593
       -
       	}

     

       594
       594
       -
       

     

       595
       595
       -
       	if nullableSource.Valid {

     

       596
       596
       -
       		*source = nullableSource.String

     

       597
       597
       -
       	} else {

     

       598
       598
       -
       		*source = ""

     

       599
       599
       -
       	}

     

       600
       600
       -
       

     

       601
       601
       -
       	return nil

     

       602
       602
       -
       }

+26

appview/db/star.go

···

       1
       1
        
       package db

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"database/sql"

     

       5
       5
       +
       	"errors"

     

       4
       6
        
       	"fmt"

     

       5
       7
        
       	"log"

     

       6
       8
        
       	"strings"

     
···

       183
       185
        
       	return stars, nil

     

       184
       186
        
       }

     

       185
       187
        
       

     

       188
       188
       +
       func CountStars(e Execer, filters ...filter) (int64, error) {

     

       189
       189
       +
       	var conditions []string

     

       190
       190
       +
       	var args []any

     

       191
       191
       +
       	for _, filter := range filters {

     

       192
       192
       +
       		conditions = append(conditions, filter.Condition())

     

       193
       193
       +
       		args = append(args, filter.Arg()...)

     

       194
       194
       +
       	}

     

       195
       195
       +
       

     

       196
       196
       +
       	whereClause := ""

     

       197
       197
       +
       	if conditions != nil {

     

       198
       198
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       199
       199
       +
       	}

     

       200
       200
       +
       

     

       201
       201
       +
       	repoQuery := fmt.Sprintf(`select count(1) from stars %s`, whereClause)

     

       202
       202
       +
       	var count int64

     

       203
       203
       +
       	err := e.QueryRow(repoQuery, args...).Scan(&count)

     

       204
       204
       +
       

     

       205
       205
       +
       	if !errors.Is(err, sql.ErrNoRows) && err != nil {

     

       206
       206
       +
       		return 0, err

     

       207
       207
       +
       	}

     

       208
       208
       +
       

     

       209
       209
       +
       	return count, nil

     

       210
       210
       +
       }

     

       211
       211
       +
       

     

       186
       212
        
       func GetAllStars(e Execer, limit int) ([]Star, error) {

     

       187
       213
        
       	var stars []Star

     

       188
       214

+24

appview/db/strings.go

···

       206
       206
        
       	return all, nil

     

       207
       207
        
       }

     

       208
       208
        
       

     

       209
       209
       +
       func CountStrings(e Execer, filters ...filter) (int64, error) {

     

       210
       210
       +
       	var conditions []string

     

       211
       211
       +
       	var args []any

     

       212
       212
       +
       	for _, filter := range filters {

     

       213
       213
       +
       		conditions = append(conditions, filter.Condition())

     

       214
       214
       +
       		args = append(args, filter.Arg()...)

     

       215
       215
       +
       	}

     

       216
       216
       +
       

     

       217
       217
       +
       	whereClause := ""

     

       218
       218
       +
       	if conditions != nil {

     

       219
       219
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       220
       220
       +
       	}

     

       221
       221
       +
       

     

       222
       222
       +
       	repoQuery := fmt.Sprintf(`select count(1) from strings %s`, whereClause)

     

       223
       223
       +
       	var count int64

     

       224
       224
       +
       	err := e.QueryRow(repoQuery, args...).Scan(&count)

     

       225
       225
       +
       

     

       226
       226
       +
       	if !errors.Is(err, sql.ErrNoRows) && err != nil {

     

       227
       227
       +
       		return 0, err

     

       228
       228
       +
       	}

     

       229
       229
       +
       

     

       230
       230
       +
       	return count, nil

     

       231
       231
       +
       }

     

       232
       232
       +
       

     

       209
       233
        
       func DeleteString(e Execer, filters ...filter) error {

     

       210
       234
        
       	var conditions []string

     

       211
       235
        
       	var args []any