composite_primary_keys 8.1.1 → 8.1.2

data/lib/composite_primary_keys/composite_relation.rb

@@ -1,48 +1,48 @@
-module CompositePrimaryKeys
-  module CompositeRelation
-    include CompositePrimaryKeys::ActiveRecord::Batches
-    include CompositePrimaryKeys::ActiveRecord::Calculations
-    include CompositePrimaryKeys::ActiveRecord::FinderMethods
-    include CompositePrimaryKeys::ActiveRecord::QueryMethods
-
-    def delete(id_or_array)
-      # CPK
-      if self.composite?
-        id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
-                        [id_or_array]
-                      else
-                        Array(id_or_array)
-                      end
-
-        id_or_array.each do |id|
-          # Is the passed in id actually a record?
-          id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
-          where(cpk_id_predicate(table, self.primary_key, id)).delete_all
-        end
-      else
-        where(primary_key => id_or_array).delete_all
-      end
-    end
-
-    def destroy(id_or_array)
-      # Without CPK:
-      #if id.is_a?(Array)
-      #  id.map { |one_id| destroy(one_id) }
-      #else
-      #  find(id).destroy
-      #end
-
-      id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
-        [id_or_array]
-      else
-        Array(id_or_array)
-      end
-
-      id_or_array.each do |id|
-        where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
-          record.destroy
-        end
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module CompositeRelation
+    include CompositePrimaryKeys::ActiveRecord::Batches
+    include CompositePrimaryKeys::ActiveRecord::Calculations
+    include CompositePrimaryKeys::ActiveRecord::FinderMethods
+    include CompositePrimaryKeys::ActiveRecord::QueryMethods
+
+    def delete(id_or_array)
+      # CPK
+      if self.composite?
+        id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
+                        [id_or_array]
+                      else
+                        Array(id_or_array)
+                      end
+
+        id_or_array.each do |id|
+          # Is the passed in id actually a record?
+          id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
+          where(cpk_id_predicate(table, self.primary_key, id)).delete_all
+        end
+      else
+        where(primary_key => id_or_array).delete_all
+      end
+    end
+
+    def destroy(id_or_array)
+      # Without CPK:
+      #if id.is_a?(Array)
+      #  id.map { |one_id| destroy(one_id) }
+      #else
+      #  find(id).destroy
+      #end
+
+      id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
+        [id_or_array]
+      else
+        Array(id_or_array)
+      end
+
+      id_or_array.each do |id|
+        where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
+          record.destroy
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/abstract/connection_specification_changes.rb

@@ -1,10 +1,10 @@
 module ActiveRecord
   class Base
     def self.load_cpk_adapter(adapter)
-      if (adapter.to_s =~ /postgresql/) or (adapter.to_s =~ /postgis/)
+      if adapter.to_s =~ /postgresql/ || adapter.to_s =~ /postgis/
         require "composite_primary_keys/connection_adapters/postgresql_adapter.rb"
       end
-      if (adapter.to_s =~ /sqlserver/)
+      if adapter.to_s =~ /sqlserver/
         require "composite_primary_keys/connection_adapters/sqlserver_adapter.rb"
       end
     end

data/lib/composite_primary_keys/connection_adapters/postgresql_adapter.rb

@@ -1,46 +1,19 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class PostgreSQLAdapter
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        unless pk
-          # Extract the table from the insert sql. Yuck.
-          table_ref = extract_table_ref_from_insert_sql(sql)
-          pk = primary_key(table_ref) if table_ref
-        end
-
-        if pk
-          # CPK
-          # select_value("#{sql} RETURNING #{quote_column_name(pk)}")
-          select_value("#{sql} RETURNING #{quote_column_names(pk)}")
-        else
-          super
-        end
-      end
-      alias :create :insert
-
-      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-        unless pk
-          # Extract the table from the insert sql. Yuck.
-          table_ref = extract_table_ref_from_insert_sql(sql)
-          pk = primary_key(table_ref) if table_ref
-        end
-
-        # CPK
-        # sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
-        sql = "#{sql} RETURNING #{quote_column_names(pk)}" if pk
-
-        [sql, binds]
-      end
-
-      # Returns a single value if query returns a single element
-      # otherwise returns an array coresponding to the composite keys
-      #
-      def last_inserted_id(result)
-        row = result && result.rows.first
-        if Array === row
-          row.size == 1 ? row[0] : row
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module Quoting
+        def quote_column_name(name)
+          # CPK
+          # PGconn.quote_ident(name.to_s)
+          if name.is_a?(Array)
+            name.map do |column|
+              PGconn.quote_ident(column.to_s)
+            end.join(', ')
+          else
+            PGconn.quote_ident(name.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/sqlserver_adapter.rb

@@ -3,15 +3,19 @@ module ActiveRecord
     class SQLServerAdapter
       def sql_for_insert(sql, pk, id_value, sequence_name, binds)
         sql = if pk && self.class.use_output_inserted
-          # support composite primary keys consisting of more than one column name
+          # CPK
+          # quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
+          # sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
           quoted_pks = [pk].flatten.map {|pk| "INSERTED.#{SQLServer::Utils.extract_identifiers(pk).quoted}"}
           sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT #{quoted_pks.join(", ")}"
-#          p sql
         else
           "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
         end
+
+        # CPK
+        # super
         [sql, binds]
       end
-        end
-      end
+    end
+  end
 end

data/lib/composite_primary_keys/fixtures.rb

@@ -1,22 +1,26 @@
-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.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
+    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/locking/optimistic.rb

@@ -1,55 +1,54 @@
-  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?
-                stmt = relation.where(
-                  relation.cpk_id_predicate(relation.table, self.class.primary_key, id_was).and(
-                    relation.table[lock_col].eq(self.class.quote_value(previous_lock_value, column_for_attribute(lock_col)))
-                  )
-                ).arel.compile_update(
-                  arel_attributes_with_values_for_update(attribute_names),
-                  self.class.primary_key
-                )
-              else
-                stmt = relation.where(
-                  relation.table[self.class.primary_key].eq(id).and(
-                    relation.table[lock_col].eq(self.class.quote_value(previous_lock_value, column_for_attribute(lock_col)))
-                  )
-                ).arel.compile_update(
-                  arel_attributes_with_values_for_update(attribute_names),
-                  self.class.primary_key
-                )
-              end
-
-              affected_rows = self.class.connection.update stmt
-
-              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
+  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
+          end
+        end
+    end
+  end
+end

data/lib/composite_primary_keys/relation.rb

@@ -16,20 +16,23 @@ module ActiveRecord
       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
+      # CPK
+      nodes_from_and = where_values.grep(Arel::Nodes::And).map { |and_node|
+        and_node.children.grep(Arel::Nodes::Equality)
+      }.flatten
 
+      # 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) {
@@ -48,6 +51,7 @@ module ActiveRecord
       # 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
@@ -55,8 +59,11 @@ module ActiveRecord
         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)
+
+        relation = scope.where(@klass.primary_key => (id_was || id))
+        binds += relation.bind_values
+
+        relation.arel.compile_update(substitutes, @klass.primary_key)
       end
 
       @klass.connection.update(

data/lib/composite_primary_keys/relation/batches.rb

@@ -2,33 +2,39 @@ module CompositePrimaryKeys
   module ActiveRecord
     module Batches
       def find_in_batches(options = {})
+        options.assert_valid_keys(:start, :batch_size)
+
         relation = self
+        start = options[:start]
+        batch_size = options[:batch_size] || 1000
 
-        unless arel.orders.blank? && arel.taken.blank?
-          ::ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+        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
         end
 
-        if (finder_options = options.except(:start, :batch_size)).present?
-          raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order].present?
-          raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit].present?
-
-          relation = apply_finder_options(finder_options)
+        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
 
-        start = options.delete(:start).to_i
-        batch_size = options.delete(:batch_size) || 1000
-
         relation = relation.reorder(batch_order).limit(batch_size)
 
         # CPK
-        # records = relation.where(table[primary_key].gteq(start)).all
-        records = self.primary_key.reduce(relation) do |rel, key|
-          rel.where(table[key].gteq(start))
-        end
+        # 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
 
         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
 
           yield records
 
@@ -51,11 +57,9 @@ module CompositePrimaryKeys
 
               Arel::Nodes::Grouping.new(and_clause)
             end.reduce(:or)
-
-            records = relation.where(query)
-          else
-            raise "Primary key not included in the custom select clause"
           end
+
+          records = relation.where(query)
         end
       end
 
@@ -70,7 +74,7 @@ module CompositePrimaryKeys
 
       def batch_order
         # CPK
-        #"#{quoted_table_name}.#{quoted_primary_key} ASC"
+        # "#{quoted_table_name}.#{quoted_primary_key} ASC"
         self.primary_key.map do |key|
           "#{quoted_table_name}.#{key} ASC"
         end.join(",")