composite_primary_keys 7.0.13 → 7.0.14

data/lib/composite_primary_keys/associations/preloader/has_and_belongs_to_many.rb

@@ -1,46 +1,46 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class HasAndBelongsToMany
-        def records_for(ids)
-          # CPK
-          # scope = super
-          predicate = cpk_in_predicate(join_table, reflection.foreign_key, ids)
-          scope = build_scope.where(predicate)
-
-          klass.connection.select_all(scope.arel.to_sql, 'SQL', scope.bind_values)
-        end
-
-        def join
-          # CPK
-          #condition = table[reflection.association_primary_key].eq(
-           # join_table[reflection.association_foreign_key])
-          condition = cpk_join_predicate(table, reflection.association_primary_key,
-                                         join_table, reflection.association_foreign_key)
-
-          table.create_join(join_table, table.create_on(condition))
-        end
-
-        def association_key_alias(field)
-          "ar_association_key_name_#{field.to_s}"
-        end
-
-        def join_select
-          # CPK
-          # association_key.as(Arel.sql(association_key_name))
-          Array(reflection.foreign_key).map do |key|
-            join_table[key].as(Arel.sql(association_key_alias(key)))
-          end
-        end
-
-        def association_key_name
-          # CPK
-          # 'ar_association_key_name'
-          Array(reflection.foreign_key).map do |key|
-            association_key_alias(key)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasAndBelongsToMany
+        def records_for(ids)
+          # CPK
+          # scope = super
+          predicate = cpk_in_predicate(join_table, reflection.foreign_key, ids)
+          scope = build_scope.where(predicate)
+
+          klass.connection.select_all(scope.arel.to_sql, 'SQL', scope.bind_values)
+        end
+
+        def join
+          # CPK
+          #condition = table[reflection.association_primary_key].eq(
+           # join_table[reflection.association_foreign_key])
+          condition = cpk_join_predicate(table, reflection.association_primary_key,
+                                         join_table, reflection.association_foreign_key)
+
+          table.create_join(join_table, table.create_on(condition))
+        end
+
+        def association_key_alias(field)
+          "ar_association_key_name_#{field.to_s}"
+        end
+
+        def join_select
+          # CPK
+          # association_key.as(Arel.sql(association_key_name))
+          Array(reflection.foreign_key).map do |key|
+            join_table[key].as(Arel.sql(association_key_alias(key)))
+          end
+        end
+
+        def association_key_name
+          # CPK
+          # 'ar_association_key_name'
+          Array(reflection.foreign_key).map do |key|
+            association_key_alias(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods/dirty.rb

@@ -1,26 +1,26 @@
-module ActiveRecord
-  module AttributeMethods
-    module Dirty
-      def write_attribute(attr, value)
-        # CPK
-        if attr.kind_of?(Array)
-          # A *composite* attribute can't be marked as changed! So do nothing now.
-          # We will come back in here with an *individual* attribute when Write#write_attribute looks through the individual attributes comprising this composite key:
-          # [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
-        else
-          attr = attr.to_s
-
-          save_changed_attribute(attr, value)
-        end
-
-        # Carry on.
-        super(attr, value)
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.class_eval do
-  alias :[]= :write_attribute
-  public :[]=
-end
+module ActiveRecord
+  module AttributeMethods
+    module Dirty
+      def write_attribute(attr, value)
+        # CPK
+        if attr.kind_of?(Array)
+          # A *composite* attribute can't be marked as changed! So do nothing now.
+          # We will come back in here with an *individual* attribute when Write#write_attribute looks through the individual attributes comprising this composite key:
+          # [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
+        else
+          attr = attr.to_s
+
+          save_changed_attribute(attr, value)
+        end
+
+        # Carry on.
+        super(attr, value)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  alias :[]= :write_attribute
+  public :[]=
+end

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -1,35 +1,35 @@
-module ActiveRecord
-  module AttributeMethods
-    module Read
-      def read_attribute(attr_name)
-        if attr_name.kind_of?(Array)
-          attr_name.map {|name| read_attribute(name)}.to_composite_keys
-        else
-          # If it's cached, just return it
-          # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
-          name = attr_name.to_s
-          @attributes_cache[name] || @attributes_cache.fetch(name) {
-            column = @column_types_override[name] if @column_types_override
-            column ||= @column_types[name]
-
-            return @attributes.fetch(name) {
-              if name == 'id' && self.class.primary_key != name
-                read_attribute(self.class.primary_key)
-              end
-            } unless column
-
-            value = @attributes.fetch(name) {
-              return block_given? ? yield(name) : nil
-            }
-
-            if self.class.cache_attribute?(name)
-              @attributes_cache[name] = column.type_cast(value)
-            else
-              column.type_cast value
-            end
-          }
-        end
-      end
-    end
-  end
+module ActiveRecord
+  module AttributeMethods
+    module Read
+      def read_attribute(attr_name)
+        if attr_name.kind_of?(Array)
+          attr_name.map {|name| read_attribute(name)}.to_composite_keys
+        else
+          # If it's cached, just return it
+          # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
+          name = attr_name.to_s
+          @attributes_cache[name] || @attributes_cache.fetch(name) {
+            column = @column_types_override[name] if @column_types_override
+            column ||= @column_types[name]
+
+            return @attributes.fetch(name) {
+              if name == 'id' && self.class.primary_key != name
+                read_attribute(self.class.primary_key)
+              end
+            } unless column
+
+            value = @attributes.fetch(name) {
+              return block_given? ? yield(name) : nil
+            }
+
+            if self.class.cache_attribute?(name)
+              @attributes_cache[name] = column.type_cast(value)
+            else
+              column.type_cast value
+            end
+          }
+        end
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -1,36 +1,36 @@
-module ActiveRecord
-  module AttributeMethods
-    module Write
-      def write_attribute_with_type_cast(attr_name, value, type_cast_method)
-        # CPK
-        if attr_name.kind_of?(Array)
-          value = [nil]*attr_name.length if value.nil?
-          unless value.length == attr_name.length
-            raise "Number of attr_names #{attr_name.inspect} and values #{value.inspect} do not match"
-          end
-          [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
-          value
-        else
-          attr_name = attr_name.to_s
-          # CPK
-          # attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
-          attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key && !self.composite?
-          @attributes_cache.delete(attr_name)
-          column = column_for_attribute(attr_name)
-
-          # If we're dealing with a binary column, write the data to the cache
-          # so we don't attempt to typecast multiple times.
-          if column && column.binary?
-            @attributes_cache[attr_name] = value
-          end
-
-          if column || @attributes.has_key?(attr_name)
-            @attributes[attr_name] = send(type_cast_method, column, value)
-          else
-            raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module AttributeMethods
+    module Write
+      def write_attribute_with_type_cast(attr_name, value, type_cast_method)
+        # CPK
+        if attr_name.kind_of?(Array)
+          value = [nil]*attr_name.length if value.nil?
+          unless value.length == attr_name.length
+            raise "Number of attr_names #{attr_name.inspect} and values #{value.inspect} do not match"
+          end
+          [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
+          value
+        else
+          attr_name = attr_name.to_s
+          # CPK
+          # attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
+          attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key && !self.composite?
+          @attributes_cache.delete(attr_name)
+          column = column_for_attribute(attr_name)
+
+          # If we're dealing with a binary column, write the data to the cache
+          # so we don't attempt to typecast multiple times.
+          if column && column.binary?
+            @attributes_cache[attr_name] = value
+          end
+
+          if column || @attributes.has_key?(attr_name)
+            @attributes[attr_name] = send(type_cast_method, column, value)
+          else
+            raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/base.rb

@@ -111,12 +111,6 @@ module ActiveRecord
         id
       end
 
-      def ==(comparison_object)
-        return false if !persisted? && comparison_object.object_id != object_id
-        return true if equal? comparison_object
-        ids.is_a?(Array) ? super(comparison_object) && ids.all? {|id| !id.nil?} : super(comparison_object)
-      end
-
       def can_change_primary_key_values?
         false
       end

data/lib/composite_primary_keys/composite_arrays.rb

@@ -1,30 +1,30 @@
-module CompositePrimaryKeys
-  ID_SEP     = ','
-  ID_SET_SEP = ';'
-
-  module ArrayExtension
-    def to_composite_keys
-      CompositeKeys.new(self)
-    end
-  end
-
-  class CompositeKeys < Array
-    def self.parse(value)
-      case value
-      when Array
-        value.to_composite_keys
-      when String
-        self.new(value.split(ID_SEP))
-      else
-        raise(ArgumentError, "Unsupported type: #{value}")
-      end
-    end
-
-    def to_s
-      # Doing this makes it easier to parse Base#[](attr_name)
-      join(ID_SEP)
-    end
-  end
-end
-
-Array.send(:include, CompositePrimaryKeys::ArrayExtension)
+module CompositePrimaryKeys
+  ID_SEP     = ','
+  ID_SET_SEP = ';'
+
+  module ArrayExtension
+    def to_composite_keys
+      CompositeKeys.new(self)
+    end
+  end
+
+  class CompositeKeys < Array
+    def self.parse(value)
+      case value
+      when Array
+        value.to_composite_keys
+      when String
+        self.new(value.split(ID_SEP))
+      else
+        raise(ArgumentError, "Unsupported type: #{value}")
+      end
+    end
+
+    def to_s
+      # Doing this makes it easier to parse Base#[](attr_name)
+      join(ID_SEP)
+    end
+  end
+end
+
+Array.send(:include, CompositePrimaryKeys::ArrayExtension)

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

@@ -4,6 +4,9 @@ module ActiveRecord
       if (adapter.to_s =~ /postgresql/) or (adapter.to_s =~ /postgis/)
         require "composite_primary_keys/connection_adapters/postgresql_adapter.rb"
       end
+      if (adapter.to_s =~ /sqlserver/)
+        require "composite_primary_keys/connection_adapters/sqlserver_adapter.rb"
+      end
     end
 
     def self.establish_connection(spec = ENV["DATABASE_URL"])
@@ -61,8 +64,7 @@ module ActiveRecord
         connection_handler.clear_active_connections!
       end
 
-      delegate :clear_reloadable_connections!,
-        :clear_all_connections!,:verify_active_connections!, :to => :connection_handler
+      delegate :clear_reloadable_connections!, :clear_all_connections!, :to => :connection_handler
     end
   end
 end

data/lib/composite_primary_keys/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLServerAdapter
+      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        sql =
+          if pk
+            # support composite primary keys consisting of more than one column name
+            inserted_pks = [pk].flatten.map {|pk| "inserted.#{pk}"}
+            sql.insert(sql.index(/ (DEFAULT )?VALUES/), " OUTPUT #{inserted_pks.join(", ")}")
+          else
+            "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+          end
+        [sql, binds]
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/core.rb

@@ -1,47 +1,47 @@
-module ActiveRecord
-  module Core
-    def init_internals
-      pk = self.class.primary_key
-
-      # CPK
-      #@attributes[pk] = nil unless @attributes.key?(pk)
-      unless self.composite?
-        @attributes[pk] = nil unless @attributes.key?(pk)
-      end
-
-      @aggregation_cache        = {}
-      @association_cache        = {}
-      @attributes_cache         = {}
-      @readonly                 = false
-      @destroyed                = false
-      @marked_for_destruction   = false
-      @destroyed_by_association = nil
-      @new_record               = true
-      @txn                      = nil
-      @_start_transaction_state = {}
-      @transaction_state        = nil
-      @reflects_state           = [false]
-    end
-
-    def initialize_dup(other) # :nodoc:
-      cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
-      self.class.initialize_attributes(cloned_attributes, :serialized => false)
-
-      @attributes = cloned_attributes
-
-      # CPK
-      #@attributes[self.class.primary_key] = nil
-      Array(self.class.primary_key).each {|key| @attributes[key] = nil}
-
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
-
-      @aggregation_cache = {}
-      @association_cache = {}
-      @attributes_cache  = {}
-
-      @new_record  = true
-
-      super
-    end
-  end
-end
+module ActiveRecord
+  module Core
+    def init_internals
+      pk = self.class.primary_key
+
+      # CPK
+      #@attributes[pk] = nil unless @attributes.key?(pk)
+      unless self.composite?
+        @attributes[pk] = nil unless @attributes.key?(pk)
+      end
+
+      @aggregation_cache        = {}
+      @association_cache        = {}
+      @attributes_cache         = {}
+      @readonly                 = false
+      @destroyed                = false
+      @marked_for_destruction   = false
+      @destroyed_by_association = nil
+      @new_record               = true
+      @txn                      = nil
+      @_start_transaction_state = {}
+      @transaction_state        = nil
+      @reflects_state           = [false]
+    end
+
+    def initialize_dup(other) # :nodoc:
+      cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
+      self.class.initialize_attributes(cloned_attributes, :serialized => false)
+
+      @attributes = cloned_attributes
+
+      # CPK
+      #@attributes[self.class.primary_key] = nil
+      Array(self.class.primary_key).each {|key| @attributes[key] = nil}
+
+      run_callbacks(:initialize) unless _initialize_callbacks.empty?
+
+      @aggregation_cache = {}
+      @association_cache = {}
+      @attributes_cache  = {}
+
+      @new_record  = true
+
+      super
+    end
+  end
+end