How can I manually modify models retrieved from the database in Django? - django

Question

I wish to do something such as the following:
people = People.objects.filter(date=date)
person = people[0]
person['salary'] = 45000
The last line results in an error:
object does not support item assignment
To debug something like this I always find it easier to start with something working and modify line by line until something breaks.
I want to modify the object for rendering in the template. If I try:
person.salary = 45000
There is no error but trying
print person.salary
Immediately afterwards results in the original value being printed. Update:
In my code I was actually doing:
people[0].salary = 45000
Which doesn't work. For some reason
person = people[0]
person.salary = 45000
Does work. I thought the two pieces of code would be exactly the same

Answer 1

person is an object, you need to do like this:
person.salary = 45000
person.save()
You should read How to work with models.

Answer 2

Looking at the IDs, it seems that when you assign an entry to a variable, you get its copy, not its original reference:
In [11]: people = People.objects.filter(salary=100)
In [12]: person = people[0]
In [13]: person.salary = 5000
In [14]: print person.salary
5000
In [15]: people[0].salary
Out[15]: 100
In [16]: id(people[0])
Out[16]: 35312400
In [17]: id(person)
Out[17]: 35313104
So, let's look at what it happens in depth.
You know that in Django QuerySets are evaluated only when you need their results (lazy evaluation). To quote the Django documentation:
Slicing. As explained in Limiting QuerySets, a QuerySet can be sliced,
using Python’s array-slicing syntax. Slicing an unevaluated QuerySet
usually returns another unevaluated QuerySet, but Django will execute
the database query if you use the “step” parameter of slice syntax,
and will return a list. Slicing a QuerySet that has been evaluated
(partially or fully) also returns a list.
In particular, looking at the 'django.db.models.query' source code,
def __getitem__(self, k):
"""
Retrieves an item or slice from the set of results.
"""
# some stuff here ...
if isinstance(k, slice):
qs = self._clone()
if k.start is not None:
start = int(k.start)
else:
start = None
if k.stop is not None:
stop = int(k.stop)
else:
stop = None
qs.query.set_limits(start, stop)
return k.step and list(qs)[::k.step] or qs
qs = self._clone()
qs.query.set_limits(k, k + 1)
return list(qs)[0]
you can see that when you use slicing, you are calling the __getitem__ method.
Then the self._clone method will provide you a different instance of the same QuerySet. This is the reason you are getting different results.

Answer 3

Object-relational mapping that Django models provide hides the fact that you are interacting with a DB, by providing object-oriented interface for retrieving and manipulating data.
Unfortunately, ORM abstraction is not perfect, there are various cases when ORM semantic does not match the intuition. In these cases you need to investigate what's going on on the underlying SQL layer to figure out the cause of troubles.
Your problem arises from the fact that:
people = People.objects.filter(date=date)
does not execute any SQL query.
people[0]
executes SELECT a, b, c, .. FROM T WHERE filter, if you modify the resulting object by calling:
people[0].salary = 45000
the modification won't be saved to the DB, because the save() method was not called. The next call to people[0] again executes a SQL query, which does not return the unsaved modification.
When you encounter problems like this, Django Debug Toolbar can greatly help to identify which statements execute what SQL queries.