yellowjacket/backend/database/sql/sqlcgen/release_groups.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: release_groups.sql

package sqlcgen

import (
	"context"
	"database/sql"
)

const countReleaseGroupRecordings = `-- name: CountReleaseGroupRecordings :one
SELECT COUNT(*) FROM release_group_recordings WHERE release_group_id = ?
`

func (q *Queries) CountReleaseGroupRecordings(ctx context.Context, releaseGroupID int64) (int64, error) {
	row := q.db.QueryRowContext(ctx, countReleaseGroupRecordings, releaseGroupID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const createReleaseGroup = `-- name: CreateReleaseGroup :one
INSERT INTO release_groups (name) VALUES (?)
RETURNING id, name, cover_art_id, album_artist_credit_id, year, total_tracks, total_discs, mbid, original_year, pending_release_mbid
`

func (q *Queries) CreateReleaseGroup(ctx context.Context, name string) (ReleaseGroup, error) {
	row := q.db.QueryRowContext(ctx, createReleaseGroup, name)
	var i ReleaseGroup
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CoverArtID,
		&i.AlbumArtistCreditID,
		&i.Year,
		&i.TotalTracks,
		&i.TotalDiscs,
		&i.Mbid,
		&i.OriginalYear,
		&i.PendingReleaseMbid,
	)
	return i, err
}

const createReleaseGroupFull = `-- name: CreateReleaseGroupFull :one
INSERT INTO release_groups (
  name, cover_art_id, album_artist_credit_id, year, total_tracks, total_discs
) VALUES (?, ?, ?, ?, ?, ?)
RETURNING id, name, cover_art_id, album_artist_credit_id, year, total_tracks, total_discs, mbid, original_year, pending_release_mbid
`

type CreateReleaseGroupFullParams struct {
	Name                string
	CoverArtID          sql.NullInt64
	AlbumArtistCreditID sql.NullInt64
	Year                sql.NullInt64
	TotalTracks         sql.NullInt64
	TotalDiscs          sql.NullInt64
}

func (q *Queries) CreateReleaseGroupFull(ctx context.Context, arg CreateReleaseGroupFullParams) (ReleaseGroup, error) {
	row := q.db.QueryRowContext(ctx, createReleaseGroupFull,
		arg.Name,
		arg.CoverArtID,
		arg.AlbumArtistCreditID,
		arg.Year,
		arg.TotalTracks,
		arg.TotalDiscs,
	)
	var i ReleaseGroup
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CoverArtID,
		&i.AlbumArtistCreditID,
		&i.Year,
		&i.TotalTracks,
		&i.TotalDiscs,
		&i.Mbid,
		&i.OriginalYear,
		&i.PendingReleaseMbid,
	)
	return i, err
}

const deleteAllReleaseGroups = `-- name: DeleteAllReleaseGroups :exec
DELETE FROM release_groups
`

func (q *Queries) DeleteAllReleaseGroups(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, deleteAllReleaseGroups)
	return err
}

const deleteReleaseGroup = `-- name: DeleteReleaseGroup :exec
DELETE FROM release_groups 
WHERE id = ?
`

func (q *Queries) DeleteReleaseGroup(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deleteReleaseGroup, id)
	return err
}

const getAlbumsByArtist = `-- name: GetAlbumsByArtist :many
SELECT
    rg.id,
    rg.name,
    COALESCE(rg.original_year, rg.year) AS year,
    COALESCE(rg.year, 0) AS release_year,
    COALESCE(ac.text, fallback_ac.text, '') as artist_name,
    -- primary (first-credited) album artist's MBID, for linking the
    -- artist name to its detail page.  Empty when the album has no
    -- MB-tagged album-artist credit.
    CAST(COALESCE((
        SELECT a.mbid
        FROM artist_credit_artist aca_p
        JOIN artists a ON a.id = aca_p.artist_id
        WHERE aca_p.credit_id = rg.album_artist_credit_id
        ORDER BY aca_p.id
        LIMIT 1
    ), '') AS TEXT) as artist_mbid,
    COALESCE(ca.file_path, '') as cover_art_path
FROM release_groups rg
JOIN artist_credit ac ON rg.album_artist_credit_id = ac.id
JOIN artist_credit_artist aca ON aca.credit_id = ac.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
LEFT JOIN (
    SELECT rgr.release_group_id, ac2.text
    FROM release_group_recordings rgr
    JOIN recordings rec ON rec.id = rgr.recording_id
    JOIN artist_credit ac2 ON ac2.id = rec.artist_credit_id
    GROUP BY rgr.release_group_id
) fallback_ac ON fallback_ac.release_group_id = rg.id
WHERE aca.artist_id = ?
ORDER BY rg.name
`

type GetAlbumsByArtistRow struct {
	ID           int64
	Name         string
	Year         sql.NullInt64
	ReleaseYear  int64
	ArtistName   string
	ArtistMbid   string
	CoverArtPath string
}

func (q *Queries) GetAlbumsByArtist(ctx context.Context, artistID int64) ([]GetAlbumsByArtistRow, error) {
	rows, err := q.db.QueryContext(ctx, getAlbumsByArtist, artistID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAlbumsByArtistRow
	for rows.Next() {
		var i GetAlbumsByArtistRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Year,
			&i.ReleaseYear,
			&i.ArtistName,
			&i.ArtistMbid,
			&i.CoverArtPath,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAlbumsByArtistByLibrary = `-- name: GetAlbumsByArtistByLibrary :many
SELECT
    rg.id,
    rg.name,
    COALESCE(rg.original_year, rg.year) AS year,
    COALESCE(rg.year, 0) AS release_year,
    COALESCE(ac.text, fallback_ac.text, '') as artist_name,
    -- primary (first-credited) album artist's MBID, for linking the
    -- artist name to its detail page.  Empty when the album has no
    -- MB-tagged album-artist credit.
    CAST(COALESCE((
        SELECT a.mbid
        FROM artist_credit_artist aca_p
        JOIN artists a ON a.id = aca_p.artist_id
        WHERE aca_p.credit_id = rg.album_artist_credit_id
        ORDER BY aca_p.id
        LIMIT 1
    ), '') AS TEXT) as artist_mbid,
    COALESCE(ca.file_path, '') as cover_art_path
FROM release_groups rg
JOIN artist_credit ac ON rg.album_artist_credit_id = ac.id
JOIN artist_credit_artist aca ON aca.credit_id = ac.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
LEFT JOIN (
    SELECT rgr.release_group_id, ac2.text
    FROM release_group_recordings rgr
    JOIN recordings rec ON rec.id = rgr.recording_id
    JOIN artist_credit ac2 ON ac2.id = rec.artist_credit_id
    GROUP BY rgr.release_group_id
) fallback_ac ON fallback_ac.release_group_id = rg.id
WHERE aca.artist_id = ?
  AND rg.id IN (
    SELECT DISTINCT rgr2.release_group_id
    FROM release_group_recordings rgr2
    JOIN recordings r2 ON r2.id = rgr2.recording_id
    JOIN audio_files af2 ON af2.recording_id = r2.id
    WHERE af2.library_id = ?
)
ORDER BY rg.name
`

type GetAlbumsByArtistByLibraryParams struct {
	ArtistID  int64
	LibraryID int64
}

type GetAlbumsByArtistByLibraryRow struct {
	ID           int64
	Name         string
	Year         sql.NullInt64
	ReleaseYear  int64
	ArtistName   string
	ArtistMbid   string
	CoverArtPath string
}

func (q *Queries) GetAlbumsByArtistByLibrary(ctx context.Context, arg GetAlbumsByArtistByLibraryParams) ([]GetAlbumsByArtistByLibraryRow, error) {
	rows, err := q.db.QueryContext(ctx, getAlbumsByArtistByLibrary, arg.ArtistID, arg.LibraryID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAlbumsByArtistByLibraryRow
	for rows.Next() {
		var i GetAlbumsByArtistByLibraryRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Year,
			&i.ReleaseYear,
			&i.ArtistName,
			&i.ArtistMbid,
			&i.CoverArtPath,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllAlbumsWithDetails = `-- name: GetAllAlbumsWithDetails :many
SELECT
    rg.id,
    rg.name,
    -- year prefers original release year (MB first-release-date)
    -- over the file-tag year so the UI surfaces the album's
    -- original year by default.  release_year keeps the file-tag
    -- year accessible.
    COALESCE(rg.original_year, rg.year) AS year,
    COALESCE(rg.year, 0) AS release_year,
    rg.mbid,
    COALESCE(ac.text, fallback_ac.text, '') as artist_name,
    -- primary (first-credited) album artist's MBID, for linking the
    -- artist name to its detail page.  Empty when the album has no
    -- MB-tagged album-artist credit.
    CAST(COALESCE((
        SELECT a.mbid
        FROM artist_credit_artist aca_p
        JOIN artists a ON a.id = aca_p.artist_id
        WHERE aca_p.credit_id = rg.album_artist_credit_id
        ORDER BY aca_p.id
        LIMIT 1
    ), '') AS TEXT) as artist_mbid,
    COALESCE(ca.file_path, '') as cover_art_path
FROM release_groups rg
LEFT JOIN artist_credit ac ON rg.album_artist_credit_id = ac.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
LEFT JOIN (
    SELECT rgr.release_group_id, ac2.text
    FROM release_group_recordings rgr
    JOIN recordings rec ON rec.id = rgr.recording_id
    JOIN artist_credit ac2 ON ac2.id = rec.artist_credit_id
    GROUP BY rgr.release_group_id
) fallback_ac ON fallback_ac.release_group_id = rg.id
ORDER BY rg.name
`

type GetAllAlbumsWithDetailsRow struct {
	ID           int64
	Name         string
	Year         sql.NullInt64
	ReleaseYear  int64
	Mbid         sql.NullString
	ArtistName   string
	ArtistMbid   string
	CoverArtPath string
}

func (q *Queries) GetAllAlbumsWithDetails(ctx context.Context) ([]GetAllAlbumsWithDetailsRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllAlbumsWithDetails)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllAlbumsWithDetailsRow
	for rows.Next() {
		var i GetAllAlbumsWithDetailsRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Year,
			&i.ReleaseYear,
			&i.Mbid,
			&i.ArtistName,
			&i.ArtistMbid,
			&i.CoverArtPath,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllAlbumsWithDetailsByLibrary = `-- name: GetAllAlbumsWithDetailsByLibrary :many
SELECT
    rg.id,
    rg.name,
    -- year prefers original release year (MB first-release-date)
    -- over the file-tag year so the UI surfaces the album's
    -- original year by default.  release_year keeps the file-tag
    -- year accessible.
    COALESCE(rg.original_year, rg.year) AS year,
    COALESCE(rg.year, 0) AS release_year,
    rg.mbid,
    COALESCE(ac.text, fallback_ac.text, '') as artist_name,
    -- primary (first-credited) album artist's MBID, for linking the
    -- artist name to its detail page.  Empty when the album has no
    -- MB-tagged album-artist credit.
    CAST(COALESCE((
        SELECT a.mbid
        FROM artist_credit_artist aca_p
        JOIN artists a ON a.id = aca_p.artist_id
        WHERE aca_p.credit_id = rg.album_artist_credit_id
        ORDER BY aca_p.id
        LIMIT 1
    ), '') AS TEXT) as artist_mbid,
    COALESCE(ca.file_path, '') as cover_art_path
FROM release_groups rg
LEFT JOIN artist_credit ac ON rg.album_artist_credit_id = ac.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
LEFT JOIN (
    SELECT rgr.release_group_id, ac2.text
    FROM release_group_recordings rgr
    JOIN recordings rec ON rec.id = rgr.recording_id
    JOIN artist_credit ac2 ON ac2.id = rec.artist_credit_id
    GROUP BY rgr.release_group_id
) fallback_ac ON fallback_ac.release_group_id = rg.id
WHERE rg.id IN (
    SELECT DISTINCT rgr2.release_group_id
    FROM release_group_recordings rgr2
    JOIN recordings r2 ON r2.id = rgr2.recording_id
    JOIN audio_files af2 ON af2.recording_id = r2.id
    WHERE af2.library_id = ?
)
ORDER BY rg.name
`

type GetAllAlbumsWithDetailsByLibraryRow struct {
	ID           int64
	Name         string
	Year         sql.NullInt64
	ReleaseYear  int64
	Mbid         sql.NullString
	ArtistName   string
	ArtistMbid   string
	CoverArtPath string
}

func (q *Queries) GetAllAlbumsWithDetailsByLibrary(ctx context.Context, libraryID int64) ([]GetAllAlbumsWithDetailsByLibraryRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllAlbumsWithDetailsByLibrary, libraryID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllAlbumsWithDetailsByLibraryRow
	for rows.Next() {
		var i GetAllAlbumsWithDetailsByLibraryRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Year,
			&i.ReleaseYear,
			&i.Mbid,
			&i.ArtistName,
			&i.ArtistMbid,
			&i.CoverArtPath,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllReleaseGroups = `-- name: GetAllReleaseGroups :many
SELECT id, name, cover_art_id, album_artist_credit_id, year, total_tracks, total_discs, mbid, original_year, pending_release_mbid FROM release_groups
ORDER BY name
`

func (q *Queries) GetAllReleaseGroups(ctx context.Context) ([]ReleaseGroup, error) {
	rows, err := q.db.QueryContext(ctx, getAllReleaseGroups)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ReleaseGroup
	for rows.Next() {
		var i ReleaseGroup
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.CoverArtID,
			&i.AlbumArtistCreditID,
			&i.Year,
			&i.TotalTracks,
			&i.TotalDiscs,
			&i.Mbid,
			&i.OriginalYear,
			&i.PendingReleaseMbid,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getOrphanedReleaseGroupIDs = `-- name: GetOrphanedReleaseGroupIDs :many
SELECT rg.id FROM release_groups rg
LEFT JOIN release_group_recordings rgr ON rgr.release_group_id = rg.id
WHERE rgr.id IS NULL
`

// Release groups with no recordings left in them - run after orphaned
// recordings (and their release_group_recordings rows) are deleted, so
// a release group whose last owned track was removed is cleaned up too.
func (q *Queries) GetOrphanedReleaseGroupIDs(ctx context.Context) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, getOrphanedReleaseGroupIDs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int64
	for rows.Next() {
		var id int64
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getReleaseGroup = `-- name: GetReleaseGroup :one
SELECT id, name, cover_art_id, album_artist_credit_id, year, total_tracks, total_discs, mbid, original_year, pending_release_mbid FROM release_groups 
WHERE id = ? LIMIT 1
`

func (q *Queries) GetReleaseGroup(ctx context.Context, id int64) (ReleaseGroup, error) {
	row := q.db.QueryRowContext(ctx, getReleaseGroup, id)
	var i ReleaseGroup
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CoverArtID,
		&i.AlbumArtistCreditID,
		&i.Year,
		&i.TotalTracks,
		&i.TotalDiscs,
		&i.Mbid,
		&i.OriginalYear,
		&i.PendingReleaseMbid,
	)
	return i, err
}

const getReleaseGroupByNameAndArtist = `-- name: GetReleaseGroupByNameAndArtist :one
SELECT id, name, cover_art_id, album_artist_credit_id, year, total_tracks, total_discs, mbid, original_year, pending_release_mbid FROM release_groups
WHERE name = ? AND album_artist_credit_id = ? LIMIT 1
`

type GetReleaseGroupByNameAndArtistParams struct {
	Name                string
	AlbumArtistCreditID sql.NullInt64
}

func (q *Queries) GetReleaseGroupByNameAndArtist(ctx context.Context, arg GetReleaseGroupByNameAndArtistParams) (ReleaseGroup, error) {
	row := q.db.QueryRowContext(ctx, getReleaseGroupByNameAndArtist, arg.Name, arg.AlbumArtistCreditID)
	var i ReleaseGroup
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CoverArtID,
		&i.AlbumArtistCreditID,
		&i.Year,
		&i.TotalTracks,
		&i.TotalDiscs,
		&i.Mbid,
		&i.OriginalYear,
		&i.PendingReleaseMbid,
	)
	return i, err
}

const setReleaseGroupOriginalYear = `-- name: SetReleaseGroupOriginalYear :exec
UPDATE release_groups SET original_year = ? WHERE id = ?
`

type SetReleaseGroupOriginalYearParams struct {
	OriginalYear sql.NullInt64
	ID           int64
}

// Set the release group's original-release-year (release-group's
// first-release-date from MusicBrainz).  Called from autotag apply
// when the user confirms a candidate; the file-tag year stays in
// the year column.
func (q *Queries) SetReleaseGroupOriginalYear(ctx context.Context, arg SetReleaseGroupOriginalYearParams) error {
	_, err := q.db.ExecContext(ctx, setReleaseGroupOriginalYear, arg.OriginalYear, arg.ID)
	return err
}

const updateReleaseGroup = `-- name: UpdateReleaseGroup :exec
UPDATE release_groups 
SET name = ?
WHERE id = ?
`

type UpdateReleaseGroupParams struct {
	Name string
	ID   int64
}

func (q *Queries) UpdateReleaseGroup(ctx context.Context, arg UpdateReleaseGroupParams) error {
	_, err := q.db.ExecContext(ctx, updateReleaseGroup, arg.Name, arg.ID)
	return err
}

const updateReleaseGroupCoverArt = `-- name: UpdateReleaseGroupCoverArt :exec
UPDATE release_groups
SET cover_art_id = ?
WHERE id = ?
`

type UpdateReleaseGroupCoverArtParams struct {
	CoverArtID sql.NullInt64
	ID         int64
}

func (q *Queries) UpdateReleaseGroupCoverArt(ctx context.Context, arg UpdateReleaseGroupCoverArtParams) error {
	_, err := q.db.ExecContext(ctx, updateReleaseGroupCoverArt, arg.CoverArtID, arg.ID)
	return err
}

const upsertReleaseGroup = `-- name: UpsertReleaseGroup :one
INSERT INTO release_groups (name, album_artist_credit_id, year)
VALUES (?, ?, ?)
ON CONFLICT(name, album_artist_credit_id) DO UPDATE SET
  album_artist_credit_id = COALESCE(excluded.album_artist_credit_id, release_groups.album_artist_credit_id),
  year = COALESCE(excluded.year, release_groups.year)
RETURNING id, name, cover_art_id, album_artist_credit_id, year, total_tracks, total_discs, mbid, original_year, pending_release_mbid
`

type UpsertReleaseGroupParams struct {
	Name                string
	AlbumArtistCreditID sql.NullInt64
	Year                sql.NullInt64
}

func (q *Queries) UpsertReleaseGroup(ctx context.Context, arg UpsertReleaseGroupParams) (ReleaseGroup, error) {
	row := q.db.QueryRowContext(ctx, upsertReleaseGroup, arg.Name, arg.AlbumArtistCreditID, arg.Year)
	var i ReleaseGroup
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.CoverArtID,
		&i.AlbumArtistCreditID,
		&i.Year,
		&i.TotalTracks,
		&i.TotalDiscs,
		&i.Mbid,
		&i.OriginalYear,
		&i.PendingReleaseMbid,
	)
	return i, err
}