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

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

package sqlcgen

import (
	"context"
	"database/sql"
)

const createRecordingGenre = `-- name: CreateRecordingGenre :exec
INSERT OR IGNORE INTO recording_genres (recording_id, genre_id)
VALUES (?, ?)
`

type CreateRecordingGenreParams struct {
	RecordingID int64
	GenreID     int64
}

func (q *Queries) CreateRecordingGenre(ctx context.Context, arg CreateRecordingGenreParams) error {
	_, err := q.db.ExecContext(ctx, createRecordingGenre, arg.RecordingID, arg.GenreID)
	return err
}

const deleteAllGenres = `-- name: DeleteAllGenres :exec
DELETE FROM genres
`

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

const deleteAllRecordingGenres = `-- name: DeleteAllRecordingGenres :exec
DELETE FROM recording_genres
`

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

const deleteRecordingGenres = `-- name: DeleteRecordingGenres :exec
DELETE FROM recording_genres
WHERE recording_id = ?
`

func (q *Queries) DeleteRecordingGenres(ctx context.Context, recordingID int64) error {
	_, err := q.db.ExecContext(ctx, deleteRecordingGenres, recordingID)
	return err
}

const getAllGenresWithCounts = `-- name: GetAllGenresWithCounts :many
SELECT g.name, COUNT(rg.recording_id) AS track_count
FROM genres g
JOIN recording_genres rg ON g.id = rg.genre_id
GROUP BY g.id, g.name
ORDER BY g.name
`

type GetAllGenresWithCountsRow struct {
	Name       string
	TrackCount int64
}

func (q *Queries) GetAllGenresWithCounts(ctx context.Context) ([]GetAllGenresWithCountsRow, error) {
	rows, err := q.db.QueryContext(ctx, getAllGenresWithCounts)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetAllGenresWithCountsRow
	for rows.Next() {
		var i GetAllGenresWithCountsRow
		if err := rows.Scan(&i.Name, &i.TrackCount); 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 getGenresByRecordingID = `-- name: GetGenresByRecordingID :many
SELECT g.id, g.name
FROM genres g
JOIN recording_genres rg ON g.id = rg.genre_id
WHERE rg.recording_id = ?
`

func (q *Queries) GetGenresByRecordingID(ctx context.Context, recordingID int64) ([]Genre, error) {
	rows, err := q.db.QueryContext(ctx, getGenresByRecordingID, recordingID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Genre
	for rows.Next() {
		var i Genre
		if err := rows.Scan(&i.ID, &i.Name); 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 getTracksByGenre = `-- name: GetTracksByGenre :many
SELECT
    af.file_path,
    af.length_milliseconds,
    COALESCE(r.name, '') AS title,
    COALESCE(ac.text, '') AS artist_name,
    r.track_number,
    r.disc_number,
    COALESCE(rlg.name, '') AS album,
    CAST(COALESCE(
        (SELECT GROUP_CONCAT(g2.name, '||')
         FROM recording_genres rg2
         JOIN genres g2 ON rg2.genre_id = g2.id
         WHERE rg2.recording_id = r.id),
        ''
    ) AS TEXT) AS genre,
    COALESCE(r.year, 0) AS year,
    COALESCE(r.composer, '') AS composer,
    COALESCE(ft.extension, '') AS file_type,
    af.sample_rate,
    af.bit_depth,
    af.channels,
    af.bitrate,
    af.file_size
FROM genres g
JOIN recording_genres rg ON g.id = rg.genre_id
JOIN recordings r ON rg.recording_id = r.id
JOIN audio_files af ON af.recording_id = r.id
JOIN artist_credit ac ON r.artist_credit_id = ac.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 rlg ON rgr.release_group_id = rlg.id
LEFT JOIN file_types ft ON af.file_type_id = ft.id
WHERE g.name = ?
ORDER BY r.name
`

type GetTracksByGenreRow struct {
	FilePath           string
	LengthMilliseconds int64
	Title              string
	ArtistName         string
	TrackNumber        sql.NullInt64
	DiscNumber         sql.NullInt64
	Album              string
	Genre              string
	Year               int64
	Composer           string
	FileType           string
	SampleRate         int64
	BitDepth           int64
	Channels           int64
	Bitrate            int64
	FileSize           int64
}

func (q *Queries) GetTracksByGenre(ctx context.Context, name string) ([]GetTracksByGenreRow, error) {
	rows, err := q.db.QueryContext(ctx, getTracksByGenre, name)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetTracksByGenreRow
	for rows.Next() {
		var i GetTracksByGenreRow
		if err := rows.Scan(
			&i.FilePath,
			&i.LengthMilliseconds,
			&i.Title,
			&i.ArtistName,
			&i.TrackNumber,
			&i.DiscNumber,
			&i.Album,
			&i.Genre,
			&i.Year,
			&i.Composer,
			&i.FileType,
			&i.SampleRate,
			&i.BitDepth,
			&i.Channels,
			&i.Bitrate,
			&i.FileSize,
		); 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 upsertGenre = `-- name: UpsertGenre :one
INSERT INTO genres (name) VALUES (?)
ON CONFLICT(name) DO UPDATE SET name = name
RETURNING id, name
`

func (q *Queries) UpsertGenre(ctx context.Context, name string) (Genre, error) {
	row := q.db.QueryRowContext(ctx, upsertGenre, name)
	var i Genre
	err := row.Scan(&i.ID, &i.Name)
	return i, err
}