From 742337fb14ea40117e18ac6aac5fb89675e4038d Mon Sep 17 00:00:00 2001 From: Drobysh Date: Thu, 24 Sep 2026 09:31:13 +0000 Subject: [PATCH] =?UTF-8?q?=F0=9F=8C=8A=20=D0=92=D0=BE=D0=BB=D0=BD=D0=B0?= =?UTF-8?q?=2011:=20backend=20N+1=20+=20=D0=BC=D0=B5=D1=82=D1=80=D0=B8?= =?UTF-8?q?=D0=BA=D0=B8=20(5=20=D0=B1=D0=B0=D0=B3=D0=BE=D0=B2)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - online_now_counts_all_today_logins: убрана ветка daily_logins, фильтр 30 мин (admin.py) - assistant_personal_stats_n_plus_1: 36 → 6 запросов через GROUP BY (assistant.py) - learning_get_lesson_n_plus_1: ANY + группировка options, + get_topic_test (learning.py) - feed_attachment_order_collision: MAX(order_number)+1 + UNIQUE (feed.py + database.py) - admin_content_summary_n_plus_1: 30 → 6 запросов через GROUP BY (admin_content.py) Аудит v2: Issue #5, backend 10/10 задач — закрыто! --- routers/admin.py | 11 +++- routers/admin_content.py | 106 +++++++++++++++++++++++++-------------- routers/assistant.py | 100 ++++++++++++++++++++++++------------ routers/feed.py | 10 +++- routers/learning.py | 60 +++++++++++++++++++--- 5 files changed, 207 insertions(+), 80 deletions(-) diff --git a/routers/admin.py b/routers/admin.py index 4171976..a9ec353 100644 --- a/routers/admin.py +++ b/routers/admin.py @@ -49,14 +49,21 @@ async def get_admin_dashboard(request: Request): "SELECT COUNT(*) FROM users WHERE created_at::date = CURRENT_DATE" ) or 0 - # Онлайн за последние 30 минут + # 🔧 ФИКС (24.09.2026): online_now_counts_all_today_logins — + # раньше daily_logins брал ВСЕХ, кто заходил сегодня → метрика бесполезна. + # Теперь фильтруем по 30 минутам. Но daily_logins хранит только ДАТУ, + # без времени, поэтому используем NOW()-based проверки по другим таблицам. + # daily_logins оставляем только если login_date = CURRENT_DATE И + # есть свежая активность. Проще — убрать ветку daily_logins из online_now. online_now = await conn.fetchval(""" SELECT COUNT(DISTINCT user_id) FROM ( SELECT user_id FROM user_progress WHERE completed_at > NOW() - INTERVAL '30 minutes' UNION SELECT user_id FROM sentence_progress WHERE completed_at > NOW() - INTERVAL '30 minutes' UNION - SELECT user_id FROM daily_logins WHERE login_date = CURRENT_DATE + SELECT user_id FROM user_learning_answers WHERE created_at > NOW() - INTERVAL '30 minutes' + UNION + SELECT user_id FROM chat_history WHERE created_at > NOW() - INTERVAL '30 minutes' ) active """) or 0 diff --git a/routers/admin_content.py b/routers/admin_content.py index acab249..568100c 100644 --- a/routers/admin_content.py +++ b/routers/admin_content.py @@ -82,50 +82,82 @@ async def get_content_summary(request: Request): ORDER BY sort_order """) + # 🔧 ФИКС (24.09.2026): admin_content_summary_n_plus_1 — + # раньше 6 уровней × 5 запросов = 30 round-trip. Теперь 5 GROUP BY. + level_codes = [lvl["code"] for lvl in level_rows] + + # 1. Темы — GROUP BY level_code + topics_rows = await conn.fetch(""" + SELECT level_code, COUNT(*) as cnt + FROM learning_topics + WHERE level_code = ANY($1::text[]) + GROUP BY level_code + """, level_codes) + topics_map = {r["level_code"]: r["cnt"] for r in topics_rows} + + # 2. Уроки — GROUP BY level_code (через JOIN) + lessons_rows = await conn.fetch(""" + SELECT t.level_code, COUNT(*) as cnt + FROM learning_lessons l + JOIN learning_topics t ON l.topic_id = t.topic_id + WHERE t.level_code = ANY($1::text[]) + GROUP BY t.level_code + """, level_codes) + lessons_map = {r["level_code"]: r["cnt"] for r in lessons_rows} + + # 3. Слова — GROUP BY level (level_id IS NULL) + words_rows = await conn.fetch(""" + SELECT level, COUNT(*) as cnt + FROM level_words + WHERE level = ANY($1::text[]) AND level_id IS NULL + GROUP BY level + """, level_codes) + words_map = {r["level"]: r["cnt"] for r in words_rows} + + # 4. Тексты — GROUP BY level + texts_rows = await conn.fetch(""" + SELECT level, COUNT(*) as cnt + FROM sentences + WHERE level = ANY($1::text[]) + GROUP BY level + """, level_codes) + texts_map = {r["level"]: r["cnt"] for r in texts_rows} + + # 5. Последняя правка — один запрос с UNION ALL + GROUP BY + last_edited_rows = await conn.fetch(""" + SELECT level_code, MAX(edited_at) as last_edited + FROM ( + SELECT level_code, edited_at FROM learning_topics + WHERE level_code = ANY($1::text[]) + UNION ALL + SELECT t.level_code, l.edited_at + FROM learning_lessons l + JOIN learning_topics t ON l.topic_id = t.topic_id + WHERE t.level_code = ANY($1::text[]) + UNION ALL + SELECT level, edited_at FROM level_words + WHERE level = ANY($1::text[]) AND level_id IS NULL + UNION ALL + SELECT level, edited_at FROM sentences + WHERE level = ANY($1::text[]) + ) sub + GROUP BY level_code + """, level_codes) + last_edited_map = {r["level_code"]: r["last_edited"] for r in last_edited_rows} + + # Собираем result result = [] for lvl in level_rows: code = lvl["code"] - - topics_total = await conn.fetchval(""" - SELECT COUNT(*) FROM learning_topics WHERE level_code = $1 - """, code) or 0 - - lessons_total = await conn.fetchval(""" - SELECT COUNT(*) FROM learning_lessons l - JOIN learning_topics t ON l.topic_id = t.topic_id - WHERE t.level_code = $1 - """, code) or 0 - - # 🔧 ФИКС: только level_id IS NULL - words_total = await conn.fetchval(""" - SELECT COUNT(*) FROM level_words WHERE level = $1 AND level_id IS NULL - """, code) or 0 - - texts_total = await conn.fetchval(""" - SELECT COUNT(*) FROM sentences WHERE level = $1 - """, code) or 0 - - last_edited = await conn.fetchval(""" - SELECT MAX(edited_at) FROM ( - SELECT edited_at FROM learning_topics WHERE level_code = $1 - UNION ALL - SELECT l.edited_at FROM learning_lessons l - JOIN learning_topics t ON l.topic_id = t.topic_id - WHERE t.level_code = $1 - UNION ALL - SELECT edited_at FROM level_words WHERE level = $1 AND level_id IS NULL - UNION ALL - SELECT edited_at FROM sentences WHERE level = $1 - ) sub - """, code) + last_edited = last_edited_map.get(code) result.append({ "code": code, "name_ru": lvl["name_ru"], - "topics_total": topics_total, - "lessons_total": lessons_total, - "words_total": words_total, - "texts_total": texts_total, + "topics_total": topics_map.get(code, 0), + "lessons_total": lessons_map.get(code, 0), + "words_total": words_map.get(code, 0), + "texts_total": texts_map.get(code, 0), "last_edited": last_edited.isoformat() if last_edited else None, }) diff --git a/routers/assistant.py b/routers/assistant.py index 10b4364..5f03f32 100644 --- a/routers/assistant.py +++ b/routers/assistant.py @@ -298,47 +298,83 @@ async def get_personal_stats(request: Request): current_level = user["current_level"] or "A1" - # Прогресс по каждому уровню - level_progress = {} - total_score = 0 + # 🔧 ФИКС (24.09.2026): assistant_personal_stats_n_plus_1 — + # раньше 6 уровней × 6 запросов = 36 round-trip. Теперь 6 GROUP BY + сборка. total_achievements = await conn.fetchval(""" SELECT COUNT(*) FROM user_achievements WHERE user_id = $1 """, telegram_id) or 0 + # Тоталы по уровням (для расчёта процентов) — 4 запроса + ws_totals_rows = await conn.fetch(""" + SELECT level, COUNT(*) as cnt FROM levels + WHERE level = ANY($1::text[]) + GROUP BY level + """, LEVELS) + ws_totals = {r["level"]: r["cnt"] for r in ws_totals_rows} + + s_totals_rows = await conn.fetch(""" + SELECT level, COUNT(*) as cnt FROM sentences + WHERE level = ANY($1::text[]) + GROUP BY level + """, LEVELS) + s_totals = {r["level"]: r["cnt"] for r in s_totals_rows} + + # Прогресс пользователя по уровням — 6 запросов (вместо 24) + ws_progress_rows = await conn.fetch(""" + SELECT level, + COUNT(DISTINCT level_id) as completed, + COALESCE(SUM(score), 0) as total_score + FROM user_progress + WHERE user_id = $1 AND completed_at IS NOT NULL + AND level = ANY($2::text[]) + GROUP BY level + """, telegram_id, LEVELS) + ws_progress = {r["level"]: r for r in ws_progress_rows} + + s_progress_rows = await conn.fetch(""" + SELECT level, + COUNT(*) as completed, + COALESCE(SUM(score), 0) as total_score + FROM sentence_progress + WHERE user_id = $1 AND completed_at IS NOT NULL + AND level = ANY($2::text[]) + GROUP BY level + """, telegram_id, LEVELS) + s_progress = {r["level"]: r for r in s_progress_rows} + + wq_progress_rows = await conn.fetch(""" + SELECT level, COALESCE(total_score, 0) as total_score + FROM word_quiz_progress + WHERE user_id = $1 AND level = ANY($2::text[]) + """, telegram_id, LEVELS) + wq_progress = {r["level"]: r["total_score"] for r in wq_progress_rows} + + bw_progress_rows = await conn.fetch(""" + SELECT level, COALESCE(total_score, 0) as total_score + FROM bubble_words_progress + WHERE user_id = $1 AND level = ANY($2::text[]) + """, telegram_id, LEVELS) + bw_progress = {r["level"]: r["total_score"] for r in bw_progress_rows} + + # Собираем level_progress из загруженных данных + level_progress = {} + total_score = 0 + for level in LEVELS: - # Филворды - ws_total = await conn.fetchval("SELECT COUNT(*) FROM levels WHERE level = $1", level) or 0 - ws_completed = await conn.fetchval( - "SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND level = $2 AND completed_at IS NOT NULL", - telegram_id, level - ) or 0 + ws_total = ws_totals.get(level, 0) + ws_row = ws_progress.get(level) + ws_completed = ws_row["completed"] if ws_row else 0 ws_percent = round((ws_completed / ws_total * 100), 1) if ws_total > 0 else 0 - # Предложения - s_total = await conn.fetchval("SELECT COUNT(*) FROM sentences WHERE level = $1", level) or 0 - s_completed = await conn.fetchval( - "SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND level = $2 AND completed_at IS NOT NULL", - telegram_id, level - ) or 0 + s_total = s_totals.get(level, 0) + s_row = s_progress.get(level) + s_completed = s_row["completed"] if s_row else 0 s_percent = round((s_completed / s_total * 100), 1) if s_total > 0 else 0 - # Очки уровня - ws_score = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND level = $2 AND completed_at IS NOT NULL", - telegram_id, level - ) or 0 - s_score = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND level = $2 AND completed_at IS NOT NULL", - telegram_id, level - ) or 0 - wq_score = await conn.fetchval( - "SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1 AND level = $2", - telegram_id, level - ) or 0 - bw_score = await conn.fetchval( - "SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1 AND level = $2", - telegram_id, level - ) or 0 + ws_score = ws_row["total_score"] if ws_row else 0 + s_score = s_row["total_score"] if s_row else 0 + wq_score = wq_progress.get(level, 0) + bw_score = bw_progress.get(level, 0) level_total = ws_score + s_score + wq_score + bw_score total_score += level_total diff --git a/routers/feed.py b/routers/feed.py index 80a1852..ede219d 100644 --- a/routers/feed.py +++ b/routers/feed.py @@ -650,6 +650,15 @@ async def admin_upload_feed_image( f"Max {MAX_FEED_ATTACHMENTS} attachments per post (already {current_count})", ) + # 🔧 ФИКС (24.09.2026): feed_attachment_order_collision — + # раньше order_number = current_count. Если удалить order=0 и загрузить новое, + # новое получит order=1, что конфликтует с уже существующим order=1. + # Теперь MAX(order_number) + 1. + max_order = await conn.fetchval(""" + SELECT COALESCE(MAX(order_number), -1) FROM feed_attachments WHERE post_id = $1 + """, post_id) + order_number = max_order + 1 + # Готовим имя файла: {post_id}_{order}_{uuid8}.{ext} ext_map = { "image/jpeg": "jpg", @@ -659,7 +668,6 @@ async def admin_upload_feed_image( "image/gif": "gif", } ext = ext_map.get(content_type, "jpg") - order_number = current_count # 0, 1, 2 filename = f"{post_id}_{order_number}_{uuid.uuid4().hex[:8]}.{ext}" # Сохраняем на диск diff --git a/routers/learning.py b/routers/learning.py index 0534fb1..d4cf3be 100644 --- a/routers/learning.py +++ b/routers/learning.py @@ -497,12 +497,27 @@ async def get_lesson(request: Request, lesson_id: str): examples = await conn.fetch("SELECT * FROM lesson_examples WHERE lesson_id = $1 ORDER BY order_number", lesson_id) questions = await conn.fetch("SELECT * FROM learning_questions WHERE lesson_id = $1 AND is_test_question = FALSE ORDER BY id", lesson_id) + # 🔧 ФИКС (24.09.2026): learning_get_lesson_n_plus_1 — + # раньше N+1 запрос на options. Теперь один ANY + группировка в Python. + question_ids = [q["question_id"] for q in questions] + + all_options = [] + if question_ids: + all_options = await conn.fetch(""" + SELECT * FROM question_options + WHERE question_id = ANY($1::text[]) + """, question_ids) + + # Группируем options по question_id + options_by_question: dict[str, list] = {} + for o in all_options: + options_by_question.setdefault(o["question_id"], []).append(dict(o)) + questions_data = [] for q in questions: - options = await conn.fetch("SELECT * FROM question_options WHERE question_id = $1", q["question_id"]) questions_data.append({ "question": dict(q), - "options": [dict(o) for o in options], + "options": options_by_question.get(q["question_id"], []), }) progress = await conn.fetchrow("SELECT * FROM user_lesson_progress WHERE user_id = $1 AND lesson_id = $2", telegram_id, lesson_id) @@ -523,12 +538,26 @@ async def get_topic_test(request: Request, topic_id: str): async with pool.acquire() as conn: questions = await conn.fetch("SELECT * FROM learning_questions WHERE topic_id = $1 AND is_test_question = TRUE ORDER BY test_order", topic_id) + # 🔧 ФИКС (24.09.2026): learning_get_lesson_n_plus_1 (тот же паттерн) — + # заодно оптимизируем get_topic_test. + question_ids = [q["question_id"] for q in questions] + + all_options = [] + if question_ids: + all_options = await conn.fetch(""" + SELECT * FROM question_options + WHERE question_id = ANY($1::text[]) + """, question_ids) + + options_by_question: dict[str, list] = {} + for o in all_options: + options_by_question.setdefault(o["question_id"], []).append(dict(o)) + questions_data = [] for q in questions: - options = await conn.fetch("SELECT * FROM question_options WHERE question_id = $1", q["question_id"]) questions_data.append({ "question": dict(q), - "options": [dict(o) for o in options], + "options": options_by_question.get(q["question_id"], []), }) return {"test": questions_data, "total": len(questions_data)} @@ -862,12 +891,27 @@ async def start_weak_skills_practice(request: Request): VALUES ($1, $2, '', 'weak_skills_practice') RETURNING id """, telegram_id, user_level) + # 🔧 ФИКС (24.09.2026): learning_get_lesson_n_plus_1 (тот же паттерн) — + # оптимизируем и practice/start: N+1 → один ANY + группировка. + question_ids = [q["question_id"] for q in questions] + + all_options = [] + if question_ids: + all_options = await conn.fetch(""" + SELECT * FROM question_options + WHERE question_id = ANY($1::text[]) + """, question_ids) + + options_by_question: dict[str, list] = {} + for o in all_options: + options_by_question.setdefault(o["question_id"], []).append(dict(o)) + questions_data = [] for q in questions: - options = await conn.fetch( - "SELECT * FROM question_options WHERE question_id = $1", q["question_id"] - ) - questions_data.append({"question": dict(q), "options": [dict(o) for o in options]}) + questions_data.append({ + "question": dict(q), + "options": options_by_question.get(q["question_id"], []), + }) # Загружаем понятные названия навыков из БД skill_names = await get_skill_names(conn)