Permalink
Browse files

Add Model.select/group/order/limit/joins/conditions/preload/eager_loa…

…d class methods returning a lazy relation.

  Examples :

    posts = Post.select('id).order('name') # Returns a lazy relation
    posts.each {|p| puts p.id } # Fires "select id from posts order by name"
  • Loading branch information...
1 parent 8f6da94 commit a7fd564ab197a376336ebfa8bceaf14553e7628f @lifo lifo committed Dec 25, 2009
View
10 activerecord/lib/active_record/base.rb
@@ -13,6 +13,7 @@
require 'active_support/core_ext/hash/slice'
require 'active_support/core_ext/string/behavior'
require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/module/delegation'
module ActiveRecord #:nodoc:
# Generic Active Record exception class.
@@ -650,6 +651,8 @@ def find(*args)
end
end
+ delegate :select, :group, :order, :limit, :joins, :conditions, :preload, :eager_load, :to => :arel_table
+
# A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
# same arguments to this method as you can to <tt>find(:first)</tt>.
def first(*args)
@@ -1514,13 +1517,8 @@ def merge_conditions(*conditions)
"(#{segments.join(') AND (')})" unless segments.empty?
end
-
def arel_table(table = nil)
- table = table_name if table.blank?
- if @arel_table.nil? || @arel_table.name != table
- @arel_table = Relation.new(self, Arel::Table.new(table))
- end
- @arel_table
+ Relation.new(self, Arel::Table.new(table || table_name))
end
private
View
21 activerecord/lib/active_record/named_scope.rb
@@ -23,7 +23,26 @@ module ClassMethods
#
# You can define a scope that applies to all finders using ActiveRecord::Base.default_scope.
def scoped(options = {}, &block)
- options.present? ? Scope.new(self, options, &block) : arel_table
+ if options.present?
+ Scope.new(self, options, &block)
+ else
+ if !scoped?(:find)
+ relation = arel_table
+ else
+ relation = construct_finder_arel
+ include_associations = scope(:find, :include)
+
+ if include_associations.present?
+ if references_eager_loaded_tables?(options)
+ relation.eager_load(include_associations)
+ else
+ relation.preload(include_associations)
+ end
+ end
+ end
+
+ relation
+ end
end
def scopes
View
56 activerecord/lib/active_record/relation.rb
@@ -4,20 +4,20 @@ class Relation
delegate :length, :collect, :find, :map, :each, :to => :to_a
attr_reader :relation, :klass
- def initialize(klass, relation)
+ def initialize(klass, relation, readonly = false, preload = [], eager_load = [])
@klass, @relation = klass, relation
- @readonly = false
- @associations_to_preload = []
- @eager_load_associations = []
+ @readonly = readonly
+ @associations_to_preload = preload
+ @eager_load_associations = eager_load
end
- def preload(association)
- @associations_to_preload += association
+ def preload(associations)
+ @associations_to_preload << associations
self
end
- def eager_load(association)
- @eager_load_associations += association
+ def eager_load(associations)
+ @eager_load_associations += Array.wrap(associations)
self
end
@@ -45,7 +45,7 @@ def to_a
@klass.find_by_sql(@relation.to_sql)
end
- @klass.send(:preload_associations, records, @associations_to_preload) unless @associations_to_preload.empty?
+ @associations_to_preload.each {|associations| @klass.send(:preload_associations, records, associations) }
records.each { |record| record.readonly! } if @readonly
records
@@ -57,27 +57,27 @@ def first
end
def select(selects)
- selects.blank? ? self : Relation.new(@klass, @relation.project(selects))
+ selects.blank? ? self : create_new_relation(@relation.project(selects))
end
def group(groups)
- groups.blank? ? self : Relation.new(@klass, @relation.group(groups))
+ groups.blank? ? self : create_new_relation(@relation.group(groups))
end
def order(orders)
- orders.blank? ? self : Relation.new(@klass, @relation.order(orders))
+ orders.blank? ? self : create_new_relation(@relation.order(orders))
end
def limit(limits)
- limits.blank? ? self : Relation.new(@klass, @relation.take(limits))
+ limits.blank? ? self : create_new_relation(@relation.take(limits))
end
def offset(offsets)
- offsets.blank? ? self : Relation.new(@klass, @relation.skip(offsets))
+ offsets.blank? ? self : create_new_relation(@relation.skip(offsets))
end
def on(join)
- join.blank? ? self : Relation.new(@klass, @relation.on(join))
+ join.blank? ? self : create_new_relation(@relation.on(join))
end
def joins(join, join_type = nil)
@@ -96,7 +96,7 @@ def joins(join, join_type = nil)
else
@relation.join(join, join_type)
end
- Relation.new(@klass, join)
+ create_new_relation(join)
end
end
@@ -105,7 +105,7 @@ def conditions(conditions)
self
else
conditions = @klass.send(:merge_conditions, conditions) if [String, Hash, Array].include?(conditions.class)
- Relation.new(@klass, @relation.where(conditions))
+ create_new_relation(@relation.where(conditions))
end
end
@@ -114,14 +114,20 @@ def respond_to?(method)
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
+
+ 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
+
+ def create_new_relation(relation)
+ Relation.new(@klass, relation, @readonly, @associations_to_preload, @eager_load_associations)
+ end
+
end
end
View
60 activerecord/test/cases/relations_test.rb
@@ -19,47 +19,49 @@ def test_scoped
end
def test_finding_with_conditions
- assert_equal Author.find(:all, :conditions => "name = 'David'"), Author.all.conditions("name = 'David'").to_a
+ assert_equal ["David"], Author.conditions(:name => 'David').map(&:name)
+ assert_equal ['Mary'], Author.conditions(["name = ?", 'Mary']).map(&:name)
end
def test_finding_with_order
- topics = Topic.all.order('id')
+ topics = Topic.order('id')
assert_equal 4, topics.size
assert_equal topics(:first).title, topics.first.title
end
def test_finding_with_order_and_take
- entrants = Entrant.all.order("id ASC").limit(2).to_a
+ entrants = Entrant.order("id ASC").limit(2).to_a
assert_equal(2, entrants.size)
assert_equal(entrants(:first).name, entrants.first.name)
end
def test_finding_with_order_limit_and_offset
- entrants = Entrant.all.order("id ASC").limit(2).offset(1)
+ entrants = Entrant.order("id ASC").limit(2).offset(1)
assert_equal(2, entrants.size)
assert_equal(entrants(:second).name, entrants.first.name)
- entrants = Entrant.all.order("id ASC").limit(2).offset(2)
+ entrants = Entrant.order("id ASC").limit(2).offset(2)
assert_equal(1, entrants.size)
assert_equal(entrants(:third).name, entrants.first.name)
end
def test_finding_with_group
- developers = Developer.all.group("salary").select("salary").to_a
+ developers = Developer.group("salary").select("salary").to_a
assert_equal 4, developers.size
assert_equal 4, developers.map(&:salary).uniq.size
end
def test_finding_with_hash_conditions_on_joined_table
- firms = DependentFirm.all.joins(:account).conditions({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
+ firms = DependentFirm.joins(:account).conditions({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
assert_equal 1, firms.size
assert_equal companies(:rails_core), firms.first
end
def test_find_all_with_join
- developers_on_project_one = Developer.all.joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').conditions('project_id=1').to_a
+ developers_on_project_one = Developer.joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').
+ conditions('project_id=1').to_a
assert_equal 3, developers_on_project_one.length
developer_names = developers_on_project_one.map { |d| d.name }
@@ -68,34 +70,35 @@ def test_find_all_with_join
end
def test_find_on_hash_conditions
- assert_equal Topic.find(:all, :conditions => {:approved => false}), Topic.all.conditions({ :approved => false }).to_a
+ assert_equal Topic.find(:all, :conditions => {:approved => false}), Topic.conditions({ :approved => false }).to_a
end
def test_joins_with_string_array
- person_with_reader_and_post = Post.all.joins([
+ person_with_reader_and_post = Post.joins([
"INNER JOIN categorizations ON categorizations.post_id = posts.id",
"INNER JOIN categories ON categories.id = categorizations.category_id AND categories.type = 'SpecialCategory'"
]
).to_a
assert_equal 1, person_with_reader_and_post.size
end
- def test_relation_responds_to_delegated_methods
- relation = Topic.all
+ def test_scoped_responds_to_delegated_methods
+ relation = Topic.scoped
["map", "uniq", "sort", "insert", "delete", "update"].each do |method|
assert relation.respond_to?(method), "Topic.all should respond to #{method.inspect}"
end
end
def test_find_with_readonly_option
- Developer.all.each { |d| assert !d.readonly? }
- Developer.all.readonly.each { |d| assert d.readonly? }
- Developer.all(:readonly => true).each { |d| assert d.readonly? }
+ Developer.scoped.each { |d| assert !d.readonly? }
+ Developer.scoped.readonly.each { |d| assert d.readonly? }
end
def test_eager_association_loading_of_stis_with_multiple_references
- authors = Author.all(:include => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4').to_a
+ authors = Author.eager_load(:posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } }).
+ order('comments.body, very_special_comments_posts.body').conditions('posts.id = 4').to_a
+
assert_equal [authors(:david)], authors
assert_no_queries do
authors.first.posts.first.special_comments.first.post.special_comments
@@ -105,50 +108,53 @@ def test_eager_association_loading_of_stis_with_multiple_references
def test_find_with_included_associations
assert_queries(2) do
- posts = Post.find(:all, :include => :comments)
+ posts = Post.preload(:comments)
posts.first.comments.first
end
+
assert_queries(2) do
- posts = Post.all(:include => :comments).to_a
+ posts = Post.preload(:comments).to_a
posts.first.comments.first
end
+
assert_queries(2) do
- posts = Post.find(:all, :include => :author)
+ posts = Post.preload(:author)
posts.first.author
end
+
assert_queries(2) do
- posts = Post.all(:include => :author).to_a
+ posts = Post.preload(:author).to_a
posts.first.author
end
end
def test_default_scope_with_conditions_string
- assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.all.to_a.map(&:id).sort
+ assert_equal Developer.find_all_by_name('David').map(&:id).sort, DeveloperCalledDavid.scoped.to_a.map(&:id).sort
assert_equal nil, DeveloperCalledDavid.create!.name
end
def test_default_scope_with_conditions_hash
- assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
+ assert_equal Developer.find_all_by_name('Jamis').map(&:id).sort, DeveloperCalledJamis.scoped.map(&:id).sort
assert_equal 'Jamis', DeveloperCalledJamis.create!.name
end
- def test_loading_with_one_association
- posts = Post.all(:include => :comments)
+ def test_loading_with_one_association
+ posts = Post.preload(:comments)
post = posts.find { |p| p.id == 1 }
assert_equal 2, post.comments.size
assert post.comments.include?(comments(:greetings))
- post = Post.find(:first, :include => :comments, :conditions => "posts.title = 'Welcome to the weblog'")
+ post = Post.conditions("posts.title = 'Welcome to the weblog'").preload(:comments).first
assert_equal 2, post.comments.size
assert post.comments.include?(comments(:greetings))
- posts = Post.all(:include => :last_comment)
+ posts = Post.preload(:last_comment)
post = posts.find { |p| p.id == 1 }
assert_equal Post.find(1).last_comment, post.last_comment
end
def test_loading_with_one_association_with_non_preload
- posts = Post.all(:include => :last_comment, :order => 'comments.id DESC')
+ posts = Post.eager_load(:last_comment).order('comments.id DESC')
post = posts.find { |p| p.id == 1 }
assert_equal Post.find(1).last_comment, post.last_comment
end

0 comments on commit a7fd564

Please sign in to comment.