sqlalchemy-code-review

Reviews SQLAlchemy code for session management, relationships, N+1 queries, and migration patterns. Use when reviewing SQLAlchemy 2.0 code, checking session lifecycle, relationship() usage, or Alembic migrations.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 3, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill provides a comprehensive automated review for SQLAlchemy code, focusing on performance optimization, session lifecycle management, and database migration best practices. It ensures compliance with SQLAlchemy 2.0 standards, identifies N+1 query issues, and validates Alembic migration patterns to maintain database integrity and application efficiency.

Use Cases

  • Performance Optimization: Identifying and resolving N+1 query issues by suggesting appropriate eager loading strategies like joinedload or selectinload.
  • Session Management Audit: Ensuring database sessions are correctly handled using context managers to prevent leaks and ensure thread safety.
  • Migration Quality Control: Reviewing Alembic migration scripts for reversibility, proper dependency ordering, and correct use of op.execute for data migrations.
  • SQLAlchemy 2.0 Modernization: Detecting legacy query() syntax and providing guidance on transitioning to the modern select() style and bulk operations.
namesqlalchemy-code-review
descriptionReviews SQLAlchemy code for session management, relationships, N+1 queries, and migration patterns. Use when reviewing SQLAlchemy 2.0 code, checking session lifecycle, relationship() usage, or Alembic migrations.

SQLAlchemy Code Review

Quick Reference

Issue Type Reference
Session lifecycle, context managers, async sessions references/sessions.md
relationship(), lazy loading, N+1, joinedload references/relationships.md
select() vs query(), ORM overhead, bulk ops references/queries.md
Alembic patterns, reversible migrations, data migrations references/migrations.md

Review Checklist

  • Sessions use context managers (with, async with)
  • No session sharing across requests or threads
  • Sessions closed/cleaned up properly
  • relationship() uses appropriate lazy strategy
  • Explicit joinedload/selectinload to avoid N+1
  • No lazy loading in loops (N+1 queries)
  • Using SQLAlchemy 2.0 select() syntax, not legacy query()
  • Bulk operations use bulk_insert/bulk_update, not ORM loops
  • Async sessions use proper async context managers
  • Migrations are reversible with downgrade()
  • Data migrations use op.execute() not ORM models
  • Migration dependencies properly ordered

When to Load References

  • Reviewing session creation/cleanup → sessions.md
  • Reviewing model relationships → relationships.md
  • Reviewing database queries → queries.md
  • Reviewing Alembic migration files → migrations.md

Review Questions

  1. Are all sessions properly managed with context managers?
  2. Are relationships configured to avoid N+1 queries?
  3. Are queries using SQLAlchemy 2.0 select() syntax?
  4. Are all migrations reversible and properly tested?