Deletes the row with a primary key matching the id argument, using
a SQL DELETE statement, and returns the number of rows deleted.
Active Record objects are not instantiated, so the object’s callbacks are
not executed, including any :dependent association options or Observer methods.

Note: Although it is often much faster than the alternative,
#destroy, skipping callbacks might bypass business logic in your
application that ensures referential integrity or performs other essential
jobs.

Deletes the records matching conditions without instantiating the
records first, and hence not calling the destroy method nor
invoking callbacks. This is a single SQL DELETE statement that goes
straight to the database, much more efficient than destroy_all. Be
careful with relations though, in particular :dependent rules
defined on associations are not honored. Returns the number of rows
affected.

Parameters

conditions - Conditions are specified the same way as with
find method.

Both calls delete the affected posts all at once with a single DELETE
statement. If you need to destroy dependent associations or call your
before_* or after_destroy callbacks, use the
destroy_all method instead.

Destroy an object (or multiple objects) that has the given id, the object
is instantiated first, therefore all callbacks and filters are fired off
before the object is deleted. This method is less efficient than
ActiveRecord#delete but allows cleanup methods and other actions to be run.

This essentially finds the object (or multiple objects) with the given id,
creates a new object from the attributes, and then calls destroy on it.

Destroys the records matching conditions by instantiating each
record and calling its destroy method. Each object’s callbacks
are executed (including :dependent association options and
before_destroy/after_destroyObserver methods). Returns the collection of
objects that were destroyed; each will be frozen, to reflect that no
changes should be made (since they can’t be persisted).

Note: Instantiation, callback execution, and deletion of each record can be
time consuming when you’re removing many records at once. It generates at
least one SQL DELETE query per record (or possibly more, to
enforce your callbacks). If you want to delete many rows quickly, without
concern for their associations or callbacks, use delete_all
instead.

Parameters

conditions - A string, array, or hash that specifies which records
to destroy. If omitted, all records are destroyed. See the Conditions
section in the introduction to ActiveRecord::Base
for more information.

Joins that are also marked for preloading. In which case we should just
eager load them. Note that this is a naive implementation because we could
have strings and symbols which represent the same association, but that
aren’t matched by this. Also, we could have nested hashes which partially
match, e.g. { :a => :b } & { :a => [:b, :c] }

Updates all records with details given if they match a set of conditions
supplied, limits and order can also be supplied. This method constructs a
single SQL UPDATE statement and sends it straight to the database. It does
not instantiate the involved models and it does not trigger Active Record
callbacks or validations.

Parameters

updates - A string, array, or hash representing the SET part of an
SQL statement.

conditions - A string, array, or hash representing the WHERE part
of an SQL statement. See conditions in the intro.

options - Additional options are :limit and
:order, see the examples for usage.

Examples

# Update all customers with the given attributes
Customer.update_all :wants_email => true
# Update all books with 'Rails' in their title
Book.update_all "author = 'David'", "title LIKE '%Rails%'"
# Update all avatars migrated more than a week ago
Avatar.update_all ['migrated_at = ?', Time.now.utc], ['migrated_at > ?', 1.week.ago]
# Update all books that match conditions, but limit it to 5 ordered by date
Book.update_all "author = 'David'", "title LIKE '%Rails%'", :order => 'created_at', :limit => 5
# Conditions from the current relation also works
Book.where('title LIKE ?', '%Rails%').update_all(:author => 'David')
# The same idea applies to limit and order
Book.where('title LIKE ?', '%Rails%').order(:created_at).limit(5).update_all(:author => 'David')