composite_primary_keys 8.1.8 → 9.0.0.beta1

data/lib/composite_primary_keys/persistence.rb

@@ -1,56 +1,64 @@
 module ActiveRecord
   module Persistence
-    def relation_for_destroy
-      # CPK
-      if self.composite?
-        relation = self.class.unscoped
-
-        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]]]
+    silence_warnings do
+      def relation_for_destroy
+        # CPK
+        if self.composite?
+          relation = self.class.unscoped
+
+          Array(self.class.primary_key).each do |key|
+            column     = self.class.arel_table[key]
+            value      = self[key]
+            relation = relation.where(column.eq(value))
+          end
+
+          relation
+        else
+          self.class.unscoped.where(self.class.primary_key => id)
         end
+      end
 
-        relation
-      else
-        pk         = self.class.primary_key
-        column     = self.class.columns_hash[pk]
-        substitute = self.class.connection.substitute_at(column, 0)
+      def touch(*names, time: nil)
+        raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
 
-        relation = self.class.unscoped.where(
-          self.class.arel_table[pk].eq(substitute))
+        time ||= current_time_from_proper_timezone
+        attributes = timestamp_attributes_for_update_in_model
+        attributes.concat(names)
 
-        relation.bind_values = [[column, id]]
-        relation
-      end
-    end
+        unless attributes.empty?
+          changes = {}
 
-    def touch(*names)
-      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+          attributes.each do |column|
+            column = column.to_s
+            changes[column] = write_attribute(column, time)
+          end
 
-      attributes = timestamp_attributes_for_update_in_model
-      attributes.concat(names)
+          clear_attribute_changes(changes.keys)
+          primary_key = self.class.primary_key
+          scope = self.class.unscoped.where(primary_key => _read_attribute(primary_key))
 
-      unless attributes.empty?
-        current_time = current_time_from_proper_timezone
-        changes = {}
+          if locking_enabled?
+            locking_column = self.class.locking_column
+            scope = scope.where(locking_column => _read_attribute(locking_column))
+            changes[locking_column] = increment_lock
+          end
 
-        attributes.each do |column|
-          column = column.to_s
-          changes[column] = write_attribute(column, current_time)
-        end
+          # CPK
+          if composite?
+            primary_key_predicate = self.class.unscoped.cpk_id_predicate(self.class.arel_table, Array(primary_key), Array(id))
+            scope = self.class.unscoped.where(primary_key_predicate)
+          end
 
-        changes[self.class.locking_column] = increment_lock if locking_enabled?
+          result = scope.update_all(changes) == 1
 
-        clear_attribute_changes(changes.keys)
-        primary_key = self.class.primary_key
-        # CPK
-        #self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
-        primary_key_predicate = self.class.unscoped.cpk_id_predicate(self.class.arel_table, Array(primary_key), Array(id))
-        self.class.unscoped.where(primary_key_predicate).update_all(changes) == 1
-      else
-        true
+          if !result && locking_enabled?
+            raise ActiveRecord::StaleObjectError.new(self, "touch")
+          end
+
+          result
+        else
+          true
+        end
       end
     end
   end

data/lib/composite_primary_keys/relation.rb

@@ -1,8 +1,8 @@
 module ActiveRecord
   class Relation
     alias :initialize_without_cpk :initialize
-    def initialize(klass, table, values = {})
-      initialize_without_cpk(klass, table, values)
+    def initialize(klass, table, predicate_builder, values = {})
+      initialize_without_cpk(klass, table, predicate_builder, values)
       add_cpk_support if klass && klass.composite?
     end
 
@@ -16,60 +16,35 @@ module ActiveRecord
       extend CompositePrimaryKeys::CompositeRelation
     end
 
-    alias :where_values_hash_without_cpk :where_values_hash
-    def where_values_hash(relation_table_name = table_name)
-      # CPK
-      nodes_from_and = where_values.grep(Arel::Nodes::And).map { |and_node|
-        and_node.children.grep(Arel::Nodes::Equality)
-      }.flatten
+    silence_warnings do
+      def _update_record(values, id, id_was) # :nodoc:
+        substitutes, binds = substitute_values values
 
-      # CPK
-      # equalities = where_values.grep(Arel::Nodes::Equality).find_all { |node|
-      #   node.left.relation.name == relation_table_name
-      # }
-      equalities = (nodes_from_and + where_values.grep(Arel::Nodes::Equality)).find_all { |node|
-        node.left.relation.name == relation_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) {
-          case where.right
-          when Array then where.right.map(&:val)
-          else
-            where.right.val
-          end
-        }]
-      }]
-    end
-
-    def _update_record(values, id, id_was)
-      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
         scope = @klass.unscoped
 
         if @klass.finder_needs_type_condition?
           scope.unscope!(where: @klass.inheritance_column)
         end
 
-        relation = scope.where(@klass.primary_key => (id_was || id))
-        binds += relation.bind_values
+        # CPK
+        if self.composite?
+          relation = @klass.unscoped.where(cpk_id_predicate(@klass.arel_table, @klass.primary_key, id_was || id))
+        else
+          relation = scope.where(@klass.primary_key => (id_was || id))
+        end
 
-        relation.arel.compile_update(substitutes, @klass.primary_key)
-      end
 
-      @klass.connection.update(
-        um,
-        'SQL',
-        binds)
+        bvs = binds + relation.bound_attributes
+        um = relation
+          .arel
+          .compile_update(substitutes, @klass.primary_key)
+
+        @klass.connection.update(
+          um,
+          'SQL',
+          bvs,
+        )
+      end
     end
   end
 end

data/lib/composite_primary_keys/relation/batches.rb

@@ -1,46 +1,48 @@
 module CompositePrimaryKeys
   module ActiveRecord
     module Batches
-      def find_in_batches(options = {})
-        options.assert_valid_keys(:start, :batch_size)
-
+      def in_batches(of: 1000, start: nil, finish: nil, load: false)
         relation = self
-        start = options[:start]
-        batch_size = options[:batch_size] || 1000
-
         unless block_given?
-          return to_enum(:find_in_batches, options) do
-            total = start ? where(table[primary_key].gteq(start)).size : size
-            (total - 1).div(batch_size) + 1
-          end
+          return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
         end
 
         if logger && (arel.orders.present? || arel.taken.present?)
           logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
         end
 
-        relation = relation.reorder(batch_order).limit(batch_size)
+        relation = relation.reorder(batch_order).limit(of)
+        relation = apply_limits(relation, start, finish)
+        batch_relation = relation
 
-        # CPK
-        # records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
-        records = if start
-                    self.primary_key.reduce(relation) do |rel, key|
-                      rel.where(table[key].gteq(start))
-                    end
-                  else
-                    relation.to_a
-                  end
+        loop do
+          if load
+            records = batch_relation.records
+            ids = records.map(&:id)
+            # CPK
+            # yielded_relation = self.where(primary_key => ids)
+            yielded_relation = self.where(cpk_in_predicate(table, primary_keys, ids))
+            yielded_relation.load_records(records)
+          else
+            # CPK
+            # ids = batch_relation.pluck(primary_key)
+            ids = batch_relation.pluck(*Array(primary_keys))
+            # CPK
+            # yielded_relation = self.where(primary_key => ids)
+            yielded_relation = self.where(cpk_in_predicate(table, primary_keys, ids))
+          end
 
-        while records.any?
-          records_size = records.size
-          primary_key_offset = records.last.id
-          raise "Primary key not included in the custom select clause" unless primary_key_offset
+          break if ids.empty?
 
-          yield records
+          primary_key_offset = ids.last
+          raise ArgumentError.new("Primary key not included in the custom select clause") unless primary_key_offset
 
-          break if records_size < batch_size
+          yield yielded_relation
 
-          if primary_key_offset
+          break if ids.length < of
+          # CPK
+          # batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+          batch_relation = if composite?
             # CPK
             # Lexicographically select records
             #
@@ -57,15 +59,16 @@ module CompositePrimaryKeys
 
               Arel::Nodes::Grouping.new(and_clause)
             end.reduce(:or)
+            relation.where(query)
+          else
+            relation.where(arel_attribute(primary_key).gt(primary_key_offset))
           end
-
-          records = relation.where(query).to_a
         end
       end
 
       private
 
-      # Helper method to collect prefixes of an array:
+      # CPK Helper method to collect prefixes of an array:
       # prefixes([:a, :b, :c]) => [[:a], [:a, :b], [:a, :b, :c]]
       #
       def prefixes(ary)

data/lib/composite_primary_keys/relation/calculations.rb

@@ -14,14 +14,12 @@ module CompositePrimaryKeys
         end
       end
 
-      def execute_simple_calculation(operation, column_name, distinct)
-        # Postgresql doesn't like ORDER BY when there are no GROUP BY
+      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+        # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
         relation = unscope(:order)
 
         column_alias = column_name
 
-        bind_values = nil
-
         # CPK
         # if operation == "count" && (relation.limit_value || relation.offset_value)
         if operation == "count"
@@ -29,7 +27,6 @@ module CompositePrimaryKeys
           return 0 if relation.limit_value == 0
 
           query_builder = build_count_subquery(relation, column_name, distinct)
-          bind_values = query_builder.bind_values + relation.bind_values
         else
           column = aggregate_column(column_name)
 
@@ -40,10 +37,9 @@ module CompositePrimaryKeys
           relation.select_values = [select_value]
 
           query_builder = relation.arel
-          bind_values = query_builder.bind_values + relation.bind_values
         end
 
-        result = @klass.connection.select_all(query_builder, nil, bind_values)
+        result = @klass.connection.select_all(query_builder, nil, bound_attributes)
         row    = result.first
         value  = row && row.values.first
         column = result.column_types.fetch(column_alias) do

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -30,17 +30,17 @@ module CompositePrimaryKeys
         relation = relation.except(:select).select(values).distinct!
         arel = relation.arel
 
-        id_rows = @klass.connection.select_all(arel, 'SQL', arel.bind_values + relation.bind_values)
+        id_rows = @klass.connection.select_all(arel, 'SQL', relation.bound_attributes)
 
         # CPK
         #id_rows.map {|row| row[primary_key]}
         id_rows.map {|row| row.values}
       end
-      
+
       def exists?(conditions = :none)
         if ::ActiveRecord::Base === conditions
           conditions = conditions.id
-          ::ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
           You are passing an instance of ActiveRecord::Base to `exists?`.
           Please pass the id of the object by calling `.id`
           MSG
@@ -53,30 +53,28 @@ module CompositePrimaryKeys
 
         relation = relation.except(:select, :order).select(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit(1)
 
-        # case conditions
-        # when Array, Hash
-        #   relation = relation.where(conditions)
-        # else
-        #   unless conditions == :none
-        #     relation = relation.where(primary_key => conditions)
-        #   end
-        # end
         case conditions
-        when CompositePrimaryKeys::CompositeKeys
-          relation = relation.where(cpk_id_predicate(table, primary_key, conditions))
-        when Array
-          pk_length = @klass.primary_keys.length
-
-          if conditions.length == pk_length # E.g. conditions = ['France', 'Paris']
-            return self.exists?(conditions.to_composite_keys)
-          else # Assume that conditions contains where relation
+          # CPK
+          when CompositePrimaryKeys::CompositeKeys
+            relation = relation.where(cpk_id_predicate(table, primary_key, conditions))
+          # CPK
+          when Array
+            pk_length = @klass.primary_keys.length
+
+            if conditions.length == pk_length # E.g. conditions = ['France', 'Paris']
+              return self.exists?(conditions.to_composite_keys)
+            else # Assume that conditions contains where relation
+              relation = relation.where(conditions)
+            end
+          when Array, Hash
             relation = relation.where(conditions)
-          end
-        when Hash
-          relation = relation.where(conditions)
+          else
+            unless conditions == :none
+              relation = relation.where(primary_key => conditions)
+            end
         end
 
-        connection.select_value(relation, "#{name} Exists", relation.bind_values) ? true : false
+        connection.select_value(relation, "#{name} Exists", relation.bound_attributes) ? true : false
       end
 
       def find_with_ids(*ids)
@@ -84,9 +82,8 @@ module CompositePrimaryKeys
 
         # CPK
         # expects_array = ids.first.kind_of?(Array)
-        ids = CompositePrimaryKeys.normalize(ids, @klass.primary_keys.length)
+        ids = CompositePrimaryKeys.normalize(ids)
         expects_array = ids.flatten != ids.flatten(1)
-
         return ids.first if expects_array && ids.first.empty?
 
         # CPK
@@ -106,6 +103,59 @@ module CompositePrimaryKeys
         raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"
       end
 
+      def last(limit = nil)
+        return find_last(limit) if loaded? || limit_value
+
+        result = limit(limit || 1)
+        # CPK
+        # result.order!(arel_attribute(primary_key)) if order_values.empty? && primary_key
+        if order_values.empty? && primary_key
+          if composite?
+            result.order!(primary_keys.map { |pk| arel_attribute(pk).asc })
+          elsif
+            result.order!(arel_attribute(primary_key))
+          end
+        end
+
+        result = result.reverse_order!
+
+        limit ? result.reverse : result.first
+      rescue ::ActiveRecord::IrreversibleOrderError
+        ActiveSupport::Deprecation.warn(<<-WARNING.squish)
+            Finding a last element by loading the relation when SQL ORDER
+            can not be reversed is deprecated.
+            Rails 5.1 will raise ActiveRecord::IrreversibleOrderError in this case.
+            Please call `to_a.last` if you still want to load the relation.
+        WARNING
+        find_last(limit)
+      end
+
+
+      def find_nth_with_limit(index, limit)
+        # TODO: once the offset argument is removed from find_nth,
+        # find_nth_with_limit_and_offset can be merged into this method
+        #
+        # CPK
+        # relation = if order_values.empty? && primary_key
+        #             order(arel_attribute(primary_key).asc)
+        #           else
+        #             self
+        #           end
+
+        relation = self
+
+        if order_values.empty? && primary_key
+          if composite?
+            relation = relation.order(primary_keys.map { |pk| arel_attribute(pk).asc })
+          elsif
+            relation = relation.order(arel_attribute(primary_key).asc)
+          end
+        end
+
+        relation = relation.offset(index) unless index.zero?
+        relation.limit(limit).to_a
+      end
+
       def find_one(id)
         # CPK
         # if ActiveRecord::Base === id
@@ -117,14 +167,9 @@ module CompositePrimaryKeys
           MSG
         end
 
-        relation = self
-        values = primary_keys.each_with_index.map do |primary_key, i|
-          column = columns_hash[primary_key]
-          relation.bind_values += [[column, id[i]]]
-          connection.substitute_at(column, bind_values.length - 1)
-        end
-
-        relation = relation.where(cpk_id_predicate(table, primary_keys, values))
+        # CPK
+        #relation = where(primary_key => id)
+        relation = where(cpk_id_predicate(table, primary_keys, id))
         record = relation.take
 
         raise_record_not_found_exception!(id, 0, 1) unless record
@@ -134,33 +179,23 @@ module CompositePrimaryKeys
 
       def find_some(ids)
         # CPK
-        # result = where(table[primary_key].in(ids)).to_a
-
-        result = ids.map do |cpk_ids|
-          cpk_ids = if cpk_ids.length == 1
-            CompositePrimaryKeys::CompositeKeys.parse(cpk_ids.first)
+        if composite?
+          ids = if ids.length == 1
+            ids.first.split(CompositePrimaryKeys::ID_SEP).to_composite_keys
           else
-            cpk_ids.to_composite_keys
-          end
-
-          unless cpk_ids.length == @klass.primary_keys.length
-            raise "#{cpk_ids.inspect}: Incorrect number of primary keys for #{@klass.name}: #{@klass.primary_keys.inspect}"
-          end
-
-          new_relation = clone
-          [@klass.primary_keys, cpk_ids].transpose.map do |key, id|
-            new_relation = new_relation.where(key => id)
+            ids.to_composite_keys
           end
+        end
 
-          records = new_relation.to_a
+        return find_some_ordered(ids) unless order_values.present?
 
-          if records.empty?
-            conditions = new_relation.arel.where_sql
-            raise(::ActiveRecord::RecordNotFound,
-                  "Couldn't find #{@klass.name} with ID=#{cpk_ids} #{conditions}")
-          end
-          records
-        end.flatten
+        # CPK
+        # result = where(primary_key => ids).to_a
+        result = if composite?
+          result = where(cpk_in_predicate(table, primary_keys, ids)).to_a
+        else
+          result = where(primary_key => ids).to_a
+        end
 
         expected_size =
           if limit_value && ids.size > limit_value
@@ -180,6 +215,38 @@ module CompositePrimaryKeys
           raise_record_not_found_exception!(ids, result.size, expected_size)
         end
       end
+
+      def find_some_ordered(ids)
+        ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
+
+        # CPK
+        # result = except(:limit, :offset).where(primary_key => ids).records
+        result = if composite?
+          except(:limit, :offset).where(cpk_in_predicate(table, primary_keys, ids)).records
+        else
+          except(:limit, :offset).where(primary_key => ids).records
+        end
+
+        if result.size == ids.size
+          pk_type = @klass.type_for_attribute(primary_key)
+
+          records_by_id = result.index_by(&:id)
+          # CPK
+          # ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
+          if composite?
+            ids.map do |id|
+              typecasted_id = primary_keys.zip(id).map do |col, val|
+                @klass.type_for_attribute(col).cast(val)
+              end
+              records_by_id.fetch(typecasted_id)
+            end
+          else
+            ids.map { |id| records_by_id.fetch(pk_type.cast(id)) }
+          end
+        else
+          raise_record_not_found_exception!(ids, result.size, ids.size)
+        end
+      end
     end
   end
 end