composite_primary_keys 10.0.5 → 11.0.0.beta1

data/lib/composite_primary_keys/relation/batches.rb

@@ -7,17 +7,11 @@ module CompositePrimaryKeys
           return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
         end
 
-        if arel.orders.present?
-          act_on_ignored_order(error_on_ignore)
+        if arel.orders.present? || arel.taken.present?
+          act_on_order_or_limit_ignored(error_on_ignore)
         end
 
-        batch_limit = of
-        if limit_value
-          remaining   = limit_value
-          batch_limit = remaining if remaining < batch_limit
-        end
-
-        relation = relation.reorder(batch_order).limit(batch_limit)
+        relation = relation.reorder(batch_order).limit(of)
         relation = apply_limits(relation, start, finish)
         batch_relation = relation
 
@@ -45,22 +39,9 @@ module CompositePrimaryKeys
 
           yield yielded_relation
 
-          break if ids.length < batch_limit
-
-          if limit_value
-            remaining -= ids.length
-
-            if remaining == 0
-              # Saves a useless iteration when the limit is a multiple of the
-              # batch size.
-              break
-            elsif remaining < batch_limit
-              relation = relation.limit(remaining)
-            end
-          end
-
+          break if ids.length < of
           # CPK
-          batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
+          # batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
           batch_relation = if composite?
             # CPK
             # Lexicographically select records
@@ -95,11 +76,9 @@ module CompositePrimaryKeys
       end
 
       def batch_order
-        # CPK
-        # "#{quoted_table_name}.#{quoted_primary_key} ASC"
         self.primary_key.map do |key|
-          "#{quoted_table_name}.#{key} ASC"
-        end.join(",")
+          arel_attribute(key).asc
+        end
       end
     end
   end

data/lib/composite_primary_keys/relation/calculations.rb

@@ -15,22 +15,25 @@ module CompositePrimaryKeys
       end
 
       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
 
         # CPK
-        # if operation == "count" && (relation.limit_value || relation.offset_value)
+        #if operation == "count" && has_limit_or_offset?
         if operation == "count"
           # Shortcut when limit is zero.
-          return 0 if relation.limit_value == 0
+          return 0 if limit_value == 0
 
-          query_builder = build_count_subquery(relation, column_name, distinct)
+          query_builder = build_count_subquery(spawn, column_name, distinct)
         else
+          # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
+          relation = unscope(:order).distinct!(false)
+
           column = aggregate_column(column_name)
 
           select_value = operation_over_aggregate_column(column, operation, distinct)
+          if operation == "sum" && distinct
+            select_value.distinct = true
+          end
 
           column_alias = select_value.alias
           column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
@@ -39,38 +42,35 @@ module CompositePrimaryKeys
           query_builder = relation.arel
         end
 
-        result = @klass.connection.select_all(query_builder, nil, bound_attributes)
+        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder, nil) }
         row    = result.first
         value  = row && row.values.first
-        column = result.column_types.fetch(column_alias) do
+        type   = result.column_types.fetch(column_alias) do
           type_for(column_name)
         end
 
-        type_cast_calculated_value(value, column, operation)
+        type_cast_calculated_value(value, type, 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')
+        relation.select_values = [
+            if column_name == :all
+              distinct ? table[Arel.star] : Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE)
+            # CPK
+            elsif column_name.is_a?(Array)
+              relation.select_values = column_name.map do |column|
+                Arel::Attribute.new(@klass.unscoped.table, column)
+              end
+            else
+              column_alias = Arel.sql("count_column")
+              aggregate_column(column_name).as(column_alias)
+            end
+        ]
 
-        # 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
+        subquery = relation.arel.as(Arel.sql("subquery_for_count"))
+        select_value = operation_over_aggregate_column(column_alias || Arel.star, "count", false)
 
-        relation = relation.distinct(true)
-        subquery = relation.arel.as(subquery_alias)
-
-        sm = Arel::SelectManager.new relation.engine
-        sm.bind_values = relation.arel.bind_values
-        # 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)
+        Arel::SelectManager.new(subquery).project(select_value)
       end
     end
   end

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -1,9 +1,8 @@
 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
+      def apply_join_dependency(join_dependency = construct_join_dependency)
+        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
         if using_limitable_reflections?(join_dependency.reflections)
           relation
@@ -11,7 +10,7 @@ module CompositePrimaryKeys
           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!(primary_key => limited_ids)
             limited_ids.empty? ? relation.none! : relation.where!(cpk_in_predicate(table, self.primary_keys, limited_ids))
           end
           relation.except(:limit, :offset)
@@ -21,37 +20,28 @@ module CompositePrimaryKeys
       def limited_ids_for(relation)
         # CPK
         # values = @klass.connection.columns_for_distinct(
-        #     "#{quoted_table_name}.#{quoted_primary_key}", relation.order_values)
+        #     connection.column_name_from_arel_node(arel_attribute(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!
-        arel = relation.arel
-
-        id_rows = @klass.connection.select_all(arel, 'SQL', relation.bound_attributes)
 
+        id_rows = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, "SQL") }
         # CPK
-        #id_rows.map {|row| row[primary_key]}
-        id_rows.map {|row| row.values}
+        # id_rows.map { |row| row[primary_key] }
+         id_rows.map do |row|
+           @klass.primary_keys.map do |key|
+            row[key]
+           end
+         end
       end
 
-      def exists?(conditions = :none)
-        if ::ActiveRecord::Base === conditions
-          conditions = conditions.id
-          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
-        end
-
-        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)
+      def construct_relation_for_exists(conditions)
+        relation = except(:select, :distinct, :order)._select!(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit!(1)
 
         case conditions
           # CPK
@@ -62,7 +52,7 @@ module CompositePrimaryKeys
             pk_length = @klass.primary_keys.length
 
             if conditions.length == pk_length # E.g. conditions = ['France', 'Paris']
-              return self.exists?(conditions.to_composite_keys)
+              return self.construct_relation_for_exists(conditions.to_composite_keys)
             else # Assume that conditions contains where relation
               relation = relation.where(conditions)
             end
@@ -74,7 +64,7 @@ module CompositePrimaryKeys
             end
         end
 
-        connection.select_value(relation, "#{name} Exists", relation.bound_attributes) ? true : false
+        relation
       end
 
       def find_with_ids(*ids)
@@ -90,17 +80,21 @@ module CompositePrimaryKeys
         # ids = ids.flatten.compact.uniq
         ids = expects_array ? ids.first : ids
 
+        model_name = @klass.name
+
         case ids.size
           when 0
-            raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+            error_message = "Couldn't find #{model_name} without an ID"
+            raise RecordNotFound.new(error_message, model_name, primary_key)
           when 1
             result = find_one(ids.first)
             expects_array ? [ result ] : result
           else
             find_some(ids)
         end
-      rescue RangeError
-        raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"
+      rescue ::RangeError
+        error_message = "Couldn't find #{model_name} with an out of range ID"
+        raise RecordNotFound.new(error_message, model_name, primary_key, ids)
       end
 
       def last(limit = nil)
@@ -130,32 +124,6 @@ module CompositePrimaryKeys
         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
@@ -247,6 +215,16 @@ module CompositePrimaryKeys
           raise_record_not_found_exception!(ids, result.size, ids.size)
         end
       end
+
+      def ordered_relation
+        if order_values.empty? && primary_key
+          # CPK
+          #order(arel_attribute(primary_key).asc)
+          order(Array(primary_key).map {|key| arel_attribute(key).asc})
+        else
+          self
+        end
+      end
     end
   end
 end

data/lib/composite_primary_keys/relation/predicate_builder/association_query_value.rb

@@ -0,0 +1,18 @@
+module ActiveRecord
+  class PredicateBuilder
+    class AssociationQueryValue
+      def queries
+        # CPK
+        if associated_table.association_join_foreign_key.is_a?(Array)
+          result = associated_table.association_join_foreign_key.zip(ids).reduce(Hash.new) do |hash, pair|
+            hash[pair.first.to_s] = pair.last
+            hash
+          end
+          [result]
+        else
+          [associated_table.association_join_foreign_key.to_s => ids]
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/query_methods.rb

@@ -2,27 +2,39 @@ 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?
+        if order_query.empty?
+          # CPK
+          # return [arel_attribute(primary_key).desc] if primary_key
 
-        # break apart CPKs
-        order_query = primary_key.map do |key|
-          "#{quoted_table_name}.#{connection.quote_column_name(key)} ASC"
-        end if order_query.empty?
+          if primary_key
+            # break apart CPKs
+            return primary_key.map do |key|
+              arel_attribute(key).desc
+            end
+          else
+            raise IrreversibleOrderError,
+                  "Relation has no current order and table has no primary key to be used as default order"
+          end
+        end
 
-        order_query.map do |o|
+        order_query.flat_map do |o|
           case o
+            when Arel::Attribute
+              o.desc
             when Arel::Nodes::Ordering
               o.reverse
-            when String, Symbol
-              o.to_s.split(',').collect do |s|
+            when String
+              if does_not_support_reverse?(o)
+                raise IrreversibleOrderError, "Order #{o.inspect} can not be reversed automatically"
+              end
+              o.split(",").map! do |s|
                 s.strip!
-                s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+                s.gsub!(/\sasc\Z/i, " DESC") || s.gsub!(/\sdesc\Z/i, " ASC") || (s << " DESC")
               end
             else
               o
           end
-        end.flatten
+        end
       end
     end
   end

data/lib/composite_primary_keys/relation/where_clause.rb

@@ -1,32 +1,23 @@
 module ActiveRecord
   class Relation
     class WhereClause
-      silence_warnings do
-        def to_h(table_name = nil)
-          equalities = predicates.grep(Arel::Nodes::Equality)
+      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?
+        # 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
+        if table_name
+          equalities = equalities.select do |node|
+            node.left.relation.name == table_name
           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
+
+        equalities.map { |node|
+          name = node.left.name.to_s
+          value = extract_node_value(node.right)
+          [name, value]
+        }.to_h
       end
     end
   end

data/lib/composite_primary_keys/sanitization.rb

@@ -1,8 +1,6 @@
 module ActiveRecord
   module Sanitization
     module ClassMethods
-      protected
-
       def expand_hash_conditions_for_aggregates(attrs)
         expanded_attrs = {}
         attrs.each do |attr, value|

data/lib/composite_primary_keys/version.rb

@@ -1,8 +1,8 @@
 module CompositePrimaryKeys
   module VERSION
-    MAJOR = 10
+    MAJOR = 11
     MINOR = 0
-    TINY  = 5
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    TINY  = 0
+    STRING = [MAJOR, MINOR, TINY, 'beta1'].join('.')
   end
 end