Django and Flex

There is (in my humble opinion).

This kind of polymorphism belongs in object-oriented code, not relational database semantics. In my application (which has nothing to do with antiques but I can't say what it is without giving the client away), I represent categories as classes: the django model holds the name of a class, each category maps to one class. That class then defines the required data and the defaults and the validation methods, and so on (they inherit from a base class, so most of this is pretty easy).

# A sample category class, with the properties it expects, and their data types.
class FurnitureAntique (Category):
   scratches = ListOf(LocatedDefect)
   period = TimePeriod()
   primaryWood = Choice(WOOD_TYPES)

The classes so defined are held in a simple registry (a dictionary mapping name to class)

# Add the category class to the registry, so it can be retrieved by name later.
Cateogry.registerClass(FurnitureAntique)

And the django database model for a category allows you to easily get the corresponding class.

# The django model representing a category of antique
class AntiqueCategory (models.Model):
   categoryClass = models.CharField(maxlength=64)
   def getClass(self):
       # Retrieve the corresponding category class from the registry by name
       Category.getCategoryByName(self.categoryClass)

Then I have another django model for the antiques. This has a text field that holds pickled data for its properties. I have added a method to the django model that will unpickle the data, find the classes for the categories, create and return a new instance of the category class with the unpickled data (below I've shown this where each antique has one and only one category, in my app it is a many to many relation, and for instances that belong to more than one category the correctly uses multiple inheritance and an anonymous class).

class Antique (models.Model):
    pickle = models.TextField()
    category = models.ForeignKey(AntiqueCategory) # Using a many-to-one for clarity here.
 
    def getCateogryInstance(self):
        cls = category.getClass()
        data = pickle.loads(self.pickle)
        return cls(**data)

This allows me to store any number of well-validated properties in the antique table, corresponding to validation requirements in the category table, without having to have lots and lots of tables in the database.

The downside is that I can't use the databases optimised searching systems (such as indexes) to search the pickled properties. In my application this doesn't matter (it would be difficult to create a user interface that allowed the user to specify such a highly polymorphic search in any case), but in other domains this may be a killer for this approach.

Now in the example above I'm using a very simple set of class properties in the Category class to define what properties we expect. Rather than create a whole new set of validation building blocks, I suspect I can reuse the newforms fields from Django for this same purpose (with the addition of fields representing compound data). But I haven't got far trying this yet. In my application parameters are all of one type (an enumerated choice), so I haven't need this yet, but I'm keen to have a go at some point.