composite_primary_keys 0.3.3 → 0.6.0

data/CHANGELOG

@@ -1,3 +1,7 @@
+* 0.3.3 * - bug fixes
+  - id=
+  - create now work
+
 * 0.1.4 *
 	- it was important that #{primary_key} for composites --> 'key1,key2' and not 'key1key2'
 	  so created PrimaryKeys class

data/README

@@ -0,0 +1,16 @@
+
+Composite Primary Keys for ActiveRecords
+Summary:
+ActiveRecords/Rails famously doesn't support composite primary keys. 
+For 2 years there has been no support for this aspect of legacy databases. 
+This project will be a fully-featured solution and I welcome use cases and 
+legacy DB schema samples to help make the project work with as many common 
+legacy environments as possible.
+
+Url:
+http://compositekeys.rubyforge.org
+
+Questions and Discussion:
+http://groups.google.com/compositekeys
+
+Written by Dr Nic Williams, drnicwilliams@gmail

data/lib/composite_primary_keys/associations.rb

@@ -1,4 +1,329 @@
-module ActiveRecord
-  class Base
+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 #{table_name} "
+          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+          
+          add_joins!(sql, options, 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 << ")"
+          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] || table_name} "
+          sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+ 
+          add_joins!(sql, options, 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.table_name}.#{column}"}
+        end
+        
+        def quoted_table_columns(columns)
+          table_columns(columns).join(ID_SEP)
+        end
+        
+      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
+
+          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 row[join.aliased_primary_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
+    
+    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
+
+      def record_id(row)
+        active_record.composite? ?
+          aliased_primary_key.map {|key| row[key]}.to_composite_ids :
+          row[aliased_primary_key]
+      end
+
+      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
+    
+    class JoinAssociation < JoinBase
+      alias single_association_join association_join
+      def association_join
+        reflection.active_record.composite? ?
+          composite_association_join :
+          single_association_join
+      end
+      
+      def composite_association_join
+        join = case reflection.macro
+          when :has_and_belongs_to_many
+            " LEFT OUTER JOIN %s ON (%s) = (%s) " % [
+               table_alias_for(options[:join_table], aliased_join_table_name),
+               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) = (%s) " % [
+               table_name_and_alias, 
+               full_keys(aliased_table_name, klass.primary_key),
+               full_keys(aliased_join_table_name, options[:association_foreign_key] || klass.table_name.classify.foreign_key)
+               ]
+          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]))}" : ''
+                if through_reflection.options[:as] # has_many :through against a polymorphic join
+                  raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+                else
+                  if source_reflection.macro == :has_many && source_reflection.options[:as]
+                    raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+                  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
+                    
+                    " LEFT OUTER JOIN %s ON (%s) = (%s) "  % [
+                      table_alias_for(through_reflection.klass.table_name, aliased_join_table_name), 
+                      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) = (%s) " % [
+                      table_name_and_alias,
+                      full_keys(aliased_table_name, first_key), 
+                      full_keys(aliased_join_table_name, second_key)
+                    ]
+                  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"
+              else
+                foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
+                " LEFT OUTER JOIN %s ON (%s) = (%s) " % [
+                  table_name_and_alias,
+                  full_keys(aliased_table_name, foreign_key),
+                  full_keys(parent.aliased_table_name, parent.primary_key)
+                ]
+            end
+          when :belongs_to
+            " LEFT OUTER JOIN %s ON (%s) = (%s) " % [
+               table_name_and_alias, 
+               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.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)
+        keys.collect {|key| "#{table_name}.#{key}"}.join(CompositePrimaryKeys::ID_SEP)
+      end
+    end
+  end
+end
+
+module ActiveRecord::Associations
+  class AssociationProxy #:nodoc:
+    def full_keys(table_name, keys)
+      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
+      keys.is_a?(Array) ?
+        keys.collect {|key| "#{table_name}.#{key}"}.join(CompositePrimaryKeys::ID_SEP) :
+        "#{table_name}.#{keys}"
+    end
+    
+    def full_columns_equals(table_name, keys, quoted_ids)
+      keys = keys.split(CompositePrimaryKeys::ID_SEP) if keys.is_a?(String)
+      keys_ids = [keys, quoted_ids]
+      keys_ids = keys.is_a?(Symbol) ? [keys_ids] : keys_ids.transpose
+      keys_ids.collect {|key, id| "(#{table_name}.#{key} = #{id})"}.join(' AND ')
+    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.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
+            "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote @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
+  end
+  
+  class HasOneAssociation < BelongsToAssociation #:nodoc:
+    def construct_sql
+      case
+        when @reflection.options[:as]
+          @finder_sql = 
+            "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_id = #{@owner.quoted_id} AND " + 
+            "#{@reflection.klass.table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote @owner.class.base_class.name.to_s}"          
+        else
+          @finder_sql = "(%s) = (%s)" % [
+            full_keys(@reflection.table_name, @reflection.primary_key_name),
+            @owner.quoted_id
+          ]
+      end
+      @finder_sql << " AND (#{conditions})" if conditions
+    end
+  end
+  
+  class HasManyThroughAssociation < AssociationProxy #:nodoc:
+    def construct_conditions
+      conditions = if @reflection.through_reflection.options[:as]
+          "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.options[:as]}_id = #{@owner.quoted_id} " + 
+          "AND #{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.options[:as]}_type = #{@owner.class.quote @owner.class.base_class.name.to_s}"
+      else
+        @finder_sql = full_columns_equals(@reflection.through_reflection.table_name, 
+                                  @reflection.through_reflection.primary_key_name, @owner.quoted_id)
+      end
+      conditions << " AND (#{sql_conditions})" if sql_conditions
+      
+      return conditions
+    end
+    
+    def construct_joins(custom_joins = nil)          
+      polymorphic_join = nil
+      if @reflection.through_reflection.options[:as] || @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
+        if @reflection.source_reflection.options[:as]
+          polymorphic_join = "AND %s.%s = %s" % [
+            @reflection.table_name, "#{@reflection.source_reflection.options[:as]}_type",
+                @owner.class.quote(@reflection.through_reflection.klass.name)
+              ]
+            end
+          end
+
+          "INNER JOIN %s ON (%s) = (%s) %s #{@reflection.options[:joins]} #{custom_joins}" % [
+            @reflection.through_reflection.table_name,
+            full_keys(@reflection.table_name, reflection_primary_key),
+            full_keys(@reflection.through_reflection.table_name, source_primary_key),
+            polymorphic_join
+          ]
+    end
+    
+    def construct_sql
+      case
+        when @reflection.options[:finder_sql]
+          @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+          @finder_sql = "(%s) = (%s)" % [
+                          full_keys(@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
+  end
+end

data/lib/composite_primary_keys/base.rb

@@ -16,16 +16,15 @@ module CompositePrimaryKeys
     
       module ClassMethods
         def set_primary_keys(*keys)
-          keys = keys.first if keys.first.is_a?(Array) or keys.first.is_a?(CompositeKeys)
+          keys = keys.first if keys.first.is_a?(Array)
           cattr_accessor :primary_keys 
           self.primary_keys = keys.to_composite_keys
           
           class_eval <<-EOV
-            include CompositePrimaryKeys::ActiveRecord::Base::CompositeInstanceMethods
             extend CompositePrimaryKeys::ActiveRecord::Base::CompositeClassMethods
+            include CompositePrimaryKeys::ActiveRecord::Base::CompositeInstanceMethods
+            include CompositePrimaryKeys::ActiveRecord::Associations
           EOV
-          
-          #puts "#{self.class}-#{self}.composite = #{self.composite?}"
         end
         
         def composite?
@@ -75,19 +74,6 @@ module CompositePrimaryKeys
           id
         end
           
-        # Deletes the record in the database and freezes this instance to reflect that no changes should
-        # be made (since they can't be persisted).
-        def destroy
-          unless new_record?
-            connection.delete <<-end_sql, "#{self.class.name} Destroy"
-              DELETE FROM #{self.class.table_name}
-              WHERE (#{self.class.primary_key}) = (#{quoted_id})
-            end_sql
-          end
-  
-          freeze
-        end
-  
         # Returns a clone of the record that hasn't been assigned an id yet and
         # is treated as a new record.  Note that this is a "shallow" clone:
         # it copies the object's attributes only, not its associations.
@@ -171,20 +157,11 @@ module CompositePrimaryKeys
         end
         
       private
-        # Updates the associated record with values matching those of the instance attributes.
-        def update
-          connection.update(
-            "UPDATE #{self.class.table_name} " +
-            "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
-            "WHERE (#{self.class.primary_key}) = (#{id})",
-            "#{self.class.name} Update"
-          )
-          return true
-        end
-        
+        # The xx_without_callbacks methods are overwritten as that is the end of the alias chain
+      
         # Creates a new record with values matching those of the instance attributes.
-        def create
-          if self.id.nil?
+        def create_without_callbacks
+          unless self.id
             raise CompositeKeyError, "Composite keys do not generated ids from sequences, you must provide id values"
           end
   
@@ -195,11 +172,34 @@ module CompositePrimaryKeys
             "#{self.class.name} Create",
             self.class.primary_key, self.id
           )
-  
           @new_record = false
-          
           return true
         end
+        
+        # Updates the associated record with values matching those of the instance attributes.
+        def update_without_callbacks
+          connection.update(
+            "UPDATE #{self.class.table_name} " +
+            "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
+            "WHERE (#{self.class.primary_key}) = (#{id})",
+            "#{self.class.name} Update"
+          )
+          return true
+        end
+        
+        # Deletes the record in the database and freezes this instance to reflect that no changes should
+        # be made (since they can't be persisted).
+        def destroy_without_callbacks
+          unless new_record?
+            connection.delete <<-end_sql, "#{self.class.name} Destroy"
+              DELETE FROM #{self.class.table_name}
+              WHERE (#{self.class.primary_key}) = (#{quoted_id})
+            end_sql
+          end
+  
+          freeze
+        end
+  
       end
       
       module CompositeClassMethods

data/lib/composite_primary_keys/version.rb

@@ -1,8 +1,8 @@
 module CompositePrimaryKeys
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 3
-    TINY  = 3
+    MINOR = 6
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/associations_test.rb

@@ -21,11 +21,22 @@ class AssociationTest < Test::Unit::TestCase
     assert_not_nil @first_flat
   end
   
+  def test_quoted_table_columns
+    assert_equal "product_tariffs.product_id,product_tariffs.tariff_id,product_tariffs.tariff_start_date", 
+        ProductTariff.send(:quoted_table_columns, ProductTariff.primary_key)
+  end
+  
+  def test_count
+    assert_equal 2, Product.count(:include => :product_tariffs)
+    assert_equal 3, Tariff.count(:include => :product_tariffs)
+  end
+  
   def test_products
     assert_not_nil @first_product.product_tariffs
     assert_equal 2, @first_product.product_tariffs.length
     assert_not_nil @first_product.tariffs
     assert_equal 2, @first_product.tariffs.length
+    assert_not_nil @first_product.product_tariff
   end
   
   def test_product_tariffs
@@ -37,8 +48,39 @@ class AssociationTest < Test::Unit::TestCase
   
   def test_tariffs
     assert_not_nil @flat.product_tariffs
-    assert_equal 2, @flat.product_tariffs.length
+    assert_equal 1, @flat.product_tariffs.length
     assert_not_nil @flat.products
-    assert_equal 2, @flat.products.length
+    assert_equal 1, @flat.products.length
+    assert_not_nil @flat.product_tariff
+  end
+  
+  # Its not generating the instances of associated classes from the rows
+  def test_find_includes_products
+    assert @products = Product.find(:all, :include => :product_tariffs)
+    assert_equal 2, @products.length
+    assert_not_nil @products.first.instance_variable_get('@product_tariffs'), '@product_tariffs not set; should be array'
+    assert_equal 3, @products.inject(0) {|sum, tariff| sum + tariff.instance_variable_get('@product_tariffs').length}, "Incorrect number of product_tariffs returned"
   end
+  
+  def test_find_includes_tariffs
+    assert @tariffs = Tariff.find(:all, :include => :product_tariffs)
+    assert_equal 3, @tariffs.length
+    assert_not_nil @tariffs.first.instance_variable_get('@product_tariffs'), '@product_tariffs not set; should be array'
+    assert_equal 3, @tariffs.inject(0) {|sum, tariff| sum + tariff.instance_variable_get('@product_tariffs').length}, "Incorrect number of product_tariffs returned"
+  end
+  
+  def XXX_test_find_includes_extended
+    # TODO - what's the correct syntax?
+    assert @products = Product.find(:all, :include => {:product_tariffs => :tariffs})
+    assert_equal 3, @products.inject(0) {|sum, tariff| sum + tariff.instance_variable_get('@product_tariffs').length}, "Incorrect number of product_tariffs returned"
+    
+    assert @tariffs = Tariff.find(:all, :include => {:product_tariffs => :products})
+    assert_equal 3, @tariffs.inject(0) {|sum, tariff| sum + tariff.instance_variable_get('@product_tariffs').length}, "Incorrect number of product_tariffs returned"
+    
+  end
+  
+  #I'm also having problems when I use composite primary keys together with eager loading of associations. Here I'm doing
+#ArtistName.find(:all, :include => :artist, ...)
+# => ActiveRecord::StatementInvalid: Mysql::Error: Unknown column 'artists_names.artist_id,name' in 'field list': SELECT artists_names.`artist_id,name` AS t0_r0, ....
+# Had a brief look into it but couldn't spot the code causing this...
 end

data/test/fixtures/product.rb

@@ -1,5 +1,6 @@
 class Product < ActiveRecord::Base
 	set_primary_key :id  # redundant
 	has_many :product_tariffs, :foreign_key => :product_id
+	has_one :product_tariff, :foreign_key => :product_id
 	has_many :tariffs, :through => :product_tariffs, :foreign_key => :product_id
 end

data/test/fixtures/tariff.rb

@@ -1,4 +1,6 @@
 class Tariff < ActiveRecord::Base
 	set_primary_keys [:tariff_id, :start_date]
 	has_many :product_tariffs, :foreign_key => [:tariff_id, :tariff_start_date]
+	has_one :product_tariff, :foreign_key => [:tariff_id, :tariff_start_date]
+	has_many :products, :through => :product_tariffs, :foreign_key => [:tariff_id, :tariff_start_date]
 end

data/test/miscellaneous_test.rb

@@ -32,4 +32,9 @@ class MiscellaneousTest < Test::Unit::TestCase
       assert_equal composite?, @first.composite?
     end
   end
+  
+  def test_count
+    assert_equal 2, Product.count
+  end
+  
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: composite_primary_keys
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
-date: 2006-07-30 00:00:00 +02:00
+  version: 0.6.0
+date: 2006-08-02 00:00:00 +02:00
 summary: Support for composite primary keys in ActiveRecords
 require_paths: 
 - lib