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

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

package repository

import (
	"context"

	"github.com/google/uuid"
)

const addSoundtrackPlayed = `-- name: AddSoundtrackPlayed :exec
UPDATE soundtrack SET times_played = times_played + 1, last_played = now() WHERE id = $1
`

func (q *Queries) AddSoundtrackPlayed(ctx context.Context, id int32) error {
	_, err := q.db.Exec(ctx, addSoundtrackPlayed, id)
	return err
}

const clearSoundtracks = `-- name: ClearSoundtracks :exec
DELETE FROM soundtrack
`

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

const findAllSoundtracks = `-- name: FindAllSoundtracks :many
SELECT id, soundtrack_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash, uuid, fingerprint
FROM soundtrack
WHERE deleted IS NULL
ORDER BY soundtrack_name
`

func (q *Queries) FindAllSoundtracks(ctx context.Context) ([]Soundtrack, error) {
	rows, err := q.db.Query(ctx, findAllSoundtracks)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Soundtrack
	for rows.Next() {
		var i Soundtrack
		if err := rows.Scan(
			&i.ID,
			&i.SoundtrackName,
			&i.Added,
			&i.Deleted,
			&i.LastChanged,
			&i.Path,
			&i.TimesPlayed,
			&i.LastPlayed,
			&i.NumberOfSongs,
			&i.Hash,
			&i.Uuid,
			&i.Fingerprint,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getAllSoundtracksIncludingDeleted = `-- name: GetAllSoundtracksIncludingDeleted :many
SELECT id, soundtrack_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash, uuid, fingerprint
FROM soundtrack
ORDER BY soundtrack_name
`

func (q *Queries) GetAllSoundtracksIncludingDeleted(ctx context.Context) ([]Soundtrack, error) {
	rows, err := q.db.Query(ctx, getAllSoundtracksIncludingDeleted)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Soundtrack
	for rows.Next() {
		var i Soundtrack
		if err := rows.Scan(
			&i.ID,
			&i.SoundtrackName,
			&i.Added,
			&i.Deleted,
			&i.LastChanged,
			&i.Path,
			&i.TimesPlayed,
			&i.LastPlayed,
			&i.NumberOfSongs,
			&i.Hash,
			&i.Uuid,
			&i.Fingerprint,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getIdBySoundtrackName = `-- name: GetIdBySoundtrackName :one
SELECT id FROM soundtrack WHERE soundtrack_name = $1
`

func (q *Queries) GetIdBySoundtrackName(ctx context.Context, soundtrackName string) (int32, error) {
	row := q.db.QueryRow(ctx, getIdBySoundtrackName, soundtrackName)
	var id int32
	err := row.Scan(&id)
	return id, err
}

const getSoundtrackById = `-- name: GetSoundtrackById :one
SELECT id, soundtrack_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash, uuid, fingerprint 
FROM soundtrack 
WHERE id = $1 
AND deleted IS NULL
`

func (q *Queries) GetSoundtrackById(ctx context.Context, id int32) (Soundtrack, error) {
	row := q.db.QueryRow(ctx, getSoundtrackById, id)
	var i Soundtrack
	err := row.Scan(
		&i.ID,
		&i.SoundtrackName,
		&i.Added,
		&i.Deleted,
		&i.LastChanged,
		&i.Path,
		&i.TimesPlayed,
		&i.LastPlayed,
		&i.NumberOfSongs,
		&i.Hash,
		&i.Uuid,
		&i.Fingerprint,
	)
	return i, err
}

const getSoundtrackByUUID = `-- name: GetSoundtrackByUUID :one
SELECT id, soundtrack_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash, uuid, fingerprint 
FROM soundtrack 
WHERE uuid = $1 
AND deleted IS NULL
`

func (q *Queries) GetSoundtrackByUUID(ctx context.Context, argUuid uuid.UUID) (Soundtrack, error) {
	row := q.db.QueryRow(ctx, getSoundtrackByUUID, argUuid)
	var i Soundtrack
	err := row.Scan(
		&i.ID,
		&i.SoundtrackName,
		&i.Added,
		&i.Deleted,
		&i.LastChanged,
		&i.Path,
		&i.TimesPlayed,
		&i.LastPlayed,
		&i.NumberOfSongs,
		&i.Hash,
		&i.Uuid,
		&i.Fingerprint,
	)
	return i, err
}

const getSoundtrackNameById = `-- name: GetSoundtrackNameById :one
SELECT soundtrack_name FROM soundtrack WHERE id = $1
`

func (q *Queries) GetSoundtrackNameById(ctx context.Context, id int32) (string, error) {
	row := q.db.QueryRow(ctx, getSoundtrackNameById, id)
	var soundtrack_name string
	err := row.Scan(&soundtrack_name)
	return soundtrack_name, err
}

const getSoundtrackUUIDById = `-- name: GetSoundtrackUUIDById :one
SELECT uuid FROM soundtrack WHERE id = $1
`

func (q *Queries) GetSoundtrackUUIDById(ctx context.Context, id int32) (uuid.UUID, error) {
	row := q.db.QueryRow(ctx, getSoundtrackUUIDById, id)
	var uuid uuid.UUID
	err := row.Scan(&uuid)
	return uuid, err
}

const insertSoundtrack = `-- name: InsertSoundtrack :one
INSERT INTO soundtrack (soundtrack_name, path, hash, added, uuid) VALUES ($1, $2, $3, now(), $4) returning id, uuid
`

type InsertSoundtrackParams struct {
	SoundtrackName string    `json:"soundtrack_name"`
	Path           string    `json:"path"`
	Hash           string    `json:"hash"`
	Uuid           uuid.UUID `json:"uuid"`
}

type InsertSoundtrackRow struct {
	ID   int32     `json:"id"`
	Uuid uuid.UUID `json:"uuid"`
}

func (q *Queries) InsertSoundtrack(ctx context.Context, arg InsertSoundtrackParams) (InsertSoundtrackRow, error) {
	row := q.db.QueryRow(ctx, insertSoundtrack,
		arg.SoundtrackName,
		arg.Path,
		arg.Hash,
		arg.Uuid,
	)
	var i InsertSoundtrackRow
	err := row.Scan(&i.ID, &i.Uuid)
	return i, err
}

const insertSoundtrackWithExistingId = `-- name: InsertSoundtrackWithExistingId :exec
INSERT INTO soundtrack (id, soundtrack_name, path, hash, added) VALUES ($1, $2, $3, $4, now())
`

type InsertSoundtrackWithExistingIdParams struct {
	ID             int32  `json:"id"`
	SoundtrackName string `json:"soundtrack_name"`
	Path           string `json:"path"`
	Hash           string `json:"hash"`
}

func (q *Queries) InsertSoundtrackWithExistingId(ctx context.Context, arg InsertSoundtrackWithExistingIdParams) error {
	_, err := q.db.Exec(ctx, insertSoundtrackWithExistingId,
		arg.ID,
		arg.SoundtrackName,
		arg.Path,
		arg.Hash,
	)
	return err
}

const markSoundtracksDeletedExcept = `-- name: MarkSoundtracksDeletedExcept :exec
UPDATE soundtrack SET deleted=now() WHERE deleted IS NULL AND NOT (id = ANY($1::int[]))
`

func (q *Queries) MarkSoundtracksDeletedExcept(ctx context.Context, ids []int32) error {
	_, err := q.db.Exec(ctx, markSoundtracksDeletedExcept, ids)
	return err
}

const removeSoundtrackDeletionDate = `-- name: RemoveSoundtrackDeletionDate :exec
UPDATE soundtrack SET deleted=NULL WHERE id=$1
`

func (q *Queries) RemoveSoundtrackDeletionDate(ctx context.Context, id int32) error {
	_, err := q.db.Exec(ctx, removeSoundtrackDeletionDate, id)
	return err
}

const resetSoundtrackIdSeq = `-- name: ResetSoundtrackIdSeq :one
SELECT setval('soundtrack_id_seq', (SELECT MAX(id) FROM soundtrack)+1)
`

func (q *Queries) ResetSoundtrackIdSeq(ctx context.Context) (int64, error) {
	row := q.db.QueryRow(ctx, resetSoundtrackIdSeq)
	var setval int64
	err := row.Scan(&setval)
	return setval, err
}

const setSoundtrackDeletionDate = `-- name: SetSoundtrackDeletionDate :exec
UPDATE soundtrack SET deleted=now() WHERE deleted IS NULL
`

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

const setSoundtrackFingerprint = `-- name: SetSoundtrackFingerprint :exec
UPDATE soundtrack SET fingerprint=$1 WHERE id=$2
`

type SetSoundtrackFingerprintParams struct {
	Fingerprint string `json:"fingerprint"`
	ID          int32  `json:"id"`
}

func (q *Queries) SetSoundtrackFingerprint(ctx context.Context, arg SetSoundtrackFingerprintParams) error {
	_, err := q.db.Exec(ctx, setSoundtrackFingerprint, arg.Fingerprint, arg.ID)
	return err
}

const updateSoundtrackHash = `-- name: UpdateSoundtrackHash :exec
UPDATE soundtrack SET hash=$1, last_changed=now() WHERE id=$2
`

type UpdateSoundtrackHashParams struct {
	Hash string `json:"hash"`
	ID   int32  `json:"id"`
}

func (q *Queries) UpdateSoundtrackHash(ctx context.Context, arg UpdateSoundtrackHashParams) error {
	_, err := q.db.Exec(ctx, updateSoundtrackHash, arg.Hash, arg.ID)
	return err
}

const updateSoundtrackName = `-- name: UpdateSoundtrackName :exec
UPDATE soundtrack SET soundtrack_name=$1, path=$2, last_changed=now() WHERE id=$3
`

type UpdateSoundtrackNameParams struct {
	Name string `json:"name"`
	Path string `json:"path"`
	ID   int32  `json:"id"`
}

func (q *Queries) UpdateSoundtrackName(ctx context.Context, arg UpdateSoundtrackNameParams) error {
	_, err := q.db.Exec(ctx, updateSoundtrackName, arg.Name, arg.Path, arg.ID)
	return err
}