composite_primary_keys 8.1.6 → 9.0.10

data/lib/composite_primary_keys/base.rb

@@ -7,21 +7,8 @@ module ActiveRecord
     NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
 
     class << self
-      def primary_keys
-        unless defined?(@primary_keys)
-          reset_primary_keys
-        end
-        @primary_keys
-      end
-
-      # Don't like this method name, but its modeled after how AR does it
-      def reset_primary_keys
-        if self != base_class
-          self.primary_keys = base_class.primary_keys
-        end
-      end
-
-      def primary_key_with_composite_key_support=(keys)
+      alias_method :primary_key_without_composite_key_support=, :primary_key=
+      def primary_key=(keys)
         unless keys.kind_of?(Array)
           self.primary_key_without_composite_key_support = keys
           return
@@ -34,7 +21,6 @@ module ActiveRecord
           include CompositeInstanceMethods
         EOV
       end
-      alias_method_chain :primary_key=, :composite_key_support
       alias_method :primary_keys=, :primary_key=
 
       def set_primary_keys(*keys)
@@ -48,75 +34,11 @@ module ActiveRecord
         else
           self.primary_keys = keys
         end
-     end
+      end
 
       def composite?
         false
       end
-
-      def find_in_batches(options = {})
-        return super unless primary_key.is_a?(Array)
-
-        # Unfortunately .count uses a subquery temp table, which is a big problem when your table is large
-        number_of_rows = count(primary_key.first)
-        batch_size = options[:batch_size] || 100000
-        row_number = 0
-
-        while row_number < number_of_rows
-          end_row_number = row_number + batch_size - 1
-          end_row_number = number_of_rows - 1 if end_row_number > number_of_rows - 1
-
-          # Force the necessary sorting; AR as is will sort a PK table incorrectly
-          start_key = order(*primary_key).
-                         offset(row_number).
-                             first.
-                                 attributes.
-                                     slice(*primary_key)
-
-          end_key =   order(*(primary_key.map { |k| "#{k} ASC" })).
-                         offset(end_row_number).
-                             first.
-                                 attributes.
-                                     slice(*primary_key)
-
-          relation = self
-          lower_bounds = []
-          upper_bounds = []
-
-          # Iterate through the PKs positionally; when we have found a discrepancy between start and end
-          # then we know that's where the boundaries are
-          primary_key.each do |col|
-             if start_key[col] == end_key[col]
-                              relation = relation.where("#{col} = '#{start_key[col]}'")
-                            else
-                                             lower_bounds << [col, start_key[col]]
-                                             upper_bounds << [col, end_key[col]]
-                                           end
-           end
-
-          relation = relation.where(build_batch_case(lower_bounds, '>')) unless lower_bounds.empty?
-          relation = relation.where(build_batch_case(upper_bounds, '<')) unless upper_bounds.empty?
-
-          yield(relation.order(*primary_key))
-
-          row_number = end_row_number + 1
-        end
-      end
-
-      private
-
-      def build_batch_case(bounds, operator)
-        bounds = bounds.dup
-        bound = bounds.shift
-        if bounds.empty?
-          "#{bound[0]} #{operator}= '#{bound[1]}' "
-          else
-          sql_case = "CASE WHEN #{bound[0]} = '#{bound[1]}' THEN "
-          sql_case += build_batch_case(bounds, operator)
-          sql_case += "ELSE #{bound[0]} #{operator} '#{bound[1]}' END "
-          sql_case
-        end
-      end
     end
 
     def composite?
@@ -124,12 +46,26 @@ module ActiveRecord
     end
 
     module CompositeClassMethods
+      def primary_keys
+        unless defined?(@primary_keys)
+          reset_primary_keys
+        end
+        @primary_keys
+      end
+
+      # Don't like this method name, but its modeled after how AR does it
+      def reset_primary_keys
+        if self != base_class
+          self.primary_keys = base_class.primary_keys
+        end
+      end
+
       def primary_key
         primary_keys
       end
 
       def primary_key=(keys)
-        primary_keys = keys
+        self.primary_keys = keys
       end
 
       def composite?

data/lib/composite_primary_keys/composite_arrays.rb

@@ -22,7 +22,7 @@ module CompositePrimaryKeys
 
   class CompositeKeys < Array
 
-  def self.parse(value)
+    def self.parse(value)
       case value
       when Array
         value.to_composite_keys
@@ -33,6 +33,14 @@ module CompositePrimaryKeys
       end
     end
 
+    def in(other)
+      case other
+        when Arel::SelectManager
+          CompositePrimaryKeys::Nodes::In.new(self, other.ast)
+      end
+    end
+
+
     def to_s
       # Doing this makes it easier to parse Base#[](attr_name)
       join(ID_SEP)

data/lib/composite_primary_keys/composite_predicates.rb

@@ -39,6 +39,7 @@ module CompositePrimaryKeys
       key2_fields = Array(key2).map {|key| table2[key]}
 
       eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
+        key_field2 = Arel::Nodes::Quoted.new(key_field2) unless Arel::Attributes::Attribute === key_field2
         key_field1.eq(key_field2)
       end
       cpk_and_predicate(eq_predicates)

data/lib/composite_primary_keys/connection_adapters/abstract_adapter.rb

@@ -1,11 +1,11 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class AbstractAdapter
-      def quote_column_names(name)
-        Array(name).map do |col|
-          quote_column_name(col.to_s)
-        end.join(CompositePrimaryKeys::ID_SEP)
-      end
-    end
-  end
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      def quote_column_names(name)
+        Array(name).map do |col|
+          quote_column_name(col.to_s)
+        end.join(CompositePrimaryKeys::ID_SEP)
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/connection_adapters/abstract_mysql_adapter.rb

@@ -1,8 +1,6 @@
 module ActiveRecord
   module ConnectionAdapters
-    class AbstractMysqlAdapter < AbstractAdapter
-      # MySQL is too stupid to create a temporary table for use subquery, so we have
-      # to give it some prompting in the form of a subsubquery. Ugh!
+    class AbstractMysqlAdapter
       def subquery_for(key, select)
         subsubselect = select.clone
         subsubselect.projections = [key]
@@ -13,9 +11,10 @@ module ActiveRecord
 
         subselect = Arel::SelectManager.new(select.engine)
 
-        # subselect.project Arel.sql(key.name)
-        arel_table = select.engine.arel_table
-        subselect.project *key.name.map{|x| arel_table[x]}
+        # CPK
+        #subselect.project Arel.sql(key.name)
+        subselect.project Arel.sql(Array(key).map(&:name).join(', '))
+
         subselect.from subsubselect.as('__active_record_temp')
       end
     end

data/lib/composite_primary_keys/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3Adapter
+      def join_to_update(update, select, key)
+        if key.is_a?(::CompositePrimaryKeys::CompositeKeys)
+          subselect = subquery_for(key, select)
+          subselect_aliased = Arel::Nodes::TableAlias.new(subselect, 'cpk_inner')
+          cpk_subselect = Arel::SelectManager.new(subselect_aliased)
+          cpk_subselect.project('*')
+          key.each do |a_key|
+            where_expr = subselect_aliased[a_key.name].eq(update.ast.relation[a_key.name])
+            cpk_subselect.where(where_expr)
+          end
+          where_clause = Arel::Nodes::SqlLiteral.new("EXISTS (#{cpk_subselect.to_sql})")
+          update.where(where_clause)
+        else
+          super
+        end
+      end
+      alias join_to_delete join_to_update
+    end
+  end
+end

data/lib/composite_primary_keys/core.rb

@@ -1,60 +1,61 @@
 module ActiveRecord
   module Core
-    def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.dup
-      # CPK
-      # @attributes.reset(self.class.primary_key)
-      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
+    silence_warnings do
+      def initialize_dup(other) # :nodoc:
+        @attributes = @attributes.dup
+        # CPK
+        # @attributes.reset(self.class.primary_key)
+        Array(self.class.primary_key).each {|key| @attributes.reset(key)}
 
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
+        run_callbacks(:initialize) unless _initialize_callbacks.empty?
 
-      @aggregation_cache = {}
-      @association_cache = {}
+        @aggregation_cache = {}
+        @association_cache = {}
 
-      @new_record  = true
-      @destroyed   = false
+        @new_record  = true
+        @destroyed   = false
 
-      super
+        super
+      end
     end
 
     module ClassMethods
-      def find(*ids) # :nodoc:
-        # We don't have cache keys for this stuff yet
-        return super unless ids.length == 1
-        # Allow symbols to super to maintain compatibility for deprecated finders until Rails 5
-        return super if ids.first.kind_of?(Symbol)
-        return super if block_given? ||
-          primary_key.nil? ||
-          default_scopes.any? ||
-          current_scope ||
-          columns_hash.include?(inheritance_column) ||
-          ids.first.kind_of?(Array)
-
-        # CPK
-        return super if self.composite?
-
-        id  = ids.first
-        if ActiveRecord::Base === id
-          id = id.id
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            You are passing an instance of ActiveRecord::Base to `find`.
-            Please pass the id of the object by calling `.id`
-          MSG
-        end
-        key = primary_key
-
-        s = find_by_statement_cache[key] || find_by_statement_cache.synchronize {
-          find_by_statement_cache[key] ||= StatementCache.create(connection) { |params|
+      silence_warnings do
+        def find(*ids) # :nodoc:
+          # We don't have cache keys for this stuff yet
+          return super unless ids.length == 1
+          return super if block_given? ||
+                          primary_key.nil? ||
+                          scope_attributes? ||
+                          columns_hash.include?(inheritance_column) ||
+                          ids.first.kind_of?(Array)
+          # CPK
+          return super if self.composite?
+
+          id  = ids.first
+          if ActiveRecord::Base === id
+            id = id.id
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              You are passing an instance of ActiveRecord::Base to `find`.
+              Please pass the id of the object by calling `.id`
+            MSG
+          end
+
+          key = primary_key
+
+          statement = cached_find_by_statement(key) { |params|
             where(key => params.bind).limit(1)
           }
-        }
-        record = s.execute([id], self, connection).first
-        unless record
-          raise RecordNotFound, "Couldn't find #{name} with '#{primary_key}'=#{id}"
+          record = statement.execute([id], self, connection).first
+          unless record
+            raise RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id}",
+                                     name, primary_key, id)
+          end
+          record
+        rescue RangeError
+          raise RecordNotFound.new("Couldn't find #{name} with an out of range value for '#{primary_key}'",
+                                   name, primary_key)
         end
-        record
-      rescue RangeError
-        raise RecordNotFound, "Couldn't find #{name} with an out of range value for '#{primary_key}'"
       end
     end
   end

data/lib/composite_primary_keys/fixtures.rb

@@ -1,25 +1,27 @@
 module ActiveRecord
   class Fixture
-    def find
-      if model_class
-        # CPK
-        # model_class.unscoped do
-        #   model_class.find(fixture[model_class.primary_key])
-        # end
-        model_class.unscoped do
-          ids = self.ids(model_class.primary_key)
-          model_class.find(ids)
+    silence_warnings do
+      def find
+        if model_class
+          # CPK
+          # model_class.unscoped do
+          #   model_class.find(fixture[model_class.primary_key])
+          # end
+          model_class.unscoped do
+            ids = self.ids(model_class.primary_key)
+            model_class.find(ids)
+          end
+        else
+          raise FixtureClassNotFound, "No class attached to find."
         end
-      else
-        raise FixtureClassNotFound, "No class attached to find."
       end
-    end
 
-    def ids(key)
-      if key.is_a? Array
-        key.map {|a_key| fixture[a_key.to_s] }
-      else
-        fixture[key]
+      def ids(key)
+        if key.is_a? Array
+          key.map {|a_key| fixture[a_key.to_s] }
+        else
+          fixture[key]
+        end
       end
     end
   end

data/lib/composite_primary_keys/locking/optimistic.rb

@@ -1,54 +1,58 @@
-  module ActiveRecord
-    module Locking
-      module Optimistic
-        private
-          def _update_record(attribute_names = @attributes.keys) #:nodoc:
-            return super unless locking_enabled?
-            return 0 if attribute_names.empty?
-
-            lock_col = self.class.locking_column
-            previous_lock_value = send(lock_col).to_i
-            increment_lock
-
-            attribute_names += [lock_col]
-            attribute_names.uniq!
-
-            begin
-              relation = self.class.unscoped
-
-              if self.composite?
-                affected_rows = relation.where(
-                    relation.cpk_id_predicate(relation.table, self.class.primary_key, id_was)
-                ).where(
-                    lock_col => previous_lock_value
-                ).update_all(
-                    Hash[attributes_for_update(attribute_names).map do |name|
-                           [name, _read_attribute(name)]
-                         end]
-                )
-              else
-                affected_rows = relation.where(
-                    self.class.primary_key => id,
-                    lock_col => previous_lock_value,
-                ).update_all(
-                    Hash[attributes_for_update(attribute_names).map do |name|
-                         [name, _read_attribute(name)]
-                       end]
-                )
-              end
-
-              unless affected_rows == 1
-                raise ActiveRecord::StaleObjectError.new(self, "update")
-              end
-
-              affected_rows
-
-            # If something went wrong, revert the version.
-            rescue Exception
-              send(lock_col + '=', previous_lock_value)
-              raise
+module ActiveRecord
+  module Locking
+    module Optimistic
+
+      private
+
+      silence_warnings do
+        def _update_record(attribute_names = self.attribute_names) #:nodoc:
+          return super unless locking_enabled?
+          return 0 if attribute_names.empty?
+
+          lock_col = self.class.locking_column
+          previous_lock_value = send(lock_col).to_i
+          increment_lock
+
+          attribute_names += [lock_col]
+          attribute_names.uniq!
+
+          begin
+            relation = self.class.unscoped
+
+            if self.composite?
+              affected_rows = relation.where(
+                  relation.cpk_id_predicate(relation.table, self.class.primary_key, id_was)
+              ).where(
+                  lock_col => previous_lock_value
+              ).update_all(
+                  attributes_for_update(attribute_names).map do |name|
+                      [name, _read_attribute(name)]
+                  end.to_h
+              )
+            else
+              affected_rows = relation.where(
+                  self.class.primary_key => id,
+                  lock_col => previous_lock_value,
+              ).update_all(
+                  attributes_for_update(attribute_names).map do |name|
+                      [name, _read_attribute(name)]
+                  end.to_h
+              )
+            end
+
+            unless affected_rows == 1
+              raise ActiveRecord::StaleObjectError.new(self, "update")
+            end
+
+            affected_rows
+
+          # If something went wrong, revert the version.
+          rescue Exception
+            send(lock_col + '=', previous_lock_value)
+            raise
           end
         end
+      end
     end
   end
 end

data/lib/composite_primary_keys/nested_attributes.rb

@@ -8,70 +8,77 @@ module ActiveRecord
       end
     end
 
-    def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
-      options = self.nested_attributes_options[association_name]
+    silence_warnings do
+      def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
+        options = self.nested_attributes_options[association_name]
 
-      unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
-        raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
-      end
+        if attributes_collection.respond_to?(:permitted?)
+          attributes_collection = attributes_collection.to_h
+        end
 
-      check_record_limit!(options[:limit], attributes_collection)
+        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+          raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+        end
 
-      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
-      end
+        check_record_limit!(options[:limit], attributes_collection)
 
-      association = association(association_name)
+        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
+        end
 
-      existing_records = if association.loaded?
-                           association.target
-                         # CPK
-                         elsif association.reflection.klass.composite?
-                           attributes_collection.map do |attribute_collection|
-                             attribute_ids = attribute_collection['id'] || attribute_collection[:id]
-                             if attribute_ids
-                               ids = CompositePrimaryKeys::CompositeKeys.parse(attribute_ids)
-                               eq_predicates = association.klass.primary_key.zip(ids).map do |primary_key, value|
-                                 association.klass.arel_table[primary_key].eq(value)
+        association = association(association_name)
+
+        existing_records = if association.loaded?
+                             association.target
+                           # CPK
+                           elsif association.reflection.klass.composite?
+                             attributes_collection.map do |attribute_collection|
+                               attribute_ids = attribute_collection['id'] || attribute_collection[:id]
+                               if attribute_ids
+                                 ids = CompositePrimaryKeys::CompositeKeys.parse(attribute_ids)
+                                 eq_predicates = Class.new.extend(CompositePrimaryKeys::Predicates).cpk_id_predicate(association.klass.arel_table, association.klass.primary_key, ids)
+                                 association.scope.where(eq_predicates).to_a
+                               else
+                                 []
                                end
-                               association.scope.where(*eq_predicates).to_a
-                             else
-                               []
-                             end
-                           end.flatten.compact
-                         else
-                           attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
-                           attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
-                         end
+                             end.flatten.compact
+                           else
+                             attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
+                             attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
+                           end
 
-      attributes_collection.each do |attributes|
-        attributes = attributes.with_indifferent_access
-        if attributes['id'].blank?
-          unless reject_new_record?(association_name, attributes)
-            association.build(attributes.except(*UNASSIGNABLE_KEYS))
+        attributes_collection.each do |attributes|
+          if attributes.respond_to?(:permitted?)
+            attributes = attributes.to_h
           end
-        elsif existing_record = cpk_detect_record(attributes['id'], existing_records)
-          unless call_reject_if(association_name, attributes)
-            # 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)
-            # Take into account that the proxy_target may have changed due to callbacks
-            target_record = cpk_detect_record(attributes['id'], association.target)
-
-            if target_record
-              existing_record = target_record
-            else
-              association.add_to_target(existing_record, :skip_callbacks)
+          attributes = attributes.with_indifferent_access
+          if attributes['id'].blank?
+            unless reject_new_record?(association_name, attributes)
+              association.build(attributes.except(*UNASSIGNABLE_KEYS))
             end
+          elsif existing_record = cpk_detect_record(attributes['id'], existing_records)
+            unless call_reject_if(association_name, attributes)
+              # 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)
+              # Take into account that the proxy_target may have changed due to callbacks
+              target_record = cpk_detect_record(attributes['id'], association.target)
 
-            assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+              if target_record
+                existing_record = target_record
+              else
+                association.add_to_target(existing_record, :skip_callbacks)
+              end
+
+              assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+            end
+          else
+            raise_nested_attributes_record_not_found!(association_name, attributes['id'])
           end
-        else
-          raise_nested_attributes_record_not_found!(association_name, attributes['id'])
         end
       end
     end