yonlu/yellowjacket
1
1
Fork 0
Code Issues 48 Pull Requests Actions Packages Projects Releases 13 Wiki Activity

feat(database): shape the library like files, and shrink the catalog
CI / check (push) Successful in 3m7s
Details
CI / e2e (push) Canceled after 1m45s
Details

Browse Source 
Plans 013 and 014, the album page that prompted them, and the smaller
fixes they turned up. Changelog, largest first.

## The local library is shaped like files, not like MusicBrainz

`audio_files` carries its own tags and points at `albums` and
`artists`; `file_genres` is the one real many-to-many. `recordings`,
`release_group_recordings`, `artist_credit`, `artist_credit_artist`,
`recording_genres`, `release_groups` and `release_to_rg` are gone from
the local side, and with them a six-way join in every read, a
`MIN(release_group_id)` subquery in eleven queries and a
first-credited-artist subquery in nine. Measured on a real 25,966-file
library, every many-to-many that model expressed was 1:1 in the data.

- Ownership is a file. `GetFilePathsByRecordingMBIDs`,
  `LibraryMBIDIndex.CheckMBIDs`, `collectLibraryEntities` and
  `pruneStaleLocalCrossReferences` all join `audio_files`, so the 812
  orphaned recordings, 216 release groups and 260 artists that library
  carried are now structurally impossible.
- One projection: every track query selects from the `track_metadata`
  view, one row type, one mapper. Nine hand-rolled copies had drifted
  far enough to report different years on different screens.
- `library_id = 0` means every library, so each list query exists once
  instead of scoped and unscoped with a branch at every call site.
- No migration chain. `sql/schemas/` is the one description of the
  shape; `sql/migrations/`, `applyMigrations` and `schema_migrations`
  are squashed away, along with the drift between them that had sqlc
  generating against a stale schema.
- `database.InsertTestTrack` is the one test seeder; twenty test files
  had been assembling the old FK chain each in its own order.

## The catalog stores its ids as bytes

`explore_index`'s three 36-char MBID columns and its entity-type text
are 16 raw bytes and a small integer. The table and its six indexes go
780 MB to 405 MB on a real 2,052,200-row catalog, which is why a fresh
install is ~0.6 GB rather than ~1.0 GB.

- `backend/explore/mbid.go` is the only place the encoding is known;
  everything above it speaks dashed strings.
- `CHECK(length(mbid) = 16)` makes a stringly write fail at the insert
  rather than silently returning no rows, since SQLite does not coerce
  between TEXT and BLOB.
- The importer asks the artifact what encoding it carries and converts
  on the way in, so the artifact already published keeps working and no
  format bump is needed.
- `indexRowColumns`/`scanIndexRow` replace four copies of a 22-column
  list, and `TestStoredEncodingRoundTrips` sweeps every read path.

## An album page that says how much of the album is yours

- One question, asked once: is there a file. `filePaths` is filled by a
  single batched lookup when the tracklist settles, and the badge, the
  Play count, the dimmed rows and every menu item read it — replacing
  four claims of decreasing confidence that could show a green tick on
  an album whose every action did nothing.
- Play, Play 7 of 12, or no play button at all.
- `total_tracks` on `explore_index` (~2 bytes over 400,677 release
  groups) and on `audio_files` from tags that have always carried it:
  a complete MBID-matched album now makes no catalog call at all, where
  it used to spend the most expensive request the app makes.
- A merged cluster shows the running order the most releases agree on,
  and the version list marks the release you own rather than standing a
  synthetic entry in for it.
- `AlbumReleasesFailed`: a slow fetch is no longer reported as a failed
  one by a 12-second timer.
- Rows not in the library are dimmed in place (with `aria-disabled`)
  instead of the owned ones wearing a green tick and a legend.

## Caches and cover art get ceilings

- Only the three tiers of a cover are stored; the full-resolution copy
  nothing rendered was 1,134 MB of a 1.4 GB covers directory.
- One artist portrait is downloaded and the rest are remembered as
  URLs — 4.1 GB of a 5.3 GB cache was candidates no code path reads.
- `browsedArtBudget` and `httpCacheBudget` bound what an age cannot:
  the same install held art for 5,770 artists in a 1,301-artist
  library.
- `OrphanedArtistImagesJob` joined a bare MBID onto a sharded
  directory, so it deleted the rows that were the only record of the
  files it left behind. `explore.ArtistImageDir` is that layout's one
  definition now.

## The autotag queue asks whether there is work

`tagging_items` was a row per album folder, not a queue, and no query
read the `tag_status` column that held the answer. The four queue
queries ask the files, which matters most where it is least visible:
`startPrefetch` was scoring every album in a tagged library against
MusicBrainz.

## Phantom playlist tracks resolve in place

An M3U8 imported before its files leaves phantom rows; they now match
by path and fall back to position, keep their place in the playlist
when resolved, and pair best-first so two phantoms cannot claim the
same file.

## Playing a track plays the list it is in

Double-click, and Play on a single row's menu, queue the list as
displayed with `startIndex` on that row — the album page and the track
list used to queue one track and discard the album around it. A
multi-row selection still plays exactly itself.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AfVYUVExXsx1nSWrXN8mAh
This commit is contained in:
yonlu
2026-08-16 13:58:15 -04:00
co-authored by Claude Opus 5
parent 1128881e8d
commit e7748f1fd5
208 changed files with 10944 additions and 12104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/smartplaylist/smartplaylist.go
+60 -89
View File
@@ -203,18 +203,17 @@ func validateOperator(op string, isNumeric bool) error {
}
// buildGenreCondition generates a subquery condition against
// recording_genres JOIN genres for every supported text operator.
// The outer query is expected to expose the `recording_id` column of
// the audio file (aliased through the smart playlist query), which is
// compared against recording_genres.recording_id.
// file_genres JOIN genres for every supported text operator. The outer
// query exposes the audio file's `id`, which is what file_genres is
// keyed by.
func buildGenreCondition(rule Rule) (string, []any, error) {
inHead := `af.recording_id IN (
SELECT rg_sub.recording_id FROM recording_genres rg_sub
JOIN genres g ON rg_sub.genre_id = g.id
inHead := `af.id IN (
SELECT fg.audio_file_id FROM file_genres fg
JOIN genres g ON fg.genre_id = g.id
WHERE `
notInHead := `af.recording_id NOT IN (
SELECT rg_sub.recording_id FROM recording_genres rg_sub
JOIN genres g ON rg_sub.genre_id = g.id
notInHead := `af.id NOT IN (
SELECT fg.audio_file_id FROM file_genres fg
JOIN genres g ON fg.genre_id = g.id
WHERE `
switch rule.Operator {
@@ -538,7 +537,7 @@ func parseBetweenValue(
// so the runtime cost is equivalent to querying the underlying tables
// directly.
const leanTrackQuery = `SELECT
af.recording_id,
af.id,
af.file_path,
af.length_milliseconds,
af.title,
@@ -559,26 +558,21 @@ const leanTrackQuery = `SELECT
FROM (
SELECT
af.id,
af.recording_id,
af.file_path,
af.length_milliseconds,
COALESCE(r.name, '') AS title,
COALESCE(ac.text, '') AS artist_name,
r.track_number,
r.disc_number,
COALESCE(rg.name, '') AS album,
af.title,
af.artist_credit AS artist_name,
af.track_number,
af.disc_number,
COALESCE(al.name, '') AS album,
-- Two year fields, matching the canonical track_metadata view:
-- year — the album's original (first-release) year,
-- year - the album's original (first-release) year,
-- the default users filter on. A 1977 album owned
-- as a 2010s reissue still filters as 1977.
-- release_year — the year of the specific release in the library
-- (the file/release-group tag), e.g. 2013 for that
-- reissue.
-- Both fall back through rg.year → r.year so a track without full
-- MusicBrainz data still gets a sensible year.
COALESCE(rg.original_year, rg.year, r.year, 0) AS year,
COALESCE(rg.year, r.year, 0) AS release_year,
COALESCE(r.composer, '') AS composer,
-- release_year - the year of the specific copy in the library.
COALESCE(al.original_year, al.year, af.year, 0) AS year,
COALESCE(al.year, af.year, 0) AS release_year,
af.composer,
COALESCE(ft.extension, '') AS file_type,
af.sample_rate,
af.bit_depth,
@@ -589,16 +583,8 @@ FROM (
af.play_count,
af.last_played
FROM audio_files af
LEFT JOIN recordings r ON af.recording_id = r.id
LEFT JOIN artist_credit ac ON r.artist_credit_id = ac.id
LEFT JOIN (
SELECT recording_id,
MIN(release_group_id) AS release_group_id
FROM release_group_recordings
GROUP BY recording_id
) rgr ON r.id = rgr.recording_id
LEFT JOIN release_groups rg ON rgr.release_group_id = rg.id
LEFT JOIN file_types ft ON af.file_type_id = ft.id
LEFT JOIN albums al ON al.id = af.album_id
LEFT JOIN file_types ft ON ft.id = af.file_type_id
) af`
// Evaluate runs the rule set against the library and returns matching
@@ -679,7 +665,7 @@ func Evaluate(
)
}
tracks, recordingIDs, err := scanTracks(rows)
tracks, fileIDs, err := scanTracks(rows)
_ = rows.Close()
@@ -689,17 +675,17 @@ func Evaluate(
mainDuration := time.Since(mainStart)
// Batch-load genres for every matched recording_id in one query
// Batch-load genres for every matched file id in one query
// instead of the per-row correlated subquery the view used.
genreStart := time.Now()
genresByRecording, err := fetchGenres(db, recordingIDs)
genresByFile, err := fetchGenres(db, fileIDs)
if err != nil {
return nil, err
}
for i, rid := range recordingIDs {
if g, ok := genresByRecording[rid]; ok {
for i, rid := range fileIDs {
if g, ok := genresByFile[rid]; ok {
tracks[i].Genre = splitGenres(g)
}
}
@@ -712,13 +698,13 @@ func Evaluate(
// and cover-art join over the whole library before WHERE/LIMIT.
artStart := time.Now()
artworkByRecording, err := fetchArtwork(db, recordingIDs)
artworkByFile, err := fetchArtwork(db, fileIDs)
if err != nil {
return nil, err
}
for i, rid := range recordingIDs {
art, ok := artworkByRecording[rid]
for i, rid := range fileIDs {
art, ok := artworkByFile[rid]
if !ok {
continue
}
@@ -771,16 +757,16 @@ func Evaluate(
// scanTracks reads all rows from a lean-query result into parallel
// slices: the Track values (minus genres, which are attached later)
// and the recording_id for each, used for the batched genre fetch.
// and the audio file id for each, used for the batched genre fetch.
func scanTracks(rows *sql.Rows) ([]library.Track, []int64, error) {
var (
tracks []library.Track
recordingIDs []int64
tracks []library.Track
fileIDs []int64
)
for rows.Next() {
var (
recordingID sql.NullInt64
fileID sql.NullInt64
filePath string
lengthMs int64
title string
@@ -801,7 +787,7 @@ func scanTracks(rows *sql.Rows) ([]library.Track, []int64, error) {
)
if err := rows.Scan(
&recordingID, &filePath, &lengthMs, &title, &artistName,
&fileID, &filePath, &lengthMs, &title, &artistName,
&trackNumber, &discNumber,
&album, &year, &composer, &fileType,
&sampleRate, &bitDepth, &channels,
@@ -834,7 +820,7 @@ func scanTracks(rows *sql.Rows) ([]library.Track, []int64, error) {
}
tracks = append(tracks, track)
recordingIDs = append(recordingIDs, recordingID.Int64)
fileIDs = append(fileIDs, fileID.Int64)
}
if err := rows.Err(); err != nil {
@@ -843,12 +829,12 @@ func scanTracks(rows *sql.Rows) ([]library.Track, []int64, error) {
)
}
return tracks, recordingIDs, nil
return tracks, fileIDs, nil
}
// fetchGenres batch-loads the GROUP_CONCAT-joined genre string for
// every recording_id in ids using a single IN-list query. Returns a
// map from recording_id to the concatenated genre string.
// every file id in ids using a single IN-list query. Returns a
// map from file id to the concatenated genre string.
func fetchGenres(
db *database.DB, ids []int64,
) (map[int64]string, error) {
@@ -888,13 +874,13 @@ func fetchGenres(
// SAFETY: placeholders are static "?" tokens; every value is
// parameterized.
query := `SELECT rg_sub.recording_id,
query := `SELECT fg.audio_file_id,
GROUP_CONCAT(g.name, '` + genreDelimiter + `')
FROM recording_genres rg_sub
JOIN genres g ON rg_sub.genre_id = g.id
WHERE rg_sub.recording_id IN (` +
FROM file_genres fg
JOIN genres g ON fg.genre_id = g.id
WHERE fg.audio_file_id IN (` +
strings.Join(placeholders, ", ") + `)
GROUP BY rg_sub.recording_id`
GROUP BY fg.audio_file_id`
rows, err := db.QueryContext(query, args...)
if err != nil {
@@ -933,7 +919,7 @@ func fetchGenres(
// trackArtwork holds the presentation-only cover-art path and
// MusicBrainz identifiers attached to a matched track after the main
// filter query, keyed by recording_id.
// filter query, keyed by audio file id.
type trackArtwork struct {
coverArtPath string
artistMBID string
@@ -942,7 +928,7 @@ type trackArtwork struct {
}
// fetchArtwork batch-loads cover-art paths and MusicBrainz IDs for the
// given recording_ids in a single IN-list query. These fields drive
// given file ids in a single IN-list query. These fields drive
// track-row styling only, so scoping them to the matched result set
// keeps the cost proportional to results rather than library size.
func fetchArtwork(
@@ -982,37 +968,22 @@ func fetchArtwork(
inList := strings.Join(placeholders, ", ")
// A recording's artist credit can name several artists; the old
// correlated subquery picked one via LIMIT 1. GROUP BY r.id with
// MIN() reproduces a single stable value without multiplying rows.
// SAFETY: placeholders are static "?" tokens; every value is
// parameterized. The IN list is bound twice (subquery + outer).
query := `SELECT r.id,
COALESCE(MIN(ca.file_path), '') AS cover_art_path,
COALESCE(MIN(a.mbid), '') AS artist_mbid,
COALESCE(MIN(rg.mbid), '') AS release_group_mbid,
COALESCE(r.mbid, '') AS recording_mbid
FROM recordings r
LEFT JOIN artist_credit ac ON r.artist_credit_id = ac.id
LEFT JOIN artist_credit_artist aca ON aca.credit_id = ac.id
LEFT JOIN artists a ON a.id = aca.artist_id
LEFT JOIN (
SELECT recording_id,
MIN(release_group_id) AS release_group_id
FROM release_group_recordings
WHERE recording_id IN (` + inList + `)
GROUP BY recording_id
) rgr ON r.id = rgr.recording_id
LEFT JOIN release_groups rg ON rgr.release_group_id = rg.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
WHERE r.id IN (` + inList + `)
GROUP BY r.id`
// parameterized.
query := `SELECT af.id,
COALESCE(ca.file_path, '') AS cover_art_path,
COALESCE(ar.mbid, '') AS artist_mbid,
COALESCE(al.mbid, '') AS release_group_mbid,
COALESCE(af.recording_mbid, '') AS recording_mbid
FROM audio_files af
LEFT JOIN artists ar ON ar.id = af.artist_id
LEFT JOIN albums al ON al.id = af.album_id
LEFT JOIN cover_art ca ON ca.id = al.cover_art_id
WHERE af.id IN (` + inList + `)`
args := make([]any, 0, len(unique)*2)
for range 2 {
for _, id := range unique {
args = append(args, id)
}
args := make([]any, 0, len(unique))
for _, id := range unique {
args = append(args, id)
}
rows, err := db.QueryContext(query, args...)
backend/smartplaylist/smartplaylist_test.go
+82 -198
View File
@@ -127,126 +127,36 @@ func seedSmartPlaylistData(t *testing.T, db *database.DB) {
},
}
// Build unique sets for artist_credit and release_groups.
artistMap := map[string]int64{}
albumMap := map[string]int64{}
var artistID, albumID int64
for _, tr := range tracks {
if _, ok := artistMap[tr.artist]; !ok {
artistID++
artistMap[tr.artist] = artistID
var trackNum, discNum int64
if tr.trackNum != nil {
trackNum = *tr.trackNum
}
if _, ok := albumMap[tr.album]; !ok {
albumID++
albumMap[tr.album] = albumID
}
}
// Insert artist_credit rows.
for text, id := range artistMap {
_, err := db.ExecContext(
"INSERT INTO artist_credit (id, text) VALUES (?, ?)",
id, text,
)
if err != nil {
t.Fatalf("insert artist_credit %q: %v", text, err)
}
}
// Insert release_groups.
for name, id := range albumMap {
_, err := db.ExecContext(
"INSERT INTO release_groups (id, name) VALUES (?, ?)",
id, name,
)
if err != nil {
t.Fatalf("insert release_group %q: %v", name, err)
}
}
// Insert genres.
genreMap := map[string]int64{}
var genreID int64
for _, tr := range tracks {
for _, g := range tr.genres {
if _, ok := genreMap[g]; !ok {
genreID++
genreMap[g] = genreID
_, err := db.ExecContext(
"INSERT INTO genres (id, name) VALUES (?, ?)",
genreID, g,
)
if err != nil {
t.Fatalf("insert genre %q: %v", g, err)
}
}
}
}
// Insert tracks with full FK chain.
for _, tr := range tracks {
acID := artistMap[tr.artist]
rgID := albumMap[tr.album]
// Insert recording.
_, err := db.ExecContext(
"INSERT INTO recordings (id, name, artist_credit_id, "+
"track_number, disc_number, year, composer) "+
"VALUES (?, ?, ?, ?, ?, ?, ?)",
tr.id, tr.title, acID, tr.trackNum, tr.discNum,
tr.year, tr.composer,
)
if err != nil {
t.Fatalf("insert recording %d %q: %v",
tr.id, tr.title, err)
if tr.discNum != nil {
discNum = *tr.discNum
}
// Insert audio_files.
_, err = db.ExecContext(
"INSERT INTO audio_files (id, file_path, "+
"length_milliseconds, file_type_id, recording_id, "+
"sample_rate, bit_depth, channels, bitrate, file_size) "+
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
tr.id, tr.filePath, tr.lenMs, tr.ftID, tr.id,
tr.sr, tr.bd, tr.ch, tr.br, tr.fsize,
)
if err != nil {
t.Fatalf("insert audio_file %d: %v", tr.id, err)
}
id := database.InsertTestTrack(t, db, database.TestTrack{
FilePath: tr.filePath,
Title: tr.title,
Artist: tr.artist,
Album: tr.album,
Genres: tr.genres,
TrackNumber: trackNum,
DiscNumber: discNum,
Year: tr.year,
LengthMs: tr.lenMs,
})
// Link recording to release_group.
_, err = db.ExecContext(
"INSERT INTO release_group_recordings "+
"(release_group_id, recording_id, track_number, disc_number) "+
"VALUES (?, ?, ?, ?)",
rgID, tr.id, tr.trackNum, tr.discNum,
)
if err != nil {
t.Fatalf("insert release_group_recordings %d→%d: %v",
rgID, tr.id, err)
}
// Insert recording_genres links (supports multi-genre).
for _, g := range tr.genres {
gID := genreMap[g]
_, err = db.ExecContext(
"INSERT INTO recording_genres "+
"(recording_id, genre_id) VALUES (?, ?)",
tr.id, gID,
)
if err != nil {
t.Fatalf(
"insert recording_genres %d→%d: %v",
tr.id, gID, err,
)
}
if _, err := db.ExecContext(
`UPDATE audio_files
SET file_type_id = ?, sample_rate = ?, bit_depth = ?,
channels = ?, bitrate = ?, file_size = ?, composer = ?
WHERE id = ?`,
tr.ftID, tr.sr, tr.bd, tr.ch, tr.br, tr.fsize, tr.composer, id,
); err != nil {
t.Fatalf("set audio properties for %q: %v", tr.filePath, err)
}
}
}
@@ -537,8 +447,8 @@ func TestBuildWhereClause_GenreIsProducesSubquery(t *testing.T) {
)
}
if !strings.Contains(clause, "recording_genres") {
t.Errorf("genre 'is' should reference recording_genres: %q",
if !strings.Contains(clause, "file_genres") {
t.Errorf("genre 'is' should reference file_genres: %q",
clause)
}
@@ -565,9 +475,9 @@ func TestBuildWhereClause_GenreIsNotProducesSubquery(t *testing.T) {
t.Errorf("genre 'is_not' should use NOT IN: %q", clause)
}
if !strings.Contains(clause, "recording_genres") {
if !strings.Contains(clause, "file_genres") {
t.Errorf(
"genre 'is_not' should reference recording_genres: %q",
"genre 'is_not' should reference file_genres: %q",
clause,
)
}
@@ -590,9 +500,9 @@ func TestBuildWhereClause_GenreIsAnyOfProducesSubquery(t *testing.T) {
t.Fatalf("unexpected error: %v", err)
}
if !strings.Contains(clause, "recording_genres") {
if !strings.Contains(clause, "file_genres") {
t.Errorf(
"genre 'is_any_of' should reference recording_genres: %q",
"genre 'is_any_of' should reference file_genres: %q",
clause,
)
}
@@ -620,11 +530,11 @@ func TestBuildWhereClause_GenreContainsUsesSubquery(t *testing.T) {
}
// Since the smart playlist query no longer projects a concatenated
// genre column, "contains" filters genres via recording_genres
// genre column, "contains" filters genres via file_genres
// with g.name LIKE applied to individual genre rows.
if !strings.Contains(clause, "recording_genres") {
if !strings.Contains(clause, "file_genres") {
t.Errorf(
"genre 'contains' should use recording_genres subquery: %q",
"genre 'contains' should use file_genres subquery: %q",
clause,
)
}
@@ -677,16 +587,16 @@ func TestBuildWhereClause_SameFieldMultipleTimes(t *testing.T) {
}
// Genre text ops combine via AND across subqueries against
// recording_genres; the exact SQL shape is asserted elsewhere.
// file_genres; the exact SQL shape is asserted elsewhere.
if !strings.Contains(clause, " AND ") {
t.Errorf("clause should combine rules with AND: %q", clause)
}
if !strings.Contains(clause, "af.recording_id IN") {
if !strings.Contains(clause, "af.id IN") {
t.Errorf("clause should include positive IN subquery: %q", clause)
}
if !strings.Contains(clause, "af.recording_id NOT IN") {
if !strings.Contains(clause, "af.id NOT IN") {
t.Errorf("clause should include NOT IN subquery: %q", clause)
}
@@ -822,34 +732,31 @@ func TestEvaluate_ArtworkEnrichment(t *testing.T) {
db := database.NewTestDB(t)
// Minimal FK chain: cover_art → release_group(mbid) →
// release_group_recordings → recording(mbid) → audio_file, plus
// artist_credit → artist_credit_artist → artist(mbid).
exec := func(query string, args ...any) {
t.Helper()
// One file, fully identified: cover art on its album, MBIDs on the
// album, the artist and the file itself.
database.InsertTestTrack(t, db, database.TestTrack{
FilePath: "/music/bohemian.mp3",
Title: "Bohemian Rhapsody",
Artist: "Queen",
ArtistMBID: "artist-mbid-1",
Album: "A Night at the Opera",
AlbumMBID: "rg-mbid-1",
RecordingMBID: "rec-mbid-1",
LengthMs: 354000,
})
if _, err := db.ExecContext(query, args...); err != nil {
t.Fatalf("seed %q: %v", query, err)
}
if _, err := db.ExecContext(
"INSERT INTO cover_art (id, file_path, mime_type) " +
"VALUES (1, '/covers/abc123.jpg', 'image/jpeg')",
); err != nil {
t.Fatalf("seed cover art: %v", err)
}
// file_types are pre-seeded by the schema (id 0 = .mp3).
exec("INSERT INTO cover_art (id, file_path, mime_type) " +
"VALUES (1, '/covers/abc123.jpg', 'image/jpeg')")
exec("INSERT INTO artists (id, name, mbid) " +
"VALUES (1, 'Queen', 'artist-mbid-1')")
exec("INSERT INTO artist_credit (id, text) VALUES (1, 'Queen')")
exec("INSERT INTO artist_credit_artist (credit_id, artist_id) " +
"VALUES (1, 1)")
exec("INSERT INTO release_groups (id, name, cover_art_id, mbid) " +
"VALUES (1, 'A Night at the Opera', 1, 'rg-mbid-1')")
exec("INSERT INTO recordings (id, name, artist_credit_id, mbid) " +
"VALUES (1, 'Bohemian Rhapsody', 1, 'rec-mbid-1')")
exec("INSERT INTO release_group_recordings " +
"(release_group_id, recording_id) VALUES (1, 1)")
exec("INSERT INTO audio_files (id, file_path, " +
"length_milliseconds, recording_id, file_type_id) " +
"VALUES (1, '/music/bohemian.mp3', 354000, 1, 0)")
if _, err := db.ExecContext(
"UPDATE albums SET cover_art_id = 1 WHERE name = 'A Night at the Opera'",
); err != nil {
t.Fatalf("attach cover art: %v", err)
}
tracks, err := Evaluate(db, RuleSet{
Rules: []Rule{
@@ -864,31 +771,22 @@ func TestEvaluate_ArtworkEnrichment(t *testing.T) {
t.Fatalf("got %d tracks, want 1", len(tracks))
}
tr := tracks[0]
got := tracks[0]
if tr.ArtistMBID != "artist-mbid-1" {
t.Errorf("ArtistMBID = %q, want artist-mbid-1", tr.ArtistMBID)
if got.CoverArtPath != coverart.ResolveURLs("/covers/abc123.jpg").Original {
t.Errorf("cover art = %q, want the resolved original", got.CoverArtPath)
}
if tr.ReleaseGroupMBID != "rg-mbid-1" {
t.Errorf("ReleaseGroupMBID = %q, want rg-mbid-1",
tr.ReleaseGroupMBID)
if got.ArtistMBID != "artist-mbid-1" {
t.Errorf("artist mbid = %q, want artist-mbid-1", got.ArtistMBID)
}
if tr.RecordingMBID != "rec-mbid-1" {
t.Errorf("RecordingMBID = %q, want rec-mbid-1",
tr.RecordingMBID)
if got.ReleaseGroupMBID != "rg-mbid-1" {
t.Errorf("release group mbid = %q, want rg-mbid-1", got.ReleaseGroupMBID)
}
wantURLs := coverart.ResolveURLs("/covers/abc123.jpg")
if tr.CoverArtPath != wantURLs.Original {
t.Errorf("CoverArtPath = %q, want %q",
tr.CoverArtPath, wantURLs.Original)
}
if tr.CoverArtSmall != wantURLs.Small {
t.Errorf("CoverArtSmall = %q, want %q",
tr.CoverArtSmall, wantURLs.Small)
if got.RecordingMBID != "rec-mbid-1" {
t.Errorf("recording mbid = %q, want rec-mbid-1", got.RecordingMBID)
}
}
@@ -1710,38 +1608,24 @@ func TestEvaluate_YearUsesOriginalReleaseYear(t *testing.T) {
db := database.NewTestDB(t)
// One track: a 1977 album the user owns as a 2013 reissue. The file
// tag / recording year is 2013, but the release group's original
// (first-release) year is 1977.
exec := func(query string, args ...any) {
t.Helper()
// One track: a 1977 album the user owns as a 2013 reissue. The
// file's own year is 2013; the album's original-release year is
// 1977, and that is what a year filter means.
database.InsertTestTrack(t, db, database.TestTrack{
FilePath: "/music/b52s/rock_lobster.mp3",
Title: "Rock Lobster",
Artist: "The B-52's",
Album: "Reissue Compilation",
Year: 2013,
LengthMs: 300000,
})
if _, err := db.ExecContext(query, args...); err != nil {
t.Fatalf("exec %q: %v", query, err)
}
if _, err := db.ExecContext(
"UPDATE albums SET year = 2013, original_year = 1977",
); err != nil {
t.Fatalf("set album years: %v", err)
}
exec("INSERT INTO artist_credit (id, text) VALUES (1, ?)", "The B-52's")
exec(
"INSERT INTO release_groups (id, name, year, original_year) "+
"VALUES (1, ?, 2013, 1977)",
"Reissue Compilation",
)
exec(
"INSERT INTO recordings (id, name, artist_credit_id, year) "+
"VALUES (1, ?, 1, 2013)",
"Rock Lobster",
)
exec(
"INSERT INTO audio_files (id, file_path, length_milliseconds, "+
"file_type_id, recording_id) VALUES (1, ?, 300000, 1, 1)",
"/music/b52s/rock_lobster.mp3",
)
exec(
"INSERT INTO release_group_recordings " +
"(release_group_id, recording_id) VALUES (1, 1)",
)
// A "2010s" filter must NOT match — the album is originally from 1977.
tracks, err := Evaluate(db, RuleSet{
Rules: []Rule{