Summary: One option is, as suggested by jpic and sgallen in the comments, to add .filter() for each category. Each additional filter adds more joins, which should not be a problem for small set of categories. There is the aggregation approach. This query would be shorter and perhaps quicker for a large set of categories. … Read more
If title and body are fields in your model, then you can deliver the keyword arguments in your dictionary using the ** operator. Assuming your model is called MyModel: # create instance of model m = MyModel(**data_dict) # don’t forget to save to database! m.save() As for your second question, the dictionary has to be … Read more
According to the documentation, you should use: from django.db.models import Count Transaction.objects.all().values(‘actor’).annotate(total=Count(‘actor’)).order_by(‘total’) values() : specifies which columns are going to be used to “group by” Django docs: “When a values() clause is used to constrain the columns that are returned in the result set, the method for evaluating annotations is slightly different. Instead of returning … Read more
Say your model is ‘Shop’ class Shop(models.Model): street = models.CharField(max_length=150) city = models.CharField(max_length=150) # some of your models may have explicit ordering class Meta: ordering = (‘city’,) Since you may have the Meta class ordering attribute set (which is tuple or a list), you can use order_by() without parameters to clear any ordering when using … Read more
Employees.objects.values_list(‘eng_name’, flat=True) That creates a flat list of all eng_names. If you want more than one field per row, you can’t do a flat list: this will create a list of tuples: Employees.objects.values_list(‘eng_name’, ‘rank’)
Use __contains or __icontains (case-insensitive): result = table.objects.filter(string__contains=”pattern”) The SQL equivalent is SELECT … WHERE string LIKE ‘%pattern%’; @Dmitri’s answer below covers patterns like ‘pattern%’ or ‘%pattern’
get() is provided specifically for this case. Use it. Option 2 is almost precisely how the get() method is actually implemented in Django, so there should be no “performance” difference (and the fact that you’re thinking about it indicates you’re violating one of the cardinal rules of programming, namely trying to optimize code before it’s … Read more
Inside a manager: def delete_everything(self): Reporter.objects.all().delete() def drop_table(self): cursor = connection.cursor() table_name = self.model._meta.db_table sql = “DROP TABLE %s;” % (table_name, ) cursor.execute(sql)
Asset.objects.filter( project__name__contains=”Foo” )
I would focus on the example queries rather than your quote from the documentation. Aggregate calculates values for the entire queryset. Annotate calculates summary values for each item in the queryset. Aggregation >>> Book.objects.aggregate(average_price=Avg(‘price’)) {‘average_price’: 34.35} Returns a dictionary containing the average price of all books in the queryset. Annotation >>> q = Book.objects.annotate(num_authors=Count(‘authors’)) >>> … Read more