composite_primary_keys 3.1.11 → 4.0.0.beta1

data/lib/composite_primary_keys/association_preload.rb

@@ -1,158 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module AssociationPreload
-      def self.append_features(base)
-        super
-        base.send(:extend, ClassMethods)
-      end
-
-      # Composite key versions of Association functions
-      module ClassMethods
-        def preload_has_and_belongs_to_many_association(records, reflection, preload_options={})
-          table_name = reflection.klass.quoted_table_name
-          id_to_record_map, ids = construct_id_map(records)
-          records.each {|record| record.send(reflection.name).loaded}
-          options = reflection.options
-
-          if composite?
-            where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
-              "(" + keys.map{|key| "t0.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
-            end.join(" OR ")
-
-            conditions = [where, ids].flatten
-            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{full_composite_join_clause(reflection, reflection.klass.table_name, reflection.klass.primary_key, 't0', reflection.association_foreign_key)}"
-            parent_primary_keys = reflection.cpk_primary_key.map{|k| "t0.#{connection.quote_column_name(k)}"}
-            concat_arr = parent_primary_keys.zip(["'#{CompositePrimaryKeys::ID_SEP}'"] * (parent_primary_keys.size - 1)).flatten.compact
-            parent_record_id = connection.concat(*concat_arr)
-          else
-            conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
-            conditions << append_conditions(reflection, preload_options)
-            conditions = [conditions, ids]
-            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}"
-            parent_record_id = reflection.primary_key_name
-         end
-
-        associated_records = reflection.klass.unscoped.where(conditions).
-            includes(options[:include]).
-            joins(joins).
-            select("#{options[:select] || table_name+'.*'}, #{parent_record_id} as the_parent_record_id").
-            order(options[:order]).to_a
-
-          set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'the_parent_record_id')
-        end
-
-        def preload_belongs_to_association(records, reflection, preload_options={})
-          return if records.first.send("loaded_#{reflection.name}?")
-          options = reflection.options
-          
-          ids = Array.new
-          
-          if options[:polymorphic]
-            # CPK
-            #polymorph_type = options[:foreign_type]
-            #klasses_and_ids = {}
-
-            # Construct a mapping from klass to a list of ids to load and a mapping of those ids back to their parent_records
-            #records.each do |record|
-            #  if klass = record.send(polymorph_type)
-            #    klass_id = record.send(primary_key_name)
-            #    if klass_id
-            #      id_map = klasses_and_ids[klass] ||= {}
-            #      id_list_for_klass_id = (id_map[klass_id.to_s] ||= [])
-            #      id_list_for_klass_id << record
-            #    end
-            #  end
-            #end
-            #klasses_and_ids = klasses_and_ids.to_a
-            raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
-          else
-            # I need to keep the original ids for each record (as opposed to the stringified) so
-            # that they get properly converted for each db so the id_map ends up looking like:
-            #
-            # { '1,2' => {:id => [1,2], :records => [...records...]}}
-            id_map = {}
-
-            records.each do |record|
-              keys = record[reflection.cpk_primary_key]
-              ids << keys
-
-              mapped_records = (id_map[keys.to_s] ||= [])
-              mapped_records << record
-            end
-
-            klasses_and_ids = [[reflection.klass.name, id_map]]
-          end
-
-          klasses_and_ids.each do |klass_and_id|
-            klass_name, id_map = *klass_and_id
-            next if id_map.empty?
-            klass = klass_name.constantize
-
-            table_name = klass.quoted_table_name
-            primary_key = [reflection.options[:primary_key] || klass.primary_key].flatten
-
-            # CPK
-            conditions = id_map.map do |key, value|
-              "(" +
-              primary_key.map do |key|
-                "#{table_name}.#{connection.quote_column_name(key)} = ?"
-              end.join(' AND ') + ")"
-            end.join(' OR ')
-
-            conditions << append_conditions(reflection, preload_options)
-
-            conditions = [conditions] + ids.uniq.flatten
-
-            associated_records = klass.unscoped.where(conditions).apply_finder_options(options.slice(:include, :select, :joins, :order)).to_a
-
-            set_association_single_records(id_map, reflection.name, associated_records, primary_key)
-          end
-        end
-        
-        def find_associated_records(ids, reflection, preload_options)
-          options = reflection.options
-          table_name = reflection.klass.quoted_table_name
-
-          if interface = reflection.options[:as]
-            conditions = "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_id"} #{in_or_equals_for_ids(ids)} and #{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_type"} = '#{self.base_class.sti_name}'"
-          else
-            foreign_key = reflection.cpk_primary_key
-
-            where = (foreign_key * ids.size).in_groups_of(foreign_key.size).map do |keys|
-              "(" + keys.map{|key| "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
-            end.join(" OR ")
-
-            conditions = [where, ids].flatten
-          end
-
-          conditions[0] << append_conditions(reflection, preload_options)
-
-          find_options = {
-            :select => preload_options[:select] || options[:select] || "#{table_name}.*",
-            :include => preload_options[:include] || options[:include],
-            # CPK
-            # :conditions => [conditions, ids],
-            :conditions => conditions,
-            :joins => options[:joins],
-            :group => preload_options[:group] || options[:group],
-            :order => preload_options[:order] || options[:order]
-          }
-
-          reflection.klass.unscoped.apply_finder_options(find_options).to_a
-        end
-
-        def full_composite_join_clause(reflection, 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)
-          where_clause = [full_keys1, full_keys2].transpose.map do |key_pair|
-            quoted1 = connection.quote_table_name(table1)
-            quoted2 = connection.quote_table_name(table2)
-            "#{quoted1}.#{connection.quote_column_name(key_pair.first)}=#{quoted2}.#{connection.quote_column_name(key_pair.last)}"
-          end.join(" AND ")
-          "(#{where_clause})"
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/associations.rb

@@ -1,155 +0,0 @@
-module ActiveRecord
-  module Associations
-    module ClassMethods
-      class JoinDependency
-        class JoinBase
-          def aliased_primary_key
-            # CPK
-            # "#{aliased_prefix}_r0"
-
-            active_record.composite? ?
-              primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
-              "#{ aliased_prefix }_r0"
-          end
-
-          def record_id(row)
-            # CPK
-            # row[aliased_primary_key]
-            active_record.composite? ?
-              aliased_primary_key.map {|key| row[key]}.to_composite_keys :
-              row[aliased_primary_key]
-          end
-
-          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
-        end
-
-        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
-
-            attributes2 = [keys2].flatten.map do |key|
-              table2[key]
-            end
-
-            [attributes1, attributes2].transpose.map do |attribute1, attribute2|
-              attribute1.eq(attribute2)
-            end
-          end
-
-          def association_join
-            return @join if @join
-
-            aliased_table = Arel::Table.new(table_name, :as      => @aliased_table_name,
-                                                        :engine  => arel_engine,
-                                                        :columns => klass.columns)
-
-            parent_table = Arel::Table.new(parent.table_name, :as      => parent.aliased_table_name,
-                                                              :engine  => arel_engine,
-                                                              :columns => parent.active_record.columns)
-
-            @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
-
-              [
-                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
-              if reflection.options[:through]
-                join_table = Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine)
-                jt_as_extra = jt_source_extra = jt_sti_extra = nil
-                first_key = second_key = as_extra = nil
-
-                if through_reflection.macro == :belongs_to
-                  jt_primary_key = through_reflection.primary_key_name
-                  jt_foreign_key = through_reflection.association_primary_key
-                else
-                  jt_primary_key = through_reflection.active_record_primary_key
-                  jt_foreign_key = through_reflection.primary_key_name
-
-                  if through_reflection.options[:as] # has_many :through against a polymorphic join
-                    jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].eq(parent.active_record.base_class.name)
-                  end
-                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
-                    first_key   = through_reflection.klass.base_class.to_s.foreign_key
-                    second_key  = options[:foreign_key] || primary_key
-                  end
-
-                  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
-
-                [
-                  [parent_table[jt_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
-                # 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.primary_key_name])]
-              composite_join_predicates(aliased_table, options[:primary_key] || reflection.klass.primary_key, parent_table, options[:foreign_key] || reflection.primary_key_name)
-            end
-
-            unless klass.descends_from_active_record?
-              sti_column = aliased_table[klass.inheritance_column]
-              sti_condition = sti_column.eq(klass.sti_name)
-              klass.descendants.each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
-
-              @join << sti_condition
-            end
-
-            [through_reflection, reflection].each do |ref|
-              if ref && ref.options[:conditions]
-                @join << process_conditions(ref.options[:conditions], aliased_table_name)
-              end
-            end
-
-            @join
-          end
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/associations/association_proxy.rb

@@ -1,33 +0,0 @@
-module ActiveRecord
-  module Associations
-    class AssociationProxy
-      def full_columns_equals(table_name, keys, quoted_ids)
-        quoted_table_name = @owner.connection.quote_table_name(table_name)
-
-        keys = [keys].flatten
-        ids = [quoted_ids].flatten
-
-        [keys,ids].transpose.map do |key, id|
-        "(#{quoted_table_name}.#{@owner.connection.quote_column_name(key)} = #{id})"
-        end.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
-          unless @owner.new_record?
-            primary_keys = Array(@reflection.options[:primary_key] || :id)
-            # CPK
-            # record[@reflection.primary_key_name] = @owner.send(primary_key)
-            # Need to flatten because a key may be :id giving a composite key
-            values = primary_keys.map {|key| @owner.send(key)}.flatten
-            key_values = @reflection.cpk_primary_key.zip(values)
-            key_values.each {|key, value| record[key] = value}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/associations/has_one_association.rb

@@ -1,27 +0,0 @@
-module ActiveRecord
-  module Associations
-    class HasOneAssociation
-      def construct_sql
-        case
-          when @reflection.options[:as]
-            @finder_sql =
-              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id} AND " +
-              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-          else
-            # CPK
-            #@finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-            @finder_sql = full_columns_equals(@reflection.table_name, @reflection.cpk_primary_key, owner_quoted_id)
-        end
-        @finder_sql << " AND (#{conditions})" if conditions
-      end
-
-      def owner_quoted_id
-        if (keys = @reflection.options[:primary_key])
-          keys.is_a?(Array) ? keys.collect {|k| @owner.class.quote_value(@owner.send(k)) } : @owner.class.quote_value(@owner.send(keys))
-        else
-          @owner.quoted_id
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/associations/through_association_scope.rb

@@ -1,103 +0,0 @@
-module ActiveRecord
-  module Associations
-    module ThroughAssociationScope
-      def composite_join_clause(table1, keys1, table2, keys2)
-        predicates = composite_join_predicates(table1, keys1, table2, keys2)
-
-        join_clause = predicates.map do |predicate|
-          predicate.to_sql
-        end.join(" AND ")
-
-        "(#{join_clause})"
-      end
-
-      def composite_join_predicates(table1, keys1, table2, keys2)
-        attributes1 = [keys1].flatten.map do |key|
-          table1[key]
-        end
-
-        attributes2 = [keys2].flatten.map do |key|
-          table2[key]
-        end
-
-        [attributes1, attributes2].transpose.map do |attribute1, attribute2|
-          attribute1.eq(attribute2)
-        end
-      end
-
-      def composite_ids_hash(keys, ids)
-        [keys].flatten.zip([ids].flatten).inject(Hash.new) do |hash, (key, value)|
-          hash[key] = value
-          hash
-        end
-      end
-      
-      def construct_quoted_owner_attributes(reflection)
-        if as = reflection.options[:as]
-          { "#{as}_id" => owner_quoted_id,
-            "#{as}_type" => reflection.klass.quote_value(
-              @owner.class.base_class.name.to_s,
-              reflection.klass.columns_hash["#{as}_type"]) }
-        elsif reflection.macro == :belongs_to
-          # CPK
-          # { reflection.klass.primary_key => @owner[reflection.primary_key_name] }
-          composite_ids_hash(reflection.klass.primary_key, @owner.quoted_id)
-        else
-          # CPK
-         #{ reflection.primary_key_name => owner_quoted_id }
-          composite_ids_hash(reflection.cpk_primary_key, @owner.quoted_id)
-        end
-      end
-
-      # Construct attributes for associate pointing to owner.
-      def construct_owner_attributes(reflection)
-        if as = reflection.options[:as]
-          { "#{as}_id" => @owner.id,
-            "#{as}_type" => @owner.class.base_class.name.to_s }
-        else
-          # CPK
-          # { reflection.primary_key_name => @owner.id }
-          composite_ids_hash(reflection.cpk_primary_key, @owner.id)
-        end
-      end
-
-      def construct_joins(custom_joins = nil)
-        polymorphic_join = nil
-        if @reflection.source_reflection.macro == :belongs_to
-          reflection_primary_key = @reflection.klass.primary_key
-          source_primary_key     = @reflection.source_reflection.cpk_primary_key
-          if @reflection.options[:source_type]
-            polymorphic_join = "AND %s.%s = %s" % [
-              @reflection.through_reflection.quoted_table_name, "#{@reflection.source_reflection.options[:foreign_type]}",
-              @owner.class.quote_value(@reflection.options[:source_type])
-            ]
-          end
-        else
-          reflection_primary_key = @reflection.source_reflection.cpk_primary_key
-          source_primary_key     = @reflection.through_reflection.klass.primary_key
-          if @reflection.source_reflection.options[:as]
-            polymorphic_join = "AND %s.%s = %s" % [
-              @reflection.quoted_table_name, "#{@reflection.source_reflection.options[:as]}_type",
-              @owner.class.quote_value(@reflection.through_reflection.klass.name)
-            ]
-          end
-        end
-
-        # CPK
-        # "INNER JOIN %s ON %s.%s = %s.%s %s #{@reflection.options[:joins]} #{custom_joins}" % [
-        #   @reflection.through_reflection.quoted_table_name,
-        #   @reflection.quoted_table_name, reflection_primary_key,
-        #   @reflection.through_reflection.quoted_table_name, source_primary_key,
-        #   polymorphic_join
-        # ]
-
-        "INNER JOIN %s ON %s %s #{@reflection.options[:joins]} #{custom_joins}" % [
-            @reflection.through_reflection.quoted_table_name,
-            composite_join_clause(@reflection.klass.arel_table, reflection_primary_key,
-                                  @reflection.through_reflection.klass.arel_table, source_primary_key),
-            polymorphic_join
-          ]
-      end
-    end
-  end
-end