composite_primary_keys 2.3.5.1 → 3.0.0.b2

data/lib/composite_primary_keys/associations.rb

@@ -1,429 +1,127 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Associations
-      def self.append_features(base)
-        super
-        base.send(:extend, ClassMethods)
-      end
-
-      # Composite key versions of Association functions
-      module ClassMethods
-
-        def construct_counter_sql_with_included_associations(options, join_dependency)
-          scope = scope(:find)
-          sql = "SELECT COUNT(DISTINCT #{quoted_table_columns(primary_key)})"
-
-          # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
-          if !self.connection.supports_count_distinct?
-            sql = "SELECT COUNT(*) FROM (SELECT DISTINCT #{quoted_table_columns(primary_key)}"
-          end
-          
-          sql << " FROM #{quoted_table_name} "
-          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
-
-          add_joins!(sql, options[:joins], scope)
-          add_conditions!(sql, options[:conditions], scope)
-          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
-
-          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
-
-          if !self.connection.supports_count_distinct?
-            sql << ")"
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      class JoinDependency
+        class JoinBase
+          def column_names_with_alias
+            unless defined?(@column_names_with_alias)
+              @column_names_with_alias = []
+              keys = active_record.composite? ? primary_key.map(&:to_s) : [primary_key]
+              (keys + (column_names - keys)).each_with_index do |column_name, i|
+                @column_names_with_alias << [column_name, "#{ aliased_prefix }_r#{ i }"]
+              end
+            end
+            @column_names_with_alias
           end
-
-          return sanitize_sql(sql)
         end
 
-        def construct_finder_sql_with_included_associations(options, join_dependency)
-          scope = scope(:find)
-          sql = "SELECT #{column_aliases(join_dependency)} FROM #{(scope && scope[:from]) || options[:from] || quoted_table_name} "
-          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
-
-          add_joins!(sql, options[:joins], scope)
-          add_conditions!(sql, options[:conditions], scope)
-          add_limited_ids_condition!(sql, options, join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && options[:limit]
-
-          sql << "ORDER BY #{options[:order]} " if options[:order]
-
-          add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
-
-          return sanitize_sql(sql)
-        end
-
-        def table_columns(columns)
-          columns.collect {|column| "#{self.quoted_table_name}.#{connection.quote_column_name(column)}"}
-        end
-
-        def quoted_table_columns(columns)
-          table_columns(columns).join(ID_SEP)
-        end
-
-      end
-
-    end
-  end
-end
-
-module ActiveRecord::Associations::ClassMethods
-  class JoinDependency
-    def construct_association(record, join, row)
-      case join.reflection.macro
-        when :has_many, :has_and_belongs_to_many
-          collection = record.send(join.reflection.name)
-          collection.loaded
+        class JoinAssociation
+          # Ugly to include this twice, but I couldn't figure out how to make this
+          # work via a module
+          def composite_join_predicates(table1, keys1, table2, keys2)
+            attributes1 = [keys1].flatten.map do |key|
+              table1[key]
+            end
 
-          join_aliased_primary_keys = join.active_record.composite? ?
-            join.aliased_primary_key : [join.aliased_primary_key]
-          return nil if
-            record.id.to_s != join.parent.record_id(row).to_s or not
-            join_aliased_primary_keys.select {|key| row[key].nil?}.blank?
-          association = join.instantiate(row)
-          collection.target.push(association) unless collection.target.include?(association)
-        when :has_one, :belongs_to
-          return if record.id.to_s != join.parent.record_id(row).to_s or
-                    [*join.aliased_primary_key].any? { |key| row[key].nil? }
-          association = join.instantiate(row)
-          record.send("set_#{join.reflection.name}_target", association)
-        else
-          raise ConfigurationError, "unknown macro: #{join.reflection.macro}"
-      end
-      return association
-    end
+            attributes2 = [keys2].flatten.map do |key|
+              table2[key]
+            end
 
-    class JoinBase
-      def aliased_primary_key
-        active_record.composite? ?
-          primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
-          "#{ aliased_prefix }_r0"
-      end
+            [attributes1, attributes2].transpose.map do |attribute1, attribute2|
+              attribute1.eq(attribute2)
+            end
+          end
 
-      def record_id(row)
-        active_record.composite? ?
-          aliased_primary_key.map {|key| row[key]}.to_composite_ids :
-          row[aliased_primary_key]
-      end
+          def association_join
+            return @join if @join
 
-      def column_names_with_alias
-        unless @column_names_with_alias
-          @column_names_with_alias = []
-          keys = active_record.composite? ? primary_key.map(&:to_s) : [primary_key]
-          (keys + (column_names - keys)).each_with_index do |column_name, i|
-            @column_names_with_alias << [column_name, "#{ aliased_prefix }_r#{ i }"]
-          end
-        end
-        return @column_names_with_alias
-      end
-    end
+            aliased_table = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
+            parent_table = Arel::Table.new(parent.table_name, :as => parent.aliased_table_name, :engine => arel_engine)
 
-    class JoinAssociation < JoinBase
-      alias single_association_join association_join
-      def association_join
-        reflection.active_record.composite? ? composite_association_join : single_association_join
-      end
+            @join = case reflection.macro
+            when :has_and_belongs_to_many
+              join_table = Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine)
+              fk = options[:foreign_key] || reflection.active_record.to_s.foreign_key
+              klass_fk = options[:association_foreign_key] || klass.to_s.foreign_key
 
-      def composite_association_join
-        join = case reflection.macro
-          when :has_and_belongs_to_many
-            " LEFT OUTER JOIN %s ON %s " % [
-              table_alias_for(options[:join_table], aliased_join_table_name),
-                composite_join_clause(
-                  full_keys(aliased_join_table_name, options[:foreign_key] || reflection.active_record.to_s.classify.foreign_key),
-                  full_keys(reflection.active_record.table_name, reflection.active_record.primary_key)
-                )
-              ] +
-             " LEFT OUTER JOIN %s ON %s " % [
-                table_name_and_alias,
-                composite_join_clause(
-                  full_keys(aliased_table_name, klass.primary_key),
-                  full_keys(aliased_join_table_name, options[:association_foreign_key] || klass.table_name.classify.foreign_key)
-                )
+              [
+                join_table[fk].eq(parent_table[reflection.active_record.primary_key]),
+                aliased_table[klass.primary_key].eq(join_table[klass_fk])
               ]
-          when :has_many, :has_one
-            case
-              when reflection.macro == :has_many && reflection.options[:through]
-                through_conditions = through_reflection.options[:conditions] ? "AND #{interpolate_sql(sanitize_sql(through_reflection.options[:conditions]))}" : ''
+            when :has_many, :has_one
+              if reflection.options[:through]
+                join_table = Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine)
+                jt_foreign_key = jt_as_extra = jt_source_extra = jt_sti_extra = nil
+                first_key = second_key = as_extra = nil
+
                 if through_reflection.options[:as] # has_many :through against a polymorphic join
-                  raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+                  jt_foreign_key = through_reflection.options[:as].to_s + '_id'
+                  jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].eq(parent.active_record.base_class.name)
                 else
-                  if source_reflection.macro == :has_many && source_reflection.options[:as]
-                    raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+                  jt_foreign_key = through_reflection.primary_key_name
+                end
+
+                case source_reflection.macro
+                when :has_many
+                  if source_reflection.options[:as]
+                    first_key   = "#{source_reflection.options[:as]}_id"
+                    second_key  = options[:foreign_key] || primary_key
+                    as_extra    = aliased_table["#{source_reflection.options[:as]}_type"].eq(source_reflection.active_record.base_class.name)
                   else
-                    case source_reflection.macro
-                      when :belongs_to
-                        first_key  = primary_key
-                        second_key = options[:foreign_key] || klass.to_s.classify.foreign_key
-                      when :has_many
-                        first_key  = through_reflection.klass.to_s.classify.foreign_key
-                        second_key = options[:foreign_key] || primary_key
-                    end
+                    first_key   = through_reflection.klass.base_class.to_s.foreign_key
+                    second_key  = options[:foreign_key] || primary_key
+                  end
 
-                    " LEFT OUTER JOIN %s ON %s "  % [
-                      table_alias_for(through_reflection.klass.table_name, aliased_join_table_name),
-                       composite_join_clause(
-                         full_keys(aliased_join_table_name, through_reflection.primary_key_name),
-                         full_keys(parent.aliased_table_name, parent.primary_key)
-                       )
-                     ] +
-                     " LEFT OUTER JOIN %s ON %s " % [
-                       table_name_and_alias,
-                       composite_join_clause(
-                         full_keys(aliased_table_name, first_key),
-                         full_keys(aliased_join_table_name, second_key)
-                       )
-                    ]
+                  unless through_reflection.klass.descends_from_active_record?
+                    jt_sti_extra = join_table[through_reflection.active_record.inheritance_column].eq(through_reflection.klass.sti_name)
+                  end
+                when :belongs_to
+                  first_key = primary_key
+                  if reflection.options[:source_type]
+                    second_key = source_reflection.association_foreign_key
+                    jt_source_extra = join_table[reflection.source_reflection.options[:foreign_type]].eq(reflection.options[:source_type])
+                  else
+                    second_key = source_reflection.primary_key_name
                   end
                 end
 
-              when reflection.macro == :has_many && reflection.options[:as]
-                raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
-              when reflection.macro == :has_one && reflection.options[:as]
-                raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+                [
+                  [parent_table[parent.primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra].reject{|x| x.blank? },
+                  aliased_table[first_key].eq(join_table[second_key])
+                ]
+              elsif reflection.options[:as]
+                id_rel = aliased_table["#{reflection.options[:as]}_id"].eq(parent_table[parent.primary_key])
+                type_rel = aliased_table["#{reflection.options[:as]}_type"].eq(parent.active_record.base_class.name)
+                [id_rel, type_rel]
               else
                 foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
-                primary_key = options[:primary_key] || parent.primary_key
-                " LEFT OUTER JOIN %s ON %s " % [
-                  table_name_and_alias,
-                  composite_join_clause(
-                    full_keys(aliased_table_name, foreign_key),
-                    full_keys(parent.aliased_table_name, primary_key)),
-                ]
+                # CPK
+                # [aliased_table[foreign_key].eq(parent_table[reflection.options[:primary_key] || parent.primary_key])]
+                composite_join_predicates(aliased_table, foreign_key,
+                                          parent_table, reflection.options[:primary_key] || parent.primary_key)
+              end
+            when :belongs_to
+              [aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.cpk_primary_key])]
             end
-          when :belongs_to
-            " LEFT OUTER JOIN %s ON %s " % [
-               table_name_and_alias,
-               composite_join_clause(
-                 full_keys(aliased_table_name, reflection.klass.primary_key),
-                 full_keys(parent.aliased_table_name, options[:foreign_key] || klass.to_s.foreign_key)),
-              ]
-          else
-            ""
-        end || ''
-        join << %(AND %s.%s = %s ) % [
-          aliased_table_name,
-          reflection.active_record.connection.quote_column_name(reflection.active_record.inheritance_column),
-          klass.connection.quote(klass.name)] unless klass.descends_from_active_record?
-        join << "AND #{interpolate_sql(sanitize_sql(reflection.options[:conditions]))} " if reflection.options[:conditions]
-        join
-      end
-
-      def full_keys(table_name, keys)
-        connection = reflection.active_record.connection
-        quoted_table_name = connection.quote_table_name(table_name)
-        if keys.is_a?(Array) 
-          keys.collect {|key| "#{quoted_table_name}.#{connection.quote_column_name(key)}"}.join(CompositePrimaryKeys::ID_SEP) 
-        else
-          "#{quoted_table_name}.#{connection.quote_column_name(keys)}"
-        end
-      end
-
-      def composite_join_clause(full_keys1, full_keys2)
-        full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
-        full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
-        where_clause = [full_keys1, full_keys2].transpose.map do |key1, key2|
-          "#{key1}=#{key2}"
-        end.join(" AND ")
-        "(#{where_clause})"
-      end
-    end
-  end
-end
-
-module ActiveRecord::Associations
-  class AssociationProxy #:nodoc:
-
-    def composite_where_clause(full_keys, ids)
-      full_keys = full_keys.split(CompositePrimaryKeys::ID_SEP) if full_keys.is_a?(String)
-
-      if ids.is_a?(String)
-        ids = [[ids]]
-      elsif not ids.first.is_a?(Array) # if single comp key passed, turn into an array of 1
-        ids = [ids.to_composite_ids]
-      end
-
-      where_clause = ids.map do |id_set|
-        transposed = id_set.size == 1 ? [[full_keys, id_set.first]] : [full_keys, id_set].transpose
-        transposed.map do |full_key, id|
-          "#{full_key.to_s}=#{@reflection.klass.sanitize(id)}"
-        end.join(" AND ")
-      end.join(") OR (")
-
-      "(#{where_clause})"
-    end
-
-    def composite_join_clause(full_keys1, full_keys2)
-      full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
-      full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
-
-      where_clause = [full_keys1, full_keys2].transpose.map do |key1, key2|
-        "#{key1}=#{key2}"
-      end.join(" AND ")
-
-      "(#{where_clause})"
-    end
-
-    def full_composite_join_clause(table1, full_keys1, table2, full_keys2)
-      connection = @reflection.active_record.connection
-      full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
-      full_keys2 = full_keys2.split(CompositePrimaryKeys::ID_SEP) if full_keys2.is_a?(String)
 
-      quoted1 = connection.quote_table_name(table1)
-      quoted2 = connection.quote_table_name(table2)
-      
-      where_clause = [full_keys1, full_keys2].transpose.map do |key_pair|
-        "#{quoted1}.#{connection.quote_column_name(key_pair.first)}=#{quoted2}.#{connection.quote_column_name(key_pair.last)}"
-      end.join(" AND ")
+            unless klass.descends_from_active_record?
+              sti_column = aliased_table[klass.inheritance_column]
+              sti_condition = sti_column.eq(klass.sti_name)
+              klass.send(:subclasses).each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
 
-      "(#{where_clause})"
-    end
-
-    def full_keys(table_name, keys)
-      connection = @reflection.active_record.connection
-      quoted_table_name = connection.quote_table_name(table_name)
-      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
-      if keys.is_a?(Array) 
-        keys.collect {|key| "#{quoted_table_name}.#{connection.quote_column_name(key)}"}.join(CompositePrimaryKeys::ID_SEP) 
-      else
-        "#{quoted_table_name}.#{connection.quote_column_name(keys)}"
-      end
-    end
-
-    def full_columns_equals(table_name, keys, quoted_ids)
-      connection = @reflection.active_record.connection
-      quoted_table_name = connection.quote_table_name(table_name)
-      if keys.is_a?(Symbol) or (keys.is_a?(String) and keys == keys.to_s.split(CompositePrimaryKeys::ID_SEP))
-        return "#{quoted_table_name}.#{connection.quote_column_name(keys)} = #{quoted_ids}"
-      end
-      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
-      quoted_ids = quoted_ids.split(CompositePrimaryKeys::ID_SEP) if quoted_ids.is_a?(String)
-      keys_ids = [keys, quoted_ids].transpose
-      keys_ids.collect {|key, id| "(#{quoted_table_name}.#{connection.quote_column_name(key)} = #{id})"}.join(' AND ')
-    end 
-
-    def set_belongs_to_association_for(record)
-      if @reflection.options[:as]
-        record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
-        record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
-      else
-        key_values = @reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP).zip([@owner.id].flatten)
-        key_values.each{|key, value| record[key] = value} unless @owner.new_record?
-      end
-    end
-  end
-
-  class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-    def construct_sql
-      @reflection.options[:finder_sql] &&= interpolate_sql(@reflection.options[:finder_sql])
-
-      if @reflection.options[:finder_sql]
-        @finder_sql = @reflection.options[:finder_sql]
-      else
-        @finder_sql = full_columns_equals(@reflection.options[:join_table], @reflection.primary_key_name, @owner.quoted_id)
-        @finder_sql << " AND (#{conditions})" if conditions
-      end
-
-      @join_sql = "INNER JOIN #{@reflection.active_record.connection.quote_table_name(@reflection.options[:join_table])} ON " +
-      full_composite_join_clause(@reflection.klass.table_name, @reflection.klass.primary_key, @reflection.options[:join_table], @reflection.association_foreign_key)
-    end
-  end
-
-  class HasManyAssociation < AssociationCollection #:nodoc:
-    def construct_sql
-      case
-        when @reflection.options[:finder_sql]
-          @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
-
-        when @reflection.options[:as]
-          @finder_sql = 
-            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
-            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-          @finder_sql << " AND (#{conditions})" if conditions
-
-        else
-          @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, owner_quoted_id)
-          @finder_sql << " AND (#{conditions})" if conditions
-      end
-
-      if @reflection.options[:counter_sql]
-        @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-      elsif @reflection.options[:finder_sql]
-        # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
-        @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
-        @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-      else
-        @counter_sql = @finder_sql
-      end
-    end
-
-    def delete_records(records)
-      if @reflection.options[:dependent]
-        records.each { |r| r.destroy }
-      else
-        connection = @reflection.active_record.connection
-        field_names = @reflection.primary_key_name.split(',')
-        field_names.collect! {|n| connection.quote_column_name(n) + " = NULL"}
-        records.each do |r|
-          where_clause = nil
-          
-          if r.quoted_id.to_s.include?(CompositePrimaryKeys::ID_SEP)
-            where_clause_terms = [@reflection.klass.primary_key, r.quoted_id].transpose.map do |pair|
-              "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
+              @join << sti_condition
             end
-            where_clause = where_clause_terms.join(" AND ")
-          else
-            where_clause = connection.quote_column_name(@reflection.klass.primary_key) + ' = ' +  r.quoted_id
-          end
-          
-          @reflection.klass.update_all(  field_names.join(',') , where_clause)
-        end
-      end
-    end
-  end
 
-  class HasOneAssociation < BelongsToAssociation #:nodoc:
-    def construct_sql
-      case
-        when @reflection.options[:as]
-          @finder_sql = 
-            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
-            "#{@reflection.klass.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-        else
-          @finder_sql = full_columns_equals(@reflection.klass.table_name, @reflection.primary_key_name, owner_quoted_id)
-      end
-
-      @finder_sql << " AND (#{conditions})" if conditions
-    end
-  end
-
-  class HasManyThroughAssociation < HasManyAssociation #:nodoc:
-    def construct_conditions_with_composite_keys
-      if @reflection.through_reflection.options[:as]
-        construct_conditions_without_composite_keys
-      else
-        conditions = full_columns_equals(@reflection.through_reflection.table_name, @reflection.through_reflection.primary_key_name, @owner.quoted_id)
-        conditions << " AND (#{sql_conditions})" if sql_conditions
-        conditions
-      end
-    end
-    alias_method_chain :construct_conditions, :composite_keys
+            [through_reflection, reflection].each do |ref|
+              if ref && ref.options[:conditions]
+                @join << interpolate_sql(sanitize_sql(ref.options[:conditions], aliased_table_name))
+              end
+            end
 
-    def construct_joins_with_composite_keys(custom_joins = nil)
-      if @reflection.through_reflection.options[:as] || @reflection.source_reflection.options[:as]
-        construct_joins_without_composite_keys(custom_joins)
-      else
-        if @reflection.source_reflection.macro == :belongs_to
-          reflection_primary_key = @reflection.klass.primary_key
-          source_primary_key     = @reflection.source_reflection.primary_key_name
-        else
-          reflection_primary_key = @reflection.source_reflection.primary_key_name
-          source_primary_key     = @reflection.klass.primary_key
+            @join
+          end
         end
-
-        "INNER JOIN %s ON %s #{@reflection.options[:joins]} #{custom_joins}" % [
-          @reflection.through_reflection.quoted_table_name,
-          composite_join_clause(full_keys(@reflection.table_name, reflection_primary_key), full_keys(@reflection.through_reflection.table_name, source_primary_key))
-        ]
       end
     end
-    alias_method_chain :construct_joins, :composite_keys
   end
-end
+end