Django ORM Query Analyzer¶

# settings.py - Add this one line
MIDDLEWARE = [
    # ... your existing middlewares
    'dbcrust.django.PerformanceAnalysisMiddleware',
]

@admin.register(Post)
class PostAdmin(ModelAdmin):
    readonly_fields = ("author", "created_at")

    # BEFORE: Heavy foreign key filter causes counting queries
    # list_filter = ('published', 'category')

    # AFTER: Optimized admin configuration
    list_per_page = 25  # Reduce page size
    show_full_result_count = False  # Disable expensive counting
    list_filter = ('published',)  # Keep simple filters only
    search_fields = ('title', 'author__username')  # Add search instead
    autocomplete_fields = ('category', 'author')  # Use autocomplete for FK fields
    list_select_related = ('category', 'author')  # Optimize related queries

@admin.register(Category)
class CategoryAdmin(ModelAdmin):
    search_fields = ('name',)  # Required for autocomplete

from dbcrust.django import analyzer

# Analyze Django ORM queries for performance issues
with analyzer.analyze() as analysis:
    # Your Django code here - analyzer captures all queries
    books = Book.objects.all()
    for book in books:
        print(book.author.name)  # Will detect N+1 query
        print(f"Reviews: {book.reviews.count()}")  # Detects missing prefetch_related

# Get comprehensive results with enhanced context
results = analysis.get_results()
print(results.summary)

from dbcrust.django.analyzer import create_enhanced_analyzer

# Full-featured analyzer with all capabilities
analyzer = create_enhanced_analyzer(
    dbcrust_url="postgres://localhost/mydb",  # EXPLAIN ANALYZE integration
    project_root="/path/to/django/project",  # Code analysis & model scanning
    enable_all_features=True  # Enable all enhancements
)

# Runtime query analysis
with analyzer.analyze() as analysis:
    # Your Django code here
    expensive_books = (
        Book.objects
        .select_related('author', 'publisher')
        .filter(price__gt=100)
        .order_by('-published_date')[:10]
    )
    list(expensive_books)

# Get comprehensive analysis including:
# - Runtime query patterns
# - Code analysis across entire project
# - Model relationship analysis
# - Database EXPLAIN insights
comprehensive_report = analysis.generate_comprehensive_report()
print(comprehensive_report)

from dbcrust.django.analyzer import analyze_django_project

# Analyze entire Django project without running queries
results = analyze_django_project(
    project_root="/path/to/django/project",
    dbcrust_url="postgres://localhost/mydb"  # Optional: for model analysis
)

print(f"📊 Optimization Score: {results['optimization_score']}/100")
print(f"🔍 Code Issues Found: {len(results['code_issues'])}")
print(f"🏗️ Models Analyzed: {len(results['models'])}")

# Get detailed recommendations
for recommendation in results['recommendations']:
    print(f"• {recommendation}")

from dbcrust.django import DjangoAnalyzer

analyzer = DjangoAnalyzer(
    dbcrust_url="postgres://localhost/mydb",  # Optional: enables EXPLAIN analysis
    transaction_safe=True,  # Default: rollback after analysis
    enable_explain=True,  # Default: run EXPLAIN ANALYZE
    database_alias='default'  # Django database to analyze
)

with analyzer.analyze() as analysis:
    # Your queries here
    MyModel.objects.all().count()

# Safe analysis that won't affect your database
with analyzer.analyze(transaction_safe=True) as analysis:
    # Even data modifications will be rolled back
    MyModel.objects.create(name="test")
    MyModel.objects.filter(name="test").update(status="active")

# Changes are rolled back, but queries were analyzed
results = analysis.get_results()

# views.py:25 - This creates N+1 queries (1 + N author lookups)
authors = Author.objects.all()  # 1 query
for author in authors:  # Line 26 - detected by AST analysis
    print(author.books.count())  # N queries - specific field identified

# BEFORE (problematic):
authors = Author.objects.all()
for author in authors:
    print(author.books.count())

# AFTER (optimized):
authors = Author.objects.prefetch_related('books')
for author in authors:
    print(author.books.count())  # No additional queries

# views.py:42 - Sequential foreign key lookups
orders = Order.objects.all()
for order in orders:  # Line 43 - AST detected loop
    print(order.customer.name)  # Line 44 - specific access pattern
    print(order.customer.email)  # Line 45 - multiple field access

# Detected: Many-to-many or reverse ForeignKey access in loops
authors = Author.objects.all()
for author in authors:
    book_titles = [book.title for book in author.books.all()]  # Detected pattern

# Detected: Database queries inside Python loops
for category in categories:
    popular_books = Book.objects.filter(
        category=category, rating__gte=4.0  # Query in loop - line-level detection
    )[:5]

# Detected through EXPLAIN analysis: sequential scans on large tables
slow_books = Book.objects.filter(category_name="Fiction")  # Missing index detected

# Automatic migration code generation
operations = [
    migrations.RunSQL(
        'CREATE INDEX CONCURRENTLY idx_book_category_name ON book (category_name);'
    ),
]

# Detected: Manual aggregation that could use database functions
total_price = 0
for book in books:  # Line-level detection
    total_price += book.price  # Should use aggregate()

# Recommended fix:
total_price = books.aggregate(Sum('price'))['price__sum']

# Detected: Individual saves that could be bulk operations
books_to_update = []
for book in Book.objects.filter(price__lt=20):
    book.price = book.price * 1.1
    book.save()  # Individual saves - bulk opportunity detected

# Recommended:
Book.objects.filter(price__lt=20).update(price=F('price') * 1.1)

# Detected: Queries fetching large datasets without limits
all_users = User.objects.all()  # Memory risk detected
user_count = len(list(all_users))  # Should use .count()

# Detected: Using len() instead of count() - performance impact calculated
book_count = len(Book.objects.all())  # Inefficient - loads all records
# Fix: Book.objects.count()           # Database-level count

# Detected: Fetching unnecessary fields
users = User.objects.all()  # Fetches all fields
for user in users:
    print(user.username)  # Only username needed

# Recommended:
users = User.objects.only('username')  # Fetch only required fields

# Detected: Repeated identical queries within request
def view_function(request):
    active_users = User.objects.filter(is_active=True)  # Query 1
    # ... some logic
    active_users = User.objects.filter(is_active=True)  # Duplicate detected

# Detected: Operations that could cause race conditions
user = User.objects.get(id=user_id)
user.credits = user.credits + 10  # Race condition risk
user.save()  # Should use F() expressions

# Detected through EXPLAIN analysis: inefficient connection patterns
# Recommendations for connection pooling configuration

# In view: books = Book.objects.select_related('author').prefetch_related('reviews')

# views.py - Product listing with multiple issues
def product_list(request):
    products = Product.objects.all()  # Line 5: Large result set

    product_data = []
    for product in products:  # Line 8: N+1 patterns ahead
        category_name = product.category.name  # Line 9: Missing select_related
        brand_name = product.brand.name  # Line 10: Another select_related issue

        review_count = 0
        total_rating = 0
        for review in product.reviews.all():  # Line 14: Missing prefetch_related
            review_count += 1  # Line 15: Manual aggregation
            total_rating += review.rating  # Line 16: Should use aggregate()

        avg_rating = total_rating / review_count if review_count > 0 else 0

        product_data.append({
            'name': product.name,
            'category': category_name,
            'brand': brand_name,
            'avg_rating': avg_rating,
            'review_count': review_count
        })

    return render(request, 'products.html', {'products': product_data})

# views.py - Optimized version following analyzer recommendations
from django.core.paginator import Paginator
from django.db.models import Count, Avg


def product_list_optimized(request):
    # Fix 1: Add pagination to handle large result sets
    # Fix 2: Use select_related for foreign key relationships
    # Fix 3: Use prefetch_related for reverse relationships
    # Fix 4: Use database aggregation
    products = (
        Product.objects
        .select_related('category', 'brand')  # Fixes lines 9-10
        .prefetch_related('reviews')  # Fixes line 14
        .annotate(
            review_count=Count('reviews'),  # Fixes line 15
            avg_rating=Avg('reviews__rating')  # Fixes line 16
        )
    )

    # Add pagination (fixes line 5)
    paginator = Paginator(products, 25)
    page_number = request.GET.get('page')
    page_products = paginator.get_page(page_number)

    # No loops needed - all data fetched efficiently
    return render(request, 'products.html', {
        'products': page_products,
        'paginator': paginator
    })

# views.py - Dashboard with multiple relationship issues
def user_dashboard(request):
    user = User.objects.get(id=request.user.id)

    # Get user's orders
    orders = user.orders.all()
    order_data = []

    for order in orders:  # Line 8: N+1 ahead
        # Get order items (N+1 issue #1)
        items = []
        for item in order.items.all():  # Line 11: Missing prefetch
            product_name = item.product.name  # Line 12: N+1 issue #2
            category = item.product.category.name  # Line 13: N+1 issue #3
            items.append({
                'name': product_name,
                'category': category,
                'price': item.price
            })

        # Get shipping info (N+1 issue #4)
        shipping_cost = order.shipping.cost  # Line 20: Missing select_related

        order_data.append({
            'id': order.id,
            'items': items,
            'shipping_cost': shipping_cost,
            'total': order.total
        })

    return render(request, 'dashboard.html', {'orders': order_data})

# Generated by: analysis.generate_comprehensive_report()

🔍 Comprehensive
Django
ORM
Analysis
Report
== == == == == == == == == == == == == == == == == == == == == == == == ==

📈 Query
Analysis:
- Total
Queries: 247
- Total
Duration: 1, 840.5
ms
- Duplicate
Queries: 0
- Patterns
Detected: 4

🎯 Priority
Recommendations:

🚨 Critical / High
Priority(4
issues):
1.
Fix
N + 1
Query
Problem(query_analysis) - Lines: 11, 12, 13, 20
2.
Use
select_related()
for Foreign Key Relationships (query_analysis)
3.
Use
prefetch_related()
for Many - to - Many Relationships(query_analysis)
    4.
Add
Database
Indexes(explain_analysis) - Missing
index
on
orders.user_id

📊 Overall
Assessment:
🚨 Action
Required: Multiple
critical
performance
issues
detected
Total
Recommendations: 6
Critical / High
Priority: 4

# views.py - Following all analyzer recommendations
def user_dashboard_optimized(request):
    user = User.objects.select_related('profile').get(id=request.user.id)

    # Single optimized query with all relationships prefetched
    orders = (
        user.orders
        .select_related('shipping')  # Fix line 20
        .prefetch_related(
            'items__product__category'  # Fix lines 11-13 combined
        )
        .order_by('-created_at')[:10]  # Limit recent orders
    )

    # No database queries in loops - everything pre-fetched
    order_data = []
    for order in orders:
        items = [
            {
                'name': item.product.name,  # No query - prefetched
                'category': item.product.category.name,  # No query - prefetched
                'price': item.price
            }
            for item in order.items.all()  # No query - prefetched
        ]

        order_data.append({
            'id': order.id,
            'items': items,
            'shipping_cost': order.shipping.cost,  # No query - selected
            'total': order.total
        })

    return render(request, 'dashboard.html', {'orders': order_data})

from dbcrust.django.analyzer import generate_optimization_report

# Generate comprehensive project report
report = generate_optimization_report(
    project_path="/path/to/django/project",
    output_file="optimization_report.md"
)

print(report)

results = analysis.get_results()
print(results.summary)

results = analysis.get_results()

# Basic metrics
print(f"Total queries: {results.total_queries}")
print(f"Total time: {results.total_duration * 1000:.2f}ms")
print(f"Duplicates: {results.duplicate_queries}")

# Query breakdown
for query_type, count in results.queries_by_type.items():
    print(f"{query_type}: {count} queries")

# Detected issues
for pattern in results.detected_patterns:
    print(f"\nIssue: {pattern.pattern_type}")
    print(f"Severity: {pattern.severity}")
    print(f"Description: {pattern.description}")
    print(f"Affected queries: {len(pattern.affected_queries)}")
    print(f"Recommendation: {pattern.recommendation}")

    if pattern.code_suggestion:
        print(f"Fix: {pattern.code_suggestion}")

# Optimization recommendations
for rec in results.recommendations:
    print(f"\n{rec.title} ({rec.impact} impact, {rec.difficulty} difficulty)")
    print(f"Description: {rec.description}")

    if rec.code_before and rec.code_after:
        print("Before:")
        print(rec.code_before)
        print("After:")
        print(rec.code_after)

# Add to your development middleware or views
from django.conf import settings

if settings.DEBUG:
    from dbcrust.django import analyzer


    def my_view(request):
        with analyzer.analyze() as analysis:
            # Your view logic
            context = get_context_data()
            return render(request, 'template.html', context)

        # Log performance issues in development
        results = analysis.get_results()
        if results.detected_patterns:
            logger.warning(f"Performance issues: {len(results.detected_patterns)}")

# In your test suite
from django.test import TestCase
from dbcrust.django import analyzer


class PerformanceTestCase(TestCase):
    def test_view_has_no_n_plus_one(self):
        with analyzer.analyze() as analysis:
            response = self.client.get('/books/')
            self.assertEqual(response.status_code, 200)

        results = analysis.get_results()

        # Assert no N+1 queries
        n_plus_one = [p for p in results.detected_patterns
                      if p.pattern_type == 'n_plus_one']
        self.assertEqual(len(n_plus_one), 0,
                         "View should not have N+1 queries")

        # Assert reasonable query count
        self.assertLess(results.total_queries, 10,
                        "View should use fewer than 10 queries")

# Monitor critical code paths in production
import logging
from dbcrust.django import analyzer


def process_user_dashboard(user_id):
    """Critical function that should be optimized."""
    with analyzer.analyze(transaction_safe=True) as analysis:
        # Dashboard logic
        user = User.objects.select_related('profile').get(id=user_id)
        recent_orders = user.orders.prefetch_related('items').recent()
        recommendations = get_product_recommendations(user)

        return {
            'user': user,
            'orders': recent_orders,
            'recommendations': recommendations
        }

    # Log performance metrics
    results = analysis.get_results()
    if results.total_queries > 5:
        logging.warning(f"Dashboard used {results.total_queries} queries for user {user_id}")

    if results.detected_patterns:
        logging.error(f"Performance issues in dashboard: {len(results.detected_patterns)}")

with analyzer.analyze(dbcrust_url="postgres://localhost/mydb") as analysis:
    # Complex query that benefits from EXPLAIN analysis
    complex_books = (
        Book.objects
        .select_related('author', 'publisher', 'author__country')
        .prefetch_related('categories', 'reviews__reviewer')
        .filter(
            published_date__year__gte=2020,
            price__between=(20, 100),
            author__country__name='USA'
        )
        .order_by('-published_date', 'price')[:50]
    )

    list(complex_books)  # Force evaluation

results = analysis.get_results()

# Database-level insights
if results.dbcrust_analysis:
    print(f"Analyzed {results.dbcrust_analysis['analyzed_queries']} queries with EXPLAIN")
    print("\nDatabase Performance Report:")
    print(results.dbcrust_analysis['performance_report'])

# ci/performance_check.py - Automated performance testing
from dbcrust.django.analyzer import analyze_django_project
import sys


def check_project_performance():
    """CI check for Django ORM performance issues."""

    # Analyze entire project without runtime execution
    results = analyze_django_project("/app")

    # Define performance thresholds
    critical_issues = [issue for issue in results['code_issues']
                       if issue.severity == 'critical']

    optimization_score = results['optimization_score']

    # Fail CI for critical issues or low optimization score
    if critical_issues:
        print(f"❌ {len(critical_issues)} critical performance issues found:")
        for issue in critical_issues[:5]:  # Show top 5
            print(f"   {issue.file_path}:{issue.line_number} - {issue.description}")
        sys.exit(1)

    if optimization_score < 70:
        print(f"⚠️ Optimization score too low: {optimization_score}/100")
        print("Consider addressing high-priority recommendations")
        sys.exit(1)

    print(f"✅ Performance check passed - Score: {optimization_score}/100")
    print(f"📊 Models analyzed: {len(results['models'])}")
    print(f"🔍 Total issues: {len(results['code_issues'])}")


if __name__ == "__main__":
    check_project_performance()

# tests/test_performance.py - Enhanced performance test suite
from django.test import TestCase, override_settings
from dbcrust.django.analyzer import create_enhanced_analyzer
from django.test.utils import override_settings


class PerformanceTestCase(TestCase):
    def setUp(self):
        """Set up enhanced analyzer for all tests."""
        self.analyzer = create_enhanced_analyzer(
            enable_all_features=True,
            project_root=settings.BASE_DIR
        )

    def test_homepage_performance_budget(self):
        """Test homepage meets performance budget."""
        with self.analyzer.analyze() as analysis:
            response = self.client.get('/')
            self.assertEqual(response.status_code, 200)

        results = analysis.get_results()

        # Strict performance budget
        self.assertLess(results.total_queries, 5,
                        "Homepage exceeded query budget (5 queries)")
        self.assertLess(results.total_duration, 0.050,  # 50ms
                        "Homepage exceeded time budget (50ms)")

        # No critical performance issues allowed
        critical_patterns = [p for p in results.detected_patterns
                             if p.severity == 'critical']
        self.assertEqual(len(critical_patterns), 0,
                         f"Critical performance issues found: {[p.description for p in critical_patterns]}")

    def test_product_listing_optimization(self):
        """Test product listing is properly optimized."""
        with self.analyzer.analyze() as analysis:
            response = self.client.get('/products/')

        results = analysis.get_results()
        comprehensive = analysis.get_comprehensive_analysis()

        # Check for specific patterns
        n_plus_one = [p for p in results.detected_patterns
                      if p.pattern_type == 'n_plus_one']
        self.assertEqual(len(n_plus_one), 0, "N+1 queries detected in product listing")

        # Check combined recommendations from all analysis types
        combined_recs = comprehensive['combined_recommendations']
        critical_recs = [r for r in combined_recs if r.get('impact') == 'critical']
        self.assertEqual(len(critical_recs), 0,
                         "Critical optimization opportunities found")

    def test_user_dashboard_complex_relationships(self):
        """Test complex dashboard query optimization."""
        with self.analyzer.analyze() as analysis:
            # Simulate authenticated user dashboard access
            response = self.client.get('/dashboard/',
                                       HTTP_AUTHORIZATION='Bearer test-token')

        results = analysis.get_results()

        # Ensure efficient relationship handling
        prefetch_issues = [p for p in results.detected_patterns
                           if 'prefetch' in p.pattern_type]
        self.assertLess(len(prefetch_issues), 2,
                        "Too many prefetch_related opportunities found")

        # Dashboard should be fast even with complex data
        self.assertLess(results.total_duration, 0.200,  # 200ms budget
                        "Dashboard query time too slow")

    def test_project_wide_optimization_score(self):
        """Test overall project optimization score."""
        # This test doesn't require runtime analysis
        comprehensive = self.analyzer.get_comprehensive_analysis()

        if comprehensive.get('model_analysis'):
            models = comprehensive['model_analysis']
            models_with_indexes = len([m for m in models if m.indexes])
            models_with_relationships = len([m for m in models
                                             if m.foreign_keys or m.many_to_many])

            # Ensure models with relationships have proper indexes
            index_coverage = models_with_indexes / models_with_relationships if models_with_relationships > 0 else 1
            self.assertGreater(index_coverage, 0.7,
                               "Less than 70% of models with relationships have indexes")

# middleware/performance_middleware.py - Development performance monitoring
from dbcrust.django.analyzer import create_enhanced_analyzer
from django.conf import settings
from django.utils.deprecation import MiddlewareMixin
import logging

logger = logging.getLogger('performance')


class PerformanceAnalysisMiddleware(MiddlewareMixin):
    """Middleware to analyze performance of all requests in development."""

    def __init__(self, get_response):
        self.get_response = get_response
        self.analyzer = None

        # Only enable in development/staging
        if settings.DEBUG or getattr(settings, 'ENABLE_PERFORMANCE_ANALYSIS', False):
            self.analyzer = create_enhanced_analyzer(
                project_root=settings.BASE_DIR,
                enable_all_features=True
            )

    def process_request(self, request):
        if self.analyzer:
            # Start analysis for this request
            request._performance_analysis = self.analyzer.analyze().__enter__()

    def process_response(self, request, response):
        if hasattr(request, '_performance_analysis'):
            # Finish analysis
            analysis = request._performance_analysis
            analysis.__exit__(None, None, None)

            results = analysis.get_results()

            # Log performance metrics
            logger.info(f"Request: {request.path}")
            logger.info(f"Queries: {results.total_queries}, Time: {results.total_duration * 1000:.1f}ms")

            # Log critical issues
            critical_patterns = [p for p in results.detected_patterns
                                 if p.severity == 'critical']
            if critical_patterns:
                logger.warning(f"Critical performance issues in {request.path}:")
                for pattern in critical_patterns:
                    logger.warning(f"  - {pattern.description}")

            # Add performance headers in development
            if settings.DEBUG:
                response['X-Query-Count'] = str(results.total_queries)
                response['X-Query-Time'] = f"{results.total_duration * 1000:.1f}ms"
                if critical_patterns:
                    response['X-Performance-Issues'] = str(len(critical_patterns))

        return response

# management/commands/analyze_performance.py - Comprehensive analysis command
from django.core.management.base import BaseCommand
from dbcrust.django.analyzer import analyze_django_project, generate_optimization_report
import os


class Command(BaseCommand):
    help = 'Analyze Django project for ORM performance issues'

    def add_arguments(self, parser):
        parser.add_argument('--output', type=str,
                            help='Output file for detailed report')
        parser.add_argument('--score-threshold', type=int, default=70,
                            help='Minimum optimization score (default: 70)')
        parser.add_argument('--fix-suggestions', action='store_true',
                            help='Include detailed fix suggestions')
        parser.add_argument('--migrations', action='store_true',
                            help='Generate index migration files')

    def handle(self, *args, **options):
        project_root = os.getcwd()

        self.stdout.write("🔍 Analyzing Django project for performance issues...")

        # Comprehensive project analysis
        if options['output']:
            report = generate_optimization_report(
                project_path=project_root,
                output_file=options['output']
            )
            self.stdout.write(f"📄 Detailed report saved to {options['output']}")

        # Quick analysis for CLI
        results = analyze_django_project(project_root)

        score = results['optimization_score']
        self.stdout.write(f"\n📊 Optimization Score: {score:.1f}/100")

        # Color-coded score output
        if score >= 85:
            self.stdout.write(self.style.SUCCESS("✅ Excellent optimization"))
        elif score >= 70:
            self.stdout.write(self.style.WARNING("⚠️ Good, with room for improvement"))
        else:
            self.stdout.write(self.style.ERROR("🚨 Needs significant optimization"))

        # Summary statistics
        self.stdout.write(f"📋 Models analyzed: {len(results['models'])}")
        self.stdout.write(f"🔍 Issues found: {len(results['code_issues'])}")

        # Issue breakdown
        issue_counts = {}
        for issue in results['code_issues']:
            issue_counts[issue.severity] = issue_counts.get(issue.severity, 0) + 1

        for severity, count in issue_counts.items():
            if severity == 'critical':
                self.stdout.write(self.style.ERROR(f"  🚨 Critical: {count}"))
            elif severity == 'high':
                self.stdout.write(self.style.WARNING(f"  ⚠️ High: {count}"))
            else:
                self.stdout.write(f"  ℹ️ {severity.title()}: {count}")

        # Check against threshold
        if score < options['score_threshold']:
            self.stdout.write(self.style.ERROR(
                f"\n❌ Score {score:.1f} below threshold {options['score_threshold']}"
            ))
            exit(1)
        else:
            self.stdout.write(self.style.SUCCESS(
                f"\n✅ Score {score:.1f} meets threshold {options['score_threshold']}"
            ))

# settings.py or settings/development.py
MIDDLEWARE = [
    'dbcrust.django.PerformanceAnalysisMiddleware',
    # ... your other middleware
]

# Optional configuration
DBCRUST_PERFORMANCE_ANALYSIS = {
    'ENABLED': True,  # Override DEBUG mode
    'QUERY_THRESHOLD': 10,  # Warn if > 10 queries
    'TIME_THRESHOLD': 100,  # Warn if > 100ms
    'LOG_ALL_REQUESTS': False,  # Only log problematic requests
    'INCLUDE_HEADERS': True,  # Add performance headers
    'ENABLE_CODE_ANALYSIS': False,  # Enable full project analysis
    'TRANSACTION_SAFE': False,  # Avoid session conflicts (default: False)
    'DEBUG_TOOLBAR_COMPATIBILITY': True,  # Auto-disable with Debug Toolbar (default: True)
}

# Performance logging (recommended)
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'dbcrust.performance': {
            'handlers': ['console'],
            'level': 'INFO',
            'propagate': False,
        },
    },
}

# For teams wanting comprehensive analysis
DBCRUST_PERFORMANCE_ANALYSIS = {
    'ENABLED': True,
    'QUERY_THRESHOLD': 5,  # Strict query limit
    'TIME_THRESHOLD': 50,  # Strict timing limit
    'LOG_ALL_REQUESTS': True,  # Log all requests for monitoring
    'INCLUDE_HEADERS': True,
    'ENABLE_CODE_ANALYSIS': True,  # Enable full project scanning
    'TRANSACTION_SAFE': False,  # Avoid session conflicts (recommended)
    'DEBUG_TOOLBAR_COMPATIBILITY': False,  # Force enable even with Debug Toolbar
}

# Analyze key business functions
with analyzer.analyze() as analysis:
    process_checkout(cart_id)  # Critical e-commerce path

results = analysis.get_results()
if results.detected_patterns:
    # Alert developers to issues in critical paths
    send_performance_alert(results)

def test_homepage_performance(self):
    with analyzer.analyze() as analysis:
        response = self.client.get('/')

    results = analysis.get_results()

    # Performance budget assertions
    self.assertLess(results.total_queries, 5, "Homepage should use < 5 queries")
    self.assertLess(results.total_duration, 0.1, "Homepage should take < 100ms")

    # No critical issues allowed
    critical_issues = [p for p in results.detected_patterns if p.severity == 'critical']
    self.assertEqual(len(critical_issues), 0, "No critical performance issues allowed")

# In your CI pipeline
import sys
from dbcrust.django import analyzer


def analyze_test_performance():
    """Run performance analysis as part of CI."""
    with analyzer.analyze() as analysis:
        # Run your test scenarios
        run_integration_tests()

    results = analysis.get_results()

    # Fail CI if critical issues found
    critical_issues = [p for p in results.detected_patterns if p.severity == 'critical']
    if critical_issues:
        print(f"❌ Found {len(critical_issues)} critical performance issues")
        for issue in critical_issues:
            print(f"   - {issue.description}")
        sys.exit(1)

    print(f"✅ Performance analysis passed: {results.total_queries} queries in {results.total_duration * 1000:.1f}ms")

# Before: N+1 queries
def list_books_bad():
    books = Book.objects.all()
    for book in books:
        print(f"{book.title} by {book.author.name}")  # N+1 queries
        print(f"Publisher: {book.publisher.name}")  # More N+1 queries
        print(f"Categories: {', '.join(c.name for c in book.categories.all())}")  # Even more N+1


# After: Optimized
def list_books_good():
    books = (
        Book.objects
        .select_related('author', 'publisher')  # Join author and publisher
        .prefetch_related('categories')  # Prefetch categories
    )
    for book in books:
        print(f"{book.title} by {book.author.name}")  # No additional queries
        print(f"Publisher: {book.publisher.name}")  # No additional queries
        print(f"Categories: {', '.join(c.name for c in book.categories.all())}")  # No additional queries

# Before: Multiple inefficiencies
def user_dashboard_bad(user_id):
    user = User.objects.get(id=user_id)
    orders = user.orders.all()  # Will fetch all orders

    recent_orders = []
    for order in orders:
        if order.created_at > recent_date:
            order_items = []
            for item in order.items.all():  # N+1 queries
                order_items.append({
                    'product': item.product.name,  # N+1 queries
                    'price': item.price
                })
            recent_orders.append({
                'id': order.id,
                'items': order_items,
                'total': sum(item.price for item in order.items.all())  # More N+1
            })

    return {'user': user, 'orders': recent_orders}


# After: Optimized
def user_dashboard_good(user_id):
    user = User.objects.select_related('profile').get(id=user_id)

    recent_orders = (
        user.orders
        .filter(created_at__gt=recent_date)
        .prefetch_related('items__product')  # Prefetch items and their products
        .order_by('-created_at')[:10]  # Limit results
    )

    orders_data = []
    for order in recent_orders:
        items_data = [
            {
                'product': item.product.name,  # No additional queries
                'price': item.price
            }
            for item in order.items.all()  # No additional queries
        ]
        orders_data.append({
            'id': order.id,
            'items': items_data,
            'total': sum(item.price for item in order.items.all())  # Still no additional queries
        })

    return {'user': user, 'orders': orders_data}

# Enable verbose debugging
import logging

logging.basicConfig(level=logging.DEBUG)

with analyzer.analyze() as analysis:
    # Your code here
    MyModel.objects.all().count()

# Print detailed query information
analysis.print_queries(verbose=True)

# Example: Detect queries in loops
def detect_queries_in_loops(queries):
    """Custom pattern detector for queries inside loops."""
    # Implementation would analyze stack traces for loop patterns
    pass

# Send metrics to monitoring systems
def send_performance_metrics(results):
    """Send analysis results to monitoring system."""
    metrics = {
        'query_count': results.total_queries,
        'duration_ms': results.total_duration * 1000,
        'n_plus_one_count': len([p for p in results.detected_patterns
                                 if p.pattern_type == 'n_plus_one']),
        'duplicate_count': results.duplicate_queries
    }

    # Send to your monitoring system
    monitoring_client.send_metrics('django.orm.performance', metrics)

# settings.py
INSTALLED_APPS = [
    # ... your other apps
    'dbcrust',
]

# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'myapp_production',
        'USER': 'myapp_user',
        'PASSWORD': 'secure_password',
        'HOST': 'db.example.com',
        'PORT': '5432',
        'OPTIONS': {
            'sslmode': 'require',
            'connect_timeout': 10,
        }
    }
}