CODEWITHSUNDEEP
sqldjangodjango-models
marky1991
marky1991

Reputation: 620

Implementing Sticky Threads In Django

Note: I'm new to both django and databases, so please excuse my ignorance.

I'm trying to implement a forum in django and wish to have sticky threads. The naive way that I was thinking of do this was to define the Thread model like this:

class Thread(models.Model):
    title = models.CharField(max_length=max_title_length)
    author = models.ForeignKey(Player, related_name="nonsticky_threads")
    post_date = models.DateField()
    parent = models.ForeignKey(Subsection, related_name="nonsticky_threads")
    closed = models.BooleanField()
    sticky = models.BooleanField()

and then to get the sticky threads, do something like this:

sticky_threads = Thread.objects.all().filter(sticky=True)

The problem is that at least theoretically this has O(n) complexity, which sounds bad. (Since sticky threads are always displayed on the first page, this query will be run fairly frequently) However, I don't know how database/django cleverness will affect the final performance or if it will still be bad.

My current alternative is to also create distinct Thread and Sticky_Thread classes: 

class Thread(models.Model):
    title = models.CharField(max_length=max_title_length)
    author = models.ForeignKey(Player, related_name="nonsticky_threads")
    post_date = models.DateField()
    parent = models.ForeignKey(Subsection, related_name="nonsticky_threads")
    closed = models.BooleanField()
class Sticky_Thread(models.Model):
    title = models.CharField(max_length=max_title_length)
    author = models.ForeignKey(Player, related_name="sticky_threads")
    post_date = models.DateField()
    parent = models.ForeignKey(Subsection, related_name="sticky_threads")
    closed = models.BooleanField()

letting me grab the sticky threads in O(1) time no matter what. What I don't like about this approach is that now if I want to just get all of a player's threads, I have to implement a special threads property like this:

class Player(models.Model):
    [snip]

    @property
    def threads(self):
        return self.sticky_threads | self.nonsticky_threads

and this approach feels ugly.

Is there an obviously best way to imeplement something like this? Do I just need to do timings to see if the naive way is acceptable? (I'm implementing this as a learning exercise, so I don't really have hard limits, making this check a little difficult) (If so, how would you recommend I do that? (IS something like timeit the bast way?) Is there a better alternative?

Thanks!

Upvotes: 1

Views: 123

Answers (1)

Daniel Roseman
Daniel Roseman

Reputation: 599450

Your analysis of the complexity of those two operations is way off. It's simply not true to classify the filter operation as O(n) and the two separate classes as O(1) - I don't know what you're using to make that distinction. Databases are highly optimized for selecting on individual criteria: an index on the sticky column will make the filter query almost exactly the same as querying for everything from a separate table.

The first way is without question the right way to go about this, as long as you ensure that your sticky column is indexed.

Upvotes: 3

Related Questions