tijl.dev-core/internal/queries/app_flags.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.27.0
// source: app_flags.sql

package queries

import (
	"context"
	"database/sql"

	"github.com/google/uuid"
	"github.com/lib/pq"
)

const appFlagsCreateGame = `-- name: AppFlagsCreateGame :one
INSERT INTO app_flags_games (uid, tags, question_amount, seconds)
VALUES ($1, $2, $3, $4)
RETURNING game_id, game_seed
`

type AppFlagsCreateGameParams struct {
	Uid            sql.NullString
	Tags           []string
	QuestionAmount int32
	Seconds        int32
}

type AppFlagsCreateGameRow struct {
	GameID   uuid.UUID
	GameSeed uuid.UUID
}

func (q *Queries) AppFlagsCreateGame(ctx context.Context, arg AppFlagsCreateGameParams) (AppFlagsCreateGameRow, error) {
	row := q.db.QueryRowContext(ctx, appFlagsCreateGame,
		arg.Uid,
		pq.Array(arg.Tags),
		arg.QuestionAmount,
		arg.Seconds,
	)
	var i AppFlagsCreateGameRow
	err := row.Scan(&i.GameID, &i.GameSeed)
	return i, err
}

const appFlagsCreateGameWithSeed = `-- name: AppFlagsCreateGameWithSeed :one
INSERT INTO app_flags_games (uid, tags, question_amount, seconds, game_seed)
VALUES ($1, $2, $3, $4, $5)
RETURNING game_id
`

type AppFlagsCreateGameWithSeedParams struct {
	Uid            sql.NullString
	Tags           []string
	QuestionAmount int32
	Seconds        int32
	GameSeed       uuid.UUID
}

func (q *Queries) AppFlagsCreateGameWithSeed(ctx context.Context, arg AppFlagsCreateGameWithSeedParams) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, appFlagsCreateGameWithSeed,
		arg.Uid,
		pq.Array(arg.Tags),
		arg.QuestionAmount,
		arg.Seconds,
		arg.GameSeed,
	)
	var game_id uuid.UUID
	err := row.Scan(&game_id)
	return game_id, err
}

const appFlagsGetGame = `-- name: AppFlagsGetGame :one
SELECT game_id, game_seed, uid, tags, seconds, question_amount, question_current, questions_errors, created_at, last_activity FROM app_flags_games WHERE game_id = $1 LIMIT 1
`

func (q *Queries) AppFlagsGetGame(ctx context.Context, gameID uuid.UUID) (AppFlagsGame, error) {
	row := q.db.QueryRowContext(ctx, appFlagsGetGame, gameID)
	var i AppFlagsGame
	err := row.Scan(
		&i.GameID,
		&i.GameSeed,
		&i.Uid,
		pq.Array(&i.Tags),
		&i.Seconds,
		&i.QuestionAmount,
		&i.QuestionCurrent,
		&i.QuestionsErrors,
		&i.CreatedAt,
		&i.LastActivity,
	)
	return i, err
}

const appFlagsGetSharedData = `-- name: AppFlagsGetSharedData :one
SELECT id, uid, share_key, game_seed, questions, tags, seconds, created_at FROM app_flags_games_shared_data WHERE share_key = $1 LIMIT 1
`

func (q *Queries) AppFlagsGetSharedData(ctx context.Context, shareKey string) (AppFlagsGamesSharedDatum, error) {
	row := q.db.QueryRowContext(ctx, appFlagsGetSharedData, shareKey)
	var i AppFlagsGamesSharedDatum
	err := row.Scan(
		&i.ID,
		&i.Uid,
		&i.ShareKey,
		&i.GameSeed,
		&i.Questions,
		pq.Array(&i.Tags),
		&i.Seconds,
		&i.CreatedAt,
	)
	return i, err
}

const appFlagsNewSharedData = `-- name: AppFlagsNewSharedData :one
INSERT INTO app_flags_games_shared_data (uid, share_key, game_seed, tags, questions, seconds) VALUES ($1, $2, $3, $4, $5, $6) RETURNING game_seed
`

type AppFlagsNewSharedDataParams struct {
	Uid       string
	ShareKey  string
	GameSeed  uuid.UUID
	Tags      []string
	Questions int32
	Seconds   int32
}

func (q *Queries) AppFlagsNewSharedData(ctx context.Context, arg AppFlagsNewSharedDataParams) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, appFlagsNewSharedData,
		arg.Uid,
		arg.ShareKey,
		arg.GameSeed,
		pq.Array(arg.Tags),
		arg.Questions,
		arg.Seconds,
	)
	var game_seed uuid.UUID
	err := row.Scan(&game_seed)
	return game_seed, err
}

const appFlagsUpdateGame = `-- name: AppFlagsUpdateGame :exec
UPDATE app_flags_games
SET question_current = $1, last_activity = CURRENT_TIMESTAMP
WHERE game_id = $2
`

type AppFlagsUpdateGameParams struct {
	QuestionCurrent int32
	GameID          uuid.UUID
}

func (q *Queries) AppFlagsUpdateGame(ctx context.Context, arg AppFlagsUpdateGameParams) error {
	_, err := q.db.ExecContext(ctx, appFlagsUpdateGame, arg.QuestionCurrent, arg.GameID)
	return err
}

const appFlagsUpdateQuestionCorrect = `-- name: AppFlagsUpdateQuestionCorrect :exec
UPDATE app_flags_games
SET questions_errors = (
    SELECT COALESCE(SUM(errors), 0)
    FROM app_flags_games_answers
    WHERE app_flags_games_answers.game_id = app_flags_games.game_id
), last_activity = CURRENT_TIMESTAMP
WHERE app_flags_games.game_id = $1
`

func (q *Queries) AppFlagsUpdateQuestionCorrect(ctx context.Context, gameID uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, appFlagsUpdateQuestionCorrect, gameID)
	return err
}

const appFlagsUpsertGameAnswer = `-- name: AppFlagsUpsertGameAnswer :exec
INSERT INTO app_flags_games_answers (game_id, question, errors)
VALUES ($1, $2, $3)
    ON CONFLICT (game_id, question)
DO UPDATE SET errors = app_flags_games_answers.errors + EXCLUDED.errors
`

type AppFlagsUpsertGameAnswerParams struct {
	GameID   uuid.UUID
	Question int32
	Errors   int32
}

func (q *Queries) AppFlagsUpsertGameAnswer(ctx context.Context, arg AppFlagsUpsertGameAnswerParams) error {
	_, err := q.db.ExecContext(ctx, appFlagsUpsertGameAnswer, arg.GameID, arg.Question, arg.Errors)
	return err
}