bvandeusen
c7adf2c87a
The fallback pulled artists only from explicit artist-likes (general_likes_artists),
but most users like albums and tracks far more than artists — so the artists row
still came up thin (a couple of tiles) even with a rich library, while the albums
row filled fine.
Broaden both fallbacks to "entities you've shown affinity for":
- artist fallback = explicit artist-likes ∪ artists of liked albums ∪ artists of
liked tracks.
- album fallback = explicit album-likes ∪ albums of liked tracks.
New dedicated queries (ListYouMightLike{Artist,Album}FallbackForUser) replace the
narrow Rediscover-fallback reuse; same projection so the Go layer still converts
directly. (Aliased + fully-qualified the UNION arms — sqlc merges UNION scopes,
so unqualified user_id was ambiguous across the three like tables.)
Test: 12 liked TRACKS by distinct artists, no artist-likes → the artist row now
fills from their artists (was empty before).
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
366 lines
12 KiB
Go
366 lines
12 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: you_might_like.sql
|
|
|
|
package dbq
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const countListeningSignalForUser = `-- name: CountListeningSignalForUser :one
|
|
|
|
SELECT
|
|
count(DISTINCT pe.track_id)::bigint AS distinct_tracks,
|
|
count(DISTINCT t.artist_id)::bigint AS distinct_artists
|
|
FROM play_events pe
|
|
JOIN tracks t ON t.id = pe.track_id
|
|
WHERE pe.user_id = $1 AND pe.was_skipped = false
|
|
`
|
|
|
|
type CountListeningSignalForUserRow struct {
|
|
DistinctTracks int64
|
|
DistinctArtists int64
|
|
}
|
|
|
|
// "You might like" Home rows (#790). The daily build computes ranked
|
|
// album/artist IDs in Go (similarity roll-up + cold-start gate) and
|
|
// atomic-replaces them here; /api/home reads them back hydrated.
|
|
// Cold-start gate. Returns the breadth of the user's real listening:
|
|
// distinct unskipped tracks played and distinct artists played. The
|
|
// build skips You-might-like entirely below a threshold (a thin history
|
|
// yields near-random roll-ups). was_skipped=false so a user spamming
|
|
// next can't inflate the signal.
|
|
func (q *Queries) CountListeningSignalForUser(ctx context.Context, userID pgtype.UUID) (CountListeningSignalForUserRow, error) {
|
|
row := q.db.QueryRow(ctx, countListeningSignalForUser, userID)
|
|
var i CountListeningSignalForUserRow
|
|
err := row.Scan(&i.DistinctTracks, &i.DistinctArtists)
|
|
return i, err
|
|
}
|
|
|
|
const deleteYouMightLikeAlbumsForUser = `-- name: DeleteYouMightLikeAlbumsForUser :exec
|
|
DELETE FROM you_might_like_albums WHERE user_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteYouMightLikeAlbumsForUser(ctx context.Context, userID pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteYouMightLikeAlbumsForUser, userID)
|
|
return err
|
|
}
|
|
|
|
const deleteYouMightLikeArtistsForUser = `-- name: DeleteYouMightLikeArtistsForUser :exec
|
|
DELETE FROM you_might_like_artists WHERE user_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteYouMightLikeArtistsForUser(ctx context.Context, userID pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteYouMightLikeArtistsForUser, userID)
|
|
return err
|
|
}
|
|
|
|
const insertYouMightLikeAlbum = `-- name: InsertYouMightLikeAlbum :exec
|
|
INSERT INTO you_might_like_albums (user_id, album_id, rank)
|
|
VALUES ($1, $2, $3)
|
|
`
|
|
|
|
type InsertYouMightLikeAlbumParams struct {
|
|
UserID pgtype.UUID
|
|
AlbumID pgtype.UUID
|
|
Rank int32
|
|
}
|
|
|
|
func (q *Queries) InsertYouMightLikeAlbum(ctx context.Context, arg InsertYouMightLikeAlbumParams) error {
|
|
_, err := q.db.Exec(ctx, insertYouMightLikeAlbum, arg.UserID, arg.AlbumID, arg.Rank)
|
|
return err
|
|
}
|
|
|
|
const insertYouMightLikeArtist = `-- name: InsertYouMightLikeArtist :exec
|
|
INSERT INTO you_might_like_artists (user_id, artist_id, rank)
|
|
VALUES ($1, $2, $3)
|
|
`
|
|
|
|
type InsertYouMightLikeArtistParams struct {
|
|
UserID pgtype.UUID
|
|
ArtistID pgtype.UUID
|
|
Rank int32
|
|
}
|
|
|
|
func (q *Queries) InsertYouMightLikeArtist(ctx context.Context, arg InsertYouMightLikeArtistParams) error {
|
|
_, err := q.db.Exec(ctx, insertYouMightLikeArtist, arg.UserID, arg.ArtistID, arg.Rank)
|
|
return err
|
|
}
|
|
|
|
const listYouMightLikeAlbumFallbackForUser = `-- name: ListYouMightLikeAlbumFallbackForUser :many
|
|
WITH liked_album_ids AS (
|
|
SELECT likb.album_id AS album_id
|
|
FROM general_likes_albums likb
|
|
WHERE likb.user_id = $1
|
|
UNION
|
|
SELECT trk.album_id AS album_id
|
|
FROM general_likes likt
|
|
JOIN tracks trk ON trk.id = likt.track_id
|
|
WHERE likt.user_id = $1
|
|
)
|
|
SELECT albums.id, albums.title, albums.sort_title, albums.artist_id, albums.release_date, albums.mbid, albums.cover_art_path, albums.created_at, albums.updated_at, albums.cover_art_source, albums.cover_art_sources_version, artists.name AS artist_name
|
|
FROM liked_album_ids lai
|
|
JOIN albums ON albums.id = lai.album_id
|
|
JOIN artists ON artists.id = albums.artist_id
|
|
ORDER BY md5(albums.id::text || current_date::text)
|
|
LIMIT $2
|
|
`
|
|
|
|
type ListYouMightLikeAlbumFallbackForUserParams struct {
|
|
UserID pgtype.UUID
|
|
Limit int32
|
|
}
|
|
|
|
type ListYouMightLikeAlbumFallbackForUserRow struct {
|
|
Album Album
|
|
ArtistName string
|
|
}
|
|
|
|
// Broad "albums you've shown affinity for" pool: explicitly liked albums PLUS
|
|
// the albums of liked tracks. Same projection as ListYouMightLikeAlbumsForUser.
|
|
func (q *Queries) ListYouMightLikeAlbumFallbackForUser(ctx context.Context, arg ListYouMightLikeAlbumFallbackForUserParams) ([]ListYouMightLikeAlbumFallbackForUserRow, error) {
|
|
rows, err := q.db.Query(ctx, listYouMightLikeAlbumFallbackForUser, arg.UserID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListYouMightLikeAlbumFallbackForUserRow
|
|
for rows.Next() {
|
|
var i ListYouMightLikeAlbumFallbackForUserRow
|
|
if err := rows.Scan(
|
|
&i.Album.ID,
|
|
&i.Album.Title,
|
|
&i.Album.SortTitle,
|
|
&i.Album.ArtistID,
|
|
&i.Album.ReleaseDate,
|
|
&i.Album.Mbid,
|
|
&i.Album.CoverArtPath,
|
|
&i.Album.CreatedAt,
|
|
&i.Album.UpdatedAt,
|
|
&i.Album.CoverArtSource,
|
|
&i.Album.CoverArtSourcesVersion,
|
|
&i.ArtistName,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listYouMightLikeAlbumsForUser = `-- name: ListYouMightLikeAlbumsForUser :many
|
|
SELECT albums.id, albums.title, albums.sort_title, albums.artist_id, albums.release_date, albums.mbid, albums.cover_art_path, albums.created_at, albums.updated_at, albums.cover_art_source, albums.cover_art_sources_version, artists.name AS artist_name
|
|
FROM you_might_like_albums yml
|
|
JOIN albums ON albums.id = yml.album_id
|
|
JOIN artists ON artists.id = albums.artist_id
|
|
WHERE yml.user_id = $1
|
|
ORDER BY yml.rank
|
|
LIMIT $2
|
|
`
|
|
|
|
type ListYouMightLikeAlbumsForUserParams struct {
|
|
UserID pgtype.UUID
|
|
Limit int32
|
|
}
|
|
|
|
type ListYouMightLikeAlbumsForUserRow struct {
|
|
Album Album
|
|
ArtistName string
|
|
}
|
|
|
|
// Read path. Same projection as ListRediscoverAlbumsForUser so the API
|
|
// layer reuses albumRefFrom(row.Album, row.ArtistName, …). Ordered by
|
|
// the rank persisted at build time. Final cross-section dedup (vs Most
|
|
// Played / Rediscover) and the output cap land in the Go layer
|
|
// (internal/recommendation/home.go).
|
|
func (q *Queries) ListYouMightLikeAlbumsForUser(ctx context.Context, arg ListYouMightLikeAlbumsForUserParams) ([]ListYouMightLikeAlbumsForUserRow, error) {
|
|
rows, err := q.db.Query(ctx, listYouMightLikeAlbumsForUser, arg.UserID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListYouMightLikeAlbumsForUserRow
|
|
for rows.Next() {
|
|
var i ListYouMightLikeAlbumsForUserRow
|
|
if err := rows.Scan(
|
|
&i.Album.ID,
|
|
&i.Album.Title,
|
|
&i.Album.SortTitle,
|
|
&i.Album.ArtistID,
|
|
&i.Album.ReleaseDate,
|
|
&i.Album.Mbid,
|
|
&i.Album.CoverArtPath,
|
|
&i.Album.CreatedAt,
|
|
&i.Album.UpdatedAt,
|
|
&i.Album.CoverArtSource,
|
|
&i.Album.CoverArtSourcesVersion,
|
|
&i.ArtistName,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listYouMightLikeArtistFallbackForUser = `-- name: ListYouMightLikeArtistFallbackForUser :many
|
|
WITH liked_artist_ids AS (
|
|
SELECT lika.artist_id AS artist_id
|
|
FROM general_likes_artists lika
|
|
WHERE lika.user_id = $1
|
|
UNION
|
|
SELECT alb.artist_id AS artist_id
|
|
FROM general_likes_albums likb
|
|
JOIN albums alb ON alb.id = likb.album_id
|
|
WHERE likb.user_id = $1
|
|
UNION
|
|
SELECT trk.artist_id AS artist_id
|
|
FROM general_likes likt
|
|
JOIN tracks trk ON trk.id = likt.track_id
|
|
WHERE likt.user_id = $1
|
|
)
|
|
SELECT artists.id, artists.name, artists.sort_name, artists.mbid, artists.created_at, artists.updated_at, artists.artist_thumb_path, artists.artist_fanart_path, artists.artist_art_source, artists.artist_art_sources_version,
|
|
cov.id AS cover_album_id,
|
|
cnt.album_count::bigint AS album_count
|
|
FROM liked_artist_ids lai
|
|
JOIN artists ON artists.id = lai.artist_id
|
|
LEFT JOIN LATERAL (
|
|
SELECT id FROM albums
|
|
WHERE artist_id = artists.id AND cover_art_path IS NOT NULL
|
|
ORDER BY created_at DESC LIMIT 1
|
|
) cov ON true
|
|
LEFT JOIN LATERAL (
|
|
SELECT count(*) AS album_count
|
|
FROM albums WHERE artist_id = artists.id
|
|
) cnt ON true
|
|
ORDER BY md5(artists.id::text || current_date::text)
|
|
LIMIT $2
|
|
`
|
|
|
|
type ListYouMightLikeArtistFallbackForUserParams struct {
|
|
UserID pgtype.UUID
|
|
Limit int32
|
|
}
|
|
|
|
type ListYouMightLikeArtistFallbackForUserRow struct {
|
|
Artist Artist
|
|
CoverAlbumID pgtype.UUID
|
|
AlbumCount int64
|
|
}
|
|
|
|
// Broad "artists you've shown affinity for" pool to fill a thin
|
|
// You-might-like artists row: explicitly liked artists PLUS the artists of
|
|
// liked albums and liked tracks. Most users like albums/tracks far more than
|
|
// they like artists explicitly, so the union is much deeper than
|
|
// general_likes_artists alone. Daily-stable order; same projection as
|
|
// ListYouMightLikeArtistsForUser so the Go layer reuses it directly.
|
|
func (q *Queries) ListYouMightLikeArtistFallbackForUser(ctx context.Context, arg ListYouMightLikeArtistFallbackForUserParams) ([]ListYouMightLikeArtistFallbackForUserRow, error) {
|
|
rows, err := q.db.Query(ctx, listYouMightLikeArtistFallbackForUser, arg.UserID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListYouMightLikeArtistFallbackForUserRow
|
|
for rows.Next() {
|
|
var i ListYouMightLikeArtistFallbackForUserRow
|
|
if err := rows.Scan(
|
|
&i.Artist.ID,
|
|
&i.Artist.Name,
|
|
&i.Artist.SortName,
|
|
&i.Artist.Mbid,
|
|
&i.Artist.CreatedAt,
|
|
&i.Artist.UpdatedAt,
|
|
&i.Artist.ArtistThumbPath,
|
|
&i.Artist.ArtistFanartPath,
|
|
&i.Artist.ArtistArtSource,
|
|
&i.Artist.ArtistArtSourcesVersion,
|
|
&i.CoverAlbumID,
|
|
&i.AlbumCount,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listYouMightLikeArtistsForUser = `-- name: ListYouMightLikeArtistsForUser :many
|
|
SELECT artists.id, artists.name, artists.sort_name, artists.mbid, artists.created_at, artists.updated_at, artists.artist_thumb_path, artists.artist_fanart_path, artists.artist_art_source, artists.artist_art_sources_version,
|
|
cov.id AS cover_album_id,
|
|
cnt.album_count::bigint AS album_count
|
|
FROM you_might_like_artists yml
|
|
JOIN artists ON artists.id = yml.artist_id
|
|
LEFT JOIN LATERAL (
|
|
SELECT id FROM albums
|
|
WHERE artist_id = artists.id AND cover_art_path IS NOT NULL
|
|
ORDER BY created_at DESC LIMIT 1
|
|
) cov ON true
|
|
LEFT JOIN LATERAL (
|
|
SELECT count(*) AS album_count
|
|
FROM albums WHERE artist_id = artists.id
|
|
) cnt ON true
|
|
WHERE yml.user_id = $1
|
|
ORDER BY yml.rank
|
|
LIMIT $2
|
|
`
|
|
|
|
type ListYouMightLikeArtistsForUserParams struct {
|
|
UserID pgtype.UUID
|
|
Limit int32
|
|
}
|
|
|
|
type ListYouMightLikeArtistsForUserRow struct {
|
|
Artist Artist
|
|
CoverAlbumID pgtype.UUID
|
|
AlbumCount int64
|
|
}
|
|
|
|
// Read path. Same projection as ListRediscoverArtistsForUser (embeds the
|
|
// artist + a representative cover_album_id + album_count) so the API
|
|
// layer reuses artistRefFromCovered. Ordered by persisted rank.
|
|
func (q *Queries) ListYouMightLikeArtistsForUser(ctx context.Context, arg ListYouMightLikeArtistsForUserParams) ([]ListYouMightLikeArtistsForUserRow, error) {
|
|
rows, err := q.db.Query(ctx, listYouMightLikeArtistsForUser, arg.UserID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListYouMightLikeArtistsForUserRow
|
|
for rows.Next() {
|
|
var i ListYouMightLikeArtistsForUserRow
|
|
if err := rows.Scan(
|
|
&i.Artist.ID,
|
|
&i.Artist.Name,
|
|
&i.Artist.SortName,
|
|
&i.Artist.Mbid,
|
|
&i.Artist.CreatedAt,
|
|
&i.Artist.UpdatedAt,
|
|
&i.Artist.ArtistThumbPath,
|
|
&i.Artist.ArtistFanartPath,
|
|
&i.Artist.ArtistArtSource,
|
|
&i.Artist.ArtistArtSourcesVersion,
|
|
&i.CoverAlbumID,
|
|
&i.AlbumCount,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|