composite_primary_keys 7.0.16 → 8.0.0

data/lib/composite_primary_keys/fixtures.rb

@@ -1,22 +1,22 @@
-module ActiveRecord
-  class Fixture
-    def find
-      if model_class
-        # CPK
-        # model_class.find(fixture[model_class.primary_key])
-        ids = self.ids(model_class.primary_key)
-        model_class.find(ids)
-      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]
-      end
-    end
-  end
-end
+module ActiveRecord
+  class Fixture
+    def find
+      if model_class
+        # CPK
+        # model_class.find(fixture[model_class.primary_key])
+        ids = self.ids(model_class.primary_key)
+        model_class.find(ids)
+      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]
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/persistence.rb

@@ -1,61 +1,57 @@
-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]]]
-        end
-
-        relation
-      else
-        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]]
-        relation
-      end
-    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
-
-      unless attributes.empty?
-        current_time = current_time_from_proper_timezone
-        changes = {}
-
-        attributes.each do |column|
-          column = column.to_s
-          changes[column] = write_attribute(column, current_time)
-        end
-
-        changes[self.class.locking_column] = increment_lock if locking_enabled?
-
-        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
-  end
+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]]]
+        end
+
+        relation
+      else
+        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]]
+        relation
+      end
+    end
+
+    def touch(*names)
+      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+
+      attributes = timestamp_attributes_for_update_in_model
+      attributes.concat(names)
+
+      unless attributes.empty?
+        current_time = current_time_from_proper_timezone
+        changes = {}
+
+        attributes.each do |column|
+          column = column.to_s
+          changes[column] = write_attribute(column, current_time)
+        end
+
+        changes[self.class.locking_column] = increment_lock if locking_enabled?
+
+        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
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/relation.rb

@@ -1,56 +1,68 @@
-module ActiveRecord
-  class Relation
-    alias :initialize_without_cpk :initialize
-    def initialize(klass, table, values = {})
-      initialize_without_cpk(klass, table, values)
-      add_cpk_support if klass && klass.composite?
-    end
-
-    alias :initialize_copy_without_cpk :initialize_copy
-    def initialize_copy(other)
-      initialize_copy_without_cpk(other)
-      add_cpk_support if klass.composite?
-    end
-
-    def add_cpk_support
-      extend CompositePrimaryKeys::CompositeRelation
-    end
-
-    # 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
-    # }
-    alias :where_values_hash_without_cpk :where_values_hash
-    def where_values_hash(relation_table_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 == 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) { where.right }]
-      }]
-    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
-        @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
+module ActiveRecord
+  class Relation
+    alias :initialize_without_cpk :initialize
+    def initialize(klass, table, values = {})
+      initialize_without_cpk(klass, table, values)
+      add_cpk_support if klass && klass.composite?
+    end
+
+    alias :initialize_copy_without_cpk :initialize_copy
+    def initialize_copy(other)
+      initialize_copy_without_cpk(other)
+      add_cpk_support if klass.composite?
+    end
+
+    def add_cpk_support
+      extend CompositePrimaryKeys::CompositeRelation
+    end
+
+    # 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
+    # }
+    alias :where_values_hash_without_cpk :where_values_hash
+    def where_values_hash(relation_table_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 == 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
+        
+        scope.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

data/lib/composite_primary_keys/relation/calculations.rb

@@ -1,75 +1,79 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Calculations
-      def aggregate_column(column_name)
-        # CPK
-        if column_name.kind_of?(Array)
-          column_name.map do |column|
-            Arel::Attribute.new(@klass.unscoped.table, column)
-          end
-        elsif @klass.column_names.include?(column_name.to_s)
-          Arel::Attribute.new(@klass.unscoped.table, column_name)
-        else
-          Arel.sql(column_name == :all ? "*" : column_name.to_s)
-        end
-      end
-
-      def execute_simple_calculation(operation, column_name, distinct)
-        # Postgresql doesn't like ORDER BY when there are no GROUP BY
-        relation = reorder(nil)
-
-        column_alias = column_name
-        # CPK
-        #if operation == "count" && (relation.limit_value || relation.offset_value)
-        if operation == "count"
-          # Shortcut when limit is zero.
-          return 0 if relation.limit_value == 0
-
-          query_builder = build_count_subquery(relation, column_name, distinct)
-        else
-          column = aggregate_column(column_name)
-
-          select_value = operation_over_aggregate_column(column, operation, distinct)
-          column_alias = select_value.alias
-
-          relation.select_values = [select_value]
-
-          query_builder = relation.arel
-        end
-
-        result = @klass.connection.select_all(query_builder, nil, relation.bind_values)
-        row    = result.first
-        value  = row && row.values.first
-        column = result.column_types.fetch(column_alias) do
-          column_for(column_name)
-        end
-
-        type_cast_calculated_value(value, column, operation)
- 
-      end
-
-      def build_count_subquery(relation, column_name, distinct)
-        return super(relation, column_name, distinct) unless column_name.kind_of?(Array)
-        # CPK
-        # column_alias = Arel.sql('count_column')
-        subquery_alias = Arel.sql('subquery_for_count')
-
-        # CPK
-        # aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
-        # relation.select_values = [aliased_column]
-        relation.select_values = column_name.map do |column|
-          Arel::Attribute.new(@klass.unscoped.table, column)
-        end
-
-        relation = relation.distinct(true)
-        subquery = relation.arel.as(subquery_alias)
-
-        sm = Arel::SelectManager.new relation.engine
-        # CPK
-        # select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
-        select_value = operation_over_aggregate_column(Arel.sql("*"), 'count', false)
-        sm.project(select_value).from(subquery)
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Calculations
+      def aggregate_column(column_name)
+        # CPK
+        if column_name.kind_of?(Array)
+          column_name.map do |column|
+            Arel::Attribute.new(@klass.unscoped.table, column)
+          end
+        elsif @klass.column_names.include?(column_name.to_s)
+          Arel::Attribute.new(@klass.unscoped.table, column_name)
+        else
+          Arel.sql(column_name == :all ? "*" : column_name.to_s)
+        end
+      end
+
+      def execute_simple_calculation(operation, column_name, distinct)
+        # 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"
+          # Shortcut when limit is zero.
+          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)
+
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+
+          column_alias = select_value.alias
+          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)
+        row    = result.first
+        value  = row && row.values.first
+        column = result.column_types.fetch(column_alias) do
+          type_for(column_name)
+        end
+
+        type_cast_calculated_value(value, column, operation)
+      end
+
+      def build_count_subquery(relation, column_name, distinct)
+        return super(relation, column_name, distinct) unless column_name.kind_of?(Array)
+        # CPK
+        # column_alias = Arel.sql('count_column')
+        subquery_alias = Arel.sql('subquery_for_count')
+
+        # CPK
+        # aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
+        # relation.select_values = [aliased_column]
+        relation.select_values = column_name.map do |column|
+          Arel::Attribute.new(@klass.unscoped.table, column)
+        end
+
+        relation = relation.distinct(true)
+        subquery = relation.arel.as(subquery_alias)
+
+        sm = Arel::SelectManager.new relation.engine
+        # CPK
+        # select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
+        select_value = operation_over_aggregate_column(Arel.sql("*"), 'count', false)
+        sm.project(select_value).from(subquery)
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -1,196 +1,175 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module FinderMethods
-      def apply_join_dependency(relation, join_dependency)
-        relation = relation.except(:includes, :eager_load, :preload)
-        relation = relation.joins join_dependency
-
-        if using_limitable_reflections?(join_dependency.reflections)
-          relation
-        else
-          if relation.limit_value
-            limited_ids = limited_ids_for(relation)
-            # CPK
-            #limited_ids.empty? ? relation.none! : relation.where!(table[primary_key].in(limited_ids))
-            limited_ids.empty? ? relation.none! : relation.where!(cpk_in_predicate(table, self.primary_keys, limited_ids))
-          end
-          relation.except(:limit, :offset)
-        end
-      end
-
-      def limited_ids_for(relation)
-        # CPK
-        #values = @klass.connection.columns_for_distinct(
-        #  "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
-        columns = @klass.primary_keys.map do |key|
-          "#{quoted_table_name}.#{connection.quote_column_name(key)}"
-        end
-        values = @klass.connection.columns_for_distinct(columns, relation.order_values)
-
-        relation = relation.except(:select).select(values).distinct!
-
-        id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
-
-        # CPK
-        #id_rows.map {|row| row[primary_key]}
-        id_rows.map {|row| row.values}
-      end
-
-      def exists?(conditions = :none)
-        # conditions can be:
-        #   Array - ['department_id = ? and location_id = ?', 1, 1]
-        #   Array -> [1,2]
-        #   CompositeKeys -> [1,2]
-
-        conditions = conditions.id if ::ActiveRecord::Base === conditions
-        return false if !conditions
-
-        relation = apply_join_dependency(self, construct_join_dependency)
-        return false if ::ActiveRecord::NullRelation === relation
-
-        relation = relation.except(:select, :order).select(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit(1)
-
-        # CPK
-        #case conditions
-        #when Array, Hash
-        #  relation = relation.where(conditions)
-        #else
-        #  relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
-        #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
-            relation = relation.where(conditions)
-          end
-        when Hash
-          relation = relation.where(conditions)
-        end
-
-        connection.select_value(relation, "#{name} Exists", relation.bind_values) ? true : false
-      end
-
-      def find_with_ids(*ids)
-        # CPK handle strings that come w/ calling to_param on CPK-enabled models
-        ids = parse_ids(ids)
-        raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
-
-        expects_array = ids.first.kind_of?(Array)
-        return ids.first if expects_array && ids.first.empty?
-
-        # CPK - don't do this, we want an array of arrays
-        #ids = ids.flatten.compact.uniq
-        case ids.size
-          when 0
-            raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
-          when 1
-            result = find_one(ids.first)
-            # CPK
-            # expects_array ? [ result ] : result
-            result
-          else
-            find_some(ids)
-        end
-      end
-
-      def find_one(id)
-        # CPK
-        #id = id.id if ActiveRecord::Base === id
-        id = id.id if ::ActiveRecord::Base === id
-
-        # CPK
-        #column = columns_hash[primary_key]
-        #substitute = connection.substitute_at(column, bind_values.length)
-        #relation = where(table[primary_key].eq(substitute))
-        #relation.bind_values += [[column, id]]
-        #record = relation.take
-        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))
-
-        record = relation.take
-        raise_record_not_found_exception!(id, 0, 1) unless record
-        record
-      end
-
-      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
-          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)
-          end
-
-          records = new_relation.to_a
-
-          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
-
-        expected_size =
-          if limit_value && ids.size > limit_value
-            limit_value
-          else
-            ids.size
-          end
-
-        # 11 ids with limit 3, offset 9 should give 2 results.
-        if offset_value && (ids.size - offset_value < expected_size)
-          expected_size = ids.size - offset_value
-        end
-
-        if result.size == expected_size
-          result
-        else
-          raise_record_not_found_exception!(ids, result.size, expected_size)
-        end
-      end
-
-      private
-      def parse_ids(ids)
-        result = []
-        ids.each do |id|
-          if id.is_a?(String)
-            if id.index(",")
-              result << [id.split(",")]
-            else
-              result << [id]
-            end
-          elsif id.is_a?(Array) && id.count > 1 && id.first.to_s.index(",")
-            result << id.map{|subid| subid.split(",")}
-          else
-            result << [id]
-          end
-        end
-        result = result.flatten(1)
-        return result
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module FinderMethods
+      def apply_join_dependency(relation, join_dependency)
+        relation = relation.except(:includes, :eager_load, :preload)
+        relation = relation.joins join_dependency
+
+        if using_limitable_reflections?(join_dependency.reflections)
+          relation
+        else
+          if relation.limit_value
+            limited_ids = limited_ids_for(relation)
+            # CPK
+            #limited_ids.empty? ? relation.none! : relation.where!(table[primary_key].in(limited_ids))
+            limited_ids.empty? ? relation.none! : relation.where!(cpk_in_predicate(table, self.primary_keys, limited_ids))
+          end
+          relation.except(:limit, :offset)
+        end
+      end
+
+      def limited_ids_for(relation)
+        # CPK
+        #values = @klass.connection.columns_for_distinct(
+        #  "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
+        columns = @klass.primary_keys.map do |key|
+          "#{quoted_table_name}.#{connection.quote_column_name(key)}"
+        end
+        values = @klass.connection.columns_for_distinct(columns, relation.order_values)
+
+        relation = relation.except(:select).select(values).distinct!
+
+        id_rows = @klass.connection.select_all(relation.arel, 'SQL', relation.bind_values)
+
+        # CPK
+        #id_rows.map {|row| row[primary_key]}
+        id_rows.map {|row| row.values}
+      end
+      
+      def exists?(conditions = :none)
+        # conditions can be:
+        #   Array - ['department_id = ? and location_id = ?', 1, 1]
+        #   Array -> [1,2]
+        #   CompositeKeys -> [1,2]
+
+        conditions = conditions.id if ::ActiveRecord::Base === conditions
+        return false if !conditions
+
+        relation = apply_join_dependency(self, construct_join_dependency)
+        return false if ::ActiveRecord::NullRelation === relation
+
+        relation = relation.except(:select, :order).select(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit(1)
+
+        # CPK
+        #case conditions
+        #when Array, Hash
+        #  relation = relation.where(conditions)
+        #else
+        #  relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
+        #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
+            relation = relation.where(conditions)
+          end
+        when Hash
+          relation = relation.where(conditions)
+        end
+
+        connection.select_value(relation, "#{name} Exists", relation.bind_values) ? true : false
+      end
+      
+      def find_with_ids(*ids)
+        # CPK handle strings that come w/ calling to_param on CPK-enabled models
+        ids = cpk_parse_ids(ids)
+        raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
+
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
+
+        # CPK - don't do this, we want an array of arrays
+        #ids = ids.flatten.compact.uniq
+        case ids.size
+          when 0
+            raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+          when 1
+            result = find_one(ids.first)
+            # CPK
+            # expects_array ? [ result ] : result
+            result
+          else
+            find_some(ids)
+        end
+      end
+
+      def find_one(id)
+        # CPK
+        #id = id.id if ActiveRecord::Base === id
+        id = id.id if ::ActiveRecord::Base === id
+
+        # CPK
+        #column = columns_hash[primary_key]
+        #substitute = connection.substitute_at(column, bind_values.length)
+        #relation = where(table[primary_key].eq(substitute))
+        #relation.bind_values += [[column, id]]
+        #record = relation.take
+        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))
+        record = relation.take
+        raise_record_not_found_exception!(id, 0, 1) unless record
+        record
+      end
+
+      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
+          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)
+          end
+
+          records = new_relation.to_a
+
+          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
+
+        expected_size =
+          if limit_value && ids.size > limit_value
+            limit_value
+          else
+            ids.size
+          end
+
+        # 11 ids with limit 3, offset 9 should give 2 results.
+        if offset_value && (ids.size - offset_value < expected_size)
+          expected_size = ids.size - offset_value
+        end
+
+        if result.size == expected_size
+          result
+        else
+          raise_record_not_found_exception!(ids, result.size, expected_size)
+        end
+      end
+    end
+  end
+end