path: root/backend/db/query.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.28.0
// source: query.sql

package db

import (
	"context"

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

const addMainPlayer = `-- name: AddMainPlayer :exec
INSERT INTO game_main_players (game_id, user_id)
VALUES ($1, $2)
`

type AddMainPlayerParams struct {
	GameID int32
	UserID int32
}

func (q *Queries) AddMainPlayer(ctx context.Context, arg AddMainPlayerParams) error {
	_, err := q.db.Exec(ctx, addMainPlayer, arg.GameID, arg.UserID)
	return err
}

const aggregateTestcaseResults = `-- name: AggregateTestcaseResults :one
SELECT
    CASE
        WHEN COUNT(*) < (SELECT COUNT(*) FROM testcases WHERE problem_id =
                         (SELECT problem_id FROM games WHERE game_id =
                          (SELECT game_id FROM submissions AS s WHERE s.submission_id = $1)))
        THEN 'running'
        WHEN COUNT(CASE WHEN r.status = 'internal_error' THEN 1 END) > 0 THEN 'internal_error'
        WHEN COUNT(CASE WHEN r.status = 'timeout'        THEN 1 END) > 0 THEN 'timeout'
        WHEN COUNT(CASE WHEN r.status = 'runtime_error'  THEN 1 END) > 0 THEN 'runtime_error'
        WHEN COUNT(CASE WHEN r.status = 'wrong_answer'   THEN 1 END) > 0 THEN 'wrong_answer'
        ELSE 'success'
    END AS status
FROM testcase_results AS r
WHERE r.submission_id = $1
`

func (q *Queries) AggregateTestcaseResults(ctx context.Context, submissionID int32) (string, error) {
	row := q.db.QueryRow(ctx, aggregateTestcaseResults, submissionID)
	var status string
	err := row.Scan(&status)
	return status, err
}

const createGame = `-- name: CreateGame :one
INSERT INTO games (game_type, is_public, display_name, duration_seconds, problem_id)
VALUES ($1, $2, $3, $4, $5)
RETURNING game_id
`

type CreateGameParams struct {
	GameType        string
	IsPublic        bool
	DisplayName     string
	DurationSeconds int32
	ProblemID       int32
}

func (q *Queries) CreateGame(ctx context.Context, arg CreateGameParams) (int32, error) {
	row := q.db.QueryRow(ctx, createGame,
		arg.GameType,
		arg.IsPublic,
		arg.DisplayName,
		arg.DurationSeconds,
		arg.ProblemID,
	)
	var game_id int32
	err := row.Scan(&game_id)
	return game_id, err
}

const createProblem = `-- name: CreateProblem :one
INSERT INTO problems (title, description, language, sample_code)
VALUES ($1, $2, $3, $4)
RETURNING problem_id
`

type CreateProblemParams struct {
	Title       string
	Description string
	Language    string
	SampleCode  string
}

func (q *Queries) CreateProblem(ctx context.Context, arg CreateProblemParams) (int32, error) {
	row := q.db.QueryRow(ctx, createProblem,
		arg.Title,
		arg.Description,
		arg.Language,
		arg.SampleCode,
	)
	var problem_id int32
	err := row.Scan(&problem_id)
	return problem_id, err
}

const createSubmission = `-- name: CreateSubmission :one
INSERT INTO submissions (game_id, user_id, code, code_size, status)
VALUES ($1, $2, $3, $4, 'running')
RETURNING submission_id
`

type CreateSubmissionParams struct {
	GameID   int32
	UserID   int32
	Code     string
	CodeSize int32
}

func (q *Queries) CreateSubmission(ctx context.Context, arg CreateSubmissionParams) (int32, error) {
	row := q.db.QueryRow(ctx, createSubmission,
		arg.GameID,
		arg.UserID,
		arg.Code,
		arg.CodeSize,
	)
	var submission_id int32
	err := row.Scan(&submission_id)
	return submission_id, err
}

const createTestcase = `-- name: CreateTestcase :one
INSERT INTO testcases (problem_id, stdin, stdout)
VALUES ($1, $2, $3)
RETURNING testcase_id
`

type CreateTestcaseParams struct {
	ProblemID int32
	Stdin     string
	Stdout    string
}

func (q *Queries) CreateTestcase(ctx context.Context, arg CreateTestcaseParams) (int32, error) {
	row := q.db.QueryRow(ctx, createTestcase, arg.ProblemID, arg.Stdin, arg.Stdout)
	var testcase_id int32
	err := row.Scan(&testcase_id)
	return testcase_id, err
}

const createTestcaseResult = `-- name: CreateTestcaseResult :exec
INSERT INTO testcase_results (submission_id, testcase_id, status, stdout, stderr)
VALUES ($1, $2, $3, $4, $5)
`

type CreateTestcaseResultParams struct {
	SubmissionID int32
	TestcaseID   int32
	Status       string
	Stdout       string
	Stderr       string
}

func (q *Queries) CreateTestcaseResult(ctx context.Context, arg CreateTestcaseResultParams) error {
	_, err := q.db.Exec(ctx, createTestcaseResult,
		arg.SubmissionID,
		arg.TestcaseID,
		arg.Status,
		arg.Stdout,
		arg.Stderr,
	)
	return err
}

const createUser = `-- name: CreateUser :one
INSERT INTO users (username, display_name, is_admin)
VALUES ($1, $1, false)
RETURNING user_id
`

func (q *Queries) CreateUser(ctx context.Context, username string) (int32, error) {
	row := q.db.QueryRow(ctx, createUser, username)
	var user_id int32
	err := row.Scan(&user_id)
	return user_id, err
}

const createUserAuth = `-- name: CreateUserAuth :exec
INSERT INTO user_auths (user_id, auth_type)
VALUES ($1, $2)
`

type CreateUserAuthParams struct {
	UserID   int32
	AuthType string
}

func (q *Queries) CreateUserAuth(ctx context.Context, arg CreateUserAuthParams) error {
	_, err := q.db.Exec(ctx, createUserAuth, arg.UserID, arg.AuthType)
	return err
}

const deleteTestcase = `-- name: DeleteTestcase :exec
DELETE FROM testcases
WHERE testcase_id = $1
`

func (q *Queries) DeleteTestcase(ctx context.Context, testcaseID int32) error {
	_, err := q.db.Exec(ctx, deleteTestcase, testcaseID)
	return err
}

const getGameByID = `-- name: GetGameByID :one
SELECT game_id, game_type, is_public, display_name, duration_seconds, created_at, started_at, games.problem_id, problems.problem_id, title, description, language, sample_code FROM games
JOIN problems ON games.problem_id = problems.problem_id
WHERE games.game_id = $1
LIMIT 1
`

type GetGameByIDRow struct {
	GameID          int32
	GameType        string
	IsPublic        bool
	DisplayName     string
	DurationSeconds int32
	CreatedAt       pgtype.Timestamp
	StartedAt       pgtype.Timestamp
	ProblemID       int32
	ProblemID_2     int32
	Title           string
	Description     string
	Language        string
	SampleCode      string
}

func (q *Queries) GetGameByID(ctx context.Context, gameID int32) (GetGameByIDRow, error) {
	row := q.db.QueryRow(ctx, getGameByID, gameID)
	var i GetGameByIDRow
	err := row.Scan(
		&i.GameID,
		&i.GameType,
		&i.IsPublic,
		&i.DisplayName,
		&i.DurationSeconds,
		&i.CreatedAt,
		&i.StartedAt,
		&i.ProblemID,
		&i.ProblemID_2,
		&i.Title,
		&i.Description,
		&i.Language,
		&i.SampleCode,
	)
	return i, err
}

const getLatestState = `-- name: GetLatestState :one
SELECT game_states.game_id, game_states.user_id, game_states.code, game_states.status, best_score_submission_id, submission_id, submissions.game_id, submissions.user_id, submissions.code, code_size, submissions.status, created_at FROM game_states
LEFT JOIN submissions ON game_states.best_score_submission_id = submissions.submission_id
WHERE game_states.game_id = $1 AND game_states.user_id = $2
LIMIT 1
`

type GetLatestStateParams struct {
	GameID int32
	UserID int32
}

type GetLatestStateRow struct {
	GameID                int32
	UserID                int32
	Code                  string
	Status                string
	BestScoreSubmissionID *int32
	SubmissionID          *int32
	GameID_2              *int32
	UserID_2              *int32
	Code_2                *string
	CodeSize              *int32
	Status_2              *string
	CreatedAt             pgtype.Timestamp
}

func (q *Queries) GetLatestState(ctx context.Context, arg GetLatestStateParams) (GetLatestStateRow, error) {
	row := q.db.QueryRow(ctx, getLatestState, arg.GameID, arg.UserID)
	var i GetLatestStateRow
	err := row.Scan(
		&i.GameID,
		&i.UserID,
		&i.Code,
		&i.Status,
		&i.BestScoreSubmissionID,
		&i.SubmissionID,
		&i.GameID_2,
		&i.UserID_2,
		&i.Code_2,
		&i.CodeSize,
		&i.Status_2,
		&i.CreatedAt,
	)
	return i, err
}

const getLatestStatesOfMainPlayers = `-- name: GetLatestStatesOfMainPlayers :many
SELECT game_main_players.game_id, game_main_players.user_id, game_states.game_id, game_states.user_id, game_states.code, game_states.status, best_score_submission_id, submission_id, submissions.game_id, submissions.user_id, submissions.code, code_size, submissions.status, created_at FROM game_main_players
LEFT JOIN game_states ON game_main_players.game_id = game_states.game_id AND game_main_players.user_id = game_states.user_id
LEFT JOIN submissions ON game_states.best_score_submission_id = submissions.submission_id
WHERE game_main_players.game_id = $1
`

type GetLatestStatesOfMainPlayersRow struct {
	GameID                int32
	UserID                int32
	GameID_2              *int32
	UserID_2              *int32
	Code                  *string
	Status                *string
	BestScoreSubmissionID *int32
	SubmissionID          *int32
	GameID_3              *int32
	UserID_3              *int32
	Code_2                *string
	CodeSize              *int32
	Status_2              *string
	CreatedAt             pgtype.Timestamp
}

func (q *Queries) GetLatestStatesOfMainPlayers(ctx context.Context, gameID int32) ([]GetLatestStatesOfMainPlayersRow, error) {
	rows, err := q.db.Query(ctx, getLatestStatesOfMainPlayers, gameID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetLatestStatesOfMainPlayersRow
	for rows.Next() {
		var i GetLatestStatesOfMainPlayersRow
		if err := rows.Scan(
			&i.GameID,
			&i.UserID,
			&i.GameID_2,
			&i.UserID_2,
			&i.Code,
			&i.Status,
			&i.BestScoreSubmissionID,
			&i.SubmissionID,
			&i.GameID_3,
			&i.UserID_3,
			&i.Code_2,
			&i.CodeSize,
			&i.Status_2,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getProblemByID = `-- name: GetProblemByID :one
SELECT problem_id, title, description, language, sample_code FROM problems
WHERE problem_id = $1
LIMIT 1
`

func (q *Queries) GetProblemByID(ctx context.Context, problemID int32) (Problem, error) {
	row := q.db.QueryRow(ctx, getProblemByID, problemID)
	var i Problem
	err := row.Scan(
		&i.ProblemID,
		&i.Title,
		&i.Description,
		&i.Language,
		&i.SampleCode,
	)
	return i, err
}

const getQualifyingRanking = `-- name: GetQualifyingRanking :many
SELECT
    u.username AS username,
    u.label AS user_label,
    s1.code_size AS code_size_1,
    s2.code_size AS code_size_2,
    s3.code_size AS code_size_3,
    (COALESCE(s1.code_size, 0) + COALESCE(s2.code_size, 0) + COALESCE(s3.code_size, 0)) AS total_code_size,
    s1.created_at AS submitted_at_1,
    s2.created_at AS submitted_at_2,
    s3.created_at AS submitted_at_3
FROM game_states gs1
JOIN submissions s1 ON gs1.best_score_submission_id = s1.submission_id
JOIN game_states gs2 ON gs1.user_id = gs2.user_id
JOIN submissions s2 ON gs2.best_score_submission_id = s2.submission_id
JOIN game_states gs3 ON gs1.user_id = gs3.user_id
JOIN submissions s3 ON gs3.best_score_submission_id = s3.submission_id
JOIN users u ON gs1.user_id = u.user_id
WHERE gs1.game_id = $1 AND gs2.game_id = $2 AND gs3.game_id = $3
ORDER BY total_code_size ASC
`

type GetQualifyingRankingParams struct {
	GameID   int32
	GameID_2 int32
	GameID_3 int32
}

type GetQualifyingRankingRow struct {
	Username      string
	UserLabel     *string
	CodeSize1     int32
	CodeSize2     int32
	CodeSize3     int32
	TotalCodeSize int32
	SubmittedAt1  pgtype.Timestamp
	SubmittedAt2  pgtype.Timestamp
	SubmittedAt3  pgtype.Timestamp
}

func (q *Queries) GetQualifyingRanking(ctx context.Context, arg GetQualifyingRankingParams) ([]GetQualifyingRankingRow, error) {
	rows, err := q.db.Query(ctx, getQualifyingRanking, arg.GameID, arg.GameID_2, arg.GameID_3)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetQualifyingRankingRow
	for rows.Next() {
		var i GetQualifyingRankingRow
		if err := rows.Scan(
			&i.Username,
			&i.UserLabel,
			&i.CodeSize1,
			&i.CodeSize2,
			&i.CodeSize3,
			&i.TotalCodeSize,
			&i.SubmittedAt1,
			&i.SubmittedAt2,
			&i.SubmittedAt3,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getRanking = `-- name: GetRanking :many
SELECT
    submissions.submission_id, submissions.game_id, submissions.user_id, submissions.code, submissions.code_size, submissions.status, submissions.created_at,
    users.user_id, users.username, users.display_name, users.icon_path, users.is_admin, users.label, users.created_at
FROM game_states
JOIN users ON game_states.user_id = users.user_id
JOIN submissions ON game_states.best_score_submission_id = submissions.submission_id
WHERE game_states.game_id = $1
ORDER BY submissions.code_size ASC, submissions.created_at ASC
LIMIT 30
`

type GetRankingRow struct {
	Submission Submission
	User       User
}

func (q *Queries) GetRanking(ctx context.Context, gameID int32) ([]GetRankingRow, error) {
	rows, err := q.db.Query(ctx, getRanking, gameID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetRankingRow
	for rows.Next() {
		var i GetRankingRow
		if err := rows.Scan(
			&i.Submission.SubmissionID,
			&i.Submission.GameID,
			&i.Submission.UserID,
			&i.Submission.Code,
			&i.Submission.CodeSize,
			&i.Submission.Status,
			&i.Submission.CreatedAt,
			&i.User.UserID,
			&i.User.Username,
			&i.User.DisplayName,
			&i.User.IconPath,
			&i.User.IsAdmin,
			&i.User.Label,
			&i.User.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTestcaseByID = `-- name: GetTestcaseByID :one
SELECT testcase_id, problem_id, stdin, stdout FROM testcases
WHERE testcase_id = $1
LIMIT 1
`

func (q *Queries) GetTestcaseByID(ctx context.Context, testcaseID int32) (Testcase, error) {
	row := q.db.QueryRow(ctx, getTestcaseByID, testcaseID)
	var i Testcase
	err := row.Scan(
		&i.TestcaseID,
		&i.ProblemID,
		&i.Stdin,
		&i.Stdout,
	)
	return i, err
}

const getUserAuthByUsername = `-- name: GetUserAuthByUsername :one
SELECT users.user_id, username, display_name, icon_path, is_admin, label, created_at, user_auth_id, user_auths.user_id, auth_type, password_hash FROM users
JOIN user_auths ON users.user_id = user_auths.user_id
WHERE users.username = $1
LIMIT 1
`

type GetUserAuthByUsernameRow struct {
	UserID       int32
	Username     string
	DisplayName  string
	IconPath     *string
	IsAdmin      bool
	Label        *string
	CreatedAt    pgtype.Timestamp
	UserAuthID   int32
	UserID_2     int32
	AuthType     string
	PasswordHash *string
}

func (q *Queries) GetUserAuthByUsername(ctx context.Context, username string) (GetUserAuthByUsernameRow, error) {
	row := q.db.QueryRow(ctx, getUserAuthByUsername, username)
	var i GetUserAuthByUsernameRow
	err := row.Scan(
		&i.UserID,
		&i.Username,
		&i.DisplayName,
		&i.IconPath,
		&i.IsAdmin,
		&i.Label,
		&i.CreatedAt,
		&i.UserAuthID,
		&i.UserID_2,
		&i.AuthType,
		&i.PasswordHash,
	)
	return i, err
}

const getUserByID = `-- name: GetUserByID :one
SELECT user_id, username, display_name, icon_path, is_admin, label, created_at FROM users
WHERE users.user_id = $1
LIMIT 1
`

func (q *Queries) GetUserByID(ctx context.Context, userID int32) (User, error) {
	row := q.db.QueryRow(ctx, getUserByID, userID)
	var i User
	err := row.Scan(
		&i.UserID,
		&i.Username,
		&i.DisplayName,
		&i.IconPath,
		&i.IsAdmin,
		&i.Label,
		&i.CreatedAt,
	)
	return i, err
}

const getUserIDByUsername = `-- name: GetUserIDByUsername :one
SELECT user_id FROM users
WHERE users.username = $1
LIMIT 1
`

func (q *Queries) GetUserIDByUsername(ctx context.Context, username string) (int32, error) {
	row := q.db.QueryRow(ctx, getUserIDByUsername, username)
	var user_id int32
	err := row.Scan(&user_id)
	return user_id, err
}

const listAllGames = `-- name: ListAllGames :many
SELECT game_id, game_type, is_public, display_name, duration_seconds, created_at, started_at, problem_id FROM games
ORDER BY games.game_id
`

func (q *Queries) ListAllGames(ctx context.Context) ([]Game, error) {
	rows, err := q.db.Query(ctx, listAllGames)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Game
	for rows.Next() {
		var i Game
		if err := rows.Scan(
			&i.GameID,
			&i.GameType,
			&i.IsPublic,
			&i.DisplayName,
			&i.DurationSeconds,
			&i.CreatedAt,
			&i.StartedAt,
			&i.ProblemID,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listGameStateIDs = `-- name: ListGameStateIDs :many
SELECT game_id, user_id FROM game_states
`

type ListGameStateIDsRow struct {
	GameID int32
	UserID int32
}

func (q *Queries) ListGameStateIDs(ctx context.Context) ([]ListGameStateIDsRow, error) {
	rows, err := q.db.Query(ctx, listGameStateIDs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListGameStateIDsRow
	for rows.Next() {
		var i ListGameStateIDsRow
		if err := rows.Scan(&i.GameID, &i.UserID); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listMainPlayers = `-- name: ListMainPlayers :many
SELECT game_id, game_main_players.user_id, users.user_id, username, display_name, icon_path, is_admin, label, created_at FROM game_main_players
JOIN users ON game_main_players.user_id = users.user_id
WHERE game_main_players.game_id = ANY($1::INT[])
ORDER BY game_main_players.user_id
`

type ListMainPlayersRow struct {
	GameID      int32
	UserID      int32
	UserID_2    int32
	Username    string
	DisplayName string
	IconPath    *string
	IsAdmin     bool
	Label       *string
	CreatedAt   pgtype.Timestamp
}

func (q *Queries) ListMainPlayers(ctx context.Context, dollar_1 []int32) ([]ListMainPlayersRow, error) {
	rows, err := q.db.Query(ctx, listMainPlayers, dollar_1)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListMainPlayersRow
	for rows.Next() {
		var i ListMainPlayersRow
		if err := rows.Scan(
			&i.GameID,
			&i.UserID,
			&i.UserID_2,
			&i.Username,
			&i.DisplayName,
			&i.IconPath,
			&i.IsAdmin,
			&i.Label,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listProblems = `-- name: ListProblems :many
SELECT problem_id, title, description, language, sample_code FROM problems
ORDER BY problem_id
`

func (q *Queries) ListProblems(ctx context.Context) ([]Problem, error) {
	rows, err := q.db.Query(ctx, listProblems)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Problem
	for rows.Next() {
		var i Problem
		if err := rows.Scan(
			&i.ProblemID,
			&i.Title,
			&i.Description,
			&i.Language,
			&i.SampleCode,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listPublicGames = `-- name: ListPublicGames :many
SELECT game_id, game_type, is_public, display_name, duration_seconds, created_at, started_at, games.problem_id, problems.problem_id, title, description, language, sample_code FROM games
JOIN problems ON games.problem_id = problems.problem_id
WHERE is_public = true
ORDER BY games.game_id
`

type ListPublicGamesRow struct {
	GameID          int32
	GameType        string
	IsPublic        bool
	DisplayName     string
	DurationSeconds int32
	CreatedAt       pgtype.Timestamp
	StartedAt       pgtype.Timestamp
	ProblemID       int32
	ProblemID_2     int32
	Title           string
	Description     string
	Language        string
	SampleCode      string
}

func (q *Queries) ListPublicGames(ctx context.Context) ([]ListPublicGamesRow, error) {
	rows, err := q.db.Query(ctx, listPublicGames)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListPublicGamesRow
	for rows.Next() {
		var i ListPublicGamesRow
		if err := rows.Scan(
			&i.GameID,
			&i.GameType,
			&i.IsPublic,
			&i.DisplayName,
			&i.DurationSeconds,
			&i.CreatedAt,
			&i.StartedAt,
			&i.ProblemID,
			&i.ProblemID_2,
			&i.Title,
			&i.Description,
			&i.Language,
			&i.SampleCode,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listSubmissionIDs = `-- name: ListSubmissionIDs :many
SELECT submission_id FROM submissions
`

func (q *Queries) ListSubmissionIDs(ctx context.Context) ([]int32, error) {
	rows, err := q.db.Query(ctx, listSubmissionIDs)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []int32
	for rows.Next() {
		var submission_id int32
		if err := rows.Scan(&submission_id); err != nil {
			return nil, err
		}
		items = append(items, submission_id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listTestcases = `-- name: ListTestcases :many
SELECT testcase_id, problem_id, stdin, stdout FROM testcases
ORDER BY testcase_id
`

func (q *Queries) ListTestcases(ctx context.Context) ([]Testcase, error) {
	rows, err := q.db.Query(ctx, listTestcases)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Testcase
	for rows.Next() {
		var i Testcase
		if err := rows.Scan(
			&i.TestcaseID,
			&i.ProblemID,
			&i.Stdin,
			&i.Stdout,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listTestcasesByGameID = `-- name: ListTestcasesByGameID :many
SELECT testcase_id, problem_id, stdin, stdout FROM testcases
WHERE testcases.problem_id = (SELECT problem_id FROM games WHERE game_id = $1)
ORDER BY testcases.testcase_id
`

func (q *Queries) ListTestcasesByGameID(ctx context.Context, gameID int32) ([]Testcase, error) {
	rows, err := q.db.Query(ctx, listTestcasesByGameID, gameID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Testcase
	for rows.Next() {
		var i Testcase
		if err := rows.Scan(
			&i.TestcaseID,
			&i.ProblemID,
			&i.Stdin,
			&i.Stdout,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listTestcasesByProblemID = `-- name: ListTestcasesByProblemID :many
SELECT testcase_id, problem_id, stdin, stdout FROM testcases
WHERE problem_id = $1
ORDER BY testcase_id
`

func (q *Queries) ListTestcasesByProblemID(ctx context.Context, problemID int32) ([]Testcase, error) {
	rows, err := q.db.Query(ctx, listTestcasesByProblemID, problemID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Testcase
	for rows.Next() {
		var i Testcase
		if err := rows.Scan(
			&i.TestcaseID,
			&i.ProblemID,
			&i.Stdin,
			&i.Stdout,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listUsers = `-- name: ListUsers :many
SELECT user_id, username, display_name, icon_path, is_admin, label, created_at FROM users
ORDER BY users.user_id
`

func (q *Queries) ListUsers(ctx context.Context) ([]User, error) {
	rows, err := q.db.Query(ctx, listUsers)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(
			&i.UserID,
			&i.Username,
			&i.DisplayName,
			&i.IconPath,
			&i.IsAdmin,
			&i.Label,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const removeAllMainPlayers = `-- name: RemoveAllMainPlayers :exec
DELETE FROM game_main_players
WHERE game_id = $1
`

func (q *Queries) RemoveAllMainPlayers(ctx context.Context, gameID int32) error {
	_, err := q.db.Exec(ctx, removeAllMainPlayers, gameID)
	return err
}

const syncGameStateBestScoreSubmission = `-- name: SyncGameStateBestScoreSubmission :exec
UPDATE game_states
SET best_score_submission_id = (
    SELECT submission_id FROM submissions AS s
    WHERE s.game_id = $1 AND s.user_id = $2 AND s.status = 'success'
    ORDER BY s.code_size ASC, s.created_at ASC
    LIMIT 1
)
WHERE game_id = $1 AND user_id = $2
`

type SyncGameStateBestScoreSubmissionParams struct {
	GameID int32
	UserID int32
}

func (q *Queries) SyncGameStateBestScoreSubmission(ctx context.Context, arg SyncGameStateBestScoreSubmissionParams) error {
	_, err := q.db.Exec(ctx, syncGameStateBestScoreSubmission, arg.GameID, arg.UserID)
	return err
}

const updateCode = `-- name: UpdateCode :exec
INSERT INTO game_states (game_id, user_id, code, status)
VALUES ($1, $2, $3, $4)
ON CONFLICT (game_id, user_id)
DO UPDATE SET code = EXCLUDED.code
`

type UpdateCodeParams struct {
	GameID int32
	UserID int32
	Code   string
	Status string
}

func (q *Queries) UpdateCode(ctx context.Context, arg UpdateCodeParams) error {
	_, err := q.db.Exec(ctx, updateCode,
		arg.GameID,
		arg.UserID,
		arg.Code,
		arg.Status,
	)
	return err
}

const updateCodeAndStatus = `-- name: UpdateCodeAndStatus :exec
INSERT INTO game_states (game_id, user_id, code, status)
VALUES ($1, $2, $3, $4)
ON CONFLICT (game_id, user_id)
DO UPDATE SET code = EXCLUDED.code, status = EXCLUDED.status
`

type UpdateCodeAndStatusParams struct {
	GameID int32
	UserID int32
	Code   string
	Status string
}

func (q *Queries) UpdateCodeAndStatus(ctx context.Context, arg UpdateCodeAndStatusParams) error {
	_, err := q.db.Exec(ctx, updateCodeAndStatus,
		arg.GameID,
		arg.UserID,
		arg.Code,
		arg.Status,
	)
	return err
}

const updateGame = `-- name: UpdateGame :exec
UPDATE games
SET
    game_type = $2,
    is_public = $3,
    display_name = $4,
    duration_seconds = $5,
    started_at = $6,
    problem_id = $7
WHERE game_id = $1
`

type UpdateGameParams struct {
	GameID          int32
	GameType        string
	IsPublic        bool
	DisplayName     string
	DurationSeconds int32
	StartedAt       pgtype.Timestamp
	ProblemID       int32
}

func (q *Queries) UpdateGame(ctx context.Context, arg UpdateGameParams) error {
	_, err := q.db.Exec(ctx, updateGame,
		arg.GameID,
		arg.GameType,
		arg.IsPublic,
		arg.DisplayName,
		arg.DurationSeconds,
		arg.StartedAt,
		arg.ProblemID,
	)
	return err
}

const updateGameStartedAt = `-- name: UpdateGameStartedAt :exec
UPDATE games
SET started_at = $2
WHERE game_id = $1
`

type UpdateGameStartedAtParams struct {
	GameID    int32
	StartedAt pgtype.Timestamp
}

func (q *Queries) UpdateGameStartedAt(ctx context.Context, arg UpdateGameStartedAtParams) error {
	_, err := q.db.Exec(ctx, updateGameStartedAt, arg.GameID, arg.StartedAt)
	return err
}

const updateGameStateStatus = `-- name: UpdateGameStateStatus :exec
UPDATE game_states
SET status = $3
WHERE game_id = $1 AND user_id = $2
`

type UpdateGameStateStatusParams struct {
	GameID int32
	UserID int32
	Status string
}

func (q *Queries) UpdateGameStateStatus(ctx context.Context, arg UpdateGameStateStatusParams) error {
	_, err := q.db.Exec(ctx, updateGameStateStatus, arg.GameID, arg.UserID, arg.Status)
	return err
}

const updateProblem = `-- name: UpdateProblem :exec
UPDATE problems
SET
    title = $2,
    description = $3,
    language = $4,
    sample_code = $5
WHERE problem_id = $1
`

type UpdateProblemParams struct {
	ProblemID   int32
	Title       string
	Description string
	Language    string
	SampleCode  string
}

func (q *Queries) UpdateProblem(ctx context.Context, arg UpdateProblemParams) error {
	_, err := q.db.Exec(ctx, updateProblem,
		arg.ProblemID,
		arg.Title,
		arg.Description,
		arg.Language,
		arg.SampleCode,
	)
	return err
}

const updateSubmissionStatus = `-- name: UpdateSubmissionStatus :exec
UPDATE submissions
SET status = $2
WHERE submission_id = $1
`

type UpdateSubmissionStatusParams struct {
	SubmissionID int32
	Status       string
}

func (q *Queries) UpdateSubmissionStatus(ctx context.Context, arg UpdateSubmissionStatusParams) error {
	_, err := q.db.Exec(ctx, updateSubmissionStatus, arg.SubmissionID, arg.Status)
	return err
}

const updateTestcase = `-- name: UpdateTestcase :exec
UPDATE testcases
SET
    problem_id = $2,
    stdin = $3,
    stdout = $4
WHERE testcase_id = $1
`

type UpdateTestcaseParams struct {
	TestcaseID int32
	ProblemID  int32
	Stdin      string
	Stdout     string
}

func (q *Queries) UpdateTestcase(ctx context.Context, arg UpdateTestcaseParams) error {
	_, err := q.db.Exec(ctx, updateTestcase,
		arg.TestcaseID,
		arg.ProblemID,
		arg.Stdin,
		arg.Stdout,
	)
	return err
}

const updateUser = `-- name: UpdateUser :exec
UPDATE users
SET
    display_name = $2,
    icon_path = $3,
    is_admin = $4,
    label = $5
WHERE user_id = $1
`

type UpdateUserParams struct {
	UserID      int32
	DisplayName string
	IconPath    *string
	IsAdmin     bool
	Label       *string
}

func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) error {
	_, err := q.db.Exec(ctx, updateUser,
		arg.UserID,
		arg.DisplayName,
		arg.IconPath,
		arg.IsAdmin,
		arg.Label,
	)
	return err
}

const updateUserIconPath = `-- name: UpdateUserIconPath :exec
UPDATE users
SET icon_path = $2
WHERE user_id = $1
`

type UpdateUserIconPathParams struct {
	UserID   int32
	IconPath *string
}

func (q *Queries) UpdateUserIconPath(ctx context.Context, arg UpdateUserIconPathParams) error {
	_, err := q.db.Exec(ctx, updateUserIconPath, arg.UserID, arg.IconPath)
	return err
}