fix: distinguish a title collision from an attribution miss, and index for it

Two faults in the split added last change, both visible in the first real run.

It reported 700 pairs as attribution disagreements on the strength of the
library holding the same title under a different artist. The examples show what
that actually caught: "Everyday" matched Def Leppard, "Kaleidoscope" matched
Chappell Roan, "Fight for Your Right" matched Motley Crue. Different songs that
happen to share a name. Across fifty thousand tracks that is not an edge case,
it is the common case, and presenting it as a matcher failure argues for exactly
the title-only matching tier that would produce this rubbish on purpose.

The signal for a real attribution miss is narrower: the library's own title
credits the artist the play is filed under, as in "Voodoo People (Pendulum
Remix)" against a scrobble credited to Pendulum. The normalised title has that
suffix stripped -- which is what let the two meet in the first place -- so the
raw title is searched for the name. Collisions are now counted and named
separately, as what they are.

The same query also took forty-seven seconds. lidarr_track was indexed on
(norm_artist, norm_title), which a lookup by title alone cannot use because its
leading column is the artist, so every unmatched key scanned all eighty-four
thousand tracks. Add the index on the title by itself; the query plan changes
from an automatic partial index to a covering one.

music_curator.py

@@ -141,6 +141,11 @@ CREATE TABLE IF NOT EXISTS lidarr_track (
 );
 CREATE INDEX IF NOT EXISTS lidarr_track_recording ON lidarr_track (recording_mbid);
 CREATE INDEX IF NOT EXISTS lidarr_track_norm ON lidarr_track (norm_artist, norm_title);
+-- Separate from the composite above, which a lookup by title alone cannot use:
+-- its leading column is the artist. The report searches by title on its own, and
+-- without this it scans every track for every unmatched key -- forty-seven
+-- seconds on a library of eighty-four thousand.
+CREATE INDEX IF NOT EXISTS lidarr_track_title ON lidarr_track (norm_title);
 CREATE INDEX IF NOT EXISTS lidarr_track_album ON lidarr_track (album_id);
 
 -- One row per distinct thing listened to, with the verdict on whether it could
@@ -1125,47 +1130,68 @@ def coverage_report(store):
     )
 
     # Owning an artist is a weak proxy for owning a track, so that figure alone
-    # overstates the matcher's failings. Split it. A title the library holds
-    # under some other artist is an attribution disagreement -- a remixer
-    # credited as the artist, a guest billed as one -- and is a real miss. A
-    # title the library does not hold at all was simply never bought, and no
-    # amount of matching will conjure it.
+    # overstates the matcher's failings. Split it -- but not on the title alone.
+    # Across fifty thousand tracks, titles collide constantly: "Everyday" is
+    # Rusko and also Def Leppard, "Kaleidoscope" is Delta Heavy and also
+    # Chappell Roan. Matching those would be worse than missing them.
+    #
+    # The signal for a genuine attribution miss is that the library's own title
+    # credits the artist the scrobble is filed under -- "Voodoo People (Pendulum
+    # Remix)" against a play credited to Pendulum. The normalised title has that
+    # suffix stripped, which is exactly what let them meet, so the raw one has to
+    # be searched for the name.
     attribution = store.connection.execute(
+        "SELECT COUNT(*) AS pairs, COALESCE(SUM(plays), 0) AS plays FROM scrobble_key k"
+        " WHERE k.track_id IS NULL"
+        "   AND EXISTS (SELECT 1 FROM lidarr_artist a WHERE a.norm_name = k.norm_artist)"
+        "   AND EXISTS (SELECT 1 FROM lidarr_track t"
+        "                WHERE t.norm_title = k.norm_track"
+        "                  AND instr(lower(t.title), lower(k.artist)) > 0)"
+    ).fetchone()
+    collision = store.connection.execute(
         "SELECT COUNT(*) AS pairs, COALESCE(SUM(plays), 0) AS plays FROM scrobble_key k"
         " WHERE k.track_id IS NULL"
         "   AND EXISTS (SELECT 1 FROM lidarr_artist a WHERE a.norm_name = k.norm_artist)"
         "   AND EXISTS (SELECT 1 FROM lidarr_track t WHERE t.norm_title = k.norm_track)"
     ).fetchone()
     logger.info(
-        "  of those, the title exists under another artist: %d pairs, %d plays"
-        " -- attribution disagreements, and the genuine misses",
+        "  the library's title credits the scrobbled artist: %d pairs, %d plays"
+        " -- remixes and guest spots, and the genuine misses",
         attribution["pairs"],
         attribution["plays"],
     )
+    logger.info(
+        "  same title under an unrelated artist: %d pairs, %d plays"
+        " -- title collisions, not misses; matching these would be a mistake",
+        collision["pairs"] - attribution["pairs"],
+        collision["plays"] - attribution["plays"],
+    )
     logger.info(
         "  the rest, %d pairs, %d plays: you own the artist but not the track",
-        suspect["pairs"] - attribution["pairs"],
-        suspect["plays"] - attribution["plays"],
+        suspect["pairs"] - collision["pairs"],
+        suspect["plays"] - collision["plays"],
     )
 
     mismatched = store.connection.execute(
         "SELECT k.artist, k.track, k.plays,"
-        "       (SELECT a.name FROM lidarr_track t"
-        "          JOIN lidarr_artist a ON a.id = t.artist_id"
-        "         WHERE t.norm_title = k.norm_track LIMIT 1) AS filed_under"
+        "       (SELECT t.title FROM lidarr_track t"
+        "         WHERE t.norm_title = k.norm_track"
+        "           AND instr(lower(t.title), lower(k.artist)) > 0 LIMIT 1) AS library_title"
         "  FROM scrobble_key k"
         " WHERE k.track_id IS NULL"
         "   AND EXISTS (SELECT 1 FROM lidarr_artist a WHERE a.norm_name = k.norm_artist)"
-        "   AND EXISTS (SELECT 1 FROM lidarr_track t WHERE t.norm_title = k.norm_track)"
+        "   AND EXISTS (SELECT 1 FROM lidarr_track t"
+        "                WHERE t.norm_title = k.norm_track"
+        "                  AND instr(lower(t.title), lower(k.artist)) > 0)"
         " ORDER BY k.plays DESC, k.artist LIMIT 10"
     ).fetchall()
     for position, row in enumerate(mismatched, start=1):
         logger.info(
-            "  attribution %2d: %-45s %4d plays, filed under %s",
+            "  attribution %2d: %-45s %4d plays, library has %r",
             position,
             f"{row['artist']} - {row['track']}"[:45],
             row["plays"],
-            row["filed_under"],
+            row["library_title"],
         )
 
     with_files = store.scalar("SELECT COUNT(*) FROM lidarr_track WHERE has_file = 1")