In rails guides it's described like this:
Objects will be in addition destroyed if they’re associated with
:dependent => :destroy, and deleted if they’re associated with:dependent => :delete_all
Right, cool. But what's the difference between being destroyed and being deleted? I tried both and it seems to do the same thing.
The difference is with the callback.
The :delete_all is made directly in your application and deletes by SQL :
DELETE * FROM users where compagny_id = XXXX
With the :destroy, there is an instantiation of all of your children. So, if you can't destroy it or if each has their own :dependent, its callbacks can be called.
On a Rails' model association you can specify the :dependent option, which can take one of the following three forms:
:destroy/:destroy_all The associated objects are destroyed alongside this object by calling their destroy method:delete/:delete_all All associated objects are destroyed immediately without calling their :destroy method:nullify All associated objects' foreign keys are set to NULL without calling their save callbacks
:restrict. If set to :restrict this object cannot be deleted if it has any associated object.
:delete or :destroy_all options by the looks of it? The :dependent option expects either :destroy, :delete_all, :nullify or :restrict (:delete)
Feb 5, 2013 at 15:42
:delete and :destroy_all options do not exist. However, there are class methods on models that are called delete and destroy_all so it might be the reason for confusion.
Jan 9, 2014 at 22:09
See destroy deletes its associated elements where delete_all can delete multiple data from self table as DELETE * FROM table where field = 'xyz'
:Dependent possible options:
Controls what happens to the associated objects when their owner is destroyed. Note that these are implemented as callbacks, and Rails executes callbacks in order. Therefore, other similar callbacks may affect the :dependent behavior, and the :dependent behavior may affect other callbacks.
:destroy causes all the associated objects to also be destroyed.
:delete_all causes all the associated objects to be deleted directly from the database (so callbacks will not be executed).
:nullify causes the foreign keys to be set to NULL. Callbacks are not executed.
:restrict_with_exception causes an exception to be raised if there are any associated records.
:restrict_with_error causes an error to be added to the owner if there are any associated objects.
If using with the :through option, the association on the join model must be a belongs_to, and the records which get deleted are the join records, rather than the associated records.
Actually the main difference is that any callbacks will not be invoked when :delete_all was used. But when used :destroy the callbacks stack (:after_destroy, :after_commit ...) will be fired.
Consequently, if you have touch:ing declarations in models being deleted then it's better to use dependent: :delete_all rather 'dependent: :destroy'.
