Methods
A
B
C
E
F
G
H
I
J
L
O
P
R
S
U
W
Attributes
[RW] bind_values
[RW] create_with_value
[RW] eager_load_values
[RW] from_value
[RW] group_values
[RW] having_values
[RW] includes_values
[RW] joins_values
[RW] limit_value
[RW] lock_value
[RW] offset_value
[RW] order_values
[RW] preload_values
[RW] readonly_value
[RW] reordering_value
[RW] reverse_order_value
[RW] select_values
[RW] uniq_value
[RW] where_values
Instance Public methods
arel()
# File activerecord/lib/active_record/relation/query_methods.rb, line 259
def arel
  @arel ||= with_default_scope.build_arel
end
bind(value)
# File activerecord/lib/active_record/relation/query_methods.rb, line 126
def bind(value)
  relation = clone
  relation.bind_values += [value]
  relation
end
build_arel()
# File activerecord/lib/active_record/relation/query_methods.rb, line 263
def build_arel
  arel = table.from table

  build_joins(arel, @joins_values) unless @joins_values.empty?

  collapse_wheres(arel, (@where_values - ['']).uniq)

  arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?

  arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
  arel.skip(@offset_value.to_i) if @offset_value

  arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?

  order = @order_values
  order = reverse_sql_order(order) if @reverse_order_value
  arel.order(*order.uniq.reject{|o| o.blank?}) unless order.empty?

  build_select(arel, @select_values.uniq)

  arel.distinct(@uniq_value)
  arel.from(@from_value) if @from_value
  arel.lock(@lock_value) if @lock_value

  arel
end
create_with(value)
# File activerecord/lib/active_record/relation/query_methods.rb, line 179
def create_with(value)
  relation = clone
  relation.create_with_value = value ? create_with_value.merge(value) : {}
  relation
end
eager_load(*args)
# File activerecord/lib/active_record/relation/query_methods.rb, line 25
def eager_load(*args)
  return self if args.blank?

  relation = clone
  relation.eager_load_values += args
  relation
end
extending(*modules)

Used to extend a scope with additional methods, either through a module or through a block provided.

The object returned is a relation, which can be further extended.

Using a module

module Pagination
  def page(number)
    # pagination code goes here
  end
end

scope = Model.scoped.extending(Pagination)
scope.page(params[:page])

You can also pass a list of modules:

scope = Model.scoped.extending(Pagination, SomethingElse)

Using a block

scope = Model.scoped.extending do
  def page(number)
    # pagination code goes here
  end
end
scope.page(params[:page])

You can also use a block and a module list:

scope = Model.scoped.extending(Pagination) do
  def per_page(number)
    # pagination code goes here
  end
end
# File activerecord/lib/active_record/relation/query_methods.rb, line 243
def extending(*modules)
  modules << Module.new(&Proc.new) if block_given?

  return self if modules.empty?

  relation = clone
  relation.send(:apply_modules, modules.flatten)
  relation
end
from(value)
# File activerecord/lib/active_record/relation/query_methods.rb, line 185
def from(value)
  relation = clone
  relation.from_value = value
  relation
end
group(*args)
# File activerecord/lib/active_record/relation/query_methods.rb, line 80
def group(*args)
  return self if args.blank?

  relation = clone
  relation.group_values += args.flatten
  relation
end
having(opts, *rest)
# File activerecord/lib/active_record/relation/query_methods.rb, line 140
def having(opts, *rest)
  return self if opts.blank?

  relation = clone
  relation.having_values += build_where(opts, rest)
  relation
end
includes(*args)
# File activerecord/lib/active_record/relation/query_methods.rb, line 15
def includes(*args)
  args.reject! {|a| a.blank? }

  return self if args.empty?

  relation = clone
  relation.includes_values = (relation.includes_values + args).flatten.uniq
  relation
end
joins(*args)
# File activerecord/lib/active_record/relation/query_methods.rb, line 115
def joins(*args)
  return self if args.compact.blank?

  relation = clone

  args.flatten!
  relation.joins_values += args

  relation
end
limit(value)
# File activerecord/lib/active_record/relation/query_methods.rb, line 148
def limit(value)
  relation = clone
  relation.limit_value = value
  relation
end
lock(locks = true)
# File activerecord/lib/active_record/relation/query_methods.rb, line 160
def lock(locks = true)
  relation = clone

  case locks
  when String, TrueClass, NilClass
    relation.lock_value = locks || true
  else
    relation.lock_value = false
  end

  relation
end
offset(value)
# File activerecord/lib/active_record/relation/query_methods.rb, line 154
def offset(value)
  relation = clone
  relation.offset_value = value
  relation
end
order(*args)
# File activerecord/lib/active_record/relation/query_methods.rb, line 88
def order(*args)
  return self if args.blank?

  relation = clone
  relation.order_values += args.flatten
  relation
end
preload(*args)
# File activerecord/lib/active_record/relation/query_methods.rb, line 33
def preload(*args)
  return self if args.blank?

  relation = clone
  relation.preload_values += args
  relation
end
readonly(value = true)
# File activerecord/lib/active_record/relation/query_methods.rb, line 173
def readonly(value = true)
  relation = clone
  relation.readonly_value = value
  relation
end
reorder(*args)

Replaces any existing order defined on the relation with the specified order.

User.order('email DESC').reorder('id ASC') # generated SQL has 'ORDER BY id ASC'

Subsequent calls to order on the same relation will be appended. For example:

User.order('email DESC').reorder('id ASC').order('name ASC')

generates a query with ‘ORDER BY id ASC, name ASC’.

# File activerecord/lib/active_record/relation/query_methods.rb, line 106
def reorder(*args)
  return self if args.blank?

  relation = clone
  relation.reordering_value = true
  relation.order_values = args.flatten
  relation
end
reverse_order()
# File activerecord/lib/active_record/relation/query_methods.rb, line 253
def reverse_order
  relation = clone
  relation.reverse_order_value = !relation.reverse_order_value
  relation
end
select(value = Proc.new)

Works in two unique ways.

First: takes a block so it can be used just like Array#select.

Model.scoped.select { |m| m.field == value }

This will build an array of objects from the database for the scope, converting them into an array and iterating through them using Array#select.

Second: Modifies the SELECT statement for the query so that only certain fields are retrieved:

>> Model.select(:field)
=> [#<Model field:value>]

Although in the above example it looks as though this method returns an array, it actually returns a relation object and can have other query methods appended to it, such as the other methods in ActiveRecord::QueryMethods.

The argument to the method can also be an array of fields.

>> Model.select([:field, :other_field, :and_one_more])
=> [#<Model field: "value", other_field: "value", and_one_more: "value">]

Any attributes that do not have fields retrieved by a select will raise a ActiveModel::MissingAttributeError when the getter method for that attribute is used:

>> Model.select(:field).first.other_field
=> ActiveModel::MissingAttributeError: missing attribute: other_field
# File activerecord/lib/active_record/relation/query_methods.rb, line 70
def select(value = Proc.new)
  if block_given?
    to_a.select {|*block_args| value.call(*block_args) }
  else
    relation = clone
    relation.select_values += Array.wrap(value)
    relation
  end
end
uniq(value = true)

Specifies whether the records should be unique or not. For example:

User.select(:name)
# => Might return two records with the same name

User.select(:name).uniq
# => Returns 1 record per unique name

User.select(:name).uniq.uniq(false)
# => You can also remove the uniqueness
# File activerecord/lib/active_record/relation/query_methods.rb, line 201
def uniq(value = true)
  relation = clone
  relation.uniq_value = value
  relation
end
where(opts, *rest)
# File activerecord/lib/active_record/relation/query_methods.rb, line 132
def where(opts, *rest)
  return self if opts.blank?

  relation = clone
  relation.where_values += build_where(opts, rest)
  relation
end