Django do something with each different value in a model field - django

Question

I know I've seen this before, but I can't find now that I am ready to implement it.
I'm trying to list items on a page by category and subcategory, but I only want 1 category and then the subcategories in the category. Hopefully my code will make sense.
class Objects(models.Model):
# Main Checkbox.
category = models.CharField(
max_length=100,
blank=True,
)
# Checkboxes under Main Checkbox.
subcategory = models.CharField(
max_length=100,
blank=True,
)
So my objects are stored as:
category1, subcategory1
category1, subcategory2
category2, subcategory1
category2, subcategory2
And when displayed should give me:
category1
subcategory1
subcategory2
category2
subcategory1
subcategory2
How do I set my query so that my results show me each "different" category?

Answer 1

First off you should look to normalise your objects, meaning you could keep your subcategories as a separate object and use models.foreignKey to link them together. See Willem Van Onsem's answer for this.
However, to solve the current problem you should be able to utilize the regroup template tag in order to aggregate the categories.
In your case it would look something like:
{% regroup objects by category as categories %}
{% for category in categories %}
{{ category.grouper }}
{% for subcategory in category.list %}
{{ subcategory }}
{% endfor %}
{% endfor %}

Answer 2

The data duplication anti-pattern
Many computer scientists see this as bad design, since it introduces data duplication. Imagine that you later want to change the name of a category, then that means you need to find all occurrences of that category, and rename them. If you only use this for the Objects model, then that is perhaps doable, but if all sorts of elements belong to Categorys, then this easily gets out of hand.
Furthermore it also restricts categories: two different categories can never have the same name (which might here be reasonable), nor can we attach much properties to the Category: imagine that we want to add a description for the category, then that description needs to be repeated over all rows, or if we decide to store it only in one row, then it will be hard to find that specific row. Furthermore if there are two rows with different descriptions, then what description to pick?
The database will also be very huge: each row should repeat the same category. If a category on average takes 15 characters, that means that we will - depending on the encoding - easily waste 8 bytes per row (well the row contains 16 bytes for a string given it is UTF-8 encoding, and only ASCII characters, but a ForeignKey will frequently use 8 bytes). If we would add a description that has on average 63 characters, then we would again waste another 64 bytes per row. For a small amount of rows, that is not a problem, but the problem easily scales problematic. The above are of course only estimates on what problems might arise, do not see this as the "real numbers": the size a database takes is determined by a lot of parameters that are here either ignored, or estimated.
Yes all these problems probably can be solved, but instead of solving the problems ad-hoc, it is better to normalize the database.
Normalizing the models
Normalization typically means that we introduce extra tables that store for example one record per Category, and use ForeignKeys to refer to that record. For you example a normalized variant would be:
class Category(models.Model):
name = models.CharField(max_length=100)
class SubCategory(models.Model):
name = models.CharField(max_length=100)
category = models.ForeignKey(Category, on_delete=models.CASCADE)
class Object(models.Model):
subcategory = models.ForeignKey(
SubCategory,
null=True,
on_delete=models.SET_NULL
)
So we store Categorys and SubCategorys in dedicated tables, and link the models together with ForeignKeys.
Rendering lists of (Sub)Categorys
Now that we normalized the models, we can effectively render the Categorys with:
# app/views.py
def some_view(request):
categories = Category.objects.prefetch_related('subcategory_set')
return render(request, 'app/some_template.html', {'categories': categories})
and in the app/templates/some_template.html we then can render it as:
<ul>
{% for cat in categories %}
<li>{{ cat.name }}</li>
<ul>
{% for subcat in cat.subcategory_set %}
<li>{{ subcat.name }}</li>
{% endfor %}
</ul>
{% endfor %}
</ul>
We thus iterate over all categories, and for every cat, we iterate over the subcategory_set.