fix(tracks): match ISRC ignoring dashes and case, add functional index (#832)

## Summary

ISRC lookup via `GET /v1/tracks?isrc=…` failed when the stored value and
the query disagreed on dash placement. Partner report (Thomas):

Fixed purely on the search/query side (no normalization at write time):

- Normalize the incoming `isrc` query param in Go: uppercase + strip
non-alphanumeric characters before passing to the DB.
- In the SQL, compare against `regexp_replace(upper(isrc), '[^A-Z0-9]',
'', 'g')` so the stored value is normalized at compare time.

Net result: any combination of dashes/spaces/casing in either the
request or the stored row matches. `US-ANG-21-03742`, `USANG2103742`,
`usang2103742`, and `US-ANG2103742` all resolve to the same row.

## Index

Added `tracks_isrc_normalized_idx`, a **partial functional index**
matching the comparison expression so the new query can index-scan
instead of seq-scanning all of `tracks`:

```sql
create index concurrently if not exists tracks_isrc_normalized_idx
    on public.tracks ((regexp_replace(upper(isrc), '[^A-Z0-9]'::text, ''::text, 'g')))
    where isrc is not null;
```

Verified planner picks it on a 50k-row scratch table:

```
Bitmap Heap Scan on scratch_tracks  (cost=16.43..248.18 rows=500 width=4)
  Recheck Cond: (regexp_replace(upper(isrc), '[^A-Z0-9]'::text, ''::text, 'g'::text) = ANY (...))
  ->  Bitmap Index Scan on scratch_tracks_isrc_norm_idx  (cost=0.00..16.30 rows=500 width=0)
        Index Cond: (regexp_replace(upper(isrc), '[^A-Z0-9]'::text, ''::text, 'g'::text) = ANY (...))
```

Index DDL uses `CREATE INDEX CONCURRENTLY` (no `BEGIN/COMMIT` wrapper)
so the build does not take an `ACCESS EXCLUSIVE` lock on `tracks`. `IF
NOT EXISTS` keeps the migration idempotent. Partial on `isrc IS NOT
NULL` since most rows have no ISRC.

Heads-up given #830: that PR moved `0201` away from `CONCURRENTLY`
because the legacy Python Celery task on `challenge_disbursements` was
keeping ~3-minute transactions open continuously, blocking the build's
`virtualxid` wait indefinitely. `tracks` is written by the Go indexer
and isn't subject to that long-transaction pattern, so `CONCURRENTLY`
should complete normally here. If a stuck build needs to be aborted,
drop the invalid index with `DROP INDEX IF EXISTS
tracks_isrc_normalized_idx;` and re-run.

## ISWC

There is no `iswc` query-param lookup today (column exists and is
exposed in API responses, but no handler or sqlc query reads it).
Nothing to mirror — left as-is.

## Test plan

- [x] `TestGetTracksByISRC` covers: stored-with-dashes queried undashed,
queried with same dashes, queried lowercased; stored-without-dashes
queried as-is and queried with inserted dashes.
- [x] Existing tracks tests (`TestTracksEndpoint`,
`TestGetTracksByPermalink`, `TestGetTracksExcludesAccessAuthorities`,
`Test200UnAuthed`) still pass.
- [x] Migration applies cleanly and is idempotent (re-running prints
`relation \"tracks_isrc_normalized_idx\" already exists, skipping`).
- [x] `EXPLAIN` on a seeded scratch table shows `Bitmap Index Scan on
tracks_isrc_normalized_idx`.
- [ ] After deploy: verify `SELECT indexrelid::regclass, indisvalid FROM
pg_index WHERE indexrelid::regclass::text =
'tracks_isrc_normalized_idx';` returns `indisvalid = true`.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: raymondjacobson

api/dbv1/get_track_ids_by_isrc.sql.go

@@ -1,5 +1,8 @@
 -- name: GetTrackIdsByISRC :many
+-- Match ISRC ignoring dashes/whitespace/case so a stored value like
+-- "US-ANG-21-03742" matches a query of "USANG2103742" and vice versa.
+-- Inputs in @isrcs must already be normalized (uppercased, non-alphanumerics stripped).
 SELECT track_id
 FROM tracks
-WHERE isrc = ANY(@isrcs::text[])
+WHERE regexp_replace(upper(isrc), '[^A-Z0-9]', '', 'g') = ANY(@isrcs::text[])
   AND access_authorities IS NULL;

api/dbv1/queries/get_track_ids_by_isrc.sql

@@ -1,13 +1,22 @@
 package api
 
 import (
+	"regexp"
 	"strings"
 
 	"api.audius.co/api/dbv1"
 	"api.audius.co/trashid"
 	"github.com/gofiber/fiber/v2"
 )
 
+// ISRCs may be stored with or without dashes (e.g. "US-ANG-21-03742" vs
+// "USANG2103742"); normalize so either form matches the same row.
+var isrcNonAlphanum = regexp.MustCompile(`[^A-Z0-9]`)
+
+func normalizeISRC(s string) string {
+	return isrcNonAlphanum.ReplaceAllString(strings.ToUpper(s), "")
+}
+
 func (app *ApiServer) v1Tracks(c *fiber.Ctx) error {
 	myId, _ := trashid.DecodeHashId(c.Query("user_id"))
 	ids := decodeIdList(c)
@@ -41,7 +50,11 @@ func (app *ApiServer) v1Tracks(c *fiber.Ctx) error {
 	// Add ISRC ID mappings
 	isrcs := queryMulti(c, "isrc")
 	if len(isrcs) > 0 {
-		newIds, err := app.queries.GetTrackIdsByISRC(c.Context(), isrcs)
+		normalized := make([]string, len(isrcs))
+		for i, isrc := range isrcs {
+			normalized[i] = normalizeISRC(isrc)
+		}
+		newIds, err := app.queries.GetTrackIdsByISRC(c.Context(), normalized)
 		if err != nil {
 			return err
 		}

api/v1_tracks.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"api.audius.co/api/dbv1"
+	"api.audius.co/trashid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -36,6 +37,47 @@ func TestGetTracksByPermalink(t *testing.T) {
 	})
 }
 
+func TestGetTracksByISRC(t *testing.T) {
+	app := testAppWithFixtures(t)
+	ctx := context.Background()
+	require.NotNil(t, app.writePool, "test requires write pool")
+
+	// Track 100 ("T1") stored with dashes; track 101 ("T2") stored without.
+	_, err := app.writePool.Exec(ctx,
+		`UPDATE tracks SET isrc = 'US-ANG-21-03742' WHERE track_id = 100 AND is_current = true`)
+	require.NoError(t, err)
+	_, err = app.writePool.Exec(ctx,
+		`UPDATE tracks SET isrc = 'QMEU31610080' WHERE track_id = 101 AND is_current = true`)
+	require.NoError(t, err)
+
+	track100Id := trashid.MustEncodeHashID(100)
+	track101Id := trashid.MustEncodeHashID(101)
+
+	cases := []struct {
+		name   string
+		query  string
+		wantId string
+	}{
+		{"stored-with-dashes, queried without", "USANG2103742", track100Id},
+		{"stored-with-dashes, queried with same dashes", "US-ANG-21-03742", track100Id},
+		{"stored-with-dashes, queried lowercased and undashed", "usang2103742", track100Id},
+		{"stored-without-dashes, queried as-is", "QMEU31610080", track101Id},
+		{"stored-without-dashes, queried with inserted dashes", "QM-EU3-16-10080", track101Id},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			var resp struct {
+				Data []dbv1.Track
+			}
+			status, body := testGet(t, app, "/v1/tracks?isrc="+tc.query, &resp)
+			require.Equal(t, 200, status, string(body))
+			require.Len(t, resp.Data, 1, "expected exactly one track for %q: %s", tc.query, string(body))
+			jsonAssert(t, body, map[string]any{"data.0.id": tc.wantId})
+		})
+	}
+}
+
 func TestGetTracksExcludesAccessAuthorities(t *testing.T) {
 	app := testAppWithFixtures(t)
 	ctx := context.Background()

api/v1_tracks_test.go

@@ -0,0 +1,20 @@
+-- Functional index supporting GetTrackIdsByISRC. The handler normalizes the
+-- incoming ?isrc= param (uppercase + strip non-alphanumerics) and the SQL
+-- compares against regexp_replace(upper(isrc), '[^A-Z0-9]', '', 'g'), so a
+-- plain btree on isrc cannot be used. This index materializes the same
+-- normalized expression, allowing dash/case-insensitive ISRC lookups to be
+-- index-scanned instead of seq-scanning ~all tracks. Partial on
+-- isrc IS NOT NULL since the vast majority of rows have no ISRC.
+--
+-- NOTE: intentionally NOT wrapped in BEGIN/COMMIT so CREATE INDEX
+-- CONCURRENTLY can run without taking an ACCESS EXCLUSIVE lock on tracks.
+-- IF NOT EXISTS makes the migration idempotent.
+
+create index concurrently if not exists tracks_isrc_normalized_idx
+    on public.tracks (
+        (regexp_replace(upper(isrc), '[^A-Z0-9]'::text, ''::text, 'g'))
+    )
+    where isrc is not null;
+
+comment on index public.tracks_isrc_normalized_idx is
+    'Functional index supporting GetTrackIdsByISRC; matches regexp_replace(upper(isrc), ''[^A-Z0-9]'', '''', ''g'') so dash/case-insensitive ?isrc= lookups hit the index.';