MusicServer/internal/db/repository/song.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: song.sql

package repository

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const addHashToSong = `-- name: AddHashToSong :exec
UPDATE song SET hash=$1 where soundtrack_id = $2 AND path = $3
`

type AddHashToSongParams struct {
	Hash         string `json:"hash"`
	SoundtrackID int32  `json:"soundtrack_id"`
	Path         string `json:"path"`
}

func (q *Queries) AddHashToSong(ctx context.Context, arg AddHashToSongParams) error {
	_, err := q.db.Exec(ctx, addHashToSong, arg.Hash, arg.SoundtrackID, arg.Path)
	return err
}

const addSong = `-- name: AddSong :exec
INSERT INTO song(soundtrack_id, song_name, path, file_name, hash) VALUES ($1, $2, $3, $4, $5)
`

type AddSongParams struct {
	SoundtrackID int32   `json:"soundtrack_id"`
	SongName     string  `json:"song_name"`
	Path         string  `json:"path"`
	FileName     *string `json:"file_name"`
	Hash         string  `json:"hash"`
}

func (q *Queries) AddSong(ctx context.Context, arg AddSongParams) error {
	_, err := q.db.Exec(ctx, addSong,
		arg.SoundtrackID,
		arg.SongName,
		arg.Path,
		arg.FileName,
		arg.Hash,
	)
	return err
}

const addSongPlayed = `-- name: AddSongPlayed :exec
UPDATE song SET times_played = times_played + 1
WHERE soundtrack_id = $1 AND song_name = $2
`

type AddSongPlayedParams struct {
	SoundtrackID int32  `json:"soundtrack_id"`
	SongName     string `json:"song_name"`
}

func (q *Queries) AddSongPlayed(ctx context.Context, arg AddSongPlayedParams) error {
	_, err := q.db.Exec(ctx, addSongPlayed, arg.SoundtrackID, arg.SongName)
	return err
}

const checkSong = `-- name: CheckSong :one
SELECT COUNT(*) FROM song WHERE soundtrack_id = $1 AND path = $2
`

type CheckSongParams struct {
	SoundtrackID int32  `json:"soundtrack_id"`
	Path         string `json:"path"`
}

func (q *Queries) CheckSong(ctx context.Context, arg CheckSongParams) (int64, error) {
	row := q.db.QueryRow(ctx, checkSong, arg.SoundtrackID, arg.Path)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const checkSongWithHash = `-- name: CheckSongWithHash :one
SELECT COUNT(*) FROM song WHERE hash = $1
`

func (q *Queries) CheckSongWithHash(ctx context.Context, hash string) (int64, error) {
	row := q.db.QueryRow(ctx, checkSongWithHash, hash)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const clearSongs = `-- name: ClearSongs :exec
DELETE FROM song
`

func (q *Queries) ClearSongs(ctx context.Context) error {
	_, err := q.db.Exec(ctx, clearSongs)
	return err
}

const clearSongsBySoundtrackId = `-- name: ClearSongsBySoundtrackId :exec
DELETE FROM song WHERE soundtrack_id = $1
`

func (q *Queries) ClearSongsBySoundtrackId(ctx context.Context, soundtrackID int32) error {
	_, err := q.db.Exec(ctx, clearSongsBySoundtrackId, soundtrackID)
	return err
}

const fetchAllSongs = `-- name: FetchAllSongs :many
SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id, uuid FROM song
`

func (q *Queries) FetchAllSongs(ctx context.Context) ([]Song, error) {
	rows, err := q.db.Query(ctx, fetchAllSongs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Song
	for rows.Next() {
		var i Song
		if err := rows.Scan(
			&i.SoundtrackID,
			&i.SongName,
			&i.Path,
			&i.TimesPlayed,
			&i.Hash,
			&i.FileName,
			&i.ID,
			&i.Uuid,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const findSongsFromSoundtrack = `-- name: FindSongsFromSoundtrack :many
SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id, uuid
FROM song
WHERE soundtrack_id = $1
`

func (q *Queries) FindSongsFromSoundtrack(ctx context.Context, soundtrackID int32) ([]Song, error) {
	rows, err := q.db.Query(ctx, findSongsFromSoundtrack, soundtrackID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Song
	for rows.Next() {
		var i Song
		if err := rows.Scan(
			&i.SoundtrackID,
			&i.SongName,
			&i.Path,
			&i.TimesPlayed,
			&i.Hash,
			&i.FileName,
			&i.ID,
			&i.Uuid,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getSongById = `-- name: GetSongById :one
SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id, uuid FROM song WHERE id = $1
`

func (q *Queries) GetSongById(ctx context.Context, id pgtype.Int4) (Song, error) {
	row := q.db.QueryRow(ctx, getSongById, id)
	var i Song
	err := row.Scan(
		&i.SoundtrackID,
		&i.SongName,
		&i.Path,
		&i.TimesPlayed,
		&i.Hash,
		&i.FileName,
		&i.ID,
		&i.Uuid,
	)
	return i, err
}

const getSongWithHash = `-- name: GetSongWithHash :one
SELECT soundtrack_id, song_name, path, times_played, hash, file_name, id, uuid FROM song WHERE hash = $1
`

func (q *Queries) GetSongWithHash(ctx context.Context, hash string) (Song, error) {
	row := q.db.QueryRow(ctx, getSongWithHash, hash)
	var i Song
	err := row.Scan(
		&i.SoundtrackID,
		&i.SongName,
		&i.Path,
		&i.TimesPlayed,
		&i.Hash,
		&i.FileName,
		&i.ID,
		&i.Uuid,
	)
	return i, err
}

const removeBrokenSong = `-- name: RemoveBrokenSong :exec
DELETE FROM song WHERE soundtrack_id = $1 AND path = $2
`

type RemoveBrokenSongParams struct {
	SoundtrackID int32  `json:"soundtrack_id"`
	Path         string `json:"path"`
}

func (q *Queries) RemoveBrokenSong(ctx context.Context, arg RemoveBrokenSongParams) error {
	_, err := q.db.Exec(ctx, removeBrokenSong, arg.SoundtrackID, arg.Path)
	return err
}

const removeBrokenSongs = `-- name: RemoveBrokenSongs :exec
DELETE FROM song WHERE id = ANY($1)
`

func (q *Queries) RemoveBrokenSongs(ctx context.Context, id pgtype.Int4) error {
	_, err := q.db.Exec(ctx, removeBrokenSongs, id)
	return err
}

const updateSong = `-- name: UpdateSong :exec
UPDATE song SET song_name=$1, file_name=$2, path=$3 where hash=$4
`

type UpdateSongParams struct {
	SongName string  `json:"song_name"`
	FileName *string `json:"file_name"`
	Path     string  `json:"path"`
	Hash     string  `json:"hash"`
}

func (q *Queries) UpdateSong(ctx context.Context, arg UpdateSongParams) error {
	_, err := q.db.Exec(ctx, updateSong,
		arg.SongName,
		arg.FileName,
		arg.Path,
		arg.Hash,
	)
	return err
}