Using ActiveRecord, is there a way to get the old values of a record during after_update
Ruby on-RailsActiverecordModelCallbackRuby on-Rails Problem Overview
Setup using a simple example: I've got 1 table (Totals
) that holds the sum of the amount
column of each record in a second table (Things
).
When a thing.amount
gets updated, I'd like to simply add the difference between the old value and the new value to total.sum
.
Right now I'm subtracting self.amount
during before_update
and adding self.amount
during after_update
. This places WAY too much trust in the update succeeding.
Constraint: I don't want to simply recalculate the sum of all the transactions.
Question: Quite simply, I'd like to access the original value during an after_update
callback. What ways have you come up with do this?
Update: I'm going with Luke Francl's idea. During an after_update
callback you still have access to the self.attr_was
values which is exactly what I wanted. I also decided to go with an after_update
implementation because I want to keep this kind of logic in the model. This way, no matter how I decide to update transactions in the future, I'll know that I'm updating the sum of the transactions correctly. Thanks to everyone for your implementation suggestions.
Ruby on-Rails Solutions
Solution 1 - Ruby on-Rails
Ditto what everyone is saying about transactions.
That said...
ActiveRecord as of Rails 2.1 keeps track of the attribute values of an object. So if you have an attribute total
, you will have a total_changed?
method and a total_was
method that returns the old value.
There's no need to add anything to your model to keep track of this anymore.
Update: Here is the documentation for ActiveModel::Dirty as requested.
Solution 2 - Ruby on-Rails
Appending "_was" to your attribute will give you the previous value before saving the data.
These methods are called dirty methods methods.
Cheers!
Solution 3 - Ruby on-Rails
Some other folks are mentioning wrapping all this in a transaction, but I think that's done for you; you just need to trigger the rollback by raising an exception for errors in the after_ callbacks.*
See http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html
> The entire callback chain of a save, save!, or destroy call runs within a transaction. That includes after_* hooks. If everything goes fine a COMMIT is executed once the chain has been completed.
> If a before_* callback cancels the action a ROLLBACK is issued. You can also trigger a ROLLBACK raising an exception in any of the callbacks, including after_* hooks. Note, however, that in that case the client needs to be aware of it because an ordinary save will raise such exception instead of quietly returning false.
Solution 4 - Ruby on-Rails
To get all changed fields, with their old and new values respectively:
person = Person.create!(:name => 'Bill')
person.name = 'Bob'
person.save
person.changes # => {"name" => ["Bill", "Bob"]}
Solution 5 - Ruby on-Rails
ActiveRecord::Dirty is a module that's built into ActiveRecord for tracking attribute changes. So you can use thing.amount_was
to get the old value.
Solution 6 - Ruby on-Rails
Add this to your model:
def amount=(new_value)
@old_amount = read_attribute(:amount)
write_attribute(:amount,new_value)
end
Then use @old_amount in your after_update code.
Solution 7 - Ruby on-Rails
If you want to get value of particular field after update you can use field_before_last_save method.
Example:
u = User.last
u.update(name: "abc")
u.name_before_last_save will give you old value (before update value)
Solution 8 - Ruby on-Rails
From Rails 5.1, the behavior of attribute_was
inside of after callbacks have change. attribute_was
will return the value after the save is done and return the current value in an after_save
or after_update
callback.
attribute_before_last_save
is invoked two ways to get the previous value of a field in the after_save
and after_update
callbacks right now:
Option #1
attribute_before_last_save('yourfield')
Option #2
*_before_last_save
Solution 9 - Ruby on-Rails
Firstly, you should be doing this in a transaction to ensure that your data gets written together.
To answer your question, you could just set a member variable to the old value in the before_update, which you can then access in the after_update, however this isn't a very elegant solution.
Solution 10 - Ruby on-Rails
Idea 1: Wrap the update in a database transaction, so that if the update fails your Totals table isn't changed: [ActiveRecord Transactions docs][1]
Idea 2: Stash the old value in @old_total during the before_update.
[1]: http://www.railsbrain.com/api/rails-2.2.2/doc/index.html?a=C00000598&name=ActiveRecord::Transactions::ClassMethods "ActiveRecord Transactions"