Class | ActiveRecord::Relation |
In: |
lib/active_record/relation.rb
|
Parent: | Object |
JoinOperation | = | Struct.new(:relation, :join_class, :on) |
ASSOCIATION_METHODS | = | [:includes, :eager_load, :preload] |
MULTI_VALUE_METHODS | = | [:select, :group, :order, :joins, :where, :having, :bind] |
SINGLE_VALUE_METHODS | = | [:limit, :offset, :lock, :readonly, :from, :reordering, :reverse_order, :uniq] |
loaded | -> | loaded? |
default_scoped | -> | default_scoped? |
default_scoped | [RW] | |
extensions | [RW] | |
klass | [R] | |
loaded | [R] | |
table | [R] |
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.
You can delete multiple rows at once by passing an Array of ids.
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.
# Delete a single row Todo.delete(1) # Delete multiple rows Todo.delete([2,3,4])
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.
Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')") Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else']) Post.where(:person_id => 5).where(:category => ['Something', 'Else']).delete_all
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.
# Destroy a single object Todo.destroy(1) # Destroy multiple objects todos = [1,2,3] Todo.destroy(todos)
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_destroy Observer 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.
Person.destroy_all("last_login < '2004-04-04'") Person.destroy_all(:status => "inactive") Person.where(:age => 0..18).destroy_all
Runs EXPLAIN on the query or queries triggered by this relation and returns the result as a string. The string is formatted imitating the ones printed by the database shell.
Note that this method actually runs the queries, since the results of some are needed by the next ones when eager loading is going on.
Please see further details in the Active Record Query Interface guide.
Tries to load the first record; if it fails, then create is called with the same arguments as this method.
Expects arguments in the same format as Base.create.
# Find the first user named Penélope or create a new one. User.where(:first_name => 'Penélope').first_or_create # => <User id: 1, first_name: 'Penélope', last_name: nil> # Find the first user named Penélope or create a new one. # We already have one so the existing record will be returned. User.where(:first_name => 'Penélope').first_or_create # => <User id: 1, first_name: 'Penélope', last_name: nil> # Find the first user named Scarlett or create a new one with a particular last name. User.where(:first_name => 'Scarlett').first_or_create(:last_name => 'Johansson') # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'> # Find the first user named Scarlett or create a new one with a different last name. # We already have one so the existing record will be returned. User.where(:first_name => 'Scarlett').first_or_create do |user| user.last_name = "O'Hara" end # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'>
Like first_or_create but calls create! so an exception is raised if the created record is invalid.
Expects arguments in the same format as Base.create!.
Like first_or_create but calls new instead of create.
Expects arguments in the same format as Base.new.
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] }
Scope all queries to the current scope.
Comment.where(:post_id => 1).scoping do Comment.first # SELECT * FROM comments WHERE post_id = 1 end
Please check unscoped if you want to remove all previous scopes (including the default_scope) during the execution of a block.
Updates an object (or multiple objects) and saves it to the database, if validations pass. The resulting object is returned whether the object was saved successfully to the database or not.
# Updates one record Person.update(15, :user_name => 'Samuel', :group => 'expert') # Updates multiple records people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } } Person.update(people.keys, people.values)
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.
# 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')