Question

Lets say I have three django model classes – lets call them A, B and C. If A and B are abstract, I can do something like:

class C(A,B):
    pass

What if they aren’t abstract and I do the same? Will everything still work correctly or no? Or have I got it wrong and this should not be done with abstract models either?

I’m having some issues which I’m attributing to the fact that the answer is probably no, but I’d still prefer to make sure about this if anyone knows 🙂
The specific use case I had for this is probably better served by Generic Relations (I only recently discovered their existence), so I guess it would be understandable if the Django team made a design decision like this (I can’t see many people needing to do this). I’d just like to know for sure what the case is.

Edit 1 (after Dominic’s answer)

Interesting… The problem we’re having is a structure similar to IMDb (I think IMDb is a bit easier to understand than the topic matter we actually have, so I’ll use them as an example). On IMDb they have pages for People and pages for Movies and both People and Movies have their own message boards.

We’ve ended up connecting message boards to the People and Movies by creating a model called MessageboardOwner (with only one attribute – the id added automatically by Django), which "owns" the message board and People and Movies inherit it. The problem is that our "People" class inherits from two other classes also. The class definition is something like:

class Person(A,B,MessageboardOwner):

Initially this seemed to work out fine, but then today something rather weird happened… I was deleting a Person in the admin and the admin asked the "Are you sure?" question and was showing me what other objects it would have to delete. It was trying to delete two message boards, not one. One of these message boards should have been owned by a Movie, not a Person.

Upon looking at what exactly was in the database, I found that this Person instance was using the same MessageboardOwner instance as the Movie was. When I played around with it, what came out was that the Movie class, which inherited only after MessageboardOwner, seemed to work ok. Saving the Person, however, only created a MessageboardOwner object if one didn’t already exist (or possibly overwrote the existing one – I’m not sure). I also found that the id fields inherited from A, B and MessageboardOwner were always equal, which seemed strange to me.

Answer 1

Yes, you can use normal Python multiple-inheritance with models. Bear in mind this warning though:

Just as with Python’s subclassing,
it’s possible for a Django model to
inherit from multiple parent models.
Keep in mind that normal Python name
resolution rules apply. The first base
class that a particular name (e.g.
Meta) appears in will be the one that
is used; for example, this means that
if multiple parents contain a Meta
class, only the first one is going to
be used, and all others will be
ignored.

Generally, you won’t need to inherit
from multiple parents. The main
use-case where this is useful is for
“mix-in” classes: adding a particular
extra field or method to every class
that inherits the mix-in. Try to keep
your inheritance hierarchies as simple
and straightforward as possible so
that you won’t have to struggle to
work out where a particular piece of
information is coming from.

From the Django docs.

Generally, multiple inheritance is a bad idea, and there are simpler ways to do things. If you flesh out what problem you’re trying to solve a bit more clearly, we might be able to help a bit better.