minstrel/internal/db/dbq/songs.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: songs.sql

package dbq

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const linkTracksAsSong = `-- name: LinkTracksAsSong :one

WITH keys AS (
    SELECT DISTINCT song_key FROM tracks WHERE id = ANY($1::uuid[])
), target AS (
    SELECT song_key FROM keys ORDER BY song_key LIMIT 1
), moved AS (
    UPDATE tracks t
       SET song_id = (SELECT song_key FROM target)
     WHERE t.song_key IN (SELECT song_key FROM keys)
       AND t.song_key <> (SELECT song_key FROM target)
    RETURNING t.id
)
SELECT (SELECT song_key FROM target)::uuid AS song_key,
       (SELECT count(*) FROM moved)::bigint AS moved
`

type LinkTracksAsSongRow struct {
	SongKey pgtype.UUID
	Moved   int64
}

// Song links: copies of one song on different releases share a
// song_key (migration 0076).
// Links the tracks into one song, joining any songs they already belong to.
// The song keeps the lowest key among them, so linking the same set again
// changes nothing. Returns that key and how many tracks moved to it.
func (q *Queries) LinkTracksAsSong(ctx context.Context, trackIds []pgtype.UUID) (LinkTracksAsSongRow, error) {
	row := q.db.QueryRow(ctx, linkTracksAsSong, trackIds)
	var i LinkTracksAsSongRow
	err := row.Scan(&i.SongKey, &i.Moved)
	return i, err
}

const listTrackSongKeys = `-- name: ListTrackSongKeys :many
SELECT id, song_key, (source_verdict IS NOT DISTINCT FROM 'suspect')::boolean AS held_back
  FROM tracks WHERE id = ANY($1::uuid[])
`

type ListTrackSongKeysRow struct {
	ID       pgtype.UUID
	SongKey  pgtype.UUID
	HeldBack bool
}

// What the mix writer needs to place a track: its song, and whether it is a
// video rip held back from the mixes.
func (q *Queries) ListTrackSongKeys(ctx context.Context, ids []pgtype.UUID) ([]ListTrackSongKeysRow, error) {
	rows, err := q.db.Query(ctx, listTrackSongKeys, ids)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListTrackSongKeysRow
	for rows.Next() {
		var i ListTrackSongKeysRow
		if err := rows.Scan(&i.ID, &i.SongKey, &i.HeldBack); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const mergeInheritSongLink = `-- name: MergeInheritSongLink :exec
UPDATE tracks s
   SET song_id = l.song_key
  FROM tracks l
 WHERE s.id = $1::uuid
   AND l.id = $2::uuid
   AND s.song_id IS NULL
   AND EXISTS (SELECT 1 FROM tracks o
                WHERE o.song_key = l.song_key AND o.id <> l.id AND o.id <> s.id)
`

type MergeInheritSongLinkParams struct {
	SurvivorID pgtype.UUID
	LoserID    pgtype.UUID
}

// A merge keeps the removed copy's song link: when the copy being removed was
// linked to copies on other releases and the survivor was not, the survivor
// joins that song. The copy whose id names the song has no song_id of its
// own, so "linked" is another copy sharing its key, not a song_id.
func (q *Queries) MergeInheritSongLink(ctx context.Context, arg MergeInheritSongLinkParams) error {
	_, err := q.db.Exec(ctx, mergeInheritSongLink, arg.SurvivorID, arg.LoserID)
	return err
}

const shareSongLikes = `-- name: ShareSongLikes :many
INSERT INTO general_likes (user_id, track_id, liked_at)
SELECT l.user_id, t.id, min(l.liked_at)
  FROM general_likes l
  JOIN tracks lt ON lt.id = l.track_id
  JOIN tracks t  ON t.song_key = lt.song_key
 WHERE lt.song_key = $1::uuid
 GROUP BY l.user_id, t.id
ON CONFLICT (user_id, track_id) DO NOTHING
RETURNING user_id, track_id
`

type ShareSongLikesRow struct {
	UserID  pgtype.UUID
	TrackID pgtype.UUID
}

// A like on any copy of the song becomes a like on every copy, dated the
// earliest. Returns the likes added, for the sync log.
func (q *Queries) ShareSongLikes(ctx context.Context, songKey pgtype.UUID) ([]ShareSongLikesRow, error) {
	rows, err := q.db.Query(ctx, shareSongLikes, songKey)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ShareSongLikesRow
	for rows.Next() {
		var i ShareSongLikesRow
		if err := rows.Scan(&i.UserID, &i.TrackID); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const unlinkDuplicateGroupSongs = `-- name: UnlinkDuplicateGroupSongs :exec
UPDATE tracks SET song_id = NULL
 WHERE song_id IS NOT NULL
   AND id IN (SELECT track_id FROM duplicate_group_members WHERE group_id = $1)
`

// "Not the same song": the group's copies stop sharing a song. Likes already
// shared stay where they are.
func (q *Queries) UnlinkDuplicateGroupSongs(ctx context.Context, groupID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, unlinkDuplicateGroupSongs, groupID)
	return err
}