Class: ActiveRecord::Relation

new(klass, table)

  # File activerecord/lib/active_record/relation.rb, line 20
def initialize(klass, table)
  @klass, @table = klass, table

  @implicit_readonly = nil
  @loaded            = false

  SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
  (ASSOCIATION_METHODS + MULTI_VALUE_METHODS).each {|v| instance_variable_set(:"@#{v}_values", [])}
  @extensions = []
end

==(other)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 349
def ==(other)
  case other
  when Relation
    other.to_sql == to_sql
  when Array
    to_a == other.to_a
  end
end

any?()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 96
def any?
  if block_given?
    to_a.any? { |*block_args| yield(*block_args) }
  else
    !empty?
  end
end

create(*args, &block)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 41
def create(*args, &block)
  scoping { @klass.create(*args, &block) }
end

create!(*args, &block)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 45
def create!(*args, &block)
  scoping { @klass.create!(*args, &block) }
end

delete(id_or_array)

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.

Examples

# Delete a single row
Todo.delete(1)

# Delete multiple rows
Todo.delete([2,3,4])

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 299
def delete(id_or_array)
  where(@klass.primary_key => id_or_array).delete_all
end

delete_all(conditions = nil)

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.

Example

Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')")
Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else'])

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.

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 275
def delete_all(conditions = nil)
  conditions ? where(conditions).delete_all : arel.delete.tap { reset }
end

destroy(id)

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.

Parameters

id - Can be either an Integer or an Array of Integers.

Examples

# Destroy a single object
Todo.destroy(1)

# Destroy multiple objects
todos = [1,2,3]
Todo.destroy(todos)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 249
def destroy(id)
  if id.is_a?(Array)
    id.map { |one_id| destroy(one_id) }
  else
    find(id).destroy
  end
end

destroy_all(conditions = nil)

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.

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.

Examples

Person.destroy_all("last_login < '2004-04-04'")
Person.destroy_all(:status => "inactive")

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 222
def destroy_all(conditions = nil)
  if conditions
    where(conditions).destroy_all
  else
    to_a.each {|object| object.destroy }.tap { reset }
  end
end

eager_loading?()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 345
def eager_loading?
  @should_eager_load ||= (@eager_load_values.any? || (@includes_values.any? && references_eager_loaded_tables?))
end

empty?()

Returns true if there are no records.

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 89
def empty?
  return @records.empty? if loaded?

  c = count
  c.respond_to?(:zero?) ? c.zero? : c.empty?
end

initialize_copy(other)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 35
def initialize_copy(other)
  reset
end

inspect()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 358
def inspect
  to_a.inspect
end

many?()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 104
def many?
  if block_given?
    to_a.many? { |*block_args| yield(*block_args) }
  else
    @limit_value ? to_a.many? : size > 1
  end
end

new(*args, &block)

This method is also aliased as build

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 31
def new(*args, &block)
  scoping { @klass.new(*args, &block) }
end

primary_key()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 316
def primary_key
  @primary_key ||= table[@klass.primary_key]
end

reload()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 303
def reload
  reset
  to_a # force reload
  self
end

reset()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 309
def reset
  @first = @last = @to_sql = @order_clause = @scope_for_create = @arel = @loaded = nil
  @should_eager_load = @join_dependency = nil
  @records = []
  self
end

respond_to?(method, include_private = false)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 49
def respond_to?(method, include_private = false)
  return true if arel.respond_to?(method, include_private) || Array.method_defined?(method) || @klass.respond_to?(method, include_private)

  if match = DynamicFinderMatch.match(method)
    return true if @klass.send(:all_attributes_exists?, match.attribute_names)
  elsif match = DynamicScopeMatch.match(method)
    return true if @klass.send(:all_attributes_exists?, match.attribute_names)
  else
    super
  end
end

scope_for_create()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 335
def scope_for_create
  @scope_for_create ||= begin
    if @create_with_value
      @create_with_value.reverse_merge(where_values_hash)
    else
      where_values_hash
    end
  end
end

scoping()

Scope all queries to the current scope.

Example

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.

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 122
def scoping
  @klass.scoped_methods << self
  begin
    yield
  ensure
    @klass.scoped_methods.pop
  end
end

size()

Returns size of the records.

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 84
def size
  loaded? ? @records.length : count
end

to_a()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 61
def to_a
  return @records if loaded?

  @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql)

  preload = @preload_values
  preload +=  @includes_values unless eager_loading?
  preload.each {|associations| @klass.send(:preload_associations, @records, associations) }

  # @readonly_value is true only if set explicitly. @implicit_readonly is true if there
  # are JOINS and no explicit SELECT.
  readonly = @readonly_value.nil? ? @implicit_readonly : @readonly_value
  @records.each { |record| record.readonly! } if readonly

  @loaded = true
  @records
end

to_sql()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 320
def to_sql
  @to_sql ||= arel.to_sql
end

update(id, attributes)

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.

Parameters

id - This should be the id or an array of ids to be updated.
attributes - This should be a hash of attributes or an array of hashes.

Examples

# 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)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 185
def update(id, attributes)
  if id.is_a?(Array)
    idx = -1
    id.collect { |one_id| idx += 1; update(one_id, attributes[idx]) }
  else
    object = find(id)
    object.update_attributes(attributes)
    object
  end
end

update_all(updates, conditions = nil, options = {})

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

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 156
def update_all(updates, conditions = nil, options = {})
  if conditions || options.present?
    where(conditions).apply_finder_options(options.slice(:limit, :order)).update_all(updates)
  else
    # Apply limit and order only if they're both present
    if @limit_value.present? == @order_values.present?
      arel.update(Arel::SqlLiteral.new(@klass.send(:sanitize_sql_for_assignment, updates)))
    else
      except(:limit, :order).update_all(updates)
    end
  end
end

where_values_hash()

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 324
def where_values_hash
  Hash[@where_values.find_all { |w|
    w.respond_to?(:operator) && w.operator == :== && w.left.relation.name == table_name
  }.map { |where|
    [
      where.left.name,
      where.right.respond_to?(:value) ? where.right.value : where.right
    ]
  }]
end

method_missing(method, *args, &block)

[ show source ]

  # File activerecord/lib/active_record/relation.rb, line 364
def method_missing(method, *args, &block)
  if Array.method_defined?(method)
    to_a.send(method, *args, &block)
  elsif @klass.scopes[method]
    merge(@klass.send(method, *args, &block))
  elsif @klass.respond_to?(method)
    scoping { @klass.send(method, *args, &block) }
  elsif arel.respond_to?(method)
    arel.send(method, *args, &block)
  else
    super
  end
end

JoinOperation	=	Struct.new(:relation, :join_class, :on)
ASSOCIATION_METHODS	=	[:includes, :eager_load, :preload]
MULTI_VALUE_METHODS	=	[:select, :group, :order, :joins, :where, :having]
SINGLE_VALUE_METHODS	=	[:limit, :offset, :lock, :readonly, :create_with, :from]

[R]	table
[R]	klass
[R]	loaded
[RW]	extensions
[R]	loaded?

Active Record Relation

Examples

Parameters

Example

Parameters

Examples

Parameters

Examples

Example

Parameters

Examples

Parameters

Examples