128 lines
3.4 KiB
Ruby
128 lines
3.4 KiB
Ruby
module ActiveRecord
|
|
class Relation
|
|
delegate :to_sql, :to => :relation
|
|
delegate :length, :collect, :find, :map, :each, :to => :to_a
|
|
attr_reader :relation, :klass
|
|
|
|
def initialize(klass, relation)
|
|
@klass, @relation = klass, relation
|
|
@readonly = false
|
|
@associations_to_preload = []
|
|
@eager_load_associations = []
|
|
end
|
|
|
|
def preload(association)
|
|
@associations_to_preload += association
|
|
self
|
|
end
|
|
|
|
def eager_load(association)
|
|
@eager_load_associations += association
|
|
self
|
|
end
|
|
|
|
def readonly
|
|
@readonly = true
|
|
self
|
|
end
|
|
|
|
def to_a
|
|
records = if @eager_load_associations.any?
|
|
catch :invalid_query do
|
|
return @klass.send(:find_with_associations, {
|
|
:select => @relation.send(:select_clauses).join(', '),
|
|
:joins => @relation.joins(relation),
|
|
:group => @relation.send(:group_clauses).join(', '),
|
|
:order => @relation.send(:order_clauses).join(', '),
|
|
:conditions => @relation.send(:where_clauses).join("\n\tAND "),
|
|
:limit => @relation.taken,
|
|
:offset => @relation.skipped
|
|
},
|
|
ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, @eager_load_associations, nil))
|
|
end
|
|
[]
|
|
else
|
|
@klass.find_by_sql(@relation.to_sql)
|
|
end
|
|
|
|
@klass.send(:preload_associations, records, @associations_to_preload) unless @associations_to_preload.empty?
|
|
records.each { |record| record.readonly! } if @readonly
|
|
|
|
records
|
|
end
|
|
|
|
def first
|
|
@relation = @relation.take(1)
|
|
to_a.first
|
|
end
|
|
|
|
def select(selects)
|
|
selects.blank? ? self : Relation.new(@klass, @relation.project(selects))
|
|
end
|
|
|
|
def group(groups)
|
|
groups.blank? ? self : Relation.new(@klass, @relation.group(groups))
|
|
end
|
|
|
|
def order(orders)
|
|
orders.blank? ? self : Relation.new(@klass, @relation.order(orders))
|
|
end
|
|
|
|
def limit(limits)
|
|
limits.blank? ? self : Relation.new(@klass, @relation.take(limits))
|
|
end
|
|
|
|
def offset(offsets)
|
|
offsets.blank? ? self : Relation.new(@klass, @relation.skip(offsets))
|
|
end
|
|
|
|
def on(join)
|
|
join.blank? ? self : Relation.new(@klass, @relation.on(join))
|
|
end
|
|
|
|
def joins(join, join_type = nil)
|
|
if join.blank?
|
|
self
|
|
else
|
|
join = case join
|
|
when String
|
|
@relation.join(join)
|
|
when Hash, Array, Symbol
|
|
if @klass.send(:array_of_strings?, join)
|
|
@relation.join(join.join(' '))
|
|
else
|
|
@relation.join(@klass.send(:build_association_joins, join))
|
|
end
|
|
else
|
|
@relation.join(join, join_type)
|
|
end
|
|
Relation.new(@klass, join)
|
|
end
|
|
end
|
|
|
|
def conditions(conditions)
|
|
if conditions.blank?
|
|
self
|
|
else
|
|
conditions = @klass.send(:merge_conditions, conditions) if [String, Hash, Array].include?(conditions.class)
|
|
Relation.new(@klass, @relation.where(conditions))
|
|
end
|
|
end
|
|
|
|
def respond_to?(method)
|
|
@relation.respond_to?(method) || Array.method_defined?(method) || super
|
|
end
|
|
|
|
private
|
|
def method_missing(method, *args, &block)
|
|
if @relation.respond_to?(method)
|
|
@relation.send(method, *args, &block)
|
|
elsif Array.method_defined?(method)
|
|
to_a.send(method, *args, &block)
|
|
else
|
|
super
|
|
end
|
|
end
|
|
end
|
|
end
|