activerecord 3.0.20 → 3.1.0.beta1

data/lib/active_record/associations/join_helper.rb

@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Associations
+    # Helper class module which gets mixed into JoinDependency::JoinAssociation and AssociationScope
+    module JoinHelper #:nodoc:
+
+      def join_type
+        Arel::InnerJoin
+      end
+
+      private
+
+      def construct_tables
+        tables = []
+        chain.each do |reflection|
+          tables << alias_tracker.aliased_table_for(
+            table_name_for(reflection),
+            table_alias_for(reflection, reflection != self.reflection)
+          )
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            tables << alias_tracker.aliased_table_for(
+              (reflection.source_reflection || reflection).options[:join_table],
+              table_alias_for(reflection, true)
+            )
+          end
+        end
+        tables
+      end
+
+      def table_name_for(reflection)
+        reflection.table_name
+      end
+
+      def table_alias_for(reflection, join = false)
+        name = alias_tracker.pluralize(reflection.name)
+        name << "_#{alias_suffix}"
+        name << "_join" if join
+        name
+      end
+
+      def join(table, constraint)
+        table.create_join(table, table.create_on(constraint), join_type)
+      end
+
+      def sanitize(conditions, table)
+        conditions = conditions.map do |condition|
+          condition = active_record.send(:sanitize_sql, interpolate(condition), table.table_alias || table.name)
+          condition = Arel.sql(condition) unless condition.is_a?(Arel::Node)
+          condition
+        end
+
+        conditions.length == 1 ? conditions.first : Arel::Nodes::And.new(conditions)
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader.rb

@@ -0,0 +1,177 @@
+module ActiveRecord
+  module Associations
+    # Implements the details of eager loading of Active Record associations.
+    #
+    # Note that 'eager loading' and 'preloading' are actually the same thing.
+    # However, there are two different eager loading strategies.
+    #
+    # The first one is by using table joins. This was only strategy available
+    # prior to Rails 2.1. Suppose that you have an Author model with columns
+    # 'name' and 'age', and a Book model with columns 'name' and 'sales'. Using
+    # this strategy, Active Record would try to retrieve all data for an author
+    # and all of its books via a single query:
+    #
+    #   SELECT * FROM authors
+    #   LEFT OUTER JOIN books ON authors.id = books.id
+    #   WHERE authors.name = 'Ken Akamatsu'
+    #
+    # However, this could result in many rows that contain redundant data. After
+    # having received the first row, we already have enough data to instantiate
+    # the Author object. In all subsequent rows, only the data for the joined
+    # 'books' table is useful; the joined 'authors' data is just redundant, and
+    # processing this redundant data takes memory and CPU time. The problem
+    # quickly becomes worse and worse as the level of eager loading increases
+    # (i.e. if Active Record is to eager load the associations' associations as
+    # well).
+    #
+    # The second strategy is to use multiple database queries, one for each
+    # level of association. Since Rails 2.1, this is the default strategy. In
+    # situations where a table join is necessary (e.g. when the +:conditions+
+    # option references an association's column), it will fallback to the table
+    # join strategy.
+    class Preloader #:nodoc:
+      autoload :Association,           'active_record/associations/preloader/association'
+      autoload :SingularAssociation,   'active_record/associations/preloader/singular_association'
+      autoload :CollectionAssociation, 'active_record/associations/preloader/collection_association'
+      autoload :ThroughAssociation,    'active_record/associations/preloader/through_association'
+
+      autoload :HasMany,             'active_record/associations/preloader/has_many'
+      autoload :HasManyThrough,      'active_record/associations/preloader/has_many_through'
+      autoload :HasOne,              'active_record/associations/preloader/has_one'
+      autoload :HasOneThrough,       'active_record/associations/preloader/has_one_through'
+      autoload :HasAndBelongsToMany, 'active_record/associations/preloader/has_and_belongs_to_many'
+      autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
+
+      attr_reader :records, :associations, :options, :model
+
+      # Eager loads the named associations for the given Active Record record(s).
+      #
+      # In this description, 'association name' shall refer to the name passed
+      # to an association creation method. For example, a model that specifies
+      # <tt>belongs_to :author</tt>, <tt>has_many :buyers</tt> has association
+      # names +:author+ and +:buyers+.
+      #
+      # == Parameters
+      # +records+ is an array of ActiveRecord::Base. This array needs not be flat,
+      # i.e. +records+ itself may also contain arrays of records. In any case,
+      # +preload_associations+ will preload the all associations records by
+      # flattening +records+.
+      #
+      # +associations+ specifies one or more associations that you want to
+      # preload. It may be:
+      # - a Symbol or a String which specifies a single association name. For
+      #   example, specifying +:books+ allows this method to preload all books
+      #   for an Author.
+      # - an Array which specifies multiple association names. This array
+      #   is processed recursively. For example, specifying <tt>[:avatar, :books]</tt>
+      #   allows this method to preload an author's avatar as well as all of his
+      #   books.
+      # - a Hash which specifies multiple association names, as well as
+      #   association names for the to-be-preloaded association objects. For
+      #   example, specifying <tt>{ :author => :avatar }</tt> will preload a
+      #   book's author, as well as that author's avatar.
+      #
+      # +:associations+ has the same format as the +:include+ option for
+      # <tt>ActiveRecord::Base.find</tt>. So +associations+ could look like this:
+      #
+      #   :books
+      #   [ :books, :author ]
+      #   { :author => :avatar }
+      #   [ :books, { :author => :avatar } ]
+      #
+      # +options+ contains options that will be passed to ActiveRecord::Base#find
+      # (which is called under the hood for preloading records). But it is passed
+      # only one level deep in the +associations+ argument, i.e. it's not passed
+      # to the child associations when +associations+ is a Hash.
+      def initialize(records, associations, options = {})
+        @records      = Array.wrap(records).compact.uniq
+        @associations = Array.wrap(associations)
+        @options      = options
+      end
+
+      def run
+        unless records.empty?
+          associations.each { |association| preload(association) }
+        end
+      end
+
+      private
+
+      def preload(association)
+        case association
+        when Hash
+          preload_hash(association)
+        when String, Symbol
+          preload_one(association.to_sym)
+        else
+          raise ArgumentError, "#{association.inspect} was not recognised for preload"
+        end
+      end
+
+      def preload_hash(association)
+        association.each do |parent, child|
+          Preloader.new(records, parent, options).run
+          Preloader.new(records.map { |record| record.send(parent) }.flatten, child).run
+        end
+      end
+
+      # Not all records have the same class, so group then preload group on the reflection
+      # itself so that if various subclass share the same association then we do not split
+      # them unnecessarily
+      #
+      # Additionally, polymorphic belongs_to associations can have multiple associated
+      # classes, depending on the polymorphic_type field. So we group by the classes as
+      # well.
+      def preload_one(association)
+        grouped_records(association).each do |reflection, klasses|
+          klasses.each do |klass, records|
+            preloader_for(reflection).new(klass, records, reflection, options).run
+          end
+        end
+      end
+
+      def grouped_records(association)
+        Hash[
+          records_by_reflection(association).map do |reflection, records|
+            [reflection, records.group_by { |record| association_klass(reflection, record) }]
+          end
+        ]
+      end
+
+      def records_by_reflection(association)
+        records.group_by do |record|
+          reflection = record.class.reflections[association]
+
+          unless reflection
+            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found; " \
+                                                    "perhaps you misspelled it?"
+          end
+
+          reflection
+        end
+      end
+
+      def association_klass(reflection, record)
+        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
+          klass = record.send(reflection.foreign_type)
+          klass && klass.constantize
+        else
+          reflection.klass
+        end
+      end
+
+      def preloader_for(reflection)
+        case reflection.macro
+        when :has_many
+          reflection.options[:through] ? HasManyThrough : HasMany
+        when :has_one
+          reflection.options[:through] ? HasOneThrough : HasOne
+        when :has_and_belongs_to_many
+          HasAndBelongsToMany
+        when :belongs_to
+          BelongsTo
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/association.rb

@@ -0,0 +1,126 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association #:nodoc:
+        attr_reader :owners, :reflection, :preload_options, :model, :klass
+
+        def initialize(klass, owners, reflection, preload_options)
+          @klass           = klass
+          @owners          = owners
+          @reflection      = reflection
+          @preload_options = preload_options || {}
+          @model           = owners.first && owners.first.class
+          @scoped          = nil
+          @owners_by_key   = nil
+        end
+
+        def run
+          unless owners.first.association(reflection.name).loaded?
+            preload
+          end
+        end
+
+        def preload
+          raise NotImplementedError
+        end
+
+        def scoped
+          @scoped ||= build_scope
+        end
+
+        def records_for(ids)
+          scoped.where(association_key.in(ids))
+        end
+
+        def table
+          klass.arel_table
+        end
+
+        # The name of the key on the associated records
+        def association_key_name
+          raise NotImplementedError
+        end
+
+        # This is overridden by HABTM as the condition should be on the foreign_key column in
+        # the join table
+        def association_key
+          table[association_key_name]
+        end
+
+        # The name of the key on the model which declares the association
+        def owner_key_name
+          raise NotImplementedError
+        end
+
+        # We're converting to a string here because postgres will return the aliased association
+        # key in a habtm as a string (for whatever reason)
+        def owners_by_key
+          @owners_by_key ||= owners.group_by do |owner|
+            key = owner[owner_key_name]
+            key && key.to_s
+          end
+        end
+
+        def options
+          reflection.options
+        end
+
+        private
+
+        def associated_records_by_owner
+          owner_keys = owners.map { |owner| owner[owner_key_name] }.compact.uniq
+
+          if klass.nil? || owner_keys.empty?
+            records = []
+          else
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
+            records = sliced.map { |slice| records_for(slice) }.flatten
+          end
+
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = Hash[owners.map { |owner| [owner, []] }]
+          records.each do |record|
+            owner_key = record[association_key_name].to_s
+
+            owners_by_key[owner_key].each do |owner|
+              records_by_owner[owner] << record
+            end
+          end
+          records_by_owner
+        end
+
+        def build_scope
+          scope = klass.scoped
+
+          scope = scope.where(process_conditions(options[:conditions]))
+          scope = scope.where(process_conditions(preload_options[:conditions]))
+
+          scope = scope.select(preload_options[:select] || options[:select] || table[Arel.star])
+          scope = scope.includes(preload_options[:include] || options[:include])
+
+          if options[:as]
+            scope = scope.where(
+              klass.table_name => {
+                reflection.type => model.base_class.sti_name
+              }
+            )
+          end
+
+          scope
+        end
+
+        def process_conditions(conditions)
+          if conditions.respond_to?(:to_proc)
+            conditions = klass.send(:instance_eval, &conditions)
+          end
+
+          if conditions
+            klass.send(:sanitize_sql, conditions)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/belongs_to.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class BelongsTo < SingularAssociation #:nodoc:
+
+        def association_key_name
+          reflection.options[:primary_key] || klass && klass.primary_key
+        end
+
+        def owner_key_name
+          reflection.foreign_key
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/collection_association.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class CollectionAssociation < Association #:nodoc:
+
+        private
+
+        def build_scope
+          super.order(preload_options[:order] || options[:order])
+        end
+
+        def preload
+          associated_records_by_owner.each do |owner, records|
+            association = owner.association(reflection.name)
+            association.loaded!
+            association.target.concat(records)
+            records.each { |record| association.set_inverse_instance(record) }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/has_and_belongs_to_many.rb

@@ -0,0 +1,60 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasAndBelongsToMany < CollectionAssociation #:nodoc:
+        attr_reader :join_table
+
+        def initialize(klass, records, reflection, preload_options)
+          super
+          @join_table = Arel::Table.new(options[:join_table]).alias('t0')
+        end
+
+        # Unlike the other associations, we want to get a raw array of rows so that we can
+        # access the aliased column on the join table
+        def records_for(ids)
+          scope = super
+          klass.connection.select_all(scope.arel.to_sql, 'SQL', scope.bind_values)
+        end
+
+        def owner_key_name
+          reflection.active_record_primary_key
+        end
+
+        def association_key_name
+          'ar_association_key_name'
+        end
+
+        def association_key
+          join_table[reflection.foreign_key]
+        end
+
+        private
+
+        # Once we have used the join table column (in super), we manually instantiate the
+        # actual records, ensuring that we don't create more than one instances of the same
+        # record
+        def associated_records_by_owner
+          records = {}
+          super.each do |owner_key, rows|
+            rows.map! { |row| records[row[klass.primary_key]] ||= klass.instantiate(row) }
+          end
+        end
+
+        def build_scope
+          super.joins(join).select(join_select)
+        end
+
+        def join_select
+          association_key.as(Arel.sql(association_key_name))
+        end
+
+        def join
+          condition = table[reflection.association_primary_key].eq(
+            join_table[reflection.association_foreign_key])
+
+          table.create_join(join_table, table.create_on(condition))
+        end
+      end
+    end
+  end
+end