composite_primary_keys 8.1.6 → 9.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1f837ed1d8f5f9a5af46c14b91dfed1101e55de3
-  data.tar.gz: e115fe2d97338b6d2aa19132be1f936f107dea74
+SHA256:
+  metadata.gz: 133a4025b9fe7ee82617de7c3c34373d8f52d38d5e88c03ab742ebd954bf6064
+  data.tar.gz: 579e4d9e564e4c9e40f976d0d56b76533296c8f7e5b5ba925d7244141604fb08
 SHA512:
-  metadata.gz: f81ee887e2a3145def527fbdce440bd2cc986fa2a03d4fef914e269e642ba355d09c307cb8be25723d6d79fed632fe238cd28376fb6734a549de54d7b9f16a2a
-  data.tar.gz: 2e0166164b07de368e07758d72029c6461fab1596d311c11634b8c4e97dfd4159a3593d5acde2af2b60eec7701b7214f8487824b3b6185d687df064b5ebe91ef
+  metadata.gz: 334933952b9a84db67746c48c074c38d197215fa607640e134bf7aedd564e122a0c809318fab4529e0ad5bd181081baa792395419b25a4b19149066122cdfdfc
+  data.tar.gz: 2820381f390429bbdf61b0a04434c0432faa88d2cffdb04c5cd74f9dfc26682893809531b2d4dc14b03620614bec0ce1a69e128624b6a511b5718b19e24c9970

data/History.rdoc

@@ -1,11 +1,62 @@
-== 8.1.6 (2017-05-20)
+== 9.0.10 (2018-06-24)
 
-Query cache with bind params (ttw)
-Fix TestIds#test_set_ids_string. Sqlite's serial and integer are a bit different (Boris Peterbarg)
-Associations with inverse fix (Boris Peterbarg)
-Fix save_has_one_association and add a test for it (Boris Peterbarg)
-Fix save_belongs_to_association override (Boris Peterbarg)
-Extend approach from #344 to fix autosave for has_one associations as well (Cameron Finucane)
+* Fix AR 5.0.7 (Jordan Owens)
+
+== 9.0.9 (2018-03-06)
+
+* Fix update statements that incorrectly pass NULL values for the primary key components (Sean Linsley)
+
+== 9.0.8 (2017-10-11)
+
+* Fix Paper Trail compatibility (Sean Linsley)
+
+== 9.0.7 (2017-05-22)
+
+* Update sqlite3 to support deletes and updates (Charlie Savage)
+* Specify version for sql server gem so it works with Rails 5.0 (Charlie Savage)
+* Use `datetime` datatype to address Invalid default value for updated_at (Yasuo Honda)
+* Fix ORA-00900 error when it attempts to execute blank statement (pustomytnyk)
+* Override ActiveRecord::Associations::CollectionAssociation#ids_reader (pustomytnyk)
+* Only define #primary_keys if #primary_keys=(value) is called (Charlie Savage)
+* Change `timestamp` to `datetime` for MySQL as ActiveRecord timestamps type does (Oriol Collel)
+* Fix incorrect case statement to get PK for SQLServer (Oriol Collel)
+* Fixes random failures in test_preload_of_polymorphic_association (Boris Peterbarg)
+
+== 9.0.6 (2017-01-08)
+
+* Uncomment tests (Sammy Larbi)
+* Update readme (Charlie Savage)
+
+== 9.0.5 (2017-01-02)
+
+* Don't nest PK twice when looking up id, fixes #319 (Kerey Roper)
+* Simplify database setup  for tests (Charlie Savage)
+* Revamp gem management (Charlie Savage)
+* Add support for Relation#update_all when using joins (Charlie Savage)
+* Add erb support to test database.yml files (Charlie Savage)
+* Sqlserver fixes for ordering (Charlie Savage)
+* Sqlserver refresh (Charlie Savage)
+* Oracle refresh (Charlie Savage)
+* Fix delete_all for MySql (Charlie Savage)
+* Added test cases for preloading associations with and without conditions (Martin Körner)
+* Revamp single association handling to correctly setup SQL binds (Charlie Savage)
+* Remove references to ActiveModel - #352 (Charlie Savage)
+* Fixes for #232, #359, #367 and #371 (Charlie Savage)
+
+== 9.0.4 (2016-08-17)
+* Do not set associations to readonly.  See https://github.com/rails/rails/issues/24093 (Charlie Savage)
+
+== 9.0.2 (2016-08-10)
+* Fix delete_all when used with a join (Charlie Savage)
+
+== 9.0.1 (2016-07-27)
+* Create OR predicates in a nicely balanced tree fixing #320 (Nathan Samson)
+
+== 9.0.0 (2016-07-06)
+* Support connection_specification_name in rails5.0.0.rc1 (pocari)
+
+== 9.0.0.beta1 (2016-04-16)
+* Rails 5 beta support (Sammy Larbi)
 
 == 8.1.5 (2017-01-01)
 
@@ -38,6 +89,7 @@ Extend approach from #344 to fix autosave for has_one associations as well (Came
 * Remove call to verify_active_connections! which was removed from AR 4.1 (Steve Pletcher)
 * Aligned the establish connection paramater handling to be similar to latest version of rails (Harish Shetty)
 
+
 == 8.1.0 (2014-03-23)
 
 * ActiveRecord 4.2.1 support (Charlie Savage)

data/README.rdoc

@@ -20,6 +20,7 @@ Every major version of ActiveRecord has included numerous internal changes.  As
 CPK has to be rewritten for each version of ActiveRecord.  To help keep
 things straight, here is the mapping:
 
+    Version 9.x is designed to work with ActiveRecord 5.0.x
     Version 8.x is designed to work with ActiveRecord 4.2.x
     Version 7.x is designed to work with ActiveRecord 4.1.x
     Version 6.x is designed to work with ActiveRecord 4.0.x
@@ -97,9 +98,69 @@ CPK supports the following databases:
 
 == Tests
 
+To run tests you first need to install the appropriate gems for the database you want to test.  Database gems are
+divided into the following bundler groups:
+
+ * mysql
+ * oracle
+ * postgresql
+ * sqlite
+ * sqlserver
+
+Since it is likely you do not have all the above databases installed on your computer, you want to install just the
+gems for your database.  For example, to test postgresql you would install the appropriate gems like this:
+
+  bundler install --without "mysql oracle sqlite sqlserver"
+
+Once you have installed the appropriate gems, the next step is to create the test database. There is a rake
+command for each database. Using our example:
+
+  rake postgresql:build_database
+
+You can also rebuild the database if it already exists using this command:
+
+  rake postgresql:rebuild_database
+
+To get a list of commands for your database use:
+
+  Rake -T
+
+Finally, to run tests:
+
+  rake postgresql:test
+
 Travis build status: {<img src="https://travis-ci.org/composite-primary-keys/composite_primary_keys.svg" alt="Build Status" />}[https://travis-ci.org/composite-primary-keys/composite_primary_keys]
 
-See test/README_tests.rdoc for more information about running tests.
+=== DB2
+
+DB2 is no longer supported due to difficulties in getting the ibm_db2 gem to build.  Thus tests
+have not been run against db2.
+
+=== MariaDb (mysql)
+
+MariaDb is fully supported with all tests passing.
+
+=== Oracle
+
+Oracle is fully supported with all tests passing.
+
+=== Postgresql
+
+Postgresql is fully supported with all tests passing.
+
+=== Sqlite 3
+
+The sqlite database is created at the path composite_primary_keys/db.  Note you must *first* create the database using the
+built-in rake task before running tests:
+
+  rake sqlite:build_database
+
+Note not all tests currently pass on sqlite3.  These failures happen when trying to DELETE records where the query
+includes a JOIN.
+
+=== SqlServer
+
+SqlServer is partially supported.  There are a number of failing tests - patches welcomed.
 
 == Questions, Discussion and Contributions
 

data/Rakefile

@@ -8,6 +8,9 @@ require 'rubygems/package_task'
 ::PROJECT_ROOT = File.expand_path(".")
 ::GEM_NAME = 'composite_primary_keys'
 
+require File.join(PROJECT_ROOT, 'lib', 'composite_primary_keys')
+require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
+
 # Read the spec file
 spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
 
@@ -20,7 +23,7 @@ Dir.glob('tasks/**/*.rake').each do |rake_file|
 end
 
 # Set up test tasks for each supported connection adapter
-%w(mysql sqlite3 oracle oracle_enhanced postgresql ibm_db sqlserver).each do |adapter|
+%w(mysql sqlite oracle oracle_enhanced postgresql ibm_db sqlserver).each do |adapter|
   namespace adapter do
     desc "Run tests using the #{adapter} adapter"
     task "test" do

data/lib/composite_primary_keys/arel/in.rb

@@ -0,0 +1,6 @@
+module CompositePrimaryKeys
+  module Nodes
+    class In < ::Arel::Nodes::Equality
+    end
+  end
+end

data/lib/composite_primary_keys/arel/sqlserver.rb

@@ -0,0 +1,36 @@
+module Arel
+  module Visitors
+    class SQLServer
+      def make_Fetch_Possible_And_Deterministic o
+        return if o.limit.nil? && o.offset.nil?
+        t = table_From_Statement o
+        pk = primary_Key_From_Table t
+        return unless pk
+        if o.orders.empty?
+          # Prefer deterministic vs a simple `(SELECT NULL)` expr.
+          # CPK
+          #o.orders = [pk.asc]
+          o.orders = pk.map {|a_pk| a_pk.asc}
+        end
+      end
+
+      def primary_Key_From_Table t
+        return unless t
+        column_name = schema_cache.primary_keys(t.name) || column_cache(t.name).first.second.try(:name)
+
+        # CPK
+        # column_name ? t[column_name] : nil
+        case column_name
+          when Array
+            column_name.map do |name|
+              t[name]
+            end
+          when NilClass
+            nil
+          else
+            [t[column_name]]
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/arel/to_sql.rb

@@ -0,0 +1,26 @@
+module Arel
+  module Visitors
+    class ToSql
+      def visit_CompositePrimaryKeys_Nodes_In o, collector
+        collector << "("
+        visit(o.left, collector)
+        collector << ")"
+        collector << " IN ("
+        visit(o.right, collector) << ")"
+      end
+
+      def visit_CompositePrimaryKeys_CompositeKeys o, collector
+        values = o.map do |key|
+          case key
+            when Arel::Attributes::Attribute
+              "#{key.relation.name}.#{key.name}"
+            else
+              key
+          end
+        end
+        collector << "#{values.join(', ')}"
+        collector
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association.rb

@@ -1,22 +1,24 @@
 module ActiveRecord
   module Associations
     class Association
-      def creation_attributes
-        attributes = {}
+      silence_warnings do
+        def creation_attributes
+          attributes = {}
 
-        if (reflection.has_one? || reflection.collection?) && !options[:through]
-          # CPK
-          # attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
-          Array(reflection.foreign_key).zip(Array(reflection.active_record_primary_key)).each do |key1, key2|
-            attributes[key1] = owner[key2]
-          end
+          if (reflection.has_one? || reflection.collection?) && !options[:through]
+            # CPK
+            # attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+            Array(reflection.foreign_key).zip(Array(reflection.active_record_primary_key)).each do |key1, key2|
+              attributes[key1] = owner[key2]
+            end
 
-          if reflection.options[:as]
-            attributes[reflection.type] = owner.class.base_class.name
+            if reflection.options[:as]
+              attributes[reflection.type] = owner.class.base_class.name
+            end
           end
-        end
 
-        attributes
+          attributes
+        end
       end
     end
   end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -23,49 +23,44 @@ module ActiveRecord
         binds
       end
 
-      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
-        join_keys = reflection.join_keys(assoc_klass)
+      def last_chain_scope(scope, table, reflection, owner, association_klass)
+        join_keys = reflection.join_keys(association_klass)
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
         # CPK
-        # constraint = table[key].eq(foreign_table[foreign_key])
-        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+        #value = transform_value(owner[foreign_key])
+        #scope = scope.where(table.name => { key => value })
+        mappings = Array(key).zip(Array(foreign_key))
+        joins = mappings.reduce(Hash.new) do |hash, mapping|
+          hash[mapping.first] = transform_value(owner[mapping.last])
+          hash
+        end
+        scope = scope.where(table.name => joins)
 
         if reflection.type
-          value    = next_reflection.klass.base_class.name
-          bind_val = bind scope, table.table_name, reflection.type, value, tracker
-          scope    = scope.where(table[reflection.type].eq(bind_val))
+          polymorphic_type = transform_value(owner.class.base_class.name)
+          scope = scope.where(table.name => { reflection.type => polymorphic_type })
         end
 
-        scope.joins(join(foreign_table, constraint))
+        scope
       end
 
-      def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
-        join_keys = reflection.join_keys(assoc_klass)
+      def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(association_klass)
         key = join_keys.key
         foreign_key = join_keys.foreign_key
 
-        if key.kind_of?(Array) || foreign_key.kind_of?(Array)
-          key = Array(key) unless key.kind_of?(Array)
-          foreign_key = Array(foreign_key) unless foreign_key.kind_of?(Array)
-          key.zip(foreign_key).map do |k, fk|
-            bind_val = bind scope, table.table_name, k.to_s, owner[fk], tracker
-            scope    = scope.where(table[k].eq(bind_val))
-          end
-        else
-          bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
-          scope    = scope.where(table[key].eq(bind_val))
-        end
+        # CPK
+        # constraint = table[key].eq(foreign_table[foreign_key])
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
         if reflection.type
-          value    = owner.class.base_class.name
-          bind_val = bind scope, table.table_name, reflection.type, value, tracker
-
-          scope.where(table[reflection.type].eq(bind_val))
-        else
-          scope
+          value = transform_value(next_reflection.klass.base_class.name)
+          scope = scope.where(table.name => { reflection.type => value })
         end
+
+        scope = scope.joins(join(foreign_table, constraint))
       end
     end
   end

data/lib/composite_primary_keys/associations/collection_association.rb

@@ -1,15 +1,46 @@
 module CompositePrimaryKeys
   module CollectionAssociation
-    extend ActiveSupport::Concern
-    included do
-      def get_records_with_cpk_support
-        cpk_applies = (target && target.respond_to?(:composite?) && target.composite?) || (owner && owner.respond_to?(:composite?) && owner.composite?)
-        return scope.to_a if cpk_applies
-        get_records_without_cpk_support
+    def get_records
+      cpk_applies = target.try(:composite?) || owner.try(:composite?)
+      return scope.to_a if cpk_applies
+      super
+    end
+
+    def ids_reader
+      if loaded?
+        load_target.map do |record|
+          if reflection.association_primary_key.is_a?(Array)
+            reflection.association_primary_key.map { |key| record.send(key) }
+          else
+            record.send(reflection.association_primary_key)
+          end
+        end
+      else
+        @association_ids ||= (
+        column = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
+        scope.pluck(column)
+        )
+      end
+    end
+
+    def ids_writer(ids)
+      pk_type = reflection.primary_key_type
+      ids = Array(ids).reject(&:blank?)
+      ids.map! { |i| pk_type.cast(i) }
+      # CPK
+      if reflection.association_primary_key.is_a?(Array)
+        predicate = Class.new.extend(CompositePrimaryKeys::Predicates).cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
+        records = klass.where(predicate).index_by do |r|
+          reflection.association_primary_key.map{ |k| r.send(k) }
+        end.values_at(*ids)
+      else
+        records = klass.where(reflection.association_primary_key => ids).index_by do |r|
+          r.send(reflection.association_primary_key)
+        end.values_at(*ids)
       end
-      alias_method_chain :get_records, :cpk_support
+      replace(records)
     end
   end
 end
 
-ActiveRecord::Associations::CollectionAssociation.send(:include, CompositePrimaryKeys::CollectionAssociation)
+ActiveRecord::Associations::CollectionAssociation.prepend CompositePrimaryKeys::CollectionAssociation

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,6 +1,23 @@
 module ActiveRecord
   module Associations
     class HasManyAssociation
+      include CompositePrimaryKeys::Predicates
+
+      def delete_records(records, method)
+        if method == :destroy
+          records.each(&:destroy!)
+          update_counter(-records.length) unless reflection.inverse_updates_counter_cache?
+          return
+        # Zerista
+        elsif self.reflection.klass.composite?
+          predicate = cpk_in_predicate(self.scope.table, self.reflection.klass.primary_keys, records.map(&:id))
+          scope = self.scope.where(predicate)
+        else
+          scope = self.scope.where(reflection.klass.primary_key => records)
+        end
+        update_counter(-delete_count(method, scope))
+      end
+
       def delete_count(method, scope)
         if method == :delete_all
           scope.delete_all
@@ -15,46 +32,6 @@ module ActiveRecord
         end
       end
 
-      def delete_records(records, method)
-        if method == :destroy
-          records.each(&:destroy!)
-          update_counter(-records.length) unless inverse_updates_counter_cache?
-        else
-          if records == :all || !reflection.klass.primary_key
-            scope = self.scope
-          else
-            # CPK
-            # scope = self.scope.where(reflection.klass.primary_key => records)
-            table = Arel::Table.new(reflection.table_name)
-            and_conditions = records.map do |record|
-              eq_conditions = Array(reflection.association_primary_key).map do |name|
-                table[name].eq(record[name])
-              end
-              Arel::Nodes::And.new(eq_conditions)
-            end
-
-            condition = and_conditions.shift
-            and_conditions.each do |and_condition|
-              condition = condition.or(and_condition)
-            end
-
-            scope = self.scope.where(condition)
-          end
-
-          if method == :delete_all
-            update_counter(-scope.delete_all)
-          else
-            # CPK
-            # update_counter(-scope.update_all(reflection.foreign_key => nil))
-            update_hash = Array(reflection.foreign_key).inject(Hash.new) do |hash, key|
-              hash[key] = nil
-              hash
-            end
-            update_counter(-scope.update_all(update_hash))
-          end
-        end
-      end
-
       def foreign_key_present?
         if reflection.klass.primary_key
           # CPK

data/lib/composite_primary_keys/associations/has_many_through_association.rb

@@ -13,79 +13,79 @@ module ActiveRecord
         cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
       end
 
-      def delete_records(records, method)
-        ensure_not_nested
+      silence_warnings do
+        def delete_records(records, method)
+          ensure_not_nested
 
-        scope = through_association.scope
-        # CPK
-        # scope.where! construct_join_attributes(*records)
-        source_klass = source_reflection.polymorphic? ? klass : source_reflection.klass
-        if source_klass.composite?
-          scope.where! cpk_join_through_predicate(*records)
-        else
-          scope.where! construct_join_attributes(*records)
-        end
-
-        case method
-        when :destroy
-          if scope.klass.primary_key
-            count = scope.destroy_all.length
+          scope = through_association.scope
+          # CPK
+          # scope.where! construct_join_attributes(*records)
+          if source_reflection.klass.composite?
+            scope.where! cpk_join_through_predicate(*records)
           else
-            scope.to_a.each do |record|
-              record.run_callbacks :destroy
-            end
+            scope.where! construct_join_attributes(*records)
+          end
 
-            arel = scope.arel
+          case method
+          when :destroy
+            if scope.klass.primary_key
+              count = scope.destroy_all.length
+            else
+              scope.to_a.each do |record|
+                record.run_callbacks :destroy
+              end
 
-            stmt = Arel::DeleteManager.new arel.engine
-            stmt.from scope.klass.arel_table
-            stmt.wheres = arel.constraints
+              arel = scope.arel
 
-            count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+              stmt = Arel::DeleteManager.new arel.engine
+              stmt.from scope.klass.arel_table
+              stmt.wheres = arel.constraints
+
+              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+            end
+          when :nullify
+            count = scope.update_all(source_reflection.foreign_key => nil)
+          else
+            count = scope.delete_all
           end
-        when :nullify
-          count = scope.update_all(source_reflection.foreign_key => nil)
-        else
-          count = scope.delete_all
-        end
 
-        delete_through_records(records)
+          delete_through_records(records)
 
-        if source_reflection.options[:counter_cache] && method != :destroy
-          counter = source_reflection.counter_cache_column
-          klass.decrement_counter counter, records.map(&:id)
-        end
+          if source_reflection.options[:counter_cache] && method != :destroy
+            counter = source_reflection.counter_cache_column
+            klass.decrement_counter counter, records.map(&:id)
+          end
 
-        if through_reflection.collection? && update_through_counter?(method)
-          update_counter(-count, through_reflection)
-        end
+          if through_reflection.collection? && update_through_counter?(method)
+            update_counter(-count, through_reflection)
+          end
 
-        update_counter(-count)
-      end
+          update_counter(-count)
+        end
 
-      def through_records_for(record)
-        # CPK
-        # attributes = construct_join_attributes(record)
-        # candidates = Array.wrap(through_association.target)
-        # candidates.find_all do |c|
-        #   attributes.all? do |key, value|
-        #     c.public_send(key) == value
-        #   end
-        # end
-        if record.composite?
-          candidates = Array.wrap(through_association.target)
-          candidates.find_all { |c| c.attributes.slice(*source_reflection.association_primary_key) == record.ids_hash }
-        else
-          attributes = construct_join_attributes(record)
-          candidates = Array.wrap(through_association.target)
-          candidates.find_all do |c|
-            attributes.all? do |key, value|
-              c.public_send(key) == value
+        def through_records_for(record)
+          # CPK
+          # attributes = construct_join_attributes(record)
+          # candidates = Array.wrap(through_association.target)
+          # candidates.find_all do |c|
+          #   attributes.all? do |key, value|
+          #     c.public_send(key) == value
+          #   end
+          # end
+          if record.composite?
+            candidates = Array.wrap(through_association.target)
+            candidates.find_all { |c| c.attributes.slice(*source_reflection.association_primary_key) == record.ids_hash }
+          else
+            attributes = construct_join_attributes(record)
+            candidates = Array.wrap(through_association.target)
+            candidates.find_all do |c|
+              attributes.all? do |key, value|
+                c.public_send(key) == value
+              end
             end
           end
         end
       end
-
     end
   end
 end

data/lib/composite_primary_keys/associations/join_dependency/join_association.rb

@@ -2,19 +2,21 @@ module ActiveRecord
   module Associations
     class JoinDependency
       class JoinAssociation
-        def build_constraint(klass, table, key, foreign_table, foreign_key)
-          # CPK
-          # constraint = table[key].eq(foreign_table[foreign_key])
-          constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+        silence_warnings do
+          def build_constraint(klass, table, key, foreign_table, foreign_key)
+            # CPK
+            # constraint = table[key].eq(foreign_table[foreign_key])
+            constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
-          if klass.finder_needs_type_condition?
-            constraint = table.create_and([
-              constraint,
-              klass.send(:type_condition, table)
-            ])
-          end
+            if klass.finder_needs_type_condition?
+              constraint = table.create_and([
+                constraint,
+                klass.send(:type_condition, table)
+              ])
+            end
 
-          constraint
+            constraint
+          end
         end
       end
     end