CODEWITHSUNDEEP
djangoformsdynamicmodels
Joe Jasinski
Joe Jasinski

Reputation: 10801

Seeking Good Approach to Persist Data Submitted Through Dynamic Django Forms

Summary:

Looking for a good way to save data to Django models for which the associated forms are generated dynamically.

Detail:

I've been puzzling over the best approach for creating dynamic Django forms backed by models. For example, I'd like to create an interface where a user can create an HTML form, customize the types of fields in that form dynamically (Number, String, Dropdown Box, Date, etc.), and then display that form to other users so those users can submit data which is saved to a database. I'm not sure how to make an efficient approach to persist the data.

www.formsite.com and www.mailchimp.com have some form-building tools that are nice examples of what I am trying to do. Jacob Kaplan-Moss has an excellent tutorial on how to create the forms dynamically, but the tutorial doesn't get into how to persist the data.

As a dummy example, one (perhaps bad?) approach might be to create some models like below, where there is a database table for the SurveyQuestions (storing the customizable names and datatypes of each field) and one for the SurveyQuestionResponses (each record storing an individual response for a SurveyQuestion on a particular Survey).

However, it seems like this approach might result in really complex and slow queries. For example, if a Survey has 10 questions and you would like to display 10 user responses to that survey, there would be queries to select all 10 SurveyQuestions and then for each survey responder, there would be a query to select each of the SurveyQuestionResponses. It seems like the number of queries needed could add up really fast! 

class Survey(models.Model):
    # some fields here. 
    pass

class SurveyQuestion(models.Model):
    """ Defines the headings and field
        types for a given Survey. 
    """
    survey = models.ForeignKey(Survey)
    field_name = models.CharField(
        max_length=255, 
        help_text='Enter the name for this field heading')
    field_type = models.IntegerField(
        choices=choices.FIELD_TYPES,  
        help_text='Enter the data type for this field')
    display_order = models.IntegerField(default=0)

class SurveyQuestionResponse(models.Model):
    survey_field = models.ForeignKey(SurveyQuestion)
    response value = models.TextArea(blank=True, null=True)

Is there a better approach to persisting data based on dynamic forms? Should I be somehow converting a form respondent's response to some sort of pickled format and store it to a TextField (Instead of having 10 SurveyQuestionResponse records there would be one record with all the response values pickled together)? I'm not too familiar with NoSQL options, but would a NoSQL approach work best for this type of thing? Is there some sort of rendering or caching that would make sense to do?

I keep encountering situations where saving data from dynamic forms like this would be very useful. I am wondering what other people's approaches are. Any advice is much appreciated. Thanks for reading this admittedly long question.

Joe

Upvotes: 1

Views: 478

Answers (1)

solartic
solartic

Reputation: 4319

For a relational database an Entity-attribute-value model(EAV) could be used to achieve a dynamic, or open schema. Relational databases are not really suited for this type of schema, and this generally results in very slow queries over time. NoSQL has its own set of issues but I think that it would be best suited to your requirements. If you decide to take this route you can take a look at MongoDB. I have not used it extensively, but it seems most similar to relational database than the other NoSQL database out there, and its python interface seems pretty similar to django's ORM. By the was I remember finding a nice EAV example for Django. Though I don't remember where at the moment.

Upvotes: 1

Related Questions