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

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

package sqlcgen

import (
	"context"
)

const addPlaylistTrack = `-- name: AddPlaylistTrack :one
INSERT INTO playlist_tracks (playlist_id, audio_file_id, position) VALUES (?, ?, ?)
RETURNING id, playlist_id, audio_file_id, position
`

type AddPlaylistTrackParams struct {
	PlaylistID  int64
	AudioFileID int64
	Position    int64
}

func (q *Queries) AddPlaylistTrack(ctx context.Context, arg AddPlaylistTrackParams) (PlaylistTrack, error) {
	row := q.db.QueryRowContext(ctx, addPlaylistTrack, arg.PlaylistID, arg.AudioFileID, arg.Position)
	var i PlaylistTrack
	err := row.Scan(
		&i.ID,
		&i.PlaylistID,
		&i.AudioFileID,
		&i.Position,
	)
	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 createPlaylist = `-- name: CreatePlaylist :one
INSERT INTO playlists (name) VALUES (?)
RETURNING id, name, 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.CreatedAt,
		&i.UpdatedAt,
	)
	return i, 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 getAllPlaylists = `-- name: GetAllPlaylists :many
SELECT id, name, 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.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 getPlaylist = `-- name: GetPlaylist :one
SELECT id, name, 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.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getPlaylistTracks = `-- name: GetPlaylistTracks :many
SELECT pt.id, pt.playlist_id, pt.audio_file_id, pt.position, af.file_path
FROM playlist_tracks pt
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 int64
	Position    int64
	FilePath    string
}

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,
		); 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 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 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
}