composite_primary_keys 6.0.8 → 7.0.0

data/lib/composite_primary_keys/associations/preloader/association.rb

@@ -2,14 +2,19 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association
-        def records_for(ids)
+        def query_scope(ids)
           # CPK
           # scope.where(association_key.in(ids))
-          predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
-          scope.where(predicate)
+
+          if reflection.foreign_key.is_a?(Array)
+            predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
+            scope.where(predicate)
+          else
+            scope.where(association_key.in(ids))
+          end
         end
-        
-        def associated_records_by_owner
+
+        def associated_records_by_owner(preloader)
           # CPK
           owners_map = owners_by_key
           #owner_keys = owners_map.keys.compact
@@ -19,29 +24,40 @@ module ActiveRecord
             end
           end.compact.uniq
 
-          if klass.nil? || owner_keys.empty?
-            records = []
-          else
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = owners.each_with_object({}) do |owner,h|
+            h[owner] = []
+          end
+
+          if owner_keys.any?
             # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
             # Make several smaller queries if necessary or make one query if the adapter supports it
-            sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
-            records = sliced.map { |slice| records_for(slice) }.flatten
+            sliced  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+
+            records = load_slices sliced
+            records.each do |record, owner_key|
+              owners_map[owner_key].each do |owner|
+                records_by_owner[owner] << record
+              end
+            end
           end
 
-          # Each record may have multiple owners, and vice-versa
-          records_by_owner = Hash[owners.map { |owner| [owner, []] }]
-          records.each do |record|
+          records_by_owner
+        end
+
+        def load_slices(slices)
+          @preloaded_records = slices.flat_map { |slice|
+            records_for(slice)
+          }
+
+          @preloaded_records.map { |record|
             # CPK
-            # owner_key = record[association_key_name].to_s
+            #[record, record[association_key_name]]
             owner_key = Array(association_key_name).map do |key_name|
               record[key_name]
             end.join(CompositePrimaryKeys::ID_SEP)
-
-            owners_map[owner_key].each do |owner|
-              records_by_owner[owner] << record
-            end
-          end
-          records_by_owner
+            [record, owner_key]
+          }
         end
 
         def owners_by_key
@@ -59,4 +75,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/associations/preloader/belongs_to.rb

@@ -2,10 +2,16 @@ module ActiveRecord
   module Associations
     class Preloader
       class BelongsTo
-        def records_for(ids)
+        def query_scope(ids)
           # CPK
-          predicate = cpk_in_predicate(table, association_key_name, ids)
-          scope.where(predicate)
+          # scope.where(association_key.in(ids))
+
+          if association_key_name.is_a?(Array)
+            predicate = cpk_in_predicate(table, association_key_name, ids)
+            scope.where(predicate)
+          else
+            scope.where(association_key.in(ids))
+          end
         end
       end
     end

data/lib/composite_primary_keys/base.rb

@@ -4,7 +4,6 @@ module ActiveRecord
 
   class Base
     include CompositePrimaryKeys::ActiveRecord::Persistence
-    include CompositePrimaryKeys::ActiveRecord::Locking::Optimistic
     
     INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
     NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'

data/lib/composite_primary_keys/composite_predicates.rb

@@ -8,27 +8,10 @@ module CompositePrimaryKeys
       end
     end
 
-    def figure_engine(table)
-      case table
-        when Arel::Nodes::TableAlias
-          table.left.engine
-        when Arel::Table
-          table.engine
-        when ::ActiveRecord::Base
-          table
-        else
-          nil
-      end
-    end
-
-    def cpk_or_predicate(predicates, table = nil)
-      engine = figure_engine(table)
-      predicates = predicates.map do |predicate|
-        predicate_sql = engine ? predicate.to_sql(engine) : predicate.to_sql
-        "(#{predicate_sql})"
-      end
-      predicates = "(#{predicates.join(" OR ")})"
-      Arel::Nodes::SqlLiteral.new(predicates)
+    def cpk_or_predicate(predicates)
+      ::Arel::Nodes::Grouping.new(predicates.inject { |memo,node|
+        ::Arel::Nodes::Or.new(memo, node)
+      })
     end
 
     def cpk_id_predicate(table, keys, values)
@@ -49,25 +32,19 @@ module CompositePrimaryKeys
     end
 
     def cpk_in_predicate(table, primary_keys, ids)
-      primary_keys = Array(primary_keys)
-      if primary_keys.length > 1
-        and_predicates = ids.map do |id_set|
-          eq_predicates = Array(primary_keys).zip(Array(id_set)).map do |primary_key, value|
-            table[primary_key].eq(value)
-          end
-          cpk_and_predicate(eq_predicates)
-        end
-
-        cpk_or_predicate(and_predicates, table)
-      else
-        table[primary_keys.first].in(ids.flatten)
+      and_predicates = ids.map do |id|
+        cpk_id_predicate(table, primary_keys, id)
       end
+      cpk_or_predicate(and_predicates)
     end
   end
 end
 
 ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::HasAndBelongsToManyAssociation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
+
+
+

data/lib/composite_primary_keys/connection_adapters/abstract/connection_specification_changes.rb

@@ -5,14 +5,15 @@ module ActiveRecord
         require "composite_primary_keys/connection_adapters/postgresql_adapter.rb"
       end
     end
-    
+
     def self.establish_connection(spec = ENV["DATABASE_URL"])
-      resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new spec, configurations
-      spec = resolver.spec
-      
+      spec     ||= ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_sym
+      resolver =   ConnectionAdapters::ConnectionSpecification::Resolver.new configurations
+      spec     =   resolver.spec(spec)
+
       # CPK
       load_cpk_adapter(spec.config[:adapter])
-      
+
       unless respond_to?(spec.adapter_method)
         raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
       end

data/lib/composite_primary_keys/core.rb

@@ -1,26 +1,39 @@
 module ActiveRecord
   module Core
-    def init_internals_with_cpk
-      init_internals_without_cpk
-      # Remove cpk array from attributes, fixes to_json
-      @attributes.delete(self.class.primary_key) if self.composite?
+    def init_internals
+      pk = self.class.primary_key
+
+      # CPK
+      #@attributes[pk] = nil unless @attributes.key?(pk)
+      unless self.composite?
+        @attributes[pk] = nil unless @attributes.key?(pk)
+      end
+
+      @aggregation_cache        = {}
+      @association_cache        = {}
+      @attributes_cache         = {}
+      @readonly                 = false
+      @destroyed                = false
+      @marked_for_destruction   = false
+      @destroyed_by_association = nil
+      @new_record               = true
+      @txn                      = nil
+      @_start_transaction_state = {}
+      @transaction_state        = nil
+      @reflects_state           = [false]
     end
-    alias_method_chain :init_internals, :cpk
 
-    def initialize_dup(other)
+    def initialize_dup(other) # :nodoc:
       cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
       self.class.initialize_attributes(cloned_attributes, :serialized => false)
-      # CPK
-      # cloned_attributes.delete(self.class.primary_key)
-      Array(self.class.primary_key).each {|key| cloned_attributes.delete(key.to_s)}
+
       @attributes = cloned_attributes
-      
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
 
-      @changed_attributes = {}
-      self.class.column_defaults.each do |attr, orig_value|
-        @changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
-      end
+      # CPK
+      #@attributes[self.class.primary_key] = nil
+      Array(self.class.primary_key).each {|key| @attributes[key] = nil}
+
+      run_callbacks(:initialize) unless _initialize_callbacks.empty?
 
       @aggregation_cache = {}
       @association_cache = {}
@@ -28,7 +41,6 @@ module ActiveRecord
 
       @new_record  = true
 
-      ensure_proper_type
       super
     end
   end

data/lib/composite_primary_keys/model_schema.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ModelSchema
+    module ClassMethods
+      def columns
+        @columns ||= connection.schema_cache.columns(table_name).map do |col|
+          col = col.dup
+          # CPK
+          #col.primary = (col.name == primary_key)
+          col.primary = Array(primary_key).include?(col.name)
+          col
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/nested_attributes.rb

@@ -12,10 +12,10 @@ module ActiveRecord
       if attributes_collection.is_a? Hash
         keys = attributes_collection.keys
         attributes_collection = if keys.include?('id') || keys.include?(:id)
-          [attributes_collection]
-        else
-          attributes_collection.values
-        end
+                                  [attributes_collection]
+                                else
+                                  attributes_collection.values
+                                end
       end
 
       association = association(association_name)
@@ -50,18 +50,16 @@ module ActiveRecord
           end
         elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
           unless call_reject_if(association_name, attributes)
-            # Make sure we are operatingon the actual object which is in the assocaition's
+            # Make sure we are operating on the actual object which is in the association's
             # proxy_target array (either by finding it, or adding it if not found)
-            target_record = association.target.detect { |record| record == existing_record }
-
+            # Take into account that the proxy_target may have changed due to callbacks
+            target_record = association.target.detect { |record| record.id.to_s == attributes['id'].to_s }
             if target_record
               existing_record = target_record
             else
-              association.add_to_target(existing_record)
+              association.add_to_target(existing_record, :skip_callbacks)
             end
-          end
 
-          if !call_reject_if(association_name, attributes)
             assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
           end
         else

data/lib/composite_primary_keys/persistence.rb

@@ -2,24 +2,29 @@ module CompositePrimaryKeys
   module ActiveRecord
     module Persistence
       def relation_for_destroy
-        return super unless composite?
-        
-        where_hash = {}
-        primary_keys = Array(self.class.primary_key)
+        # CPK
+        #pk         = self.class.primary_key
+        #column     = self.class.columns_hash[pk]
+        #substitute = self.class.connection.substitute_at(column, 0)
+        #relation = self.class.unscoped.where(
+        #  self.class.arel_table[pk].eq(substitute))
+        #relation.bind_values = [[column, id]]
 
-        if primary_keys.empty?
-          raise ActiveRecord::CompositeKeyError, "No primary key(s) defined for #{self.class.name}"
-        end
+        relation = self.class.unscoped
 
-        primary_keys.each do |key|
-          where_hash[key.to_s] = self[key]
+        Array(self.class.primary_key).each_with_index do |key, index|
+          column     = self.class.columns_hash[key]
+          substitute = self.class.connection.substitute_at(column, index)
+          relation = relation.where(self.class.arel_table[key].eq(substitute))
+          relation.bind_values += [[column, self[key]]]
         end
 
-        relation = self.class.unscoped.where(where_hash)
+        relation
       end
-      
 
       def touch(name = nil)
+        raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+
         attributes = timestamp_attributes_for_update_in_model
         attributes << name if name
 
@@ -34,35 +39,29 @@ module CompositePrimaryKeys
 
           changes[self.class.locking_column] = increment_lock if locking_enabled?
 
-          @changed_attributes.except!(*changes.keys)
+          changed_attributes.except!(*changes.keys)
 
           relation    = self.class.send(:relation)
           arel_table  = self.class.arel_table
           primary_key = self.class.primary_key
 
+          # CPK
+          #self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
           primary_key_predicate = relation.cpk_id_predicate(arel_table, Array(primary_key), Array(id))
-
           self.class.unscoped.where(primary_key_predicate).update_all(changes) == 1
+        else
+          true
         end
       end
 
-      def _update_record(attribute_names = @attributes.keys)
-        return super(attribute_names) unless composite?
-        
-        klass = self.class
-        
-        attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
-        return 0 if attributes_with_values.empty?
+      def create_record(attribute_names = @attributes.keys)
+        attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
-        if !can_change_primary_key? and primary_key_changed?
-          raise ActiveRecord::CompositeKeyError, "Cannot update primary key values without ActiveModel::Dirty"
-        elsif primary_key_changed?
-          stmt = klass.unscoped.where(primary_key_was).arel.compile_update(attributes_with_values)
-        else
-          stmt = klass.unscoped.where(ids_hash).arel.compile_update(attributes_with_values)
-        end
-        
-        klass.connection.update stmt.to_sql
+        new_id = self.class.unscoped.insert attributes_values
+        self.id ||= new_id if self.class.primary_key
+
+        @new_record = false
+        id
       end
     end
   end

data/lib/composite_primary_keys/relation.rb

@@ -1,25 +1,10 @@
 module ActiveRecord
   class Relation
-    def add_cpk_support
-      extend CompositePrimaryKeys::CompositeRelation
-    end
-
-    alias :where_values_hash_without_cpk :where_values_hash
-    def where_values_hash(relation_table_name = table_name)
-      # CPK adds this so that it finds the Equality nodes beneath the And node:
-      nodes_from_and = with_default_scope.where_values.grep(Arel::Nodes::And).map {|and_node| and_node.children.grep(Arel::Nodes::Equality) }.flatten
-
-      equalities = (nodes_from_and + with_default_scope.where_values.grep(Arel::Nodes::Equality)).find_all { |node|
-        node.left.relation.name == relation_table_name
-      }
-
-      Hash[equalities.map { |where| [where.left.name, where.right] }]
-    end
-
     alias :initialize_without_cpk :initialize
     def initialize(klass, table, values = {})
       initialize_without_cpk(klass, table, values)
       add_cpk_support if klass && klass.composite?
+      add_cpk_where_values_hash
     end
 
     alias :initialize_copy_without_cpk :initialize_copy
@@ -27,5 +12,90 @@ module ActiveRecord
       initialize_copy_without_cpk(other)
       add_cpk_support if klass.composite?
     end
+
+    def add_cpk_support
+      class << self
+        include CompositePrimaryKeys::ActiveRecord::Batches
+        include CompositePrimaryKeys::ActiveRecord::Calculations
+        include CompositePrimaryKeys::ActiveRecord::FinderMethods
+        include CompositePrimaryKeys::ActiveRecord::QueryMethods
+
+        def delete(id_or_array)
+          # Without CPK:
+          # where(primary_key => id_or_array).delete_all
+
+          id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
+            [id_or_array]
+          else
+            Array(id_or_array)
+          end
+
+          id_or_array.each do |id|
+            where(cpk_id_predicate(table, self.primary_key, id)).delete_all
+          end
+        end
+
+        def destroy(id_or_array)
+          # Without CPK:
+          #if id.is_a?(Array)
+          #  id.map { |one_id| destroy(one_id) }
+          #else
+          #  find(id).destroy
+          #end
+
+          id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
+            [id_or_array]
+          else
+            Array(id_or_array)
+          end
+
+          id_or_array.each do |id|
+            where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
+              record.destroy
+            end
+          end
+        end
+      end
+    end
+
+    def add_cpk_where_values_hash
+      class << self
+        def where_values_hash
+          # CPK adds this so that it finds the Equality nodes beneath the And node:
+          #equalities = where_values.grep(Arel::Nodes::Equality).find_all { |node|
+          #  node.left.relation.name == table_name
+          # }
+          nodes_from_and = where_values.grep(Arel::Nodes::And).map {|and_node| and_node.children.grep(Arel::Nodes::Equality) }.flatten
+
+          equalities = (nodes_from_and + where_values.grep(Arel::Nodes::Equality)).find_all { |node|
+            node.left.relation.name == table_name
+          }
+
+          binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
+
+          Hash[equalities.map { |where|
+            name = where.left.name
+            [name, binds.fetch(name.to_s) { where.right }]
+          }]
+        end
+      end
+    end
+
+    def update_record(values, id, id_was) # :nodoc:
+      substitutes, binds = substitute_values values
+
+      # CPK
+      um = if self.composite?
+        relation = @klass.unscoped.where(cpk_id_predicate(@klass.arel_table, @klass.primary_key, id_was || id))
+        relation.arel.compile_update(substitutes, @klass.primary_key)
+      else
+        @klass.unscoped.where(@klass.arel_table[@klass.primary_key].eq(id_was || id)).arel.compile_update(substitutes, @klass.primary_key)
+      end
+
+      @klass.connection.update(
+        um,
+        'SQL',
+        binds)
+    end
   end
 end