activerecord 4.2.0

data/lib/active_record/associations/alias_tracker.rb

@@ -0,0 +1,87 @@
+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
+    class AliasTracker # :nodoc:
+      attr_reader :aliases, :connection
+
+      def self.empty(connection)
+        new connection, Hash.new(0)
+      end
+
+      def self.create(connection, table_joins)
+        if table_joins.empty?
+          empty connection
+        else
+          aliases = Hash.new { |h,k|
+            h[k] = initial_count_for(connection, k, table_joins)
+          }
+          new connection, aliases
+        end
+      end
+
+      def self.initial_count_for(connection, name, table_joins)
+        # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
+        quoted_name = connection.quote_table_name(name).downcase
+
+        counts = table_joins.map do |join|
+          if join.is_a?(Arel::Nodes::StringJoin)
+            # Table names + table aliases
+            join.left.downcase.scan(
+              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+            ).size
+          elsif join.respond_to? :left
+            join.left.table_name == name ? 1 : 0
+          else
+            # this branch is reached by two tests:
+            #
+            # activerecord/test/cases/associations/cascaded_eager_loading_test.rb:37
+            #   with :posts
+            #
+            # activerecord/test/cases/associations/eager_test.rb:1133
+            #   with :comments
+            #
+            0
+          end
+        end
+
+        counts.sum
+      end
+
+      # table_joins is an array of arel joins which might conflict with the aliases we assign here
+      def initialize(connection, aliases)
+        @aliases    = aliases
+        @connection = connection
+      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)
+        else
+          # Otherwise, we need to use an alias
+          aliased_name = connection.table_alias_for(aliased_name)
+
+          # Update the count
+          aliases[aliased_name] += 1
+
+          table_alias = if aliases[aliased_name] > 1
+            "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
+          else
+            aliased_name
+          end
+          Arel::Table.new(table_name).alias(table_alias)
+        end
+      end
+
+      private
+
+        def truncate(name)
+          name.slice(0, connection.table_alias_length - 2)
+        end
+    end
+  end
+end

data/lib/active_record/associations/association.rb

@@ -0,0 +1,253 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation
+    #         HasOneThroughAssociation + ThroughAssociation
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation
+    #     CollectionAssociation
+    #       HasManyAssociation
+    #         HasManyThroughAssociation + ThroughAssociation
+    class Association #:nodoc:
+      attr_reader :owner, :target, :reflection
+      attr_accessor :inversed
+
+      delegate :options, :to => :reflection
+
+      def initialize(owner, reflection)
+        reflection.check_validity!
+
+        @owner, @reflection = owner, reflection
+
+        reset
+        reset_scope
+      end
+
+      # Returns the name of the table of the associated class:
+      #
+      #   post.comments.aliased_table_name # => "comments"
+      #
+      def aliased_table_name
+        klass.table_name
+      end
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+        @stale_state = nil
+        @inversed = false
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded = true
+        @stale_state = stale_state
+        @inversed = false
+      end
+
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # stale_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        !inversed && loaded? && @stale_state != stale_state
+      end
+
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+
+      def scope
+        target_scope.merge(association_scope)
+      end
+
+      # The scope for this association.
+      #
+      # Note that the association_scope is merged into the target_scope only when the
+      # scope method is called. This is because at that point the call may be surrounded
+      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
+      # actually gets built.
+      def association_scope
+        if klass
+          @association_scope ||= AssociationScope.scope(self, klass.connection)
+        end
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        if invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+          inverse.inversed = true
+        end
+        record
+      end
+
+      # Returns the class of the target. belongs_to polymorphic overrides this to look at the
+      # polymorphic_type field on the owner.
+      def klass
+        reflection.klass
+      end
+
+      # 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)
+      end
+
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # ActiveRecord::RecordNotFound is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      def load_target
+        @target = find_target if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        target
+      rescue ActiveRecord::RecordNotFound
+        reset
+      end
+
+      def interpolate(sql, record = nil)
+        if sql.respond_to?(:to_proc)
+          owner.instance_exec(record, &sql)
+        else
+          sql
+        end
+      end
+
+      # We can't dump @reflection since it contains the scope proc
+      def marshal_dump
+        ivars = (instance_variables - [:@reflection]).map { |name| [name, instance_variable_get(name)] }
+        [@reflection.name, ivars]
+      end
+
+      def marshal_load(data)
+        reflection_name, ivars = data
+        ivars.each { |name, val| instance_variable_set(name, val) }
+        @reflection = @owner.class._reflect_on_association(reflection_name)
+      end
+
+      def initialize_attributes(record) #:nodoc:
+        skip_assign = [reflection.foreign_key, reflection.type].compact
+        attributes = create_scope.except(*(record.changed - skip_assign))
+        record.assign_attributes(attributes)
+        set_inverse_instance(record)
+      end
+
+      private
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+
+        def creation_attributes
+          attributes = {}
+
+          if (reflection.has_one? || reflection.collection?) && !options[:through]
+            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+
+            if reflection.options[:as]
+              attributes[reflection.type] = owner.class.base_class.name
+            end
+          end
+
+          attributes
+        end
+
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          creation_attributes.each { |key, value| record[key] = value }
+        end
+
+        # Returns true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key). If the owner is a new record then foreign_key must
+        # be present in order to load target.
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to.
+        def foreign_key_present?
+          false
+        end
+
+        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch!(record)
+          unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
+            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveRecord::AssociationTypeMismatch, message
+          end
+        end
+
+        # Can be redefined by subclasses, notably polymorphic belongs_to
+        # The record parameter is necessary to support polymorphic inverses as we must check for
+        # the association in the specific class of the record.
+        def inverse_reflection_for(record)
+          reflection.inverse_of
+        end
+
+        # Returns true if inverse association on the given record needs to be set.
+        # This method is redefined by subclasses.
+        def invertible_for?(record)
+          foreign_key_for?(record) && inverse_reflection_for(record)
+        end
+
+        # Returns true if record contains the foreign_key
+        def foreign_key_for?(record)
+          record.has_attribute?(reflection.foreign_key)
+        end
+
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when stale_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns nil by default.
+        def stale_state
+        end
+
+        def build_record(attributes)
+          reflection.build_association(attributes) do |record|
+            initialize_attributes(record)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/associations/association_scope.rb

@@ -0,0 +1,194 @@
+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
+      end
+
+      def self.create(&block)
+        block = block ? block : lambda { |val| val }
+        new BindSubstitution.new(block)
+      end
+
+      def initialize(bind_substitution)
+        @bind_substitution = bind_substitution
+      end
+
+      INSTANCE = create
+
+      def scope(association, connection)
+        klass         = association.klass
+        reflection    = association.reflection
+        scope         = klass.unscoped
+        owner         = association.owner
+        alias_tracker = AliasTracker.empty connection
+
+        scope.extending! Array(reflection.options[:extend])
+        add_constraints(scope, owner, klass, reflection, alias_tracker)
+      end
+
+      def join_type
+        Arel::Nodes::InnerJoin
+      end
+
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        binds << last_reflection.join_id_for(owner)
+        if last_reflection.type
+          binds << owner.class.base_class.name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
+          if reflection.type
+            binds << next_reflection.klass.base_class.name
+          end
+        end
+        binds
+      end
+
+      private
+
+      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
+
+      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)
+        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))
+
+        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
+        end
+      end
+
+      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(assoc_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))
+        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
+
+        tables = construct_tables(chain, assoc_klass, refl, tracker)
+
+        owner_reflection = chain.last
+        table = tables.last
+        scope = last_chain_scope(scope, table, owner_reflection, owner, tracker, assoc_klass)
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          unless reflection == chain.last
+            next_reflection = chain[i + 1]
+            scope = next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+          end
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? assoc_klass : reflection.klass
+
+          # 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)
+
+            if scope_chain_item == refl.scope
+              scope.merge! item.except(:where, :includes, :bind)
+            end
+
+            if is_first_chain
+              scope.includes! item.includes_values
+            end
+
+            scope.where_values += item.where_values
+            scope.bind_values  += item.bind_values
+            scope.order_values |= item.order_values
+          end
+        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
+    end
+  end
+end