composite_primary_keys 9.0.4 → 9.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5b83b2dfe1e8d6585047dd3a54fecc92c3b54d5
-  data.tar.gz: ddaa05937db47260356966115e0a16daa13f9e44
+  metadata.gz: 2a7db1ee79736fa3b98274e9577f650d27c239cd
+  data.tar.gz: 4e121d1420ba01fc56073d176888687ca78d2177
 SHA512:
-  metadata.gz: f30b4ef085f3aa5c0b48ddaf7805b8752838b928cafee0268951e6e281756c8f306e05f0bd4ff5972ddeb9b824c8d4a167818db4991eb4b01db9df531949aee9
-  data.tar.gz: 0c13040b7a4e4dc05d994dcd04856ba3f383d469a7ecfea28df07b09a0a617d1e27f56bf1acad6dc62cc3bdc4656e50df96cf53dfe6cead575edc4e0c0ff1903
+  metadata.gz: 94556da0f6cfb30ed3285635ebcdbff725d5c7ad9098c3de8b63c3920c93ae1739ab27608f2c32113c8514a688ab1fadd5effddfe05b8c67ccaaed39c7f56b69
+  data.tar.gz: df406dbc3ec9c24df294088f033ec760af5602a3ce09891ad23f5f0200bdfbba4658cf4765fc65c5f4df86ca9f749ee9f7740fb3f7c430751d201e649dd7a7c1

data/History.rdoc

@@ -1,3 +1,19 @@
+== 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)
 
@@ -13,6 +29,10 @@
 == 9.0.0.beta1 (2016-04-16)
 * Rails 5 beta support (Sammy Larbi)
 
+== 8.1.5 (2017-01-01)
+
+* Don't nest PK twice when looking up id, fixes #319 (Kerey Roper)
+
 == 8.1.4 (2016-07-27)
 
 * Create OR predicates in a nicely balanced tree fixing #320 (Nathan Samson)

data/Rakefile

@@ -1,34 +1,37 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rubygems/package_task'
-
-# Set global variable so other tasks can access them
-::PROJECT_ROOT = File.expand_path(".")
-::GEM_NAME = 'composite_primary_keys'
-
-# Read the spec file
-spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
-
-# Setup Rake tasks for managing the gem
-Gem::PackageTask.new(spec).define
-
-# Now load in other task files
-Dir.glob('tasks/**/*.rake').each do |rake_file|
-  load File.join(File.dirname(__FILE__), 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|
-  namespace adapter do
-    desc "Run tests using the #{adapter} adapter"
-    task "test" do
-      ENV["ADAPTER"] = adapter
-      Rake::TestTask.new("subtest_#{adapter}") do |t|
-        t.libs << "test"
-      end
-      Rake::Task["subtest_#{adapter}"].invoke
-    end
-  end
-end
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rubygems/package_task'
+
+# Set global variable so other tasks can access them
+::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")
+
+# Setup Rake tasks for managing the gem
+Gem::PackageTask.new(spec).define
+
+# Now load in other task files
+Dir.glob('tasks/**/*.rake').each do |rake_file|
+  load File.join(File.dirname(__FILE__), rake_file)
+end
+
+# Set up test tasks for each supported connection 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
+      ENV["ADAPTER"] = adapter
+      Rake::TestTask.new("subtest_#{adapter}") do |t|
+        t.libs << "test"
+      end
+      Rake::Task["subtest_#{adapter}"].invoke
+    end
+  end
+end

data/lib/composite_primary_keys.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2012 Nic Williams and Charlie Savage
+# Copyright (c) 2006-2016 Nic Williams and Charlie Savage
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -58,6 +58,7 @@ require 'active_record/locking/optimistic'
 require 'active_record/nested_attributes'
 
 require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/abstract_mysql_adapter'
 
 require 'active_record/relation/batches'
 require 'active_record/relation/where_clause'
@@ -66,8 +67,6 @@ require 'active_record/relation/finder_methods'
 require 'active_record/relation/predicate_builder'
 require 'active_record/relation/query_methods'
 
-require 'active_record/validations/uniqueness' unless ENV["TESTING_CPK"] == "true"
-
 # CPK files
 require 'composite_primary_keys/persistence'
 require 'composite_primary_keys/base'
@@ -89,11 +88,8 @@ require 'composite_primary_keys/associations/join_dependency'
 require 'composite_primary_keys/associations/join_dependency/join_association'
 require 'composite_primary_keys/associations/preloader/association'
 require 'composite_primary_keys/associations/preloader/belongs_to'
-require 'composite_primary_keys/associations/singular_association'
 require 'composite_primary_keys/associations/collection_association'
 
-require 'composite_primary_keys/dirty'
-
 require 'composite_primary_keys/attribute_methods/primary_key'
 require 'composite_primary_keys/attribute_methods/read'
 require 'composite_primary_keys/attribute_methods/write'
@@ -101,7 +97,7 @@ require 'composite_primary_keys/locking/optimistic'
 require 'composite_primary_keys/nested_attributes'
 
 require 'composite_primary_keys/connection_adapters/abstract_adapter'
-require 'composite_primary_keys/connection_adapters/abstract/connection_specification_changes'
+require 'composite_primary_keys/connection_adapters/abstract_mysql_adapter'
 
 require 'composite_primary_keys/relation/batches'
 require 'composite_primary_keys/relation/where_clause'
@@ -110,9 +106,8 @@ require 'composite_primary_keys/relation/finder_methods'
 require 'composite_primary_keys/relation/predicate_builder'
 require 'composite_primary_keys/relation/query_methods'
 
-require 'composite_primary_keys/validations/uniqueness'
-
 require 'composite_primary_keys/composite_relation'
 
 require 'composite_primary_keys/arel/in'
-require 'composite_primary_keys/arel/to_sql'
+require 'composite_primary_keys/arel/to_sql'
+require 'composite_primary_keys/arel/sqlserver'

data/lib/composite_primary_keys/arel/in.rb

@@ -1,6 +1,6 @@
-module CompositePrimaryKeys
-  module Nodes
-    class In < ::Arel::Nodes::Equality
-    end
-  end
-end
+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
+            [t[column_name]]
+          else
+            nil
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -1,44 +1,66 @@
 module ActiveRecord
   module Associations
     class AssociationScope
-      silence_warnings do
-        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
-          # CPK
-          # constraint = table[key].eq(foreign_table[foreign_key])
-          constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
+      def self.get_bind_values(owner, chain)
+        binds = []
+        last_reflection = chain.last
+
+        # CPK
+        # binds << last_reflection.join_id_for(owner)
+        values = last_reflection.join_id_for(owner)
+        binds += Array(values)
+
+        if last_reflection.type
+          binds << owner.class.base_class.name
+        end
+
+        chain.each_cons(2).each do |reflection, next_reflection|
           if reflection.type
-            value = transform_value(next_reflection.klass.base_class.name)
-            scope = scope.where(table.name => { reflection.type => value })
+            binds << next_reflection.klass.base_class.name
           end
+        end
+        binds
+      end
 
-          scope = scope.joins(join(foreign_table, constraint))
+      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
+        #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)
 
-        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
-          if key.kind_of?(Array) || foreign_key.kind_of?(Array)
-            predicate = cpk_join_predicate(table, key, owner, foreign_key)
-            scope = scope.where(predicate)
-          else
-            value = transform_value(owner[foreign_key])
-            scope = scope.where(table.name => { key => value })
-          end
+        if reflection.type
+          polymorphic_type = transform_value(owner.class.base_class.name)
+          scope = scope.where(table.name => { reflection.type => polymorphic_type })
+        end
 
-          if reflection.type
-            polymorphic_type = transform_value(owner.class.base_class.name)
-            scope = scope.where(table.name => { reflection.type => polymorphic_type })
-          end
+        scope
+      end
 
-          scope
+      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
+
+        # CPK
+        # constraint = table[key].eq(foreign_table[foreign_key])
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+
+        if reflection.type
+          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/attribute_methods/read.rb

@@ -8,7 +8,9 @@ module ActiveRecord
             _read_attribute(attr_name, &block)
           else
             name = attr_name.to_s
-            name = self.class.primary_key if name == 'id'.freeze
+            # CPK
+            #name = self.class.primary_key if name == 'id'.freeze
+            name = self.class.primary_key if name == 'id'.freeze && !composite?
             _read_attribute(name, &block)
           end
         end

data/lib/composite_primary_keys/connection_adapters/abstract_mysql_adapter.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter
+      def subquery_for(key, select)
+        subsubselect = select.clone
+        subsubselect.projections = [key]
+
+        # Materialize subquery by adding distinct
+        # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
+        subsubselect.distinct unless select.limit || select.offset || select.orders.any?
+
+        subselect = Arel::SelectManager.new(select.engine)
+
+        # CPK
+        #subselect.project Arel.sql(key.name)
+        subselect.project Arel.sql(Array(key).map(&:name).join(', '))
+
+        subselect.from subsubselect.as('__active_record_temp')
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation.rb

@@ -47,6 +47,36 @@ module ActiveRecord
       end
     end
 
+    def update_all(updates)
+      raise ArgumentError, "Empty list of attributes to change" if updates.blank?
+
+      stmt = Arel::UpdateManager.new
+
+      stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
+      stmt.table(table)
+
+      if joins_values.any?
+        # CPK
+        #@klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
+        if primary_key.kind_of?(Array)
+          attributes = primary_key.map do |key|
+            arel_attribute(key)
+          end
+          @klass.connection.join_to_update(stmt, arel, attributes.to_composite_keys)
+        else
+          @klass.connection.join_to_update(stmt, arel, arel_attribute(primary_key))
+        end
+      else
+        stmt.key = arel_attribute(primary_key)
+        stmt.take(arel.limit)
+        stmt.order(*arel.orders)
+        stmt.wheres = arel.constraints
+      end
+
+      @klass.connection.update stmt, 'SQL', bound_attributes
+    end
+
+
     def delete_all(conditions = nil)
       invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select { |method|
         if MULTI_VALUE_METHODS.include?(method)

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
+