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

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

package repository

import (
	"context"
)

const addGamePlayed = `-- name: AddGamePlayed :exec
UPDATE game SET times_played = times_played + 1, last_played = now() WHERE id = $1
`

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

const clearGames = `-- name: ClearGames :exec
DELETE FROM game
`

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

const findAllGames = `-- name: FindAllGames :many
SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash
FROM game
WHERE deleted IS NULL
ORDER BY game_name
`

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

const getAllGamesIncludingDeleted = `-- name: GetAllGamesIncludingDeleted :many
SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash
FROM game
ORDER BY game_name
`

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

const getGameById = `-- name: GetGameById :one
SELECT id, game_name, added, deleted, last_changed, path, times_played, last_played, number_of_songs, hash 
FROM game 
WHERE id = $1 
AND deleted IS NULL
`

func (q *Queries) GetGameById(ctx context.Context, id int32) (Game, error) {
	row := q.db.QueryRow(ctx, getGameById, id)
	var i Game
	err := row.Scan(
		&i.ID,
		&i.GameName,
		&i.Added,
		&i.Deleted,
		&i.LastChanged,
		&i.Path,
		&i.TimesPlayed,
		&i.LastPlayed,
		&i.NumberOfSongs,
		&i.Hash,
	)
	return i, err
}

const getGameNameById = `-- name: GetGameNameById :one
SELECT game_name FROM game WHERE id = $1
`

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

const getIdByGameName = `-- name: GetIdByGameName :one
SELECT id FROM game WHERE game_name = $1
`

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

const insertGame = `-- name: InsertGame :one
INSERT INTO game (game_name, path, hash, added) VALUES ($1, $2, $3, now()) returning id
`

type InsertGameParams struct {
	GameName string `json:"game_name"`
	Path     string `json:"path"`
	Hash     string `json:"hash"`
}

func (q *Queries) InsertGame(ctx context.Context, arg InsertGameParams) (int32, error) {
	row := q.db.QueryRow(ctx, insertGame, arg.GameName, arg.Path, arg.Hash)
	var id int32
	err := row.Scan(&id)
	return id, err
}

const insertGameWithExistingId = `-- name: InsertGameWithExistingId :exec
INSERT INTO game (id, game_name, path, hash, added) VALUES ($1, $2, $3, $4, now())
`

type InsertGameWithExistingIdParams struct {
	ID       int32  `json:"id"`
	GameName string `json:"game_name"`
	Path     string `json:"path"`
	Hash     string `json:"hash"`
}

func (q *Queries) InsertGameWithExistingId(ctx context.Context, arg InsertGameWithExistingIdParams) error {
	_, err := q.db.Exec(ctx, insertGameWithExistingId,
		arg.ID,
		arg.GameName,
		arg.Path,
		arg.Hash,
	)
	return err
}

const removeDeletionDate = `-- name: RemoveDeletionDate :exec
UPDATE game SET deleted=NULL WHERE id=$1
`

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

const resetGameIdSeq = `-- name: ResetGameIdSeq :one
SELECT setval('game_id_seq', (SELECT MAX(id) FROM game)+1)
`

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

const setGameDeletionDate = `-- name: SetGameDeletionDate :exec
UPDATE game SET deleted=now() WHERE deleted IS NULL
`

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

const updateGameHash = `-- name: UpdateGameHash :exec
UPDATE game SET hash=$1, last_changed=now() WHERE id=$2
`

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

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

const updateGameName = `-- name: UpdateGameName :exec
UPDATE game SET game_name=$1, path=$2, last_changed=now() WHERE id=$3
`

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

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