Jump the Review list to an artist by letter

An A–Z/# bar above the Songs and Albums lists jumps to the first artist
starting with that letter. Songs come from a new /letters endpoint giving
each leading character's offset; the song list now sorts case-insensitively
like the album list so each letter stays together.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/store/models.go

@@ -432,7 +432,7 @@ func (s *Store) Matches(ctx context.Context, pairID int64, f MatchFilter) ([]Mat
 		f.Limit = 100
 	}
 	rows, err := s.DB.QueryContext(ctx, `SELECT `+matchCols+` FROM matches WHERE `+w+
-		` ORDER BY rel_slave LIMIT ? OFFSET ?`, append(args, f.Limit, f.Offset)...)
+		` ORDER BY rel_slave COLLATE NOCASE, rel_slave LIMIT ? OFFSET ?`, append(args, f.Limit, f.Offset)...)
 	if err != nil {
 		return nil, 0, err
 	}
@@ -448,6 +448,39 @@ func (s *Store) Matches(ctx context.Context, pairID int64, f MatchFilter) ([]Mat
 	return out, total, rows.Err()
 }
 
+// LetterStart is where the paths beginning with one (lowercased) character
+// start in the Matches listing of a filter.
+type LetterStart struct {
+	Letter string `json:"letter"`
+	Offset int    `json:"offset"`
+}
+
+// MatchLetters returns, in listing order, the offset of the first match for
+// each leading character of rel_slave, for jumping to an artist by letter.
+// Grouping on lower() of the first character keeps each group contiguous
+// under the NOCASE order Matches uses.
+func (s *Store) MatchLetters(ctx context.Context, pairID int64, f MatchFilter) ([]LetterStart, error) {
+	w, args := matchWhere(pairID, f)
+	rows, err := s.DB.QueryContext(ctx, `SELECT lower(substr(rel_slave, 1, 1)) AS l, COUNT(*) FROM matches WHERE `+w+
+		` GROUP BY l ORDER BY l`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := []LetterStart{}
+	offset := 0
+	for rows.Next() {
+		var l string
+		var n int
+		if err := rows.Scan(&l, &n); err != nil {
+			return nil, err
+		}
+		out = append(out, LetterStart{Letter: l, Offset: offset})
+		offset += n
+	}
+	return out, rows.Err()
+}
+
 // ExportMatches calls fn for every match of the filter, ordered by slave
 // path. Rows are read in pages so a slow download never holds the database
 // connection (scans need it) for longer than one page.

internal/store/store_test.go

@@ -1,6 +1,11 @@
 package store
 
-import "testing"
+import (
+	"context"
+	"reflect"
+	"strings"
+	"testing"
+)
 
 func TestDecodeWarnings(t *testing.T) {
 	old := decodeWarnings(`["Only 3 of 9 folders match."]`)
@@ -15,3 +20,40 @@ func TestDecodeWarnings(t *testing.T) {
 		t.Fatalf("empty list should stay an empty (non-nil) list, got %#v", ws)
 	}
 }
+
+func TestMatchLetters(t *testing.T) {
+	ctx := context.Background()
+	st, err := Open(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { st.DB.Close() })
+	p := Pair{Name: "p", MasterRoot: "/m", SlaveRoot: "/s", RetentionDays: 30}
+	if err := st.SavePair(ctx, &p); err != nil {
+		t.Fatal(err)
+	}
+	for _, rel := range []string{"beck/a.flac", "ABBA/a.flac", "Air/a.flac", "2Pac/a.flac", "Björk/a.flac", "abba/b.flac"} {
+		m := Match{PairID: p.ID, RelSlave: rel, Status: StatusUnmatched, Kind: KindNone}
+		if err := st.UpsertMatch(ctx, &m); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ls, err := st.MatchLetters(ctx, p.ID, MatchFilter{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []LetterStart{{"2", 0}, {"a", 1}, {"b", 4}}
+	if !reflect.DeepEqual(ls, want) {
+		t.Fatalf("letters = %+v, want %+v", ls, want)
+	}
+	// The offsets must agree with the listing order, whatever the case.
+	ms, _, err := st.Matches(ctx, p.ID, MatchFilter{Limit: 10})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, l := range ls {
+		if got := strings.ToLower(ms[l.Offset].RelSlave[:1]); got != l.Letter {
+			t.Fatalf("offset %d starts with %q, want %q (listing %v)", l.Offset, got, l.Letter, ms)
+		}
+	}
+}