Django dynamic model fields

188

I'm working on a multi-tenanted application in which some users can define their own data fields (via the admin) to collect additional data in forms and report on the data. The latter bit makes JSONField not a great option, so instead I have the following solution:

class CustomDataField(models.Model):
    """
    Abstract specification for arbitrary data fields.
    Not used for holding data itself, but metadata about the fields.
    """
    site = models.ForeignKey(Site, default=settings.SITE_ID)
    name = models.CharField(max_length=64)

    class Meta:
        abstract = True

class CustomDataValue(models.Model):
    """
    Abstract specification for arbitrary data.
    """
    value = models.CharField(max_length=1024)

    class Meta:
        abstract = True

Note how CustomDataField has a ForeignKey to Site - each Site will have a different set of custom data fields, but use the same database. Then the various concrete data fields can be defined as:

class UserCustomDataField(CustomDataField):
    pass

class UserCustomDataValue(CustomDataValue):
    custom_field = models.ForeignKey(UserCustomDataField)
    user = models.ForeignKey(User, related_name='custom_data')

    class Meta:
        unique_together=(('user','custom_field'),)

This leads to the following use:

custom_field = UserCustomDataField.objects.create(name='zodiac', site=my_site) #probably created in the admin
user = User.objects.create(username='foo')
user_sign = UserCustomDataValue(custom_field=custom_field, user=user, data='Libra')
user.custom_data.add(user_sign) #actually, what does this even do?

But this feels very clunky, particularly with the need to manually create the related data and associate it with the concrete model. Is there a better approach?

Options that have been pre-emptively discarded:

Custom SQL to modify tables on-the-fly. Partly b

Edit Report

301

As of today, there are four available approaches, two of them requiring a certain storage backend:

Django-eav (the original package is no longer mantained but has some thriving forks)

This solution is based on Entity Attribute Value data model, essentially, it uses several tables to store dynamic attributes of objects. Great parts about this solution is that it:
- uses several pure and simple Django models to represent dynamic fields, which makes it simple to understand and database-agnostic;
- allows you to effectively attach/detach dynamic attribute storage to Django model with simple commands like:
```
eav.unregister(Encounter)
eav.register(Patient)
```
- Nicely integrates with Django admin;
- At the same time being really powerful.
Downsides:
- Not very efficient. This is more of a criticism of the EAV pattern itself, which requires manually merging the data from a column format to a set of key-value pairs in the model.
- Harder to maintain. Maintaining data integrity requires a multi-column unique key constraint, which may be inefficient on some databases.
- You will need to select one of the forks, since the official package is no longer maintained and there is no clear leader.
The usage is pretty straightforward:
```
import eav
from app.models import Patient, Encounter

eav.register(Encounter)
eav.register(Patient)
Attr
```


                        
                        
                            answered 2011-10-28T20:32:06.570

Django dynamic model fields

1 Answer

Your Answer