indexing

app/db/database.py

@@ -17,29 +17,23 @@ logger = get_logger(__name__)
 
 
 def _build_engine(url: str):
-    """
-    Interface-style factory: returns the right async engine for the URL scheme.
-
-    SQLite  — minimal config, single-file local database.
-    Postgres — connection pool tuned for Neon free-tier (2 connections, 5-min recycle, SSL).
-    """
     if url.startswith("sqlite"):
         return create_async_engine(
             url,
             echo=False,
             connect_args={"check_same_thread": False},
         )
-    # Postgres (Neon / standard) — psycopg_async (psycopg3), works on Windows & Linux
+    # Postgres (Neon / standard) — psycopg_async (psycopg3)
     return create_async_engine(
         url,
         echo=False,
         pool_size=2,
         max_overflow=3,
-        pool_pre_ping=True,   # detect stale connections
+        pool_pre_ping=True,
         pool_recycle=300,     # recycle every 5 min — Neon closes idle connections
         connect_args={
-            "sslmode":         "require",   # psycopg3 uses libpq-style params, not ssl.SSLContext
-            "connect_timeout": 30,          # seconds — allows Neon free-tier cold-start
+            "sslmode":         "require",
+            "connect_timeout": 30,
         },
     )
 
@@ -57,8 +51,6 @@ async def init_db():
     import app.models  # noqa: F401 — registers all models with Base.metadata
 
     if _is_sqlite:
-        # Ensure the parent directory exists — critical when /data is a mounted
-        # volume that gets overlaid after the Dockerfile RUN mkdir has executed.
         file_path = settings.database_url.split("///", 1)[-1]
         parent = os.path.dirname(file_path)
         if parent:
@@ -69,43 +61,6 @@ async def init_db():
 
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
-        await _migrate_audit_columns(conn)
-
-
-async def _migrate_audit_columns(conn):
-    """
-    Safe, additive migration: add AuditMixin columns to tables that don't have them yet.
-    Works for SQLite and Postgres (uses standard ALTER TABLE ADD COLUMN IF NOT EXISTS).
-    Only adds columns — never drops or modifies existing ones.
-    """
-    from sqlalchemy import text, inspect
-
-    _AUDIT_COLS = [
-        ("created_at", "DATETIME"),
-        ("updated_at", "DATETIME"),
-        ("updated_by", "VARCHAR(320)"),
-        ("deleted_at", "DATETIME"),
-        ("deleted_by", "VARCHAR(320)"),
-    ]
-    _TABLES = ["students", "mentors", "courses", "batches", "sessions", "rooms"]
-
-    def _add_columns_sync(sync_conn):
-        insp = inspect(sync_conn)
-        for table in _TABLES:
-            existing = {col["name"] for col in insp.get_columns(table)}
-            for col_name, col_type in _AUDIT_COLS:
-                if col_name not in existing:
-                    if _is_sqlite:
-                        sync_conn.execute(
-                            text(f"ALTER TABLE {table} ADD COLUMN {col_name} {col_type}")
-                        )
-                    else:
-                        sync_conn.execute(
-                            text(f"ALTER TABLE {table} ADD COLUMN IF NOT EXISTS {col_name} {col_type}")
-                        )
-                    logger.info("migration: added %s.%s", table, col_name)
-
-    await conn.run_sync(_add_columns_sync)
 
 
 async def get_db() -> AsyncSession:

app/models/batch.py

@@ -1,6 +1,6 @@
 import uuid
 from datetime import date
-from sqlalchemy import String, ForeignKey, Date
+from sqlalchemy import String, ForeignKey, Date, Index
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from app.db.database import Base
@@ -11,6 +11,10 @@ from app.models.student_batch import student_batch_table
 
 class Batch(AuditMixin, Base):
     __tablename__ = "batches"
+    __table_args__ = (
+        Index("ix_batch_mentor_deleted", "mentor_id", "deleted_at"),
+        Index("ix_batch_status_deleted", "status", "deleted_at"),
+    )
 
     id: Mapped[str] = mapped_column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
     name: Mapped[str] = mapped_column(String(200), nullable=False)

app/models/student_batch.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Table, Column, String, ForeignKey
+from sqlalchemy import Table, Column, String, ForeignKey, Index
 from app.db.database import Base
 
 # Pure association table — no ORM class needed
@@ -7,4 +7,5 @@ student_batch_table = Table(
     Base.metadata,
     Column("student_id", String(36), ForeignKey("students.id", ondelete="CASCADE"), primary_key=True),
     Column("batch_id",   String(36), ForeignKey("batches.id",  ondelete="CASCADE"), primary_key=True),
+    Index("ix_student_batch_batch_id", "batch_id"),
 )

app/routers/rooms.py

@@ -9,6 +9,7 @@ from app.db.database import get_db
 from app.models.room import Room
 from app.schemas.room import RoomCreate, RoomUpdate, RoomRead
 from app.logging_config import get_logger
+from app.routers.schedule import _invalidate_rooms_cache
 
 router = APIRouter(prefix="/rooms", tags=["Rooms"])
 logger = get_logger(__name__)
@@ -52,6 +53,7 @@ async def create_room(
     db.add(obj)
     await db.commit()
     await db.refresh(obj)
+    _invalidate_rooms_cache()
     return obj
 
 
@@ -74,6 +76,7 @@ async def update_room(
         setattr(obj, field, value)
     await db.commit()
     await db.refresh(obj)
+    _invalidate_rooms_cache()
     return obj
 
 
@@ -93,5 +96,6 @@ async def delete_room(
     obj.deleted_by = user.email
     obj.updated_by = user.email
     await db.commit()
+    _invalidate_rooms_cache()
     logger.info("Soft-deleted room %s by %s", room_id, user.email)
     return {"message": "Room deleted"}

app/routers/schedule.py

@@ -5,6 +5,8 @@ POST /api/v1/schedule/auto-generate  — run solver, return proposals (not saved
 POST /api/v1/schedule/confirm        — save proposals as Confirmed sessions
 """
 
+import time as _time
+
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy import select
 from sqlalchemy.orm import selectinload
@@ -28,6 +30,28 @@ from app.logging_config import get_logger
 router = APIRouter(prefix="/schedule", tags=["Schedule"])
 logger = get_logger(__name__)
 
+# ── Rooms TTL cache (60 s) — rooms change rarely; no need to re-query every call ─
+_rooms_cache: list = []
+_rooms_cache_ts: float = 0.0
+_ROOMS_TTL = 60.0
+
+
+async def _get_rooms(db: AsyncSession) -> list:
+    global _rooms_cache, _rooms_cache_ts
+    if not _rooms_cache or (_time.monotonic() - _rooms_cache_ts) > _ROOMS_TTL:
+        result = await db.execute(
+            select(Room).where(Room.deleted_at.is_(None)).order_by(Room.name)
+        )
+        _rooms_cache = result.scalars().all()
+        _rooms_cache_ts = _time.monotonic()
+        logger.debug("schedule.rooms_cache.refreshed count=%d", len(_rooms_cache))
+    return _rooms_cache
+
+
+def _invalidate_rooms_cache() -> None:
+    global _rooms_cache_ts
+    _rooms_cache_ts = 0.0
+
 
 @router.post("/auto-generate", response_model=AutoGenerateResponse)
 async def auto_generate(
@@ -71,20 +95,22 @@ async def auto_generate(
             reasons=[f"Batch already has all {batch.course.total_sessions} sessions scheduled"],
         )
 
-    # Load all existing sessions (for occupation map)
+    # Load sessions from start_date forward only — past sessions cannot conflict
+    # with future placements, so loading them is wasted work.
     all_sessions_result = await db.execute(
         select(Session)
         .options(
             selectinload(Session.batch).selectinload(Batch.mentor),
             selectinload(Session.batch).selectinload(Batch.students),
         )
-        .where(Session.status.in_([SESSION_STATUS_CONFIRMED, SESSION_STATUS_LOCKED]))
+        .where(
+            Session.status.in_([SESSION_STATUS_CONFIRMED, SESSION_STATUS_LOCKED]),
+            Session.date >= body.start_date,
+        )
     )
     all_sessions = all_sessions_result.scalars().all()
 
-    # Load all rooms
-    rooms_result = await db.execute(select(Room).order_by(Room.name))
-    rooms = rooms_result.scalars().all()
+    rooms = await _get_rooms(db)
     if not rooms:
         raise HTTPException(422, "No rooms defined — add rooms before scheduling")
 

app/routers/sessions.py

@@ -24,6 +24,7 @@ from app.constants import (
 )
 from app.utils.session_helpers import enrich_session, session_load_options
 from app.logging_config import get_logger
+from app.routers.schedule import _get_rooms
 
 router = APIRouter(prefix="/sessions", tags=["Sessions"])
 logger = get_logger(__name__)
@@ -526,13 +527,12 @@ async def _do_reschedule(
     slot_counts: Counter = Counter(slot_result.scalars().all())
     preferred_slot = slot_counts.most_common(1)[0][0] if slot_counts else None
 
-    # Load all rooms
-    rooms_result = await db.execute(select(Room).order_by(Room.name))
-    rooms = rooms_result.scalars().all()
+    rooms = await _get_rooms(db)
     if not rooms:
         return {"status": "failed", "detail": "No rooms configured", "session_id": None}
 
-    # Load all existing confirmed/locked sessions (globally — for conflict detection)
+    # Load confirmed/locked sessions from start_date forward only —
+    # past sessions cannot conflict with future placements.
     all_sessions_result = await db.execute(
         select(Session)
         .options(
@@ -542,6 +542,7 @@ async def _do_reschedule(
         .where(
             Session.status.in_([SESSION_STATUS_CONFIRMED, SESSION_STATUS_LOCKED]),
             Session.deleted_at.is_(None),
+            Session.date >= start_date,
         )
     )
     all_sessions = all_sessions_result.scalars().all()