composite_primary_keys 2.3.5.1 → 3.0.0.b2

data/lib/composite_primary_keys/associations/association_proxy.rb

@@ -0,0 +1,32 @@
+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
+  end
+end

data/lib/composite_primary_keys/associations/has_and_belongs_to_many_association.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module Associations
+    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
+  end
+end

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -0,0 +1,72 @@
+module ActiveRecord
+  module Associations
+    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
+  end
+end

data/lib/composite_primary_keys/associations/has_one_association.rb

@@ -0,0 +1,19 @@
+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.quoted_table_name, @reflection.cpk_primary_key, owner_quoted_id)
+        end
+        @finder_sql << " AND (#{conditions})" if conditions
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/through_association_scope.rb

@@ -0,0 +1,103 @@
+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

data/lib/composite_primary_keys/base.rb

@@ -1,343 +1,186 @@
-module CompositePrimaryKeys
-  module ActiveRecord #:nodoc:
-    class CompositeKeyError < StandardError #:nodoc:
-    end
-
-    module Base #:nodoc:
-
-      INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
-      NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
+module ActiveRecord
+  class CompositeKeyError < StandardError #:nodoc:
+  end
 
-      def self.append_features(base)
-        super
-        base.send(:include, InstanceMethods)
-        base.extend(ClassMethods)
-      end
+  class Base
+    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
 
-      module ClassMethods
-        def set_primary_keys(*keys)
-          keys = keys.first if keys.first.is_a?(Array)
-          keys = keys.map { |k| k.to_sym }
-          cattr_accessor :primary_keys
-          self.primary_keys = keys.to_composite_keys
+    class << self
+      def set_primary_keys(*keys)
+        keys = keys.first if keys.first.is_a?(Array)
 
-          class_eval <<-EOV
-            extend CompositeClassMethods
-            include CompositeInstanceMethods
+        if keys.length == 1
+          set_primary_key(keys.first)
+          return
+        end
 
-            include CompositePrimaryKeys::ActiveRecord::Associations
-            include CompositePrimaryKeys::ActiveRecord::AssociationPreload
-            include CompositePrimaryKeys::ActiveRecord::Calculations
-            include CompositePrimaryKeys::ActiveRecord::AttributeMethods
+        cattr_accessor :primary_keys
+        self.primary_keys = keys.map { |k| k.to_sym }
 
-            extend CompositePrimaryKeys::ActiveRecord::Validations::Uniqueness::ClassMethods
-          EOV
-        end
+        class_eval <<-EOV
+          extend CompositeClassMethods
+          include CompositeInstanceMethods
+          include CompositePrimaryKeys::ActiveRecord::AssociationPreload
+        EOV
 
-        def composite?
-          false
+        class << unscoped
+          include CompositePrimaryKeys::ActiveRecord::FinderMethods::InstanceMethods
+          include CompositePrimaryKeys::ActiveRecord::Relation::InstanceMethods
         end
       end
 
-      module InstanceMethods
-        def composite?; self.class.composite?; end
+      def composite?
+        false
       end
+    end
 
-      module CompositeInstanceMethods
-
-        # A model instance's primary keys is always available as model.ids
-        # whether you name it the default 'id' or set it to something else.
-        def id
-          attr_names = self.class.primary_keys
-          CompositeIds.new(attr_names.map { |attr_name| read_attribute(attr_name) })
-        end
-        alias_method :ids, :id
-
-        def to_param
-          id.to_s
-        end
-
-        def id_before_type_cast #:nodoc:
-          raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
-        end
-
-        def quoted_id #:nodoc:
-          [self.class.primary_keys, ids].
-            transpose.
-            map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}.
-            to_composite_ids
-        end
-
-        # Sets the primary ID.
-        def id=(ids)
-          ids = ids.split(ID_SEP) if ids.is_a?(String)
-          ids.flatten!
-          unless ids.is_a?(Array) and ids.length == self.class.primary_keys.length
-            raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
-          end
-          [primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
-          id
-        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.
-        # The extent of a "deep" clone is application-specific and is therefore
-        # left to the application to implement according to its need.
-        def clone
-          attrs = self.attributes_before_type_cast
-          self.class.primary_keys.each {|key| attrs.delete(key.to_s)}
-          self.class.new do |record|
-            record.send :instance_variable_set, '@attributes', attrs
-          end
-        end
-
-
-        private
-        # 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_without_callbacks
-          unless self.id
-            raise CompositeKeyError, "Composite keys do not generated ids from sequences, you must provide id values"
-          end
-          attributes_minus_pks = attributes_with_quotes(false)
-          quoted_pk_columns = self.class.primary_key.map { |col| connection.quote_column_name(col) }
-          cols = quoted_column_names(attributes_minus_pks) << quoted_pk_columns
-          vals = attributes_minus_pks.values << quoted_id
-          connection.insert(
-            "INSERT INTO #{self.class.quoted_table_name} " +
-            "(#{cols.join(', ')}) " +
-            "VALUES (#{vals.join(', ')})",
-            "#{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
-          where_clause_terms = [self.class.primary_key, quoted_id].transpose.map do |pair| 
-            "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
-          end
-          where_clause = where_clause_terms.join(" AND ")
-          connection.update(
-            "UPDATE #{self.class.quoted_table_name} " +
-            "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
-            "WHERE #{where_clause}",
-            "#{self.class.name} Update"
-          )
-          return true
-        end
+    def composite?
+      self.class.composite?
+    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
-          where_clause_terms = [self.class.primary_key, quoted_id].transpose.map do |pair| 
-            "(#{connection.quote_column_name(pair[0])} = #{pair[1]})"
-          end
-          where_clause = where_clause_terms.join(" AND ")
-          unless new_record?
-            connection.delete(
-              "DELETE FROM #{self.class.quoted_table_name} " +
-              "WHERE #{where_clause}",
-              "#{self.class.name} Destroy"
-            )
-          end
-          freeze
-        end
+    def [](attr_name)
+      # CPK
+      if attr_name.is_a?(String) and attr_name != attr_name.split(CompositePrimaryKeys::ID_SEP).first
+        attr_name = attr_name.split(CompositePrimaryKeys::ID_SEP)
       end
 
-      module CompositeClassMethods
-        def primary_key; primary_keys; end
-        def primary_key=(keys); primary_keys = keys; end
+      # CPK
+      if attr_name.is_a?(Array)
+        values = attr_name.map {|name| read_attribute(name)}
+        CompositePrimaryKeys::CompositeKeys.new(values)
+      else
+        read_attribute(attr_name)
+      end
+    end
 
-        def composite?
-          true
-        end
+    def []=(attr_name, value)
+      # CPK
+      if attr_name.is_a?(String) and attr_name != attr_name.split(CompositePrimaryKeys::ID_SEP).first
+        attr_name = attr_name.split(CompositePrimaryKeys::ID_SEP)
+      end
 
-        #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
-        #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
-        def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
-          many_ids.map {|ids| "#{left_bracket}#{ids}#{right_bracket}"}.join(list_sep)
-        end
-        
-        # Creates WHERE condition from list of composited ids
-        #   User.update_all({:role => 'admin'}, :conditions => composite_where_clause([[1, 2], [2, 2]])) #=> UPDATE admins SET admin.role='admin' WHERE (admin.type=1 AND admin.type2=2) OR (admin.type=2 AND admin.type2=2)
-        #   User.find(:all, :conditions => composite_where_clause([[1, 2], [2, 2]])) #=> SELECT * FROM admins WHERE (admin.type=1 AND admin.type2=2) OR (admin.type=2 AND admin.type2=2)
-        def composite_where_clause(ids)
-          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
-          
-          ids.map do |id_set|
-            [primary_keys, id_set].transpose.map do |key, id|
-              "#{table_name}.#{key.to_s}=#{sanitize(id)}"
-            end.join(" AND ")
-          end.join(") OR (")       
+      if attr_name.is_a? Array
+        unless value.length == attr_name.length
+          raise "Number of attr_names and values do not match"
         end
+        [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
+        value
+      else
+         write_attribute(attr_name, value)
+      end
+    end
+    
+    module CompositeClassMethods
+      def primary_key
+        primary_keys
+      end
 
-        # Returns true if the given +ids+ represents the primary keys of a record in the database, false otherwise.
-        # Example:
-        #   Person.exists?(5,7)
-        def exists?(ids)
-          if ids.is_a?(Array) && ids.first.is_a?(String)
-            count(:conditions => ids) > 0
-          else
-            obj = find(ids) rescue false
-            !obj.nil? and obj.is_a?(self)            
-          end
-        end
+      def primary_key=(keys)
+        primary_keys = keys
+      end
 
-        # Deletes the record with the given +ids+ without instantiating an object first, e.g. delete(1,2)
-        # If an array of ids is provided (e.g. delete([1,2], [3,4]), all of them
-        # are deleted.
-        def delete(*ids)
-          unless ids.is_a?(Array); raise "*ids must be an Array"; end
-          ids = [ids.to_composite_ids] if not ids.first.is_a?(Array)
-          where_clause = ids.map do |id_set|
-            [primary_keys, id_set].transpose.map do |key, id|
-              "#{quoted_table_name}.#{connection.quote_column_name(key.to_s)}=#{sanitize(id)}"
-            end.join(" AND ")
-          end.join(") OR (")
-          delete_all([ "(#{where_clause})" ])
-        end
+      def composite?
+        true
+      end
 
-        # Destroys the record with the given +ids+ by instantiating the object and calling #destroy (all the callbacks are the triggered).
-        # If an array of ids is provided, all of them are destroyed.
-        def destroy(*ids)
-          unless ids.is_a?(Array); raise "*ids must be an Array"; end
-          if ids.first.is_a?(Array)
-            ids = ids.map{|compids| compids.to_composite_ids}
-          else
-            ids = ids.to_composite_ids
-          end
-          ids.first.is_a?(CompositeIds) ? ids.each { |id_set| find(id_set).destroy } : find(ids).destroy
-        end
+      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
+      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
+      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
+      end
+    end
 
-        # Returns an array of column objects for the table associated with this class.
-        # Each column that matches to one of the primary keys has its
-        # primary attribute set to true
-        def columns
-          unless @columns
-            @columns = connection.columns(table_name, "#{name} Columns")
-            @columns.each {|column| column.primary = primary_keys.include?(column.name.to_sym)}
-          end
-          @columns
-        end
+    module CompositeInstanceMethods
+      # A model instance's primary keys is always available as model.ids
+      # whether you name it the default 'id' or set it to something else.
+      def id
+        attr_names = self.class.primary_keys
+        Array.new(attr_names.map { |attr_name| read_attribute(attr_name) })
+      end
+      alias_method :ids, :id
 
-        ## DEACTIVATED METHODS ##
-        public
-        # Lazy-set the sequence name to the connection's default.  This method
-        # is only ever called once since set_sequence_name overrides it.
-        def sequence_name #:nodoc:
-          raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+      def ids_hash
+        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
+          hash[key] = value
+          hash
         end
+      end
 
-        def reset_sequence_name #:nodoc:
-          raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
-        end
+      def to_param
+        id.join(CompositePrimaryKeys::ID_SEP)
+      end
 
-        def set_primary_key(value = nil, &block)
-          raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
-        end
+      def id_before_type_cast #:nodoc:
+        raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
+      end
 
-        private
-        def find_one(id, options)
-          raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
-        end
+      def quoted_id #:nodoc:
+        [self.class.primary_keys, ids].
+          transpose.
+          map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}.
+          to_composite_ids
+      end
 
-        def find_some(ids, options)
-          raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
+      # Sets the primary ID.
+      def id=(ids)
+        ids = ids.split(CompositePrimaryKeys::ID_SEP) if ids.is_a?(String)
+        ids.flatten!
+        unless ids.is_a?(Array) and ids.length == self.class.primary_keys.length
+          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
         end
+        [primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
+        id
+      end
 
-        def find_from_ids(ids, options)
-          ids = ids.first if ids.last == nil
-          conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
-          # if ids is just a flat list, then its size must = primary_key.length (one id per primary key, in order)
-          # if ids is list of lists, then each inner list must follow rule above
-          if ids.first.is_a? String
-            # find '2,1' -> ids = ['2,1']
-            # find '2,1;7,3' -> ids = ['2,1;7,3']
-            ids = ids.first.split(ID_SET_SEP).map {|id_set| id_set.split(ID_SEP).to_composite_ids}
-            # find '2,1;7,3' -> ids = [['2','1'],['7','3']], inner [] are CompositeIds
-          end
-          ids = [ids.to_composite_ids] if not ids.first.kind_of?(Array)
-          ids.each do |id_set|
-            unless id_set.is_a?(Array)
-              raise "Ids must be in an Array, instead received: #{id_set.inspect}"
-            end
-            unless id_set.length == primary_keys.length
-              raise "#{id_set.inspect}: Incorrect number of primary keys for #{class_name}: #{primary_keys.inspect}"
-            end
-          end
-
-          # Let keys = [:a, :b]
-          # If ids = [[10, 50], [11, 51]], then :conditions => 
-          #   "(#{quoted_table_name}.a, #{quoted_table_name}.b) IN ((10, 50), (11, 51))"
-
-          conditions = ids.map do |id_set|
-            [primary_keys, id_set].transpose.map do |key, id|
-			        col = columns_hash[key.to_s]
-			        val = quote_value(id, col)
-              "#{quoted_table_name}.#{connection.quote_column_name(key.to_s)}=#{val}"
-            end.join(" AND ")
-          end.join(") OR (")
-              
-          options.update :conditions => "(#{conditions})"
-
-          result = find_every(options)
-
-          if result.size == ids.size
-            ids.size == 1 ? result[0] : result
-          else
-            raise ::ActiveRecord::RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids.inspect})#{conditions}"
-          end
+      # Cloned objects have no id assigned and are treated as new records. Note that this is a "shallow" clone
+      # as it copies the object's attributes only, not its associations. The extent of a "deep" clone is
+      # application specific and is therefore left to the application to implement according to its need.
+      def initialize_copy(other)
+        # Think the assertion which fails if the after_initialize callback goes at the end of the method is wrong. The
+        # deleted clone method called new which therefore called the after_initialize callback. It then went on to copy
+        # over the attributes. But if it's copying the attributes afterwards then it hasn't finished initializing right?
+        # For example in the test suite the topic model's after_initialize method sets the author_email_address to
+        # test@test.com. I would have thought this would mean that all cloned models would have an author email address
+        # of test@test.com. However the test_clone test method seems to test that this is not the case. As a result the
+        # after_initialize callback has to be run *before* the copying of the atrributes rather than afterwards in order
+        # for all tests to pass. This makes no sense to me.
+        callback(:after_initialize) if respond_to_without_attributes?(:after_initialize)
+        cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
+        # CPK
+        #cloned_attributes.delete(self.class.primary_key)
+        self.class.primary_key.each {|key| cloned_attributes.delete(key.to_s)}
+
+        @attributes = cloned_attributes
+        clear_aggregation_cache
+        @attributes_cache = {}
+        @new_record = true
+        ensure_proper_type
+
+        if scope = self.class.send(:current_scoped_methods)
+          create_with = scope.scope_for_create
+          create_with.each { |att,value| self.send("#{att}=", value) } if create_with
         end
       end
-    end
-  end
-end
 
+      def destroy
+        if persisted?
+          # CPK
+          # self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).delete_all
+          self.class.unscoped.where(ids_hash).delete_all
+        end
 
-module ActiveRecord
-  ID_SEP     = ','
-  ID_SET_SEP = ';'
-
-  class Base
-    # Allows +attr_name+ to be the list of primary_keys, and returns the id
-    # of the object
-    # e.g. @object[@object.class.primary_key] => [1,1]
-    def [](attr_name)
-      if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
-        attr_name = attr_name.split(ID_SEP)
-      end
-      attr_name.is_a?(Array) ?
-        attr_name.map {|name| read_attribute(name)} :
-        read_attribute(attr_name)
-    end
-
-    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-    # (Alias for the protected write_attribute method).
-    def []=(attr_name, value)
-      if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
-        attr_name = attr_name.split(ID_SEP)
+        @destroyed = true
+        freeze
       end
 
-      if attr_name.is_a? Array
-        value = value.split(ID_SEP) if value.is_a? String
-        unless value.length == attr_name.length
-          raise "Number of attr_names and values do not match"
-        end
-        #breakpoint
-        [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}
-      else
-        write_attribute(attr_name, value)
+      def update(attribute_names = @attributes.keys)
+        attributes_with_values = arel_attributes_values(false, false, attribute_names)
+        return 0 if attributes_with_values.empty?
+        # CPK
+        # self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(attributes_with_values)
+        self.class.unscoped.where(ids_hash).arel.update(attributes_with_values)
       end
     end
   end
-end
+end