activerecord 3.2.22.4 → 4.0.13

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -5,7 +5,7 @@ module ActiveRecord
       attr_reader :join_table
 
       def initialize(owner, reflection)
-        @join_table = Arel::Table.new(reflection.options[:join_table])
+        @join_table = Arel::Table.new(reflection.join_table)
         super
       end
 
@@ -26,32 +26,34 @@ module ActiveRecord
             join_table[reflection.association_foreign_key] => record.id
           )
 
-          owner.connection.insert stmt
+          owner.class.connection.insert stmt
         end
 
         record
       end
 
-      # ActiveRecord::Relation#delete_all needs to support joins before we can use a
-      # SQL-only implementation.
-      alias delete_all_on_destroy delete_all
-
       private
 
         def count_records
-          load_target.size
+          load_target.reject { |r| r.new_record? }.size
         end
 
         def delete_records(records, method)
           if sql = options[:delete_sql]
             records = load_target if records == :all
-            records.each { |record| owner.connection.delete(interpolate(sql, record)) }
+            records.each { |record| owner.class.connection.delete(interpolate(sql, record)) }
           else
-            relation = join_table
-            stmt = relation.where(relation[reflection.foreign_key].eq(owner.id).
-              and(relation[reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
-            ).compile_delete
-            owner.connection.delete stmt
+            relation  = join_table
+            condition = relation[reflection.foreign_key].eq(owner.id)
+
+            unless records == :all
+              condition = condition.and(
+                relation[reflection.association_foreign_key]
+                  .in(records.map { |x| x.id }.compact)
+              )
+            end
+
+            owner.class.connection.delete(relation.where(condition).compile_delete)
           end
         end
 

data/lib/active_record/associations/has_many_association.rb

@@ -7,6 +7,29 @@ module ActiveRecord
     # is provided by its child HasManyThroughAssociation.
     class HasManyAssociation < CollectionAssociation #:nodoc:
 
+      def handle_dependency
+        case options[:dependent]
+        when :restrict, :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.many", record: record)
+            false
+          end
+
+        else
+          if options[:dependent] == :destroy
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            load_target.each { |t| t.destroyed_by_association = reflection }
+            destroy_all
+          else
+            delete_all
+          end
+        end
+      end
+
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
         set_inverse_instance(record)
@@ -39,7 +62,7 @@ module ActiveRecord
           elsif options[:counter_sql] || options[:finder_sql]
             reflection.klass.count_by_sql(custom_counter_sql)
           else
-            scoped.count
+            scope.count
           end
 
           # If there's nothing in the database and @target has no new records
@@ -47,18 +70,18 @@ module ActiveRecord
           # documented side-effect of the method that may avoid an extra SELECT.
           @target ||= [] and loaded! if count == 0
 
-          [options[:limit], count].compact.min
+          [association_scope.limit_value, count].compact.min
         end
 
-        def has_cached_counter?(reflection = self.reflection)
+        def has_cached_counter?(reflection = reflection())
           owner.attribute_present?(cached_counter_attribute_name(reflection))
         end
 
-        def cached_counter_attribute_name(reflection = self.reflection)
-          "#{reflection.name}_count"
+        def cached_counter_attribute_name(reflection = reflection())
+          options[:counter_cache] || "#{reflection.name}_count"
         end
 
-        def update_counter(difference, reflection = self.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)
@@ -77,7 +100,7 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = self.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|
             inverse_reflection.counter_cache_column == counter_name
@@ -90,7 +113,11 @@ module ActiveRecord
             records.each { |r| r.destroy }
             update_counter(-records.length) unless inverse_updates_counter_cache?
           else
-            scope = self.scoped.where(reflection.klass.primary_key => records)
+            if records == :all
+              scope = self.scope
+            else
+              scope = self.scope.where(reflection.klass.primary_key => records)
+            end
 
             if method == :delete_all
               update_counter(-scope.delete_all)

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Has Many Through Association
@@ -30,7 +29,7 @@ module ActiveRecord
       def concat(*records)
         unless owner.new_record?
           records.flatten.each do |record|
-            raise_on_type_mismatch(record)
+            raise_on_type_mismatch!(record)
             record.save! if record.new_record?
           end
         end
@@ -38,6 +37,20 @@ module ActiveRecord
         super
       end
 
+      def concat_records(records)
+        ensure_not_nested
+
+        records = super
+
+        if owner.new_record? && records
+          records.flatten.each do |record|
+            build_through_record(record)
+          end
+        end
+
+        records
+      end
+
       def insert_record(record, validate = true, raise = false)
         ensure_not_nested
 
@@ -54,10 +67,6 @@ module ActiveRecord
         record
       end
 
-      # ActiveRecord::Relation#delete_all needs to support joins before we can use a
-      # SQL-only implementation.
-      alias delete_all_on_destroy delete_all
-
       private
 
         def through_association
@@ -75,22 +84,32 @@ 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.to_sym)
+        end
+
         def save_through_record(record)
           build_through_record(record).save!
         ensure
           @through_records.delete(record.object_id)
         end
 
-        def build_record(attributes, options = {})
+        def build_record(attributes)
           ensure_not_nested
 
-          record = super(attributes, options)
+          record = super(attributes)
 
           inverse = source_reflection.inverse_of
           if inverse
@@ -105,11 +124,7 @@ module ActiveRecord
         end
 
         def target_reflection_has_associated_record?
-          if through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?
-            false
-          else
-            true
-          end
+          !(through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?)
         end
 
         def update_through_counter?(method)
@@ -126,7 +141,12 @@ module ActiveRecord
         def delete_records(records, method)
           ensure_not_nested
 
-          scope = through_association.scoped.where(construct_join_attributes(*records))
+          # This is unoptimised; it will load all the target records
+          # even when we just want to delete everything.
+          records = load_target if records == :all
+
+          scope = through_association.scope
+          scope.where! construct_join_attributes(*records)
 
           case method
           when :destroy
@@ -139,7 +159,7 @@ module ActiveRecord
 
           delete_through_records(records)
 
-          if source_reflection.options[:counter_cache]
+          if source_reflection.options[:counter_cache] && method != :destroy
             counter = source_reflection.counter_cache_column
             klass.decrement_counter counter, records.map(&:id)
           end
@@ -175,7 +195,7 @@ module ActiveRecord
 
         def find_target
           return [] unless target_reflection_has_associated_record?
-          scoped.all
+          scope.to_a
         end
 
         # NOTE - not sure that we can actually cope with inverses here

data/lib/active_record/associations/has_one_association.rb

@@ -1,24 +1,44 @@
-require 'active_support/core_ext/object/inclusion'
 
 module ActiveRecord
   # = Active Record Belongs To Has One Association
   module Associations
     class HasOneAssociation < SingularAssociation #:nodoc:
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict, :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) if load_target
+
+        when :restrict_with_error
+          if load_target
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.one", record: record)
+            false
+          end
+
+        else
+          delete
+        end
+      end
+
       def replace(record, save = true)
-        raise_on_type_mismatch(record) if record
+        raise_on_type_mismatch!(record) if record
         load_target
 
-        # If target and record are nil, or target is equal to record,
-        # we don't need to have transaction.
-        if (target || record) && target != record
+        return self.target if !(target || record)
+
+        assigning_another_record = target != record
+        if assigning_another_record || record.changed?
+          save &&= owner.persisted?
+
           transaction_if(save) do
-            remove_target!(options[:dependent]) if target && !target.destroyed?
-  
+            remove_target!(options[:dependent]) if target && !target.destroyed? && assigning_another_record
+
             if record
               set_owner_attributes(record)
               set_inverse_instance(record)
-  
-              if owner.persisted? && save && !record.save
+
+              if save && !record.save
                 nullify_owner_attributes(record)
                 set_owner_attributes(target) if target
                 raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
@@ -38,7 +58,7 @@ module ActiveRecord
             when :destroy
               target.destroy
             when :nullify
-              target.update_attribute(reflection.foreign_key, nil)
+              target.update_columns(reflection.foreign_key => nil)
           end
         end
       end
@@ -54,16 +74,19 @@ module ActiveRecord
         end
 
         def remove_target!(method)
-          if method.in?([:delete, :destroy])
-            target.send(method)
-          else
-            nullify_owner_attributes(target)
+          case method
+            when :delete
+              target.delete
+            when :destroy
+              target.destroy
+            else
+              nullify_owner_attributes(target)
 
-            if target.persisted? && owner.persisted? && !target.save
-              set_owner_attributes(target)
-              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
-                                    "The record failed to save when after its foreign key was set to nil."
-            end
+              if target.persisted? && owner.persisted? && !target.save
+                set_owner_attributes(target)
+                raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
+                                      "The record failed to save after its foreign key was set to nil."
+              end
           end
         end
 

data/lib/active_record/associations/has_one_through_association.rb

@@ -23,7 +23,7 @@ module ActiveRecord
             attributes = construct_join_attributes(record)
 
             if through_record
-              through_record.update_attributes(attributes)
+              through_record.update(attributes)
             elsif owner.new_record?
               through_proxy.build(attributes)
             else

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

@@ -57,17 +57,17 @@ module ActiveRecord
           other_join_dependency.join_parts.detect do |join_part|
             case parent
             when JoinBase
-              parent.active_record == join_part.active_record
+              parent.base_klass == join_part.base_klass
             else
               parent == join_part
             end
           end
         end
 
-        def join_to(relation)
+        def join_to(manager)
           tables        = @tables.dup
           foreign_table = parent_table
-          foreign_klass = parent.active_record
+          foreign_klass = parent.base_klass
 
           # The chain starts with the target table, but we want to end with it here (makes
           # more sense in this context), so we reverse
@@ -80,7 +80,7 @@ module ActiveRecord
               foreign_key = reflection.foreign_key
             when :has_and_belongs_to_many
               # Join the join table first...
-              relation.from(join(
+              manager.from(join(
                 table,
                 table[reflection.foreign_key].
                   eq(foreign_table[reflection.active_record_primary_key])
@@ -97,22 +97,49 @@ module ActiveRecord
 
             constraint = build_constraint(reflection, table, key, foreign_table, foreign_key)
 
-            conditions = self.conditions[i].dup
-            conditions << { reflection.type => foreign_klass.base_class.name } if reflection.type
+            scope_chain_items = scope_chain[i]
 
-            unless conditions.empty?
-              constraint = constraint.and(sanitize(conditions, table))
+            if reflection.type
+              scope_chain_items += [
+                ActiveRecord::Relation.new(reflection.klass, table)
+                  .where(reflection.type => foreign_klass.base_class.name)
+              ]
             end
 
-            relation.from(join(table, constraint))
+            scope_chain_items += [reflection.klass.send(:build_default_scope, ActiveRecord::Relation.new(reflection.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
+
+              constraint = constraint.and(item.arel.constraints) unless item.arel.constraints.empty?
+            end
+
+            manager.from(join(table, constraint))
 
             # The current table in this iteration becomes the foreign table in the next
             foreign_table, foreign_klass = table, reflection.klass
           end
 
-          relation
+          manager
         end
 
+        #  Builds equality condition.
+        #
+        #  Example:
+        #
+        #  class Physician < ActiveRecord::Base
+        #    has_many :appointments
+        #  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
+        #
         def build_constraint(reflection, table, key, foreign_table, foreign_key)
           constraint = table[key].eq(foreign_table[foreign_key])
 
@@ -139,18 +166,8 @@ module ActiveRecord
           table.table_alias || table.name
         end
 
-        def conditions
-          @conditions ||= reflection.conditions.reverse
-        end
-
-        private
-
-        def interpolate(conditions)
-          if conditions.respond_to?(:to_proc)
-            instance_eval(&conditions)
-          else
-            conditions
-          end
+        def scope_chain
+          @scope_chain ||= reflection.scope_chain.reverse
         end
 
       end

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

@@ -4,7 +4,7 @@ module ActiveRecord
       class JoinBase < JoinPart # :nodoc:
         def ==(other)
           other.class == self.class &&
-            other.active_record == active_record
+            other.base_klass == base_klass
         end
 
         def aliased_prefix
@@ -16,7 +16,7 @@ module ActiveRecord
         end
 
         def aliased_table_name
-          active_record.table_name
+          base_klass.table_name
         end
       end
     end

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

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      # A JoinPart represents a part of a JoinDependency. It is an abstract class, inherited
+      # A JoinPart represents a part of a JoinDependency. It is inherited
       # by JoinBase and JoinAssociation. A JoinBase represents the Active Record which
       # everything else is being joined onto. A JoinAssociation represents an association which
       # is joining to the base. A JoinAssociation may result in more than one actual join
@@ -11,12 +11,12 @@ module ActiveRecord
         # 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 :active_record
+        attr_reader :base_klass
 
-        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :active_record
+        delegate :table_name, :column_names, :primary_key, :reflections, :arel_engine, :to => :base_klass
 
-        def initialize(active_record)
-          @active_record = active_record
+        def initialize(base_klass)
+          @base_klass = base_klass
           @cached_record = {}
           @column_names_with_alias = nil
         end
@@ -54,7 +54,7 @@ module ActiveRecord
           unless @column_names_with_alias
             @column_names_with_alias = []
 
-            ([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
+            ([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
@@ -62,7 +62,20 @@ module ActiveRecord
         end
 
         def extract_record(row)
-          Hash[column_names_with_alias.map{|cn, an| [cn, row[an]]}]
+          # This code is performance critical as it is called per row.
+          # see: https://github.com/rails/rails/pull/12185
+          hash = {}
+
+          index = 0
+          length = column_names_with_alias.length
+
+          while index < length
+            column_name, alias_name = column_names_with_alias[index]
+            hash[column_name] = row[alias_name]
+            index += 1
+          end
+
+          hash
         end
 
         def record_id(row)
@@ -70,7 +83,7 @@ module ActiveRecord
         end
 
         def instantiate(row)
-          @cached_record[record_id(row)] ||= active_record.send(:instantiate, extract_record(row))
+          @cached_record[record_id(row)] ||= base_klass.instantiate(extract_record(row))
         end
       end
     end

data/lib/active_record/associations/join_dependency.rb

@@ -5,10 +5,31 @@ module ActiveRecord
       autoload :JoinBase,        'active_record/associations/join_dependency/join_base'
       autoload :JoinAssociation, 'active_record/associations/join_dependency/join_association'
 
-      attr_reader :join_parts, :reflections, :alias_tracker, :active_record
-
+      attr_reader :join_parts, :reflections, :alias_tracker, :base_klass
+
+      # base is the base class on which operation is taking place.
+      # associations is the list of associations which are joined using hash, symbol or array.
+      # joins is the list of all string join commnads and arel nodes.
+      #
+      #  Example :
+      #
+      #  class Physician < ActiveRecord::Base
+      #    has_many :appointments
+      #    has_many :patients, through: :appointments
+      #  end
+      #
+      #  If I execute `@physician.patients.to_a` then
+      #    base #=> Physician
+      #    associations #=> []
+      #    joins #=>  [#<Arel::Nodes::InnerJoin: ...]
+      #
+      #  However if I execute `Physician.joins(:appointments).to_a` then
+      #    base #=> Physician
+      #    associations #=> [:appointments]
+      #    joins #=>  []
+      #
       def initialize(base, associations, joins)
-        @active_record = base
+        @base_klass    = base
         @table_joins   = joins
         @join_parts    = [JoinBase.new(base)]
         @associations  = {}
@@ -54,10 +75,12 @@ module ActiveRecord
           parent
         }.uniq
 
-        remove_duplicate_results!(active_record, records, @associations)
+        remove_duplicate_results!(base_klass, records, @associations)
         records
       end
 
+      protected
+
       def remove_duplicate_results!(base, records, associations)
         case associations
         when Symbol, String
@@ -68,7 +91,7 @@ module ActiveRecord
             remove_duplicate_results!(base, records, association)
           end
         when Hash
-          associations.keys.each do |name|
+          associations.each_key do |name|
             reflection = base.reflections[name]
             remove_uniq_by_reflection(reflection, records)
 
@@ -88,8 +111,6 @@ module ActiveRecord
         end
       end
 
-      protected
-
       def cache_joined_association(association)
         associations = []
         parent = association.parent
@@ -108,8 +129,8 @@ module ActiveRecord
         parent ||= join_parts.last
         case associations
         when Symbol, String
-          reflection = parent.reflections[associations.to_s.intern] or
-          raise ConfigurationError, "Association named '#{ associations }' was not found on #{parent.active_record.name}; perhaps you misspelled it?"
+          reflection = parent.reflections[associations.intern] or
+          raise ConfigurationError, "Association named '#{ associations }' was not found on #{ parent.base_klass.name }; perhaps you misspelled it?"
           unless join_association = find_join_association(reflection, parent)
             @reflections << reflection
             join_association = build_join_association(reflection, parent)

data/lib/active_record/associations/join_helper.rb

@@ -19,7 +19,7 @@ module ActiveRecord
 
           if reflection.source_macro == :has_and_belongs_to_many
             tables << alias_tracker.aliased_table_for(
-              (reflection.source_reflection || reflection).options[:join_table],
+              (reflection.source_reflection || reflection).join_table,
               table_alias_for(reflection, true)
             )
           end
@@ -40,16 +40,6 @@ module ActiveRecord
       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