globe-composite_primary_keys 3.0.1

data/lib/adapter_helper/base.rb

@@ -0,0 +1,63 @@
+module AdapterHelper
+  class Base
+    class << self
+      attr_accessor :adapter
+
+      def load_connection_from_env(adapter)
+        self.adapter = adapter
+        unless ENV['cpk_adapters']
+          puts error_msg_setup_helper
+          exit
+        end
+
+        ActiveRecord::Base.configurations = YAML.load(ENV['cpk_adapters'])
+        unless spec = ActiveRecord::Base.configurations[adapter]
+          puts error_msg_adapter_helper
+          exit
+        end
+        spec[:adapter] = adapter
+        spec
+      end
+    
+      def error_msg_setup_helper
+        <<-EOS
+Setup Helper:
+  CPK now has a place for your individual testing configuration.
+  That is, instead of hardcoding it in the Rakefile and test/connections files,
+  there is now a local/database_connections.rb file that is NOT in the
+  repository. Your personal DB information (username, password etc) can
+  be stored here without making it difficult to submit patches etc.
+
+Installation:
+  i)   cp locals/database_connections.rb.sample locals/database_connections.rb
+  ii)  For #{adapter} connection details see "Adapter Setup Helper" below.
+  iii) Rerun this task
+  
+#{error_msg_adapter_helper}
+  
+Current ENV:
+  #{ENV.inspect}
+        EOS
+      end
+        
+      def error_msg_adapter_helper
+        <<-EOS
+Adapter Setup Helper:
+  To run #{adapter} tests, you need to setup your #{adapter} connections.
+  In your local/database_connections.rb file, within the ENV['cpk_adapter'] hash, add:
+      "#{adapter}" => { adapter settings }
+
+  That is, it will look like:
+    ENV['cpk_adapters'] = {
+      "#{adapter}" => {
+        :adapter  => "#{adapter}",
+        :username => "root",
+        :password => "root",
+        # ...
+      }
+    }.to_yaml
+        EOS
+      end
+    end
+  end
+end

data/lib/adapter_helper/mysql.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class MySQL < Base
+    class << self
+      def load_connection_from_env
+        spec = super('mysql')
+        spec[:database] ||= 'composite_primary_keys_unittest'
+        spec
+      end
+    end
+  end
+end

data/lib/adapter_helper/oracle.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class Oracle < Base
+    class << self
+      def load_connection_from_env
+        spec = super('oracle')
+        spec
+      end
+    end
+  end
+end

data/lib/adapter_helper/oracle_enhanced.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class OracleEnhanced < Base
+    class << self
+      def load_connection_from_env
+        spec = super('oracle_enhanced')
+        spec
+      end
+    end
+  end
+end

data/lib/adapter_helper/postgresql.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class Postgresql < Base
+    class << self
+      def load_connection_from_env
+        spec = super('postgresql')
+        spec[:database] ||= 'composite_primary_keys_unittest'
+        spec
+      end
+    end
+  end
+end

data/lib/adapter_helper/sqlite3.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module AdapterHelper
+  class Sqlite3 < Base
+    class << self
+      def load_connection_from_env
+        spec = super('sqlite3')
+        spec[:dbfile] ||= "tmp/test.db"
+        spec
+      end
+    end
+  end
+end

data/lib/composite_primary_keys.rb

@@ -0,0 +1,63 @@
+#--
+# Copyright (c) 2006 Nic Williams
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+unless defined?(ActiveRecord)
+  begin
+    require 'active_record'  
+  rescue LoadError
+    require 'rubygems'
+    require_gem 'activerecord'
+  end
+end
+
+require 'active_record/associations.rb'
+require 'active_record/associations/association_collection'
+require 'active_record/associations/association_proxy'
+require 'active_record/associations/belongs_to_association'
+require 'active_record/associations/belongs_to_polymorphic_association'
+require 'active_record/associations/has_and_belongs_to_many_association'
+require 'active_record/associations/has_many_association'
+require 'active_record/associations/has_one_association'
+require 'active_record/associations/has_one_through_association'
+
+require 'composite_primary_keys/fixtures'
+require 'composite_primary_keys/composite_arrays'
+require 'composite_primary_keys/associations'
+require 'composite_primary_keys/through_association_scope'
+require 'composite_primary_keys/association_preload'
+require 'composite_primary_keys/reflection'
+require 'composite_primary_keys/relation'
+require 'composite_primary_keys/read'
+require 'composite_primary_keys/finder_methods'
+require 'composite_primary_keys/base'
+require 'composite_primary_keys/validations/uniqueness'
+
+Dir[File.dirname(__FILE__) + '/composite_primary_keys/connection_adapters/*.rb'].each do |adapter|
+  begin
+    require adapter.gsub('.rb','')
+  rescue MissingSourceFile
+  end
+end

data/lib/composite_primary_keys/association_preload.rb

@@ -0,0 +1,162 @@
+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(["', '"] * (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 = reflection.cpk_primary_key.map{|k| record.send(k)}
+              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

@@ -0,0 +1,159 @@
+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_key = @reflection.options[:primary_key] || :id
+            # CPK
+            # record[@reflection.primary_key_name] = @owner.send(primary_key)
+            values = [@owner.send(primary_key)].flatten
+            key_values = @reflection.cpk_primary_key.zip(values)
+            key_values.each {|key, value| record[key] = value}
+          end
+        end
+      end
+    end
+
+    class HasAndBelongsToManyAssociation
+      def construct_sql
+        if @reflection.options[:finder_sql]
+          @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+        else
+          # CPK
+          # @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{owner_quoted_id} "
+          @finder_sql = full_columns_equals(@reflection.options[:join_table], @reflection.cpk_primary_key, owner_quoted_id)
+          @finder_sql << " AND (#{conditions})" if conditions
+        end
+
+        join_condition = if composite?
+          conditions = Array.new
+          primary_keys.length.times do |i|
+            conditions << "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key[i]} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key[i]}"
+          end
+          conditions.join(' AND ')
+        else
+          "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
+        end
+        #@join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
+        @join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON (#{join_condition})"
+
+        construct_counter_sql
+      end
+    end
+
+    class HasManyAssociation
+      def construct_sql
+        case
+          when @reflection.options[:finder_sql]
+            @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+          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)}"
+            @finder_sql << " AND (#{conditions})" if conditions
+
+          else
+            # CPK
+            # @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
+            @finder_sql = full_columns_equals(@reflection.quoted_table_name, @reflection.cpk_primary_key, owner_quoted_id)
+            @finder_sql << " AND (#{conditions})" if conditions
+        end
+
+        construct_counter_sql
+      end
+
+      # Deletes the records according to the <tt>:dependent</tt> option.
+      def delete_records(records)
+        case @reflection.options[:dependent]
+          when :destroy
+            records.each { |r| r.destroy }
+          when :delete_all
+            @reflection.klass.delete(records.map { |record| record.id })
+          else
+            relation = Arel::Table.new(@reflection.table_name)
+            # CPK
+            # relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
+            #    and(Arel::Predicates::In.new(relation[@reflection.klass.primary_key], records.map(&:id)))
+            # ).update(relation[@reflection.primary_key_name] => nil)
+            id_predicate = nil
+            owner_key_values = @reflection.cpk_primary_key.zip([@owner.id].flatten)
+            owner_key_values.each do |key, value|
+              eq = relation[key].eq(value)
+              id_predicate = id_predicate ? id_predicate.and(eq) : eq
+            end
+
+            record_predicates = nil
+            records.each do |record|
+              keys = [@reflection.klass.primary_key].flatten
+              values = [record.id].flatten
+
+              record_predicate = nil
+              keys.zip(values).each do |key, value|
+                eq = relation[key].eq(value)
+                record_predicate = record_predicate ? record_predicate.and(eq) : eq
+              end
+              record_predicates = record_predicates ? record_predicates.or(record_predicate) : record_predicate
+            end
+
+            relation = relation.where(id_predicate.and(record_predicates))
+
+            nullify = @reflection.cpk_primary_key.inject(Hash.new) do |hash, key|
+              hash[relation[key]] = nil
+              hash
+            end
+
+            relation.update(nullify)
+
+            @owner.class.update_counters(@owner.id, cached_counter_attribute_name => -records.size) if has_cached_counter?
+        end
+      end
+    end
+
+    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.quoted_table_name, @reflection.cpk_primary_key, owner_quoted_id)
+        end
+        @finder_sql << " AND (#{conditions})" if conditions
+      end
+    end
+
+    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
+      end
+    end
+  end
+end