activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/associations/alias_tracker.rb

@@ -2,23 +2,25 @@ require 'active_support/core_ext/string/conversions'
 
 module ActiveRecord
   module Associations
-    # Keeps track of table aliases for ActiveRecord::Associations::ClassMethods::JoinDependency and
-    # ActiveRecord::Associations::ThroughAssociationScope
+    # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
     class AliasTracker # :nodoc:
-      attr_reader :aliases, :connection
+      attr_reader :aliases
 
-      def self.empty(connection)
-        new connection, Hash.new(0)
+      def self.create(connection, initial_table, type_caster)
+        aliases = Hash.new(0)
+        aliases[initial_table] = 1
+        new connection, aliases, type_caster
       end
 
-      def self.create(connection, table_joins)
-        if table_joins.empty?
-          empty connection
+      def self.create_with_joins(connection, initial_table, joins, type_caster)
+        if joins.empty?
+          create(connection, initial_table, type_caster)
         else
-          aliases = Hash.new { |h,k|
-            h[k] = initial_count_for(connection, k, table_joins)
+          aliases = Hash.new { |h, k|
+            h[k] = initial_count_for(connection, k, joins)
           }
-          new connection, aliases
+          aliases[initial_table] = 1
+          new connection, aliases, type_caster
         end
       end
 
@@ -51,19 +53,20 @@ module ActiveRecord
       end
 
       # table_joins is an array of arel joins which might conflict with the aliases we assign here
-      def initialize(connection, aliases)
+      def initialize(connection, aliases, type_caster)
         @aliases    = aliases
         @connection = connection
+        @type_caster = type_caster
       end
 
       def aliased_table_for(table_name, aliased_name)
         if aliases[table_name].zero?
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
-          Arel::Table.new(table_name)
+          Arel::Table.new(table_name, type_caster: @type_caster)
         else
           # Otherwise, we need to use an alias
-          aliased_name = connection.table_alias_for(aliased_name)
+          aliased_name = @connection.table_alias_for(aliased_name)
 
           # Update the count
           aliases[aliased_name] += 1
@@ -73,14 +76,14 @@ module ActiveRecord
           else
             aliased_name
           end
-          Arel::Table.new(table_name).alias(table_alias)
+          Arel::Table.new(table_name, type_caster: @type_caster).alias(table_alias)
         end
       end
 
       private
 
         def truncate(name)
-          name.slice(0, connection.table_alias_length - 2)
+          name.slice(0, @connection.table_alias_length - 2)
         end
     end
   end

data/lib/active_record/associations/association.rb

@@ -8,12 +8,12 @@ module ActiveRecord
     #
     #   Association
     #     SingularAssociation
-    #       HasOneAssociation
+    #       HasOneAssociation + ForeignAssociation
     #         HasOneThroughAssociation + ThroughAssociation
     #       BelongsToAssociation
     #         BelongsToPolymorphicAssociation
     #     CollectionAssociation
-    #       HasManyAssociation
+    #       HasManyAssociation + ForeignAssociation
     #         HasManyThroughAssociation + ThroughAssociation
     class Association #:nodoc:
       attr_reader :owner, :target, :reflection
@@ -121,7 +121,7 @@ module ActiveRecord
       # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
       # through association's scope)
       def target_scope
-        AssociationRelation.create(klass, klass.arel_table, self).merge!(klass.all)
+        AssociationRelation.create(klass, klass.arel_table, klass.predicate_builder, self).merge!(klass.all)
       end
 
       # Loads the \target if needed and returns it.
@@ -163,9 +163,12 @@ module ActiveRecord
         @reflection = @owner.class._reflect_on_association(reflection_name)
       end
 
-      def initialize_attributes(record) #:nodoc:
+      def initialize_attributes(record, except_from_scope_attributes = nil) #:nodoc:
+        except_from_scope_attributes ||= {}
         skip_assign = [reflection.foreign_key, reflection.type].compact
-        attributes = create_scope.except(*(record.changed - skip_assign))
+        assigned_keys = record.changed
+        assigned_keys += except_from_scope_attributes.keys.map(&:to_s)
+        attributes = create_scope.except(*(assigned_keys - skip_assign))
         record.assign_attributes(attributes)
         set_inverse_instance(record)
       end
@@ -248,7 +251,7 @@ module ActiveRecord
 
         def build_record(attributes)
           reflection.build_association(attributes) do |record|
-            initialize_attributes(record)
+            initialize_attributes(record, attributes)
           end
         end
 
@@ -256,8 +259,7 @@ module ActiveRecord
         def skip_statement_cache?
           reflection.scope_chain.any?(&:any?) ||
             scope.eager_loading? ||
-            klass.current_scope ||
-            klass.default_scopes.any? ||
+            klass.scope_attributes? ||
             reflection.source_reflection.active_record.default_scopes.any?
         end
     end

data/lib/active_record/associations/association_scope.rb

@@ -2,41 +2,30 @@ module ActiveRecord
   module Associations
     class AssociationScope #:nodoc:
       def self.scope(association, connection)
-        INSTANCE.scope association, connection
-      end
-
-      class BindSubstitution
-        def initialize(block)
-          @block = block
-        end
-
-        def bind_value(scope, column, value, alias_tracker)
-          substitute = alias_tracker.connection.substitute_at(column)
-          scope.bind_values += [[column, @block.call(value)]]
-          substitute
-        end
+        INSTANCE.scope(association, connection)
       end
 
       def self.create(&block)
-        block = block ? block : lambda { |val| val }
-        new BindSubstitution.new(block)
+        block ||= lambda { |val| val }
+        new(block)
       end
 
-      def initialize(bind_substitution)
-        @bind_substitution = bind_substitution
+      def initialize(value_transformation)
+        @value_transformation = value_transformation
       end
 
       INSTANCE = create
 
       def scope(association, connection)
-        klass         = association.klass
-        reflection    = association.reflection
-        scope         = klass.unscoped
-        owner         = association.owner
-        alias_tracker = AliasTracker.empty connection
+        klass = association.klass
+        reflection = association.reflection
+        scope = klass.unscoped
+        owner = association.owner
+        alias_tracker = AliasTracker.create connection, association.klass.table_name, klass.type_caster
+        chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
 
         scope.extending! Array(reflection.options[:extend])
-        add_constraints(scope, owner, klass, reflection, alias_tracker)
+        add_constraints(scope, owner, klass, reflection, chain_head, chain_tail)
       end
 
       def join_type
@@ -60,133 +49,115 @@ module ActiveRecord
         binds
       end
 
-      private
+      protected
 
-      def construct_tables(chain, klass, refl, alias_tracker)
-        chain.map do |reflection|
-          alias_tracker.aliased_table_for(
-            table_name_for(reflection, klass, refl),
-            table_alias_for(reflection, refl, reflection != refl)
-          )
-        end
-      end
-
-      def table_alias_for(reflection, refl, join = false)
-        name = "#{reflection.plural_name}_#{alias_suffix(refl)}"
-        name << "_join" if join
-        name
-      end
+      attr_reader :value_transformation
 
+      private
       def join(table, constraint)
         table.create_join(table, table.create_on(constraint), join_type)
       end
 
-      def column_for(table_name, column_name, alias_tracker)
-        columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
-        columns[column_name]
-      end
-
-      def bind_value(scope, column, value, alias_tracker)
-        @bind_substitution.bind_value scope, column, value, alias_tracker
-      end
-
-      def bind(scope, table_name, column_name, value, tracker)
-        column   = column_for table_name, column_name, tracker
-        bind_value scope, column, value, tracker
-      end
-
-      def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
-        join_keys = reflection.join_keys(assoc_klass)
+      def last_chain_scope(scope, table, reflection, owner, association_klass)
+        join_keys = reflection.join_keys(association_klass)
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
-        bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
-        scope    = scope.where(table[key].eq(bind_val))
+        value = transform_value(owner[foreign_key])
+        scope = scope.where(table.name => { key => value })
 
         if reflection.type
-          value    = owner.class.base_class.name
-          bind_val = bind scope, table.table_name, reflection.type, value, tracker
-          scope    = scope.where(table[reflection.type].eq(bind_val))
-        else
-          scope
+          polymorphic_type = transform_value(owner.class.base_class.name)
+          scope = scope.where(table.name => { reflection.type => polymorphic_type })
         end
+
+        scope
       end
 
-      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
-        join_keys = reflection.join_keys(assoc_klass)
+      def transform_value(value)
+        value_transformation.call(value)
+      end
+
+      def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(association_klass)
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
         constraint = table[key].eq(foreign_table[foreign_key])
 
         if reflection.type
-          value    = next_reflection.klass.base_class.name
-          bind_val = bind scope, table.table_name, reflection.type, value, tracker
-          scope    = scope.where(table[reflection.type].eq(bind_val))
+          value = transform_value(next_reflection.klass.base_class.name)
+          scope = scope.where(table.name => { reflection.type => value })
         end
 
         scope = scope.joins(join(foreign_table, constraint))
       end
 
-      def add_constraints(scope, owner, assoc_klass, refl, tracker)
-        chain = refl.chain
-        scope_chain = refl.scope_chain
+      class ReflectionProxy < SimpleDelegator # :nodoc:
+        attr_accessor :next
+        attr_reader :alias_name
 
-        tables = construct_tables(chain, assoc_klass, refl, tracker)
+        def initialize(reflection, alias_name)
+          super(reflection)
+          @alias_name = alias_name
+        end
 
-        owner_reflection = chain.last
-        table = tables.last
-        scope = last_chain_scope(scope, table, owner_reflection, owner, tracker, assoc_klass)
+        def all_includes; nil; end
+      end
 
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
+      def get_chain(reflection, association, tracker)
+        name = reflection.name
+        runtime_reflection = Reflection::RuntimeReflection.new(reflection, association)
+        previous_reflection = runtime_reflection
+        reflection.chain.drop(1).each do |refl|
+          alias_name = tracker.aliased_table_for(refl.table_name, refl.alias_candidate(name))
+          proxy = ReflectionProxy.new(refl, alias_name)
+          previous_reflection.next = proxy
+          previous_reflection = proxy
+        end
+        [runtime_reflection, previous_reflection]
+      end
 
-          unless reflection == chain.last
-            next_reflection = chain[i + 1]
-            scope = next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
-          end
+      def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail)
+        owner_reflection = chain_tail
+        table = owner_reflection.alias_name
+        scope = last_chain_scope(scope, table, owner_reflection, owner, association_klass)
 
-          is_first_chain = i == 0
-          klass = is_first_chain ? assoc_klass : reflection.klass
+        reflection = chain_head
+        loop do
+          break unless reflection
+          table = reflection.alias_name
+
+          unless reflection == chain_tail
+            next_reflection = reflection.next
+            foreign_table = next_reflection.alias_name
+            scope = next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
+          end
 
           # Exclude the scope of the association itself, because that
           # was already merged in the #scope method.
-          scope_chain[i].each do |scope_chain_item|
-            item  = eval_scope(klass, scope_chain_item, owner)
+          reflection.constraints.each do |scope_chain_item|
+            item  = eval_scope(reflection.klass, scope_chain_item, owner)
 
             if scope_chain_item == refl.scope
-              scope.merge! item.except(:where, :includes, :bind)
+              scope.merge! item.except(:where, :includes)
             end
 
-            if is_first_chain
+            reflection.all_includes do
               scope.includes! item.includes_values
             end
 
             scope.unscope!(*item.unscope_values)
-            scope.where_values += item.where_values
-            scope.bind_values  += item.bind_values
+            scope.where_clause += item.where_clause
             scope.order_values |= item.order_values
           end
+
+          reflection = reflection.next
         end
 
         scope
       end
 
-      def alias_suffix(refl)
-        refl.name
-      end
-
-      def table_name_for(reflection, klass, refl)
-        if reflection == refl
-          # If this is a polymorphic belongs_to, we want to get the klass from the
-          # association because it depends on the polymorphic_type attribute of
-          # the owner
-          klass.table_name
-        else
-          reflection.table_name
-        end
-      end
-
       def eval_scope(klass, scope, owner)
         klass.unscoped.instance_exec(owner, &scope)
       end

data/lib/active_record/associations/belongs_to_association.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       def replace(record)
         if record
           raise_on_type_mismatch!(record)
-          update_counters(record)
+          update_counters_on_replace(record)
           replace_keys(record)
           set_inverse_instance(record)
           @updated = true
@@ -32,45 +32,37 @@ module ActiveRecord
       end
 
       def decrement_counters # :nodoc:
-        with_cache_name { |name| decrement_counter name }
+        update_counters(-1)
       end
 
       def increment_counters # :nodoc:
-        with_cache_name { |name| increment_counter name }
+        update_counters(1)
       end
 
       private
 
-        def find_target?
-          !loaded? && foreign_key_present? && klass
-        end
-
-        def with_cache_name
-          counter_cache_name = reflection.counter_cache_column
-          return unless counter_cache_name && owner.persisted?
-          yield counter_cache_name
+        def update_counters(by)
+          if require_counter_update? && foreign_key_present?
+            if target && !stale_target?
+              target.increment!(reflection.counter_cache_column, by)
+            else
+              klass.update_counters(target_id, reflection.counter_cache_column => by)
+            end
+          end
         end
 
-        def update_counters(record)
-          with_cache_name do |name|
-            return unless different_target? record
-            record.class.increment_counter(name, record.id)
-            decrement_counter name
-          end
+        def find_target?
+          !loaded? && foreign_key_present? && klass
         end
 
-        def decrement_counter(counter_cache_name)
-          if foreign_key_present?
-            klass.decrement_counter(counter_cache_name, target_id)
-          end
+        def require_counter_update?
+          reflection.counter_cache_column && owner.persisted?
         end
 
-        def increment_counter(counter_cache_name)
-          if foreign_key_present?
-            klass.increment_counter(counter_cache_name, target_id)
-            if target && !stale_target? && counter_cache_available_in_memory?(counter_cache_name)
-              target.increment(counter_cache_name)
-            end
+        def update_counters_on_replace(record)
+          if require_counter_update? && different_target?(record)
+            record.increment!(reflection.counter_cache_column)
+            decrement_counters
           end
         end
 
@@ -107,13 +99,9 @@ module ActiveRecord
         end
 
         def stale_state
-          result = owner._read_attribute(reflection.foreign_key)
+          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
           result && result.to_s
         end
-
-        def counter_cache_available_in_memory?(counter_cache_name)
-          target.respond_to?(counter_cache_name)
-        end
     end
   end
 end