Subsonic: browsing endpoints (getMusicFolders, getIndexes, getMusicDirectory, getGenres, getArtists/Artist, getAlbum, getSong, getVideos/VideoInfo, getArtistInfo/2, getAlbumInfo/2, getSimilarSongs/2, getTopSongs)

2026-08-23 00:06:08 -05:00
parent b5e2bf01e2
commit f40a011c46
9 changed files with 1732 additions and 4 deletions
@@ -0,0 +1,241 @@
+package database
+
+import "database/sql"
+
+// This file collects small aggregate/lookup queries specific to shaping
+// data for the Subsonic REST API (internal/subsonic), which needs
+// things like song counts and "primary genre" that the native web UI
+// does not.
+
+// AlbumStats returns an album's song count and total duration in
+// seconds.
+func AlbumStats(db *sql.DB, albumID string) (songCount int, totalDuration float64, err error) {
+	err = db.QueryRow(`SELECT COUNT(*), COALESCE(SUM(mf.duration_seconds), 0)
+		FROM songs s JOIN media_files mf ON mf.id = s.media_file_id
+		WHERE s.album_id = ?`, albumID).Scan(&songCount, &totalDuration)
+	return
+}
+
+// ArtistAlbumCount returns how many albums an artist is credited on.
+func ArtistAlbumCount(db *sql.DB, artistID string) (int, error) {
+	var n int
+	err := db.QueryRow(`SELECT COUNT(*) FROM album_artists WHERE artist_id = ?`, artistID).Scan(&n)
+	return n, err
+}
+
+// ArtistCoverArtID returns the cover_art id of any one album by the
+// artist that has cover art, or "" if none do.
+func ArtistCoverArtID(db *sql.DB, artistID string) (string, error) {
+	var id string
+	err := db.QueryRow(`SELECT al.cover_art_id FROM albums al
+		JOIN album_artists aa ON aa.album_id = al.id
+		WHERE aa.artist_id = ? AND al.cover_art_id IS NOT NULL LIMIT 1`, artistID).Scan(&id)
+	if err == sql.ErrNoRows {
+		return "", nil
+	}
+	return id, err
+}
+
+// FirstGenreForSong returns one genre name for a song, or "" if it has
+// none.
+func FirstGenreForSong(db *sql.DB, songID string) (string, error) {
+	var name string
+	err := db.QueryRow(`SELECT g.name FROM song_genres sg JOIN genres g ON g.id = sg.genre_id
+		WHERE sg.song_id = ? ORDER BY g.name LIMIT 1`, songID).Scan(&name)
+	if err == sql.ErrNoRows {
+		return "", nil
+	}
+	return name, err
+}
+
+// FirstGenreForAlbum returns one genre name for an album, or "" if it
+// has none directly tagged (callers typically fall back to a song's
+// genre).
+func FirstGenreForAlbum(db *sql.DB, albumID string) (string, error) {
+	var name string
+	err := db.QueryRow(`SELECT g.name FROM album_genres ag JOIN genres g ON g.id = ag.genre_id
+		WHERE ag.album_id = ? ORDER BY g.name LIMIT 1`, albumID).Scan(&name)
+	if err == sql.ErrNoRows {
+		return "", nil
+	}
+	return name, err
+}
+
+// AlbumArtistName returns the display name for an album: its primary
+// album artist if set, otherwise "" (a "Various Artists"-style album
+// with no single primary artist).
+func AlbumArtistName(db *sql.DB, album *Album) (string, error) {
+	if !album.PrimaryAlbumArtistID.Valid {
+		return "", nil
+	}
+	artist, err := GetArtist(db, album.PrimaryAlbumArtistID.String)
+	if err != nil {
+		if err == ErrNotFound {
+			return "", nil
+		}
+		return "", err
+	}
+	return artist.Name, nil
+}
+
+// GenreStats aggregates per-genre song and album counts for
+// getGenres.
+type GenreStat struct {
+	Name       string
+	SongCount  int
+	AlbumCount int
+}
+
+func ListGenreStats(db *sql.DB) ([]GenreStat, error) {
+	rows, err := db.Query(`SELECT g.name,
+		(SELECT COUNT(*) FROM song_genres sg WHERE sg.genre_id = g.id) AS song_count,
+		(SELECT COUNT(*) FROM album_genres ag WHERE ag.genre_id = g.id) AS album_count
+		FROM genres g ORDER BY g.name COLLATE NOCASE`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []GenreStat
+	for rows.Next() {
+		var g GenreStat
+		if err := rows.Scan(&g.Name, &g.SongCount, &g.AlbumCount); err != nil {
+			return nil, err
+		}
+		out = append(out, g)
+	}
+	return out, rows.Err()
+}
+
+// SongsByGenre returns up to limit songs tagged with the given genre
+// name, offset for pagination.
+func SongsByGenre(db *sql.DB, genreName string, limit, offset int) ([]*Song, error) {
+	rows, err := db.Query(`SELECT s.id, s.media_file_id, s.album_id, s.title, s.sort_title, s.track_number, s.track_total, s.disc_number, s.disc_total,
+		s.composer, s.conductor, s.isrc, s.bpm, s.musicbrainz_track_id, s.musicbrainz_recording_id,
+		s.replaygain_track_gain_db, s.replaygain_track_peak, s.replaygain_album_gain_db, s.replaygain_album_peak
+		FROM songs s
+		JOIN song_genres sg ON sg.song_id = s.id
+		JOIN genres g ON g.id = sg.genre_id
+		WHERE g.name = ? ORDER BY s.id LIMIT ? OFFSET ?`, genreName, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	return scanSongs(rows)
+}
+
+// RandomSongIDs returns up to limit random song IDs, optionally
+// restricted to a genre and/or year range.
+func RandomSongIDs(db *sql.DB, limit int, genre string, fromYear, toYear int) ([]string, error) {
+	query := `SELECT DISTINCT s.id FROM songs s`
+	var args []any
+	var where []string
+	if genre != "" {
+		query += ` JOIN song_genres sg ON sg.song_id = s.id JOIN genres g ON g.id = sg.genre_id`
+		where = append(where, `g.name = ?`)
+		args = append(args, genre)
+	}
+	if fromYear != 0 || toYear != 0 {
+		query += ` JOIN albums al ON al.id = s.album_id`
+		if fromYear != 0 {
+			where = append(where, `al.year >= ?`)
+			args = append(args, fromYear)
+		}
+		if toYear != 0 {
+			where = append(where, `al.year <= ?`)
+			args = append(args, toYear)
+		}
+	}
+	if len(where) > 0 {
+		query += ` WHERE `
+		for i, w := range where {
+			if i > 0 {
+				query += ` AND `
+			}
+			query += w
+		}
+	}
+	query += ` ORDER BY RANDOM() LIMIT ?`
+	args = append(args, limit)
+
+	rows, err := db.Query(query, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []string
+	for rows.Next() {
+		var id string
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		out = append(out, id)
+	}
+	return out, rows.Err()
+}
+
+// AlbumsByYearRange lists albums sorted by year for getAlbumList's
+// byYear type.
+func AlbumsByYearRange(db *sql.DB, fromYear, toYear, limit, offset int) ([]*Album, error) {
+	order := "ASC"
+	from, to := fromYear, toYear
+	if from > to {
+		from, to = to, from
+		order = "DESC"
+	}
+	rows, err := db.Query(albumSelect+` WHERE year >= ? AND year <= ? ORDER BY year `+order+`, sort_title LIMIT ? OFFSET ?`,
+		from, to, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	return scanAlbums(rows)
+}
+
+// AlbumsByGenre lists albums tagged with the given genre.
+func AlbumsByGenre(db *sql.DB, genre string, limit, offset int) ([]*Album, error) {
+	rows, err := db.Query(`SELECT DISTINCT al.id, al.title, al.sort_title, al.year, al.original_year, al.record_label, al.musicbrainz_id, al.primary_album_artist_id, al.cover_art_id, al.created_at
+		FROM albums al JOIN album_genres ag ON ag.album_id = al.id JOIN genres g ON g.id = ag.genre_id
+		WHERE g.name = ? ORDER BY al.sort_title COLLATE NOCASE LIMIT ? OFFSET ?`, genre, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	return scanAlbums(rows)
+}
+
+// RandomAlbums returns up to limit random albums.
+func RandomAlbums(db *sql.DB, limit int) ([]*Album, error) {
+	rows, err := db.Query(albumSelect+` ORDER BY RANDOM() LIMIT ?`, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	return scanAlbums(rows)
+}
+
+// RecentlyAddedAlbums lists albums by creation order (newest first).
+func RecentlyAddedAlbums(db *sql.DB, limit, offset int) ([]*Album, error) {
+	rows, err := db.Query(albumSelect+` ORDER BY created_at DESC LIMIT ? OFFSET ?`, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	return scanAlbums(rows)
+}
+
+// AlbumsAlphabetical lists albums by title or artist name.
+func AlbumsAlphabetical(db *sql.DB, byArtist bool, limit, offset int) ([]*Album, error) {
+	order := "al.sort_title COLLATE NOCASE"
+	join := ""
+	if byArtist {
+		join = "LEFT JOIN artists ar ON ar.id = al.primary_album_artist_id"
+		order = "COALESCE(ar.sort_name, ar.name, al.sort_title) COLLATE NOCASE, al.sort_title COLLATE NOCASE"
+	}
+	rows, err := db.Query(`SELECT al.id, al.title, al.sort_title, al.year, al.original_year, al.record_label, al.musicbrainz_id, al.primary_album_artist_id, al.cover_art_id, al.created_at
+		FROM albums al `+join+` ORDER BY `+order+` LIMIT ? OFFSET ?`, limit, offset)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	return scanAlbums(rows)
+}