hao/csp
1
0
派生 0
代码 工单 合并请求 工作流 软件包 项目 发布 百科 活动

feat: rebuild CSP practice workflow, UX and automation

浏览代码
这个提交包含在：
Codex CLI
2026-02-13 15:49:05 +08:00
父节点 d33deed4c5
当前提交 e2ab522b78
共修改 105 个文件，包含 15669 行新增和 428 行删除
下载 Patch 文件 下载 Diff 文件 展开所有文件 折叠所有文件

482
backend/src/db/sqlite_db.cc
查看文件

@@ -1,6 +1,9 @@
#include "csp/db/sqlite_db.h"
#include <chrono>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
namespace csp::db {
@@ -8,11 +11,203 @@ namespace csp::db {
namespace {
void ThrowSqlite(int rc, sqlite3* db, const char* what) {
if (rc == SQLITE_OK) return;
if (rc == SQLITE_OK || rc == SQLITE_DONE || rc == SQLITE_ROW) return;
const char* msg = db ? sqlite3_errmsg(db) : "";
throw std::runtime_error(std::string(what) + ": " + msg);
}
int64_t NowSec() {
using namespace std::chrono;
return duration_cast<seconds>(system_clock::now().time_since_epoch()).count();
}
bool ColumnExists(sqlite3* db, const char* table, const char* col) {
sqlite3_stmt* stmt = nullptr;
const std::string sql = std::string("PRAGMA table_info(") + table + ")";
const int rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr);
if (rc != SQLITE_OK) {
if (stmt) sqlite3_finalize(stmt);
return false;
}
bool found = false;
while (sqlite3_step(stmt) == SQLITE_ROW) {
const unsigned char* name = sqlite3_column_text(stmt, 1);
if (name && std::string(reinterpret_cast<const char*>(name)) == col) {
found = true;
break;
}
}
sqlite3_finalize(stmt);
return found;
}
void EnsureColumn(SqliteDb& db,
const char* table,
const char* col_name,
const char* col_def) {
if (ColumnExists(db.raw(), table, col_name)) return;
db.Exec(std::string("ALTER TABLE ") + table + " ADD COLUMN " + col_def + ";");
}
int CountRows(sqlite3* db, const char* table) {
sqlite3_stmt* stmt = nullptr;
const std::string sql = std::string("SELECT COUNT(1) FROM ") + table;
int rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr);
if (rc != SQLITE_OK) {
if (stmt) sqlite3_finalize(stmt);
return 0;
}
rc = sqlite3_step(stmt);
int count = 0;
if (rc == SQLITE_ROW) count = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
return count;
}
std::optional<int64_t> QueryOneId(sqlite3* db, const std::string& sql) {
sqlite3_stmt* stmt = nullptr;
const int rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, nullptr);
if (rc != SQLITE_OK) {
if (stmt) sqlite3_finalize(stmt);
return std::nullopt;
}
if (sqlite3_step(stmt) != SQLITE_ROW) {
sqlite3_finalize(stmt);
return std::nullopt;
}
const auto id = sqlite3_column_int64(stmt, 0);
sqlite3_finalize(stmt);
return id;
}
void InsertProblem(sqlite3* db,
const std::string& slug,
const std::string& title,
const std::string& statement,
int difficulty,
const std::string& source,
const std::string& sample_in,
const std::string& sample_out,
int64_t created_at) {
sqlite3_stmt* stmt = nullptr;
const char* sql =
"INSERT INTO problems(slug,title,statement_md,difficulty,source,sample_input,sample_output,created_at) "
"VALUES(?,?,?,?,?,?,?,?)";
ThrowSqlite(sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr), db,
"prepare insert problem");
ThrowSqlite(sqlite3_bind_text(stmt, 1, slug.c_str(), -1, SQLITE_TRANSIENT), db,
"bind problem.slug");
ThrowSqlite(sqlite3_bind_text(stmt, 2, title.c_str(), -1, SQLITE_TRANSIENT), db,
"bind problem.title");
ThrowSqlite(sqlite3_bind_text(stmt, 3, statement.c_str(), -1, SQLITE_TRANSIENT), db,
"bind problem.statement");
ThrowSqlite(sqlite3_bind_int(stmt, 4, difficulty), db,
"bind problem.difficulty");
ThrowSqlite(sqlite3_bind_text(stmt, 5, source.c_str(), -1, SQLITE_TRANSIENT), db,
"bind problem.source");
ThrowSqlite(sqlite3_bind_text(stmt, 6, sample_in.c_str(), -1, SQLITE_TRANSIENT), db,
"bind problem.sample_input");
ThrowSqlite(sqlite3_bind_text(stmt, 7, sample_out.c_str(), -1, SQLITE_TRANSIENT), db,
"bind problem.sample_output");
ThrowSqlite(sqlite3_bind_int64(stmt, 8, created_at), db,
"bind problem.created_at");
ThrowSqlite(sqlite3_step(stmt), db, "insert problem");
sqlite3_finalize(stmt);
}
void InsertProblemTag(sqlite3* db, int64_t problem_id, const std::string& tag) {
sqlite3_stmt* stmt = nullptr;
const char* sql =
"INSERT OR IGNORE INTO problem_tags(problem_id,tag) VALUES(?,?)";
ThrowSqlite(sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr), db,
"prepare insert problem_tag");
ThrowSqlite(sqlite3_bind_int64(stmt, 1, problem_id), db,
"bind problem_tag.problem_id");
ThrowSqlite(sqlite3_bind_text(stmt, 2, tag.c_str(), -1, SQLITE_TRANSIENT), db,
"bind problem_tag.tag");
ThrowSqlite(sqlite3_step(stmt), db, "insert problem_tag");
sqlite3_finalize(stmt);
}
void InsertKbArticle(sqlite3* db,
const std::string& slug,
const std::string& title,
const std::string& content_md,
int64_t created_at) {
sqlite3_stmt* stmt = nullptr;
const char* sql =
"INSERT INTO kb_articles(slug,title,content_md,created_at) VALUES(?,?,?,?)";
ThrowSqlite(sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr), db,
"prepare insert kb_article");
ThrowSqlite(sqlite3_bind_text(stmt, 1, slug.c_str(), -1, SQLITE_TRANSIENT), db,
"bind kb_article.slug");
ThrowSqlite(sqlite3_bind_text(stmt, 2, title.c_str(), -1, SQLITE_TRANSIENT), db,
"bind kb_article.title");
ThrowSqlite(sqlite3_bind_text(stmt, 3, content_md.c_str(), -1, SQLITE_TRANSIENT), db,
"bind kb_article.content");
ThrowSqlite(sqlite3_bind_int64(stmt, 4, created_at), db,
"bind kb_article.created_at");
ThrowSqlite(sqlite3_step(stmt), db, "insert kb_article");
sqlite3_finalize(stmt);
}
void InsertKbLink(sqlite3* db, int64_t article_id, int64_t problem_id) {
sqlite3_stmt* stmt = nullptr;
const char* sql =
"INSERT OR IGNORE INTO kb_article_links(article_id,problem_id) VALUES(?,?)";
ThrowSqlite(sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr), db,
"prepare insert kb_article_link");
ThrowSqlite(sqlite3_bind_int64(stmt, 1, article_id), db,
"bind kb_article_link.article_id");
ThrowSqlite(sqlite3_bind_int64(stmt, 2, problem_id), db,
"bind kb_article_link.problem_id");
ThrowSqlite(sqlite3_step(stmt), db, "insert kb_article_link");
sqlite3_finalize(stmt);
}
void InsertContest(sqlite3* db,
const std::string& title,
int64_t starts_at,
int64_t ends_at,
const std::string& rule_json) {
sqlite3_stmt* stmt = nullptr;
const char* sql =
"INSERT INTO contests(title,starts_at,ends_at,rule_json) VALUES(?,?,?,?)";
ThrowSqlite(sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr), db,
"prepare insert contest");
ThrowSqlite(sqlite3_bind_text(stmt, 1, title.c_str(), -1, SQLITE_TRANSIENT), db,
"bind contest.title");
ThrowSqlite(sqlite3_bind_int64(stmt, 2, starts_at), db,
"bind contest.starts_at");
ThrowSqlite(sqlite3_bind_int64(stmt, 3, ends_at), db,
"bind contest.ends_at");
ThrowSqlite(sqlite3_bind_text(stmt, 4, rule_json.c_str(), -1, SQLITE_TRANSIENT), db,
"bind contest.rule_json");
ThrowSqlite(sqlite3_step(stmt), db, "insert contest");
sqlite3_finalize(stmt);
}
void InsertContestProblem(sqlite3* db,
int64_t contest_id,
int64_t problem_id,
int idx) {
sqlite3_stmt* stmt = nullptr;
const char* sql =
"INSERT OR IGNORE INTO contest_problems(contest_id,problem_id,idx) VALUES(?,?,?)";
ThrowSqlite(sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr), db,
"prepare insert contest_problem");
ThrowSqlite(sqlite3_bind_int64(stmt, 1, contest_id), db,
"bind contest_problem.contest_id");
ThrowSqlite(sqlite3_bind_int64(stmt, 2, problem_id), db,
"bind contest_problem.problem_id");
ThrowSqlite(sqlite3_bind_int(stmt, 3, idx), db,
"bind contest_problem.idx");
ThrowSqlite(sqlite3_step(stmt), db, "insert contest_problem");
sqlite3_finalize(stmt);
}
} // namespace
SqliteDb SqliteDb::OpenFile(const std::string& path) {
@@ -60,11 +255,9 @@ void SqliteDb::Exec(const std::string& sql) {
}
void ApplyMigrations(SqliteDb& db) {
// Keep it simple for MVP: apply the bundled init SQL.
// In later iterations we'll add a migrations table + incremental runner.
// Keep it simple for MVP: create missing tables, then patch missing columns.
db.Exec("PRAGMA foreign_keys = ON;");
// 001_init.sql (embedded)
db.Exec(R"SQL(
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -90,6 +283,10 @@ CREATE TABLE IF NOT EXISTS problems (
statement_md TEXT NOT NULL,
difficulty INTEGER NOT NULL DEFAULT 1,
source TEXT NOT NULL DEFAULT "",
statement_url TEXT NOT NULL DEFAULT "",
llm_profile_json TEXT NOT NULL DEFAULT "{}",
sample_input TEXT NOT NULL DEFAULT "",
sample_output TEXT NOT NULL DEFAULT "",
created_at INTEGER NOT NULL
);
@@ -104,15 +301,19 @@ CREATE TABLE IF NOT EXISTS submissions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL,
problem_id INTEGER NOT NULL,
contest_id INTEGER,
language TEXT NOT NULL,
code TEXT NOT NULL,
status TEXT NOT NULL,
score INTEGER NOT NULL DEFAULT 0,
time_ms INTEGER NOT NULL DEFAULT 0,
memory_kb INTEGER NOT NULL DEFAULT 0,
compile_log TEXT NOT NULL DEFAULT "",
runtime_log TEXT NOT NULL DEFAULT "",
created_at INTEGER NOT NULL,
FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
FOREIGN KEY(problem_id) REFERENCES problems(id) ON DELETE CASCADE
FOREIGN KEY(problem_id) REFERENCES problems(id) ON DELETE CASCADE,
FOREIGN KEY(contest_id) REFERENCES contests(id) ON DELETE SET NULL
);
CREATE TABLE IF NOT EXISTS wrong_book (
@@ -127,9 +328,280 @@ CREATE TABLE IF NOT EXISTS wrong_book (
FOREIGN KEY(last_submission_id) REFERENCES submissions(id) ON DELETE SET NULL
);
CREATE TABLE IF NOT EXISTS contests (
id INTEGER PRIMARY KEY AUTOINCREMENT,
title TEXT NOT NULL,
starts_at INTEGER NOT NULL,
ends_at INTEGER NOT NULL,
rule_json TEXT NOT NULL DEFAULT "{}"
);
CREATE TABLE IF NOT EXISTS contest_problems (
contest_id INTEGER NOT NULL,
problem_id INTEGER NOT NULL,
idx INTEGER NOT NULL,
PRIMARY KEY(contest_id, problem_id),
FOREIGN KEY(contest_id) REFERENCES contests(id) ON DELETE CASCADE,
FOREIGN KEY(problem_id) REFERENCES problems(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS contest_registrations (
contest_id INTEGER NOT NULL,
user_id INTEGER NOT NULL,
registered_at INTEGER NOT NULL,
PRIMARY KEY(contest_id, user_id),
FOREIGN KEY(contest_id) REFERENCES contests(id) ON DELETE CASCADE,
FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS kb_articles (
id INTEGER PRIMARY KEY AUTOINCREMENT,
slug TEXT NOT NULL UNIQUE,
title TEXT NOT NULL,
content_md TEXT NOT NULL,
created_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS kb_article_links (
article_id INTEGER NOT NULL,
problem_id INTEGER NOT NULL,
PRIMARY KEY(article_id, problem_id),
FOREIGN KEY(article_id) REFERENCES kb_articles(id) ON DELETE CASCADE,
FOREIGN KEY(problem_id) REFERENCES problems(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS import_jobs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
status TEXT NOT NULL,
trigger TEXT NOT NULL DEFAULT "manual",
total_count INTEGER NOT NULL DEFAULT 0,
processed_count INTEGER NOT NULL DEFAULT 0,
success_count INTEGER NOT NULL DEFAULT 0,
failed_count INTEGER NOT NULL DEFAULT 0,
options_json TEXT NOT NULL DEFAULT "{}",
last_error TEXT NOT NULL DEFAULT "",
started_at INTEGER NOT NULL,
finished_at INTEGER,
updated_at INTEGER NOT NULL,
created_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS import_job_items (
id INTEGER PRIMARY KEY AUTOINCREMENT,
job_id INTEGER NOT NULL,
source_path TEXT NOT NULL,
status TEXT NOT NULL DEFAULT "queued",
title TEXT NOT NULL DEFAULT "",
difficulty INTEGER NOT NULL DEFAULT 0,
problem_id INTEGER,
error_text TEXT NOT NULL DEFAULT "",
started_at INTEGER,
finished_at INTEGER,
updated_at INTEGER NOT NULL,
created_at INTEGER NOT NULL,
FOREIGN KEY(job_id) REFERENCES import_jobs(id) ON DELETE CASCADE,
UNIQUE(job_id, source_path)
);
CREATE TABLE IF NOT EXISTS problem_drafts (
user_id INTEGER NOT NULL,
problem_id INTEGER NOT NULL,
language TEXT NOT NULL DEFAULT "cpp",
code TEXT NOT NULL DEFAULT "",
stdin TEXT NOT NULL DEFAULT "",
updated_at INTEGER NOT NULL,
created_at INTEGER NOT NULL,
PRIMARY KEY(user_id, problem_id),
FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
FOREIGN KEY(problem_id) REFERENCES problems(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS problem_solution_jobs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
problem_id INTEGER NOT NULL,
status TEXT NOT NULL DEFAULT "queued",
progress INTEGER NOT NULL DEFAULT 0,
message TEXT NOT NULL DEFAULT "",
created_by INTEGER NOT NULL DEFAULT 0,
max_solutions INTEGER NOT NULL DEFAULT 3,
created_at INTEGER NOT NULL,
started_at INTEGER,
finished_at INTEGER,
updated_at INTEGER NOT NULL,
FOREIGN KEY(problem_id) REFERENCES problems(id) ON DELETE CASCADE
);
CREATE TABLE IF NOT EXISTS problem_solutions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
problem_id INTEGER NOT NULL,
variant INTEGER NOT NULL DEFAULT 1,
title TEXT NOT NULL DEFAULT "",
idea_md TEXT NOT NULL DEFAULT "",
explanation_md TEXT NOT NULL DEFAULT "",
code_cpp TEXT NOT NULL DEFAULT "",
complexity TEXT NOT NULL DEFAULT "",
tags_json TEXT NOT NULL DEFAULT "[]",
source TEXT NOT NULL DEFAULT "llm",
created_at INTEGER NOT NULL,
updated_at INTEGER NOT NULL,
FOREIGN KEY(problem_id) REFERENCES problems(id) ON DELETE CASCADE
);
)SQL");
// Backward-compatible schema upgrades for existing deployments.
EnsureColumn(db, "problems", "sample_input",
"sample_input TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problems", "sample_output",
"sample_output TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problems", "statement_url",
"statement_url TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problems", "llm_profile_json",
"llm_profile_json TEXT NOT NULL DEFAULT '{}'");
EnsureColumn(db, "import_jobs", "trigger",
"trigger TEXT NOT NULL DEFAULT 'manual'");
EnsureColumn(db, "import_jobs", "options_json",
"options_json TEXT NOT NULL DEFAULT '{}'");
EnsureColumn(db, "import_jobs", "last_error",
"last_error TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "submissions", "contest_id", "contest_id INTEGER");
EnsureColumn(db, "submissions", "compile_log",
"compile_log TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "submissions", "runtime_log",
"runtime_log TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problem_drafts", "stdin", "stdin TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problem_solution_jobs", "max_solutions",
"max_solutions INTEGER NOT NULL DEFAULT 3");
EnsureColumn(db, "problem_solutions", "variant", "variant INTEGER NOT NULL DEFAULT 1");
EnsureColumn(db, "problem_solutions", "idea_md", "idea_md TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problem_solutions", "explanation_md",
"explanation_md TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problem_solutions", "code_cpp", "code_cpp TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problem_solutions", "complexity",
"complexity TEXT NOT NULL DEFAULT ''");
EnsureColumn(db, "problem_solutions", "tags_json", "tags_json TEXT NOT NULL DEFAULT '[]'");
// Build indexes after compatibility ALTERs so old schemas won't fail on
// missing columns (e.g. legacy submissions table without contest_id).
db.Exec(R"SQL(
CREATE INDEX IF NOT EXISTS idx_submissions_user_created_at ON submissions(user_id, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_submissions_problem_created_at ON submissions(problem_id, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_submissions_contest_user_created_at ON submissions(contest_id, user_id, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_problem_tags_tag ON problem_tags(tag);
CREATE INDEX IF NOT EXISTS idx_kb_article_links_problem_id ON kb_article_links(problem_id);
CREATE INDEX IF NOT EXISTS idx_import_jobs_created_at ON import_jobs(created_at DESC);
CREATE INDEX IF NOT EXISTS idx_import_jobs_status ON import_jobs(status, updated_at DESC);
CREATE INDEX IF NOT EXISTS idx_import_job_items_job_status ON import_job_items(job_id, status, updated_at DESC);
CREATE INDEX IF NOT EXISTS idx_problem_drafts_updated ON problem_drafts(updated_at DESC);
CREATE INDEX IF NOT EXISTS idx_problem_solution_jobs_problem ON problem_solution_jobs(problem_id, created_at DESC);
CREATE INDEX IF NOT EXISTS idx_problem_solutions_problem ON problem_solutions(problem_id, variant, id);
)SQL");
}
void SeedDemoData(SqliteDb& db) {
sqlite3* raw = db.raw();
const int64_t now = NowSec();
if (CountRows(raw, "problems") == 0) {
InsertProblem(
raw,
"a-plus-b",
"A + B",
"给定两个整数 A 与 B，输出它们的和。",
1,
"CSP-入门",
"1 2\n",
"3\n",
now);
InsertProblem(
raw,
"fibonacci-n",
"Fibonacci 第 n 项",
"输入 n (0<=n<=40)，输出第 n 项 Fibonacci 数。",
2,
"CSP-基础",
"10\n",
"55\n",
now);
InsertProblem(
raw,
"sort-numbers",
"整数排序",
"输入 n 和 n 个整数，按升序输出。",
2,
"CSP-基础",
"5\n5 1 4 2 3\n",
"1 2 3 4 5\n",
now);
}
if (CountRows(raw, "problem_tags") == 0) {
const auto p1 =
QueryOneId(raw, "SELECT id FROM problems WHERE slug='a-plus-b'");
const auto p2 =
QueryOneId(raw, "SELECT id FROM problems WHERE slug='fibonacci-n'");
const auto p3 =
QueryOneId(raw, "SELECT id FROM problems WHERE slug='sort-numbers'");
if (p1) {
InsertProblemTag(raw, *p1, "math");
InsertProblemTag(raw, *p1, "implementation");
}
if (p2) {
InsertProblemTag(raw, *p2, "dp");
InsertProblemTag(raw, *p2, "recursion");
}
if (p3) {
InsertProblemTag(raw, *p3, "sort");
InsertProblemTag(raw, *p3, "array");
}
}
if (CountRows(raw, "kb_articles") == 0) {
InsertKbArticle(
raw,
"cpp-fast-io",
"C++ 快速输入输出",
"# C++ 快速输入输出\n\n在 OI/CSP 中，建议关闭同步并解绑 cin/cout：\n\n```cpp\nstd::ios::sync_with_stdio(false);\nstd::cin.tie(nullptr);\n```\n",
now);
InsertKbArticle(
raw,
"intro-dp",
"动态规划入门",
"# 动态规划入门\n\n动态规划的核心是：**状态定义**、**状态转移**、**边界条件**。\n",
now);
}
if (CountRows(raw, "kb_article_links") == 0) {
const auto p1 =
QueryOneId(raw, "SELECT id FROM problems WHERE slug='a-plus-b'");
const auto p2 =
QueryOneId(raw, "SELECT id FROM problems WHERE slug='fibonacci-n'");
const auto a1 =
QueryOneId(raw, "SELECT id FROM kb_articles WHERE slug='cpp-fast-io'");
const auto a2 =
QueryOneId(raw, "SELECT id FROM kb_articles WHERE slug='intro-dp'");
if (a1 && p1) InsertKbLink(raw, *a1, *p1);
if (a2 && p2) InsertKbLink(raw, *a2, *p2);
}
if (CountRows(raw, "contests") == 0) {
InsertContest(
raw,
"CSP 模拟赛（示例）",
now - 3600,
now + 7 * 24 * 3600,
R"({"type":"acm","desc":"按通过题数与罚时排名"})");
}
if (CountRows(raw, "contest_problems") == 0) {
const auto contest_id = QueryOneId(raw, "SELECT id FROM contests ORDER BY id LIMIT 1");
const auto p1 = QueryOneId(raw, "SELECT id FROM problems ORDER BY id LIMIT 1");
const auto p2 = QueryOneId(raw, "SELECT id FROM problems ORDER BY id LIMIT 1 OFFSET 1");
if (contest_id && p1) InsertContestProblem(raw, *contest_id, *p1, 1);
if (contest_id && p2) InsertContestProblem(raw, *contest_id, *p2, 2);
}
}
} // namespace csp::db