simplify code

Author: torcolvin

db/changes.go

@@ -534,7 +534,7 @@ func (db *DatabaseCollectionWithUser) changesFeed(ctx context.Context, singleCha
 					base.DebugfCtx(ctx, base.KeyChanges, "Terminating channel feed %s", base.UD(to))
 					return
 				case feed <- &change:
-					if !options.ActiveOnly || (!change.Deleted && len(change.Removed) == 0) {
+					if !options.ActiveOnly || logEntry.IsActive() {
 						sentChanges++
 					}
 				}

db/changes_view.go

@@ -91,9 +91,7 @@ func (dbc *DatabaseContext) getQueryHandlerForCollection(collectionID uint32) (C
 
 // Queries the 'channels' view to get a range of sequences of a single channel as LogEntries.
 // The second return value, reachedEnd, is true if the query scanned all the way through to endSeq
-// without stopping early due to the activeOnly+limit active-entry count being satisfied first. When
-// reachedEnd is false, there may be additional matching entries between the last returned entry and
-// endSeq that were never scanned - it is unsafe to assume the range up to endSeq is fully covered.
+// rather than stopping early once an activeOnly+limit active-entry count was satisfied.
 func (c *DatabaseCollection) getChangesInChannelFromQuery(ctx context.Context, channelName string, startSeq, endSeq uint64, limit int, activeOnly bool) (entries LogEntries, reachedEnd bool, err error) {
 	if c.dataStore == nil {
 		return nil, false, errors.New("No data store available for channel query")
@@ -164,14 +162,11 @@ func (c *DatabaseCollection) getChangesInChannelFromQuery(ctx context.Context, c
 		// If active-only, loop until either retrieve (limit) active entries, or reach endSeq.  Non-active entries are still
 		// included in the result set for potential cache prepend
 		if activeOnly {
-			// If we've reached limit before exhausting the range up to endSeq, we're done.  Whether
-			// the range beyond the last returned entry has been fully scanned can't be determined by
-			// comparing highSeq to endSeq alone - channels are often sparse, so the last real entry
-			// is frequently well below endSeq even when nothing was missed.  Instead, check whether
-			// this query call itself returned fewer rows than requested: if so, the store had no more
-			// matching entries anywhere in [startSeq, endSeq], regardless of where highSeq landed. If
-			// the call returned exactly `limit` rows, the LIMIT clause may have truncated further
-			// matches, so fall back to the highSeq/endSeq comparison.
+			// If we've reached limit before exhausting the range up to endSeq, we're done. highSeq
+			// alone can't tell us whether the range was fully scanned - channels are often sparse,
+			// so the last entry is frequently well below endSeq even when nothing was missed. But a
+			// query call returning fewer than `limit` rows means the store had no more matching
+			// entries in range, regardless of highSeq; otherwise fall back to the highSeq comparison.
 			if limit != 0 && activeEntryCount >= limit {
 				reachedEnd = queryRowCount < limit || (endSeq > 0 && highSeq >= endSeq)
 				break

db/channel_cache_single.go

@@ -439,27 +439,29 @@ func (c *singleChannelCacheImpl) GetChanges(ctx context.Context, options Changes
 	}
 
 	result := resultFromQuery
-	room := options.Limit - len(result)
-	// For activeOnly+limit, only append cache when the query reached the cache boundary
-	// (queryReachedEnd, reported by the query itself - not inferred from sequence numbers, since
-	// this channel's entries are sparse across the global sequence space and the last entry's
-	// sequence is often below endSeq even when the query fully scanned through to endSeq).
-	// If the query stopped early (gap exists before cacheValidFrom), the changesFeed pagination
-	// loop must fetch that range before cache results are valid.
-	// The overlap entry at cacheValidFrom is deduplicated below when cache is appended.
-	if (options.Limit == 0 || room > 0 || (options.ActiveOnly && queryReachedEnd)) && len(resultFromCache) > 0 {
-		// Concatenate the view & cache results:
-		if len(result) > 0 && resultFromCache[0].Sequence == result[len(result)-1].Sequence {
-			resultFromCache = resultFromCache[1:]
+	if options.ActiveOnly {
+		// The query's row limit doesn't correspond to a count of active entries, so cache is only
+		// safe to append once the query itself confirms (via queryReachedEnd) that it scanned all
+		// the way to the cache boundary - otherwise there may be unscanned active entries in between.
+		if queryReachedEnd && len(resultFromCache) > 0 {
+			if len(result) > 0 && resultFromCache[0].Sequence == result[len(result)-1].Sequence {
+				resultFromCache = resultFromCache[1:]
+			}
+			result = append(result, resultFromCache...)
 		}
-		n := len(resultFromCache)
-		// Limit evaluation only valid when not activeOnly, since view and cache results don't apply activeOnly filtering
-		if !options.ActiveOnly {
+	} else {
+		room := options.Limit - len(result)
+		if (options.Limit == 0 || room > 0) && len(resultFromCache) > 0 {
+			// Concatenate the view & cache results:
+			if len(result) > 0 && resultFromCache[0].Sequence == result[len(result)-1].Sequence {
+				resultFromCache = resultFromCache[1:]
+			}
+			n := len(resultFromCache)
 			if options.Limit > 0 && room > 0 && room < n {
 				n = room
 			}
+			result = append(result, resultFromCache[0:n]...)
 		}
-		result = append(result, resultFromCache[0:n]...)
 	}
 	base.InfofCtx(ctx, base.KeyCache, "GetChangesInChannel(%q) --> %d rows", base.UD(c.channelID), len(result))