Django Order模型单活跃订单一致性问题咨询：非事务类优化方案探讨

Great question! Since you want to avoid transactions and keep the "max one active order" rule consistent, here are a few robust approaches that leverage Django and database-level safeguards to solve this reliably:

1. Database-Level Association with a Singleton Model #

Instead of relying on a boolean field directly, create a dedicated singleton model that links to the currently active order. This ensures database-enforced uniqueness because a OneToOneField can only point to one order at a time, and we’ll enforce the singleton pattern in the model’s save method.

from django.db import models

class ActiveOrder(models.Model):
    order = models.OneToOneField(
        'Order', 
        on_delete=models.SET_NULL, 
        null=True,
        related_name='active_link'
    )

    class Meta:
        verbose_name = "Active Order"
        verbose_name_plural = "Active Order"  # Reinforce it's a singleton

    def save(self, *args, **kwargs):
        # Delete any existing active order entry before saving this one
        ActiveOrder.objects.exclude(pk=self.pk).delete()
        super().save(*args, **kwargs)

How to use this: #

• When you need to activate an order, create or update an ActiveOrder instance pointing to it:

  # Deactivate any existing active order and set a new one
  ActiveOrder.objects.update_or_create(defaults={'order': my_order})
  

• To get the current active order:

  active_order = ActiveOrder.objects.first().order if ActiveOrder.objects.exists() else None
  

This approach is clean, avoids race conditions, and makes it trivial to fetch the active order at any time.

2. Partial Unique Constraint (Database-Level) #

If you prefer to keep everything within the Order model, use a conditional unique constraint (supported in PostgreSQL, MySQL 8.0+, and SQLite 3.31+). This tells the database to only allow one record where active=True.

class Order(models.Model):
    open = models.DecimalField(max_digits=10, decimal_places=8)
    high = models.DecimalField(max_digits=10, decimal_places=8)
    low = models.DecimalField(max_digits=10, decimal_places=8)
    close = models.DecimalField(max_digits=10, decimal_places=8)
    time = models.DateTimeField()
    active = models.BooleanField(default=False)
    complete = models.BooleanField(default=False)

    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=['active'],
                condition=models.Q(active=True),
                name='only_one_active_order'
            )
        ]

How this works: #

• When you try to save a second order with active=True, the database will throw an IntegrityError. You can catch this in your Django code to handle the error gracefully (e.g., show a user-friendly message).
• This is a lightweight solution that enforces the rule at the lowest possible level, eliminating race conditions entirely.

3. Django Signals (Limited Use Case) #

You mentioned hooks—Django’s pre_save signal can work here, but note that it’s not concurrency-safe. It’s only suitable for low-traffic applications where race conditions are unlikely.

from django.db.models.signals import pre_save
from django.dispatch import receiver
from django.core.exceptions import ValidationError

@receiver(pre_save, sender=Order)
def enforce_single_active_order(sender, instance, **kwargs):
    if instance.active:
        # Check if another active order exists (excluding the current instance if it's being updated)
        existing_active = Order.objects.filter(active=True).exclude(pk=instance.pk).exists()
        if existing_active:
            raise ValidationError("Only one active order is allowed at a time.")

Caveat: #

In high-concurrency scenarios, two requests could both pass the check before either saves, resulting in two active orders. This is why database-level solutions are always preferred for consistency rules.

Recommendation #

For most cases, Option 2 (partial unique constraint) is the best choice—it’s simple, database-enforced, and doesn’t require additional models. If you need frequent, easy access to the active order, Option 1 (singleton model) is more convenient. Avoid Option 3 unless you’re certain your traffic volume won’t lead to race conditions.

内容的提问来源于stack exchange，提问作者Hossein Gholami