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

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

package sqlcgen

import (
	"context"
	"database/sql"
)

const addPlaylistTrack = `-- name: AddPlaylistTrack :one
INSERT INTO playlist_tracks (
    playlist_id, audio_file_id, position,
    phantom_title, phantom_artist, phantom_album,
    phantom_duration_ms, phantom_genre, phantom_cover_art_path
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
RETURNING id, playlist_id, audio_file_id, position, phantom_title, phantom_artist, phantom_album, phantom_duration_ms, phantom_genre, phantom_cover_art_path, phantom_file_path
`

type AddPlaylistTrackParams struct {
	PlaylistID          int64
	AudioFileID         sql.NullInt64
	Position            int64
	PhantomTitle        sql.NullString
	PhantomArtist       sql.NullString
	PhantomAlbum        sql.NullString
	PhantomDurationMs   sql.NullInt64
	PhantomGenre        sql.NullString
	PhantomCoverArtPath sql.NullString
}

func (q *Queries) AddPlaylistTrack(ctx context.Context, arg AddPlaylistTrackParams) (PlaylistTrack, error) {
	row := q.db.QueryRowContext(ctx, addPlaylistTrack,
		arg.PlaylistID,
		arg.AudioFileID,
		arg.Position,
		arg.PhantomTitle,
		arg.PhantomArtist,
		arg.PhantomAlbum,
		arg.PhantomDurationMs,
		arg.PhantomGenre,
		arg.PhantomCoverArtPath,
	)
	var i PlaylistTrack
	err := row.Scan(
		&i.ID,
		&i.PlaylistID,
		&i.AudioFileID,
		&i.Position,
		&i.PhantomTitle,
		&i.PhantomArtist,
		&i.PhantomAlbum,
		&i.PhantomDurationMs,
		&i.PhantomGenre,
		&i.PhantomCoverArtPath,
		&i.PhantomFilePath,
	)
	return i, err
}

const clearPlaylistTracks = `-- name: ClearPlaylistTracks :exec
DELETE FROM playlist_tracks WHERE playlist_id = ?
`

func (q *Queries) ClearPlaylistTracks(ctx context.Context, playlistID int64) error {
	_, err := q.db.ExecContext(ctx, clearPlaylistTracks, playlistID)
	return err
}

const countPlaylistsByName = `-- name: CountPlaylistsByName :one
SELECT COUNT(*) AS count FROM playlists WHERE name = ?
`

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

const createPlaylist = `-- name: CreatePlaylist :one
INSERT INTO playlists (name) VALUES (?)
RETURNING id, name, is_smart, smart_rules, smart_snapshot_at, created_at, updated_at
`

func (q *Queries) CreatePlaylist(ctx context.Context, name string) (Playlist, error) {
	row := q.db.QueryRowContext(ctx, createPlaylist, name)
	var i Playlist
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.IsSmart,
		&i.SmartRules,
		&i.SmartSnapshotAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteAllPlaylistTracks = `-- name: DeleteAllPlaylistTracks :exec
DELETE FROM playlist_tracks
`

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

const deletePlaylist = `-- name: DeletePlaylist :exec
DELETE FROM playlists WHERE id = ?
`

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

const getAllPlaylistTracksWithMetadata = `-- name: GetAllPlaylistTracksWithMetadata :many
SELECT
    pt.id,
    pt.playlist_id,
    pt.audio_file_id,
    pt.position,
    COALESCE(tm.file_path, '') AS file_path,
    COALESCE(tm.length_milliseconds, 0) AS length_milliseconds,
    COALESCE(tm.title, pt.phantom_title, '') AS title,
    COALESCE(tm.artist_name, pt.phantom_artist, '') AS artist,
    COALESCE(tm.album, pt.phantom_album, '') AS album,
    COALESCE(NULLIF(tm.cover_art_path, ''), pt.phantom_cover_art_path, '') AS cover_art_path,
    CASE WHEN pt.audio_file_id IS NULL THEN 1 ELSE 0 END AS is_phantom,
    CAST(COALESCE(tm.artist_mbid, '') AS TEXT) AS artist_mbid,
    COALESCE(tm.release_group_mbid, '') AS release_group_mbid,
    COALESCE(tm.recording_mbid, '') AS recording_mbid
FROM playlist_tracks pt
LEFT JOIN track_metadata tm ON tm.id = pt.audio_file_id
ORDER BY pt.playlist_id, pt.position
`

type GetAllPlaylistTracksWithMetadataRow struct {
	ID                 int64
	PlaylistID         int64
	AudioFileID        sql.NullInt64
	Position           int64
	FilePath           string
	LengthMilliseconds int64
	Title              string
	Artist             string
	Album              string
	CoverArtPath       string
	IsPhantom          int64
	ArtistMbid         string
	ReleaseGroupMbid   string
	RecordingMbid      string
}

func (q *Queries) GetAllPlaylistTracksWithMetadata(ctx context.Context) ([]GetAllPlaylistTracksWithMetadataRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllPlaylistTracksWithMetadata)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllPlaylistTracksWithMetadataRow
	for rows.Next() {
		var i GetAllPlaylistTracksWithMetadataRow
		if err := rows.Scan(
			&i.ID,
			&i.PlaylistID,
			&i.AudioFileID,
			&i.Position,
			&i.FilePath,
			&i.LengthMilliseconds,
			&i.Title,
			&i.Artist,
			&i.Album,
			&i.CoverArtPath,
			&i.IsPhantom,
			&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 getAllPlaylists = `-- name: GetAllPlaylists :many
SELECT id, name, is_smart, smart_rules, smart_snapshot_at, created_at, updated_at FROM playlists ORDER BY updated_at DESC
`

func (q *Queries) GetAllPlaylists(ctx context.Context) ([]Playlist, error) {
	rows, err := q.db.QueryContext(ctx, getAllPlaylists)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Playlist
	for rows.Next() {
		var i Playlist
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.IsSmart,
			&i.SmartRules,
			&i.SmartSnapshotAt,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 getNextPlaylistTrackPosition = `-- name: GetNextPlaylistTrackPosition :one
SELECT COALESCE(MAX(position), -1) + 1 AS next_position
FROM playlist_tracks WHERE playlist_id = ?
`

func (q *Queries) GetNextPlaylistTrackPosition(ctx context.Context, playlistID int64) (int64, error) {
	row := q.db.QueryRowContext(ctx, getNextPlaylistTrackPosition, playlistID)
	var next_position int64
	err := row.Scan(&next_position)
	return next_position, err
}

const getPlaylist = `-- name: GetPlaylist :one
SELECT id, name, is_smart, smart_rules, smart_snapshot_at, created_at, updated_at FROM playlists WHERE id = ? LIMIT 1
`

func (q *Queries) GetPlaylist(ctx context.Context, id int64) (Playlist, error) {
	row := q.db.QueryRowContext(ctx, getPlaylist, id)
	var i Playlist
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.IsSmart,
		&i.SmartRules,
		&i.SmartSnapshotAt,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getPlaylistTrackFilePaths = `-- name: GetPlaylistTrackFilePaths :many
SELECT COALESCE(af.file_path, '') AS file_path
FROM playlist_tracks pt
LEFT JOIN audio_files af ON pt.audio_file_id = af.id
WHERE pt.playlist_id = ? AND pt.audio_file_id IS NOT NULL
ORDER BY pt.position
`

func (q *Queries) GetPlaylistTrackFilePaths(ctx context.Context, playlistID int64) ([]string, error) {
	rows, err := q.db.QueryContext(ctx, getPlaylistTrackFilePaths, playlistID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []string
	for rows.Next() {
		var file_path string
		if err := rows.Scan(&file_path); err != nil {
			return nil, err
		}
		items = append(items, file_path)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getPlaylistTracks = `-- name: GetPlaylistTracks :many
SELECT pt.id, pt.playlist_id, pt.audio_file_id, pt.position,
    COALESCE(af.file_path, '') AS file_path,
    pt.phantom_title, pt.phantom_artist, pt.phantom_album,
    pt.phantom_duration_ms, pt.phantom_genre, pt.phantom_cover_art_path
FROM playlist_tracks pt
LEFT JOIN audio_files af ON pt.audio_file_id = af.id
WHERE pt.playlist_id = ?
ORDER BY pt.position
`

type GetPlaylistTracksRow struct {
	ID                  int64
	PlaylistID          int64
	AudioFileID         sql.NullInt64
	Position            int64
	FilePath            string
	PhantomTitle        sql.NullString
	PhantomArtist       sql.NullString
	PhantomAlbum        sql.NullString
	PhantomDurationMs   sql.NullInt64
	PhantomGenre        sql.NullString
	PhantomCoverArtPath sql.NullString
}

func (q *Queries) GetPlaylistTracks(ctx context.Context, playlistID int64) ([]GetPlaylistTracksRow, error) {
	rows, err := q.db.QueryContext(ctx, getPlaylistTracks, playlistID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetPlaylistTracksRow
	for rows.Next() {
		var i GetPlaylistTracksRow
		if err := rows.Scan(
			&i.ID,
			&i.PlaylistID,
			&i.AudioFileID,
			&i.Position,
			&i.FilePath,
			&i.PhantomTitle,
			&i.PhantomArtist,
			&i.PhantomAlbum,
			&i.PhantomDurationMs,
			&i.PhantomGenre,
			&i.PhantomCoverArtPath,
		); 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 getPlaylistTracksWithMetadata = `-- name: GetPlaylistTracksWithMetadata :many
SELECT
    pt.id,
    pt.playlist_id,
    pt.audio_file_id,
    pt.position,
    COALESCE(tm.file_path, '') AS file_path,
    COALESCE(tm.length_milliseconds, 0) AS length_milliseconds,
    COALESCE(tm.title, pt.phantom_title, '') AS title,
    COALESCE(tm.artist_name, pt.phantom_artist, '') AS artist,
    COALESCE(tm.album, pt.phantom_album, '') AS album,
    COALESCE(NULLIF(tm.cover_art_path, ''), pt.phantom_cover_art_path, '') AS cover_art_path,
    CASE WHEN pt.audio_file_id IS NULL THEN 1 ELSE 0 END AS is_phantom,
    CAST(COALESCE(tm.artist_mbid, '') AS TEXT) AS artist_mbid,
    COALESCE(tm.release_group_mbid, '') AS release_group_mbid,
    COALESCE(tm.recording_mbid, '') AS recording_mbid
FROM playlist_tracks pt
LEFT JOIN track_metadata tm ON tm.id = pt.audio_file_id
WHERE pt.playlist_id = ?
ORDER BY pt.position
`

type GetPlaylistTracksWithMetadataRow struct {
	ID                 int64
	PlaylistID         int64
	AudioFileID        sql.NullInt64
	Position           int64
	FilePath           string
	LengthMilliseconds int64
	Title              string
	Artist             string
	Album              string
	CoverArtPath       string
	IsPhantom          int64
	ArtistMbid         string
	ReleaseGroupMbid   string
	RecordingMbid      string
}

func (q *Queries) GetPlaylistTracksWithMetadata(ctx context.Context, playlistID int64) ([]GetPlaylistTracksWithMetadataRow, error) {
	rows, err := q.db.QueryContext(ctx, getPlaylistTracksWithMetadata, playlistID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetPlaylistTracksWithMetadataRow
	for rows.Next() {
		var i GetPlaylistTracksWithMetadataRow
		if err := rows.Scan(
			&i.ID,
			&i.PlaylistID,
			&i.AudioFileID,
			&i.Position,
			&i.FilePath,
			&i.LengthMilliseconds,
			&i.Title,
			&i.Artist,
			&i.Album,
			&i.CoverArtPath,
			&i.IsPhantom,
			&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 getTrackPhantomMetadata = `-- name: GetTrackPhantomMetadata :one
SELECT title, artist_name AS artist, album,
       length_milliseconds AS duration_ms, genre, cover_art_path
FROM track_metadata
WHERE id = ?
`

type GetTrackPhantomMetadataRow struct {
	Title        string
	Artist       string
	Album        string
	DurationMs   int64
	Genre        string
	CoverArtPath string
}

// The display fields a playlist row keeps after its file goes away.
func (q *Queries) GetTrackPhantomMetadata(ctx context.Context, id int64) (GetTrackPhantomMetadataRow, error) {
	row := q.db.QueryRowContext(ctx, getTrackPhantomMetadata, id)
	var i GetTrackPhantomMetadataRow
	err := row.Scan(
		&i.Title,
		&i.Artist,
		&i.Album,
		&i.DurationMs,
		&i.Genre,
		&i.CoverArtPath,
	)
	return i, err
}

const isTrackInPlaylist = `-- name: IsTrackInPlaylist :one
SELECT EXISTS(
    SELECT 1 FROM playlist_tracks pt
    LEFT JOIN audio_files af ON pt.audio_file_id = af.id
    WHERE pt.playlist_id = ? AND af.file_path = ?
) AS in_playlist
`

type IsTrackInPlaylistParams struct {
	PlaylistID int64
	FilePath   string
}

func (q *Queries) IsTrackInPlaylist(ctx context.Context, arg IsTrackInPlaylistParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, isTrackInPlaylist, arg.PlaylistID, arg.FilePath)
	var in_playlist int64
	err := row.Scan(&in_playlist)
	return in_playlist, err
}

const removePlaylistTrack = `-- name: RemovePlaylistTrack :exec
DELETE FROM playlist_tracks WHERE id = ?
`

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

const removePlaylistTrackByPath = `-- name: RemovePlaylistTrackByPath :exec
DELETE FROM playlist_tracks
WHERE playlist_id = ? AND audio_file_id = (
    SELECT id FROM audio_files WHERE file_path = ?
)
`

type RemovePlaylistTrackByPathParams struct {
	PlaylistID int64
	FilePath   string
}

func (q *Queries) RemovePlaylistTrackByPath(ctx context.Context, arg RemovePlaylistTrackByPathParams) error {
	_, err := q.db.ExecContext(ctx, removePlaylistTrackByPath, arg.PlaylistID, arg.FilePath)
	return err
}

const updatePlaylistName = `-- name: UpdatePlaylistName :exec
UPDATE playlists SET name = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
`

type UpdatePlaylistNameParams struct {
	Name string
	ID   int64
}

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