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

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

package sqlcgen

import (
	"context"
	"database/sql"
)

const countRecordingsByArtistCredit = `-- name: CountRecordingsByArtistCredit :one
SELECT COUNT(*) FROM recordings WHERE artist_credit_id = ?
`

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

const createRecording = `-- name: CreateRecording :one
INSERT INTO recordings (name, artist_credit_id) VALUES (?, ?)
RETURNING id, name, artist_credit_id, track_number, disc_number, year, genre, composer, lyrics, comment, mbid
`

type CreateRecordingParams struct {
	Name           string
	ArtistCreditID int64
}

func (q *Queries) CreateRecording(ctx context.Context, arg CreateRecordingParams) (Recording, error) {
	row := q.db.QueryRowContext(ctx, createRecording, arg.Name, arg.ArtistCreditID)
	var i Recording
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.ArtistCreditID,
		&i.TrackNumber,
		&i.DiscNumber,
		&i.Year,
		&i.Genre,
		&i.Composer,
		&i.Lyrics,
		&i.Comment,
		&i.Mbid,
	)
	return i, err
}

const createRecordingFull = `-- name: CreateRecordingFull :one
INSERT INTO recordings (
  name, artist_credit_id, track_number, disc_number,
  year, genre, composer, lyrics, comment
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
RETURNING id, name, artist_credit_id, track_number, disc_number, year, genre, composer, lyrics, comment, mbid
`

type CreateRecordingFullParams struct {
	Name           string
	ArtistCreditID int64
	TrackNumber    sql.NullInt64
	DiscNumber     sql.NullInt64
	Year           sql.NullInt64
	Genre          sql.NullString
	Composer       sql.NullString
	Lyrics         sql.NullString
	Comment        sql.NullString
}

func (q *Queries) CreateRecordingFull(ctx context.Context, arg CreateRecordingFullParams) (Recording, error) {
	row := q.db.QueryRowContext(ctx, createRecordingFull,
		arg.Name,
		arg.ArtistCreditID,
		arg.TrackNumber,
		arg.DiscNumber,
		arg.Year,
		arg.Genre,
		arg.Composer,
		arg.Lyrics,
		arg.Comment,
	)
	var i Recording
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.ArtistCreditID,
		&i.TrackNumber,
		&i.DiscNumber,
		&i.Year,
		&i.Genre,
		&i.Composer,
		&i.Lyrics,
		&i.Comment,
		&i.Mbid,
	)
	return i, err
}

const deleteAllRecordings = `-- name: DeleteAllRecordings :exec
DELETE FROM recordings
`

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

const deleteRecording = `-- name: DeleteRecording :exec
DELETE FROM recordings 
WHERE id = ?
`

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

const getAllRecordings = `-- name: GetAllRecordings :many
SELECT id, name, artist_credit_id, track_number, disc_number, year, genre, composer, lyrics, comment, mbid FROM recordings
ORDER BY name
`

func (q *Queries) GetAllRecordings(ctx context.Context) ([]Recording, error) {
	rows, err := q.db.QueryContext(ctx, getAllRecordings)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Recording
	for rows.Next() {
		var i Recording
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.ArtistCreditID,
			&i.TrackNumber,
			&i.DiscNumber,
			&i.Year,
			&i.Genre,
			&i.Composer,
			&i.Lyrics,
			&i.Comment,
			&i.Mbid,
		); 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 getOrphanedRecordingIDs = `-- name: GetOrphanedRecordingIDs :many
SELECT r.id FROM recordings r
LEFT JOIN audio_files af ON af.recording_id = r.id
WHERE af.id IS NULL
`

// Recordings no longer backed by any audio_files row - left behind
// when a scan's orphan cleanup deletes the file that used to own them,
// since deleting audio_files doesn't cascade to recordings.
func (q *Queries) GetOrphanedRecordingIDs(ctx context.Context) ([]int64, error) {
	rows, err := q.db.QueryContext(ctx, getOrphanedRecordingIDs)
	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 getRecording = `-- name: GetRecording :one
SELECT id, name, artist_credit_id, track_number, disc_number, year, genre, composer, lyrics, comment, mbid FROM recordings 
WHERE id = ? LIMIT 1
`

func (q *Queries) GetRecording(ctx context.Context, id int64) (Recording, error) {
	row := q.db.QueryRowContext(ctx, getRecording, id)
	var i Recording
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.ArtistCreditID,
		&i.TrackNumber,
		&i.DiscNumber,
		&i.Year,
		&i.Genre,
		&i.Composer,
		&i.Lyrics,
		&i.Comment,
		&i.Mbid,
	)
	return i, err
}

const updateRecording = `-- name: UpdateRecording :exec
UPDATE recordings 
SET name = ?, artist_credit_id = ?
WHERE id = ?
`

type UpdateRecordingParams struct {
	Name           string
	ArtistCreditID int64
	ID             int64
}

func (q *Queries) UpdateRecording(ctx context.Context, arg UpdateRecordingParams) error {
	_, err := q.db.ExecContext(ctx, updateRecording, arg.Name, arg.ArtistCreditID, arg.ID)
	return err
}

const updateRecordingFull = `-- name: UpdateRecordingFull :exec
UPDATE recordings
SET name = ?, artist_credit_id = ?, track_number = ?, disc_number = ?,
    year = ?, genre = ?, composer = ?, lyrics = ?, comment = ?
WHERE id = ?
`

type UpdateRecordingFullParams struct {
	Name           string
	ArtistCreditID int64
	TrackNumber    sql.NullInt64
	DiscNumber     sql.NullInt64
	Year           sql.NullInt64
	Genre          sql.NullString
	Composer       sql.NullString
	Lyrics         sql.NullString
	Comment        sql.NullString
	ID             int64
}

func (q *Queries) UpdateRecordingFull(ctx context.Context, arg UpdateRecordingFullParams) error {
	_, err := q.db.ExecContext(ctx, updateRecordingFull,
		arg.Name,
		arg.ArtistCreditID,
		arg.TrackNumber,
		arg.DiscNumber,
		arg.Year,
		arg.Genre,
		arg.Composer,
		arg.Lyrics,
		arg.Comment,
		arg.ID,
	)
	return err
}