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

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

package sqlcgen

import (
	"context"
	"database/sql"
)

const clearQueueTracks = `-- name: ClearQueueTracks :exec
DELETE FROM queue_tracks
`

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

const getQueueState = `-- name: GetQueueState :one
SELECT source_playlist_id, current_position, shuffle_mode, repeat_mode, shuffle_order
FROM queue WHERE id = 1
`

type GetQueueStateRow struct {
	SourcePlaylistID sql.NullInt64
	CurrentPosition  int64
	ShuffleMode      bool
	RepeatMode       string
	ShuffleOrder     sql.NullString
}

func (q *Queries) GetQueueState(ctx context.Context) (GetQueueStateRow, error) {
	row := q.db.QueryRowContext(ctx, getQueueState)
	var i GetQueueStateRow
	err := row.Scan(
		&i.SourcePlaylistID,
		&i.CurrentPosition,
		&i.ShuffleMode,
		&i.RepeatMode,
		&i.ShuffleOrder,
	)
	return i, err
}

const getQueueTrackCount = `-- name: GetQueueTrackCount :one
SELECT count(*) FROM queue_tracks
`

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

const getQueueTracks = `-- name: GetQueueTracks :many
SELECT qt.id, qt.audio_file_id, qt.position, af.file_path,
    COALESCE(r.name, '') AS title,
    COALESCE(ac.text, '') AS artist,
    COALESCE(rg.name, '') AS album,
    COALESCE(ca.file_path, '') AS cover_art_path,
    COALESCE(a.mbid, '') AS artist_mbid,
    COALESCE(rg.mbid, '') AS release_group_mbid,
    COALESCE(r.mbid, '') AS recording_mbid
FROM queue_tracks qt
JOIN audio_files af ON qt.audio_file_id = af.id
LEFT JOIN recordings r ON af.recording_id = r.id
LEFT JOIN artist_credit ac ON r.artist_credit_id = ac.id
LEFT JOIN artist_credit_artist aca ON aca.credit_id = ac.id
LEFT JOIN artists a ON a.id = aca.artist_id
LEFT JOIN (
    SELECT recording_id, MIN(release_group_id) AS release_group_id
    FROM release_group_recordings
    GROUP BY recording_id
) rgr ON r.id = rgr.recording_id
LEFT JOIN release_groups rg ON rgr.release_group_id = rg.id
LEFT JOIN cover_art ca ON rg.cover_art_id = ca.id
ORDER BY qt.position
`

type GetQueueTracksRow struct {
	ID               int64
	AudioFileID      int64
	Position         int64
	FilePath         string
	Title            string
	Artist           string
	Album            string
	CoverArtPath     string
	ArtistMbid       string
	ReleaseGroupMbid string
	RecordingMbid    string
}

func (q *Queries) GetQueueTracks(ctx context.Context) ([]GetQueueTracksRow, error) {
	rows, err := q.db.QueryContext(ctx, getQueueTracks)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetQueueTracksRow
	for rows.Next() {
		var i GetQueueTracksRow
		if err := rows.Scan(
			&i.ID,
			&i.AudioFileID,
			&i.Position,
			&i.FilePath,
			&i.Title,
			&i.Artist,
			&i.Album,
			&i.CoverArtPath,
			&i.ArtistMbid,
			&i.ReleaseGroupMbid,
			&i.RecordingMbid,
		); 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 insertQueueTrack = `-- name: InsertQueueTrack :one
INSERT INTO queue_tracks (audio_file_id, position) VALUES (?, ?)
RETURNING id, audio_file_id, position
`

type InsertQueueTrackParams struct {
	AudioFileID int64
	Position    int64
}

func (q *Queries) InsertQueueTrack(ctx context.Context, arg InsertQueueTrackParams) (QueueTrack, error) {
	row := q.db.QueryRowContext(ctx, insertQueueTrack, arg.AudioFileID, arg.Position)
	var i QueueTrack
	err := row.Scan(&i.ID, &i.AudioFileID, &i.Position)
	return i, err
}

const removeQueueTrack = `-- name: RemoveQueueTrack :exec
DELETE FROM queue_tracks WHERE id = ?
`

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

const removeQueueTrackByPosition = `-- name: RemoveQueueTrackByPosition :exec
DELETE FROM queue_tracks WHERE position = ?
`

func (q *Queries) RemoveQueueTrackByPosition(ctx context.Context, position int64) error {
	_, err := q.db.ExecContext(ctx, removeQueueTrackByPosition, position)
	return err
}

const shiftQueuePositionsDown = `-- name: ShiftQueuePositionsDown :exec
UPDATE queue_tracks
SET position = position - 1
WHERE position > ?
`

func (q *Queries) ShiftQueuePositionsDown(ctx context.Context, position int64) error {
	_, err := q.db.ExecContext(ctx, shiftQueuePositionsDown, position)
	return err
}

const shiftQueuePositionsUp = `-- name: ShiftQueuePositionsUp :exec
UPDATE queue_tracks
SET position = position + 1
WHERE position >= ?
`

func (q *Queries) ShiftQueuePositionsUp(ctx context.Context, position int64) error {
	_, err := q.db.ExecContext(ctx, shiftQueuePositionsUp, position)
	return err
}

const updateQueuePosition = `-- name: UpdateQueuePosition :exec
UPDATE queue
SET current_position = ?
WHERE id = 1
`

func (q *Queries) UpdateQueuePosition(ctx context.Context, currentPosition int64) error {
	_, err := q.db.ExecContext(ctx, updateQueuePosition, currentPosition)
	return err
}

const updateQueueState = `-- name: UpdateQueueState :exec
UPDATE queue
SET source_playlist_id = ?, current_position = ?, shuffle_mode = ?, repeat_mode = ?, shuffle_order = ?
WHERE id = 1
`

type UpdateQueueStateParams struct {
	SourcePlaylistID sql.NullInt64
	CurrentPosition  int64
	ShuffleMode      bool
	RepeatMode       string
	ShuffleOrder     sql.NullString
}

func (q *Queries) UpdateQueueState(ctx context.Context, arg UpdateQueueStateParams) error {
	_, err := q.db.ExecContext(ctx, updateQueueState,
		arg.SourcePlaylistID,
		arg.CurrentPosition,
		arg.ShuffleMode,
		arg.RepeatMode,
		arg.ShuffleOrder,
	)
	return err
}