appview: implement GetFollowersFollowingCounts to query follow stats for multiple dids in one go #505

+79 -3

appview/db/follow.go

··· 55 55 return err 56 56 } 57 57 58 58 - func GetFollowerFollowingCount(e Execer, did string) (int, int, error) { 58 58 + type FollowStats struct { 59 59 + Followers int 60 60 + Following int 61 61 + } 62 62 + 63 63 + func GetFollowerFollowingCount(e Execer, did string) (FollowStats, error) { 59 64 followers, following := 0, 0 60 65 err := e.QueryRow( 61 66 `SELECT ··· 63 68 COUNT(CASE WHEN user_did = ? THEN 1 END) AS following 64 69 FROM follows;`, did, did).Scan(&followers, &following) 65 70 if err != nil { 66 66 - return 0, 0, err 71 71 + return FollowStats{}, err 72 72 + } 73 73 + return FollowStats{ 74 74 + Followers: followers, 75 75 + Following: following, 76 76 + }, nil 77 77 + } 78 78 + 79 79 + func GetFollowerFollowingCounts(e Execer, dids []string) (map[string]FollowStats, error) { 80 80 + if len(dids) == 0 { 81 81 + return nil, nil 82 82 + } 83 83 + 84 84 + placeholders := make([]string, len(dids)) 85 85 + for i := range placeholders { 86 86 + placeholders[i] = "?" 67 87 } 68 68 - return followers, following, nil 88 88 + placeholderStr := strings.Join(placeholders, ",") 89 89 + 90 90 + args := make([]any, len(dids)*2) 91 91 + for i, did := range dids { 92 92 + args[i] = did 93 93 + args[i+len(dids)] = did 94 94 + } 95 95 + 96 96 + query := fmt.Sprintf(` 97 97 + select 98 98 + coalesce(f.did, g.did) as did, 99 99 + coalesce(f.followers, 0) as followers, 100 100 + coalesce(g.following, 0) as following 101 101 + from ( 102 102 + select subject_did as did, count(*) as followers 103 103 + from follows 104 104 + where subject_did in (%s) 105 105 + group by subject_did 106 106 + ) f 107 107 + full outer join ( 108 108 + select user_did as did, count(*) as following 109 109 + from follows 110 110 + where user_did in (%s) 111 111 + group by user_did 112 112 + ) g on f.did = g.did`, 113 113 + placeholderStr, placeholderStr) 114 114 + 115 115 + result := make(map[string]FollowStats) 116 116 + 117 117 + rows, err := e.Query(query, args...) 118 118 + if err != nil { 119 119 + return nil, err 120 120 + } 121 121 + defer rows.Close() 122 122 + 123 123 + for rows.Next() { 124 124 + var did string 125 125 + var followers, following int 126 126 + if err := rows.Scan(&did, &followers, &following); err != nil { 127 127 + return nil, err 128 128 + } 129 129 + result[did] = FollowStats{ 130 130 + Followers: followers, 131 131 + Following: following, 132 132 + } 133 133 + } 134 134 + 135 135 + for _, did := range dids { 136 136 + if _, exists := result[did]; !exists { 137 137 + result[did] = FollowStats{ 138 138 + Followers: 0, 139 139 + Following: 0, 140 140 + } 141 141 + } 142 142 + } 143 143 + 144 144 + return result, nil 69 145 } 70 146 71 147 func GetFollows(e Execer, limit int, filters ...filter) ([]Follow, error) {

+3 -15

appview/db/timeline.go

··· 20 20 *FollowStats 21 21 } 22 22 23 23 - type FollowStats struct { 24 24 - Followers int 25 25 - Following int 26 26 - } 27 27 - 28 23 const Limit = 50 29 24 30 25 // TODO: this gathers heterogenous events from different sources and aggregates ··· 156 151 return nil, err 157 152 } 158 153 159 159 - followStatMap := make(map[string]FollowStats) 160 160 - for _, s := range subjects { 161 161 - followers, following, err := GetFollowerFollowingCount(e, s) 162 162 - if err != nil { 163 163 - return nil, err 164 164 - } 165 165 - followStatMap[s] = FollowStats{ 166 166 - Followers: followers, 167 167 - Following: following, 168 168 - } 154 154 + followStatMap, err := GetFollowerFollowingCounts(e, subjects) 155 155 + if err != nil { 156 156 + return nil, err 169 157 } 170 158 171 159 var events []TimelineEvent

+25 -11

appview/state/profile.go

··· 61 61 log.Printf("getting profile data for %s: %s", did, err) 62 62 } 63 63 64 64 - followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did) 64 64 + followStats, err := db.GetFollowerFollowingCount(s.db, did) 65 65 if err != nil { 66 66 log.Printf("getting follow stats for %s: %s", did, err) 67 67 } ··· 80 80 UserHandle: ident.Handle.String(), 81 81 Profile: profile, 82 82 FollowStatus: followStatus, 83 83 - FollowersCount: followersCount, 84 84 - FollowingCount: followingCount, 83 83 + FollowersCount: followStats.Followers, 84 84 + FollowingCount: followStats.Following, 85 85 }, 86 86 } 87 87 } ··· 212 212 } 213 213 214 214 id := pageWithProfile.Id 215 215 + loggedInUser := pageWithProfile.LoggedInUser 215 216 216 217 follows, err := fetchFollows(s.db, id.DID.String()) 217 218 if err != nil { ··· 219 220 } 220 221 221 222 if len(follows) == 0 { 222 222 - return nil 223 223 + return &FollowsPageParams{ 224 224 + LoggedInUser: loggedInUser, 225 225 + Follows: []pages.FollowCard{}, 226 226 + Card: pageWithProfile.Card, 227 227 + } 223 228 } 224 229 225 230 followDids := make([]string, 0, len(follows)) ··· 230 235 profiles, err := db.GetProfiles(s.db, db.FilterIn("did", followDids)) 231 236 if err != nil { 232 237 log.Printf("getting profile for %s: %s", followDids, err) 233 233 - return nil 234 238 } 235 239 236 236 - loggedInUser := pageWithProfile.LoggedInUser 240 240 + followStatsMap, err := db.GetFollowerFollowingCounts(s.db, followDids) 241 241 + if err != nil { 242 242 + log.Printf("getting follow counts for %s: %s", followDids, err) 243 243 + } 244 244 + 237 245 var loggedInUserFollowing map[string]struct{} 238 246 if loggedInUser != nil { 239 247 following, err := db.GetFollowing(s.db, loggedInUser.Did) ··· 250 258 251 259 followCards := make([]pages.FollowCard, 0, len(follows)) 252 260 for _, did := range followDids { 253 253 - followersCount, followingCount, err := db.GetFollowerFollowingCount(s.db, did) 254 254 - if err != nil { 255 255 - log.Printf("getting follow stats for %s: %s", did, err) 261 261 + followStats, exists := followStatsMap[did] 262 262 + if !exists { 263 263 + followStats = db.FollowStats{} 256 264 } 257 265 followStatus := db.IsNotFollowing 258 266 if loggedInUserFollowing != nil { ··· 272 280 followCards = append(followCards, pages.FollowCard{ 273 281 UserDid: did, 274 282 FollowStatus: followStatus, 275 275 - FollowersCount: followersCount, 276 276 - FollowingCount: followingCount, 283 283 + FollowersCount: followStats.Followers, 284 284 + FollowingCount: followStats.Following, 277 285 Profile: profile, 278 286 }) 279 287 } ··· 287 295 288 296 func (s *State) followersPage(w http.ResponseWriter, r *http.Request) { 289 297 followPage := s.followPage(w, r, db.GetFollowers, func(f db.Follow) string { return f.UserDid }) 298 298 + if followPage == nil { 299 299 + return 300 300 + } 290 301 291 302 s.pages.FollowersPage(w, pages.FollowersPageParams{ 292 303 LoggedInUser: followPage.LoggedInUser, ··· 297 308 298 309 func (s *State) followingPage(w http.ResponseWriter, r *http.Request) { 299 310 followPage := s.followPage(w, r, db.GetFollowing, func(f db.Follow) string { return f.SubjectDid }) 311 311 + if followPage == nil { 312 312 + return 313 313 + } 300 314 301 315 s.pages.FollowingPage(w, pages.FollowingPageParams{ 302 316 LoggedInUser: followPage.LoggedInUser,

+3 -3

appview/strings/strings.go

··· 203 203 followStatus = db.GetFollowStatus(s.Db, loggedInUser.Did, id.DID.String()) 204 204 } 205 205 206 206 - followersCount, followingCount, err := db.GetFollowerFollowingCount(s.Db, id.DID.String()) 206 206 + followStats, err := db.GetFollowerFollowingCount(s.Db, id.DID.String()) 207 207 if err != nil { 208 208 l.Error("failed to get follow stats", "err", err) 209 209 } ··· 215 215 UserHandle: id.Handle.String(), 216 216 Profile: profile, 217 217 FollowStatus: followStatus, 218 218 - FollowersCount: followersCount, 219 219 - FollowingCount: followingCount, 218 218 + FollowersCount: followStats.Followers, 219 219 + FollowingCount: followStats.Following, 220 220 }, 221 221 Strings: all, 222 222 })