composite_primary_keys 8.1.6 → 9.0.10

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/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, error_on_ignore: nil)
         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")
+        if arel.orders.present? || arel.taken.present?
+          act_on_order_or_limit_ignored(error_on_ignore)
         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)
         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)
@@ -86,7 +84,6 @@ module CompositePrimaryKeys
         # expects_array = ids.first.kind_of?(Array)
         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
-            cpk_ids.first.split(CompositePrimaryKeys::ID_SEP).to_composite_keys
+        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

data/lib/composite_primary_keys/relation/predicate_builder.rb

@@ -1,37 +1,26 @@
 module ActiveRecord
   class PredicateBuilder
-    def self.expand(klass, table, column, value)
-      queries = []
-
-      # Find the foreign key when using queries such as:
-      # Post.where(author: author)
-      #
-      # For polymorphic relationships, find the foreign key and type:
-      # PriceEstimate.where(estimate_of: treasure)
-      if klass && reflection = klass._reflect_on_association(column)
-        base_class = polymorphic_base_class_from_value(value)
-
-        if reflection.polymorphic? && base_class
-          queries << build(table[reflection.foreign_type], base_class)
-        end
-
-        column = reflection.foreign_key
+    silence_warnings do
+      def expand(column, value)
+        # Find the foreign key when using queries such as:
+        # Post.where(author: author)
+        #
+        # For polymorphic relationships, find the foreign key and type:
+        # PriceEstimate.where(estimate_of: treasure)
 
         # CPK
-        # if base_class
-        if base_class && !(Base === value && value.composite?)
-          primary_key = reflection.association_primary_key(base_class)
-          value = convert_value_to_association_ids(value, primary_key)
+        if Base === Array(value).first && Array(value).first.composite? && reflection = table.associated_with?(column)
+          columns = reflection.foreign_key
+          values = Array(value).map{|v| columns.map{|c| v.public_send(c) }}
+          cpk_predicate_builder = Class.new.extend(CompositePrimaryKeys::Predicates)
+          predicate = cpk_predicate_builder.cpk_in_predicate(table.send(:arel_table), columns, values)
+          return predicate
+        else
+          # Original code
+          value = AssociationQueryHandler.value_for(table, column, value) if table.associated_with?(column)
+          build(table.arel_attribute(column), value)
         end
       end
-
-      #CPK
-      if Base === value && value.composite?
-        queries << cpk_id_predicate(table, column, value.id)
-      else
-        queries << build(table[column], value)
-      end
-      queries
     end
   end
-end
+end

data/lib/composite_primary_keys/relation/query_methods.rb

@@ -1,41 +1,30 @@
-module CompositePrimaryKeys::ActiveRecord::QueryMethods
+module CompositePrimaryKeys
+  module ActiveRecord
+    module QueryMethods
+      def reverse_sql_order(order_query)
+        # CPK
+        # order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
 
-  def reverse_sql_order(order_query)
-    # CPK
-    # order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
+        # break apart CPKs
+        order_query = primary_key.map do |key|
+          "#{quoted_table_name}.#{connection.quote_column_name(key)} ASC"
+        end if order_query.empty?
 
-    # break apart CPKs
-    order_query = primary_key.map do |key|
-      "#{quoted_table_name}.#{connection.quote_column_name(key)} ASC"
-    end if order_query.empty?
-
-    order_query.map do |o|
-      case o
-      when Arel::Nodes::Ordering
-        o.reverse
-      when String, Symbol
-        o.to_s.split(',').collect do |s|
-          s.strip!
-          s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
-        end
-      else
-        o
-      end
-    end.flatten
-  end
-
-
-  def order(*args)
-    args.map! do |arg|
-      if arg.is_a?(Arel::Nodes::Ordering) && arg.expr.name.is_a?(Array)
-        arg = arg.expr.name.map do |key|
-          cloned_node = arg.clone
-          cloned_node.expr.name = key
-          cloned_node
-        end
+        order_query.map do |o|
+          case o
+            when Arel::Nodes::Ordering
+              o.reverse
+            when String, Symbol
+              o.to_s.split(',').collect do |s|
+                s.strip!
+                s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+              end
+            else
+              o
+          end
+        end.flatten
       end
-      arg
-    end if composite?
-    super(*args)
+    end
   end
 end
+

data/lib/composite_primary_keys/relation/where_clause.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  class Relation
+    class WhereClause
+      silence_warnings do
+        def to_h(table_name = nil)
+          equalities = predicates.grep(Arel::Nodes::Equality)
+
+          # CPK Adds this line, because ours are coming in with AND->{EQUALITY, EQUALITY}
+          equalities = predicates.grep(Arel::Nodes::And).map(&:children).flatten.grep(Arel::Nodes::Equality) if equalities.empty?
+
+          if table_name
+            equalities = equalities.select do |node|
+              node.left.relation.name == table_name
+            end
+          end
+
+          binds = self.binds.map { |attr| [attr.name, attr.value] }.to_h
+
+          equalities.map do |node|
+            name = node.left.name
+            [name, binds.fetch(name.to_s) {
+              case node.right
+              when Array then node.right.map(&:val)
+              when Arel::Nodes::Casted, Arel::Nodes::Quoted
+                node.right.val
+              end
+            }]
+          end.to_h
+        end
+      end
+    end
+  end
+end