activerecord 4.0.4 → 4.1.16

data/lib/active_record/associations/has_many_association.rb

@@ -9,7 +9,7 @@ module ActiveRecord
 
       def handle_dependency
         case options[:dependent]
-        when :restrict, :restrict_with_exception
+        when :restrict_with_exception
           raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
 
         when :restrict_with_error
@@ -59,8 +59,6 @@ module ActiveRecord
         def count_records
           count = if has_cached_counter?
             owner.send(:read_attribute, cached_counter_attribute_name)
-          elsif options[:counter_sql] || options[:finder_sql]
-            reflection.klass.count_by_sql(custom_counter_sql)
           else
             scope.count
           end
@@ -73,15 +71,15 @@ module ActiveRecord
           [association_scope.limit_value, count].compact.min
         end
 
-        def has_cached_counter?(reflection = reflection)
+        def has_cached_counter?(reflection = reflection())
           owner.attribute_present?(cached_counter_attribute_name(reflection))
         end
 
-        def cached_counter_attribute_name(reflection = reflection)
+        def cached_counter_attribute_name(reflection = reflection())
           options[:counter_cache] || "#{reflection.name}_count"
         end
 
-        def update_counter(difference, reflection = reflection)
+        def update_counter(difference, reflection = reflection())
           if has_cached_counter?(reflection)
             counter = cached_counter_attribute_name(reflection)
             owner.class.update_counters(owner.id, counter => difference)
@@ -100,9 +98,10 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = reflection)
+        def inverse_updates_counter_cache?(reflection = reflection())
           counter_name = cached_counter_attribute_name(reflection)
-          reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
+          reflection.klass._reflections.values.any? { |inverse_reflection|
+            :belongs_to == inverse_reflection.macro &&
             inverse_reflection.counter_cache_column == counter_name
           }
         end
@@ -110,10 +109,10 @@ module ActiveRecord
         # Deletes the records according to the <tt>:dependent</tt> option.
         def delete_records(records, method)
           if method == :destroy
-            records.each { |r| r.destroy }
+            records.each(&:destroy!)
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            if records == :all
+            if records == :all || !reflection.klass.primary_key
               scope = self.scope
             else
               scope = self.scope.where(reflection.klass.primary_key => records)
@@ -128,7 +127,11 @@ module ActiveRecord
         end
 
         def foreign_key_present?
-          owner.attribute_present?(reflection.association_primary_key)
+          if reflection.klass.primary_key
+            owner.attribute_present?(reflection.association_primary_key)
+          else
+            false
+          end
         end
     end
   end

data/lib/active_record/associations/has_many_through_association.rb

@@ -22,7 +22,7 @@ module ActiveRecord
         elsif loaded?
           target.size
         else
-          count
+          super
         end
       end
 
@@ -30,7 +30,6 @@ module ActiveRecord
         unless owner.new_record?
           records.flatten.each do |record|
             raise_on_type_mismatch!(record)
-            record.save! if record.new_record?
           end
         end
 
@@ -40,7 +39,7 @@ module ActiveRecord
       def concat_records(records)
         ensure_not_nested
 
-        records = super
+        records = super(records, true)
 
         if owner.new_record? && records
           records.flatten.each do |record|
@@ -84,12 +83,22 @@ module ActiveRecord
           @through_records[record.object_id] ||= begin
             ensure_mutable
 
-            through_record = through_association.build
+            through_record = through_association.build(*options_for_through_record)
             through_record.send("#{source_reflection.name}=", record)
             through_record
           end
         end
 
+        def options_for_through_record
+          [through_scope_attributes]
+        end
+
+        def through_scope_attributes
+          scope.where_values_hash(through_association.reflection.name.to_s).
+            except!(through_association.reflection.foreign_key,
+                    through_association.reflection.klass.inheritance_column)
+        end
+
         def save_through_record(record)
           build_through_record(record).save!
         ensure
@@ -140,7 +149,21 @@ module ActiveRecord
 
           case method
           when :destroy
-            count = scope.destroy_all.length
+            if scope.klass.primary_key
+              count = scope.destroy_all.length
+            else
+              scope.to_a.each do |record|
+                record.run_callbacks :destroy
+              end
+
+              arel = scope.arel
+
+              stmt = Arel::DeleteManager.new arel.engine
+              stmt.from scope.klass.arel_table
+              stmt.wheres = arel.constraints
+
+              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+            end
           when :nullify
             count = scope.update_all(source_reflection.foreign_key => nil)
           else
@@ -164,7 +187,11 @@ module ActiveRecord
         def through_records_for(record)
           attributes = construct_join_attributes(record)
           candidates = Array.wrap(through_association.target)
-          candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
+          candidates.find_all do |c|
+            attributes.all? do |key, value|
+              c.public_send(key) == value
+            end
+          end
         end
 
         def delete_through_records(records)

data/lib/active_record/associations/has_one_association.rb

@@ -6,7 +6,7 @@ module ActiveRecord
 
       def handle_dependency
         case options[:dependent]
-        when :restrict, :restrict_with_exception
+        when :restrict_with_exception
           raise ActiveRecord::DeleteRestrictionError.new(reflection.name) if load_target
 
         when :restrict_with_error

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -1,128 +1,80 @@
+require 'active_record/associations/join_dependency/join_part'
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinAssociation < JoinPart # :nodoc:
-        include JoinHelper
-
         # The reflection of the association represented
         attr_reader :reflection
 
-        # The JoinDependency object which this JoinAssociation exists within. This is mainly
-        # relevant for generating aliases which do not conflict with other joins which are
-        # part of the query.
-        attr_reader :join_dependency
-
-        # A JoinBase instance representing the active record we are joining onto.
-        # (So in Author.has_many :posts, the Author would be that base record.)
-        attr_reader :parent
-
-        # What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
-        attr_accessor :join_type
-
-        # These implement abstract methods from the superclass
-        attr_reader :aliased_prefix
-
-        attr_reader :tables
-
-        delegate :options, :through_reflection, :source_reflection, :chain, :to => :reflection
-        delegate :table, :table_name, :to => :parent, :prefix => :parent
-        delegate :alias_tracker, :to => :join_dependency
-
-        alias :alias_suffix :parent_table_name
+        attr_accessor :tables
 
-        def initialize(reflection, join_dependency, parent = nil)
-          reflection.check_validity!
-
-          if reflection.options[:polymorphic]
-            raise EagerLoadPolymorphicError.new(reflection)
-          end
-
-          super(reflection.klass)
+        def initialize(reflection, children)
+          super(reflection.klass, children)
 
           @reflection      = reflection
-          @join_dependency = join_dependency
-          @parent          = parent
-          @join_type       = Arel::InnerJoin
-          @aliased_prefix  = "t#{ join_dependency.join_parts.size }"
-          @tables          = construct_tables.reverse
+          @tables          = nil
         end
 
-        def ==(other)
-          other.class == self.class &&
-            other.reflection == reflection &&
-            other.parent == parent
+        def match?(other)
+          return true if self == other
+          super && reflection == other.reflection
         end
 
-        def find_parent_in(other_join_dependency)
-          other_join_dependency.join_parts.detect do |join_part|
-            case parent
-            when JoinBase
-              parent.base_klass == join_part.base_klass
-            else
-              parent == join_part
-            end
-          end
-        end
+        def join_constraints(foreign_table, foreign_klass, node, join_type, tables, scope_chain, chain)
+          joins         = []
+          tables        = tables.reverse
 
-        def join_to(manager)
-          tables        = @tables.dup
-          foreign_table = parent_table
-          foreign_klass = parent.base_klass
+          scope_chain_index = 0
+          scope_chain = scope_chain.reverse
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
-          chain.reverse.each_with_index do |reflection, i|
+          chain.reverse_each do |reflection|
             table = tables.shift
+            klass = reflection.klass
 
             case reflection.source_macro
             when :belongs_to
               key         = reflection.association_primary_key
               foreign_key = reflection.foreign_key
-            when :has_and_belongs_to_many
-              # Join the join table first...
-              manager.from(join(
-                table,
-                table[reflection.foreign_key].
-                  eq(foreign_table[reflection.active_record_primary_key])
-              ))
-
-              foreign_table, table = table, tables.shift
-
-              key         = reflection.association_primary_key
-              foreign_key = reflection.association_foreign_key
             else
               key         = reflection.foreign_key
               foreign_key = reflection.active_record_primary_key
             end
 
-            constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
+            constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
-            scope_chain_items = scope_chain[i]
-
-            if reflection.type
-              scope_chain_items += [
-                ActiveRecord::Relation.new(reflection.klass, table)
-                  .where(reflection.type => foreign_klass.base_class.name)
-              ]
+            scope_chain_items = scope_chain[scope_chain_index].map do |item|
+              if item.is_a?(Relation)
+                item
+              else
+                ActiveRecord::Relation.create(klass, table).instance_exec(node, &item)
+              end
             end
+            scope_chain_index += 1
 
-            scope_chain_items += [reflection.klass.send(:build_default_scope)].compact
+            scope_chain_items.concat [klass.send(:build_default_scope, ActiveRecord::Relation.create(klass, table))].compact
 
-            scope_chain_items.each do |item|
-              unless item.is_a?(Relation)
-                item = ActiveRecord::Relation.new(reflection.klass, table).instance_exec(self, &item)
-              end
+            rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|
+              left.merge right
+            end
 
-              constraint = constraint.and(item.arel.constraints) unless item.arel.constraints.empty?
+            if reflection.type
+              constraint = constraint.and table[reflection.type].eq foreign_klass.base_class.name
             end
 
-            manager.from(join(table, constraint))
+            if rel && !rel.arel.constraints.empty?
+              constraint = constraint.and rel.arel.constraints
+            end
+
+            joins << table.create_join(table, table.create_on(constraint), join_type)
 
             # The current table in this iteration becomes the foreign table in the next
-            foreign_table, foreign_klass = table, reflection.klass
+            foreign_table, foreign_klass = table, klass
           end
 
-          manager
+          joins
         end
 
         #  Builds equality condition.
@@ -134,42 +86,32 @@ module ActiveRecord
         #  end
         #
         #  If I execute `Physician.joins(:appointments).to_a` then
-        #    reflection    #=> #<ActiveRecord::Reflection::AssociationReflection @macro=:has_many ...>
-        #    table         #=> #<Arel::Table @name="appointments" ...>
-        #    key           #=>  physician_id
-        #    foreign_table #=> #<Arel::Table @name="physicians" ...>
-        #    foreign_key   #=> id
+        #    reflection    # => #<ActiveRecord::Reflection::AssociationReflection @macro=:has_many ...>
+        #    table         # => #<Arel::Table @name="appointments" ...>
+        #    key           # =>  physician_id
+        #    foreign_table # => #<Arel::Table @name="physicians" ...>
+        #    foreign_key   # => id
         #
-        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+        def build_constraint(klass, table, key, foreign_table, foreign_key)
           constraint = table[key].eq(foreign_table[foreign_key])
 
-          if reflection.klass.finder_needs_type_condition?
+          if klass.finder_needs_type_condition?
             constraint = table.create_and([
               constraint,
-              reflection.klass.send(:type_condition, table)
+              klass.send(:type_condition, table)
             ])
           end
 
           constraint
         end
 
-        def join_relation(joining_relation)
-          self.join_type = Arel::OuterJoin
-          joining_relation.joins(self)
-        end
-
         def table
-          tables.last
+          tables.first
         end
 
         def aliased_table_name
           table.table_alias || table.name
         end
-
-        def scope_chain
-          @scope_chain ||= reflection.scope_chain.reverse
-        end
-
       end
     end
   end

data/lib/active_record/associations/join_dependency/join_base.rb

@@ -1,18 +1,16 @@
+require 'active_record/associations/join_dependency/join_part'
+
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
       class JoinBase < JoinPart # :nodoc:
-        def ==(other)
-          other.class == self.class &&
-            other.base_klass == base_klass
-        end
-
-        def aliased_prefix
-          "t0"
+        def match?(other)
+          return true if self == other
+          super && base_klass == other.base_klass
         end
 
         def table
-          Arel::Table.new(table_name, arel_engine)
+          base_klass.arel_table
         end
 
         def aliased_table_name

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -8,34 +8,36 @@ module ActiveRecord
       # operations (for example a has_and_belongs_to_many JoinAssociation would result in
       # two; one for the join table and one for the target table).
       class JoinPart # :nodoc:
+        include Enumerable
+
         # The Active Record class which this join part is associated 'about'; for a JoinBase
         # this is the actual base model, for a JoinAssociation this is the target model of the
         # association.
-        attr_reader :base_klass
+        attr_reader :base_klass, :children
 
-        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :base_klass
+        delegate :table_name, :column_names, :primary_key, :to => :base_klass
 
-        def initialize(base_klass)
+        def initialize(base_klass, children)
           @base_klass = base_klass
-          @cached_record = {}
           @column_names_with_alias = nil
+          @children = children
         end
 
-        def aliased_table
-          Arel::Nodes::TableAlias.new table, aliased_table_name
+        def name
+          reflection.name
         end
 
-        def ==(other)
-          raise NotImplementedError
+        def match?(other)
+          self.class == other.class
         end
 
-        # An Arel::Table for the active_record
-        def table
-          raise NotImplementedError
+        def each(&block)
+          yield self
+          children.each { |child| child.each(&block) }
         end
 
-        # The prefix to be used when aliasing columns in the active_record's table
-        def aliased_prefix
+        # An Arel::Table for the active_record
+        def table
           raise NotImplementedError
         end
 
@@ -44,24 +46,7 @@ module ActiveRecord
           raise NotImplementedError
         end
 
-        # The alias for the primary key of the active_record's table
-        def aliased_primary_key
-          "#{aliased_prefix}_r0"
-        end
-
-        # An array of [column_name, alias] pairs for the table
-        def column_names_with_alias
-          unless @column_names_with_alias
-            @column_names_with_alias = []
-
-            ([primary_key] + (column_names - [primary_key])).compact.each_with_index do |column_name, i|
-              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
-            end
-          end
-          @column_names_with_alias
-        end
-
-        def extract_record(row)
+        def extract_record(row, column_names_with_alias)
           # This code is performance critical as it is called per row.
           # see: https://github.com/rails/rails/pull/12185
           hash = {}
@@ -78,12 +63,8 @@ module ActiveRecord
           hash
         end
 
-        def record_id(row)
-          row[aliased_primary_key]
-        end
-
-        def instantiate(row)
-          @cached_record[record_id(row)] ||= base_klass.instantiate(extract_record(row))
+        def instantiate(row, aliases)
+          base_klass.instantiate(extract_record(row, aliases))
         end
       end
     end