composite_primary_keys 12.0.2 → 12.0.10

data/lib/composite_primary_keys/composite_arrays.rb

@@ -49,14 +49,6 @@ module CompositePrimaryKeys
       end
     end
 
-    def in(other)
-      case other
-        when Arel::SelectManager
-          Arel::Nodes::In.new(self, other.ast)
-      end
-    end
-
-
     def to_s
       # Doing this makes it easier to parse Base#[](attr_name)
       map { |key| Utils.escape_string_key(key.to_s) }.join(ID_SEP)

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

@@ -1,17 +1,37 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module DatabaseStatements
-      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        sql, binds = to_sql_and_binds(arel, binds)
-        value = exec_insert(sql, name, binds, pk, sequence_name)
-
-        # CPK
-        if value && pk.is_a?(Array)
-          id_value || value.rows.first
-        else
-          id_value || last_inserted_id(value)
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module DatabaseStatements
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        sql, binds = to_sql_and_binds(arel, binds)
+        value = exec_insert(sql, name, binds, pk, sequence_name)
+
+        return id_value if id_value
+
+        if pk.is_a?(Array) && !value.empty?
+          # This is a CPK model and the query result is not empty. Thus we can figure out the new ids for each
+          # auto incremented field
+          pk.map {|key| value.first[key]}
+        elsif pk.is_a?(Array)
+          # This is CPK, but we don't know what autoincremented fields were updated.
+          result = Array.new(pk.size)
+
+          # Is there an autoincrementing field?
+          auto_key = pk.find do |key|
+            attribute = arel.ast.relation[key]
+            column = column_for_attribute(attribute)
+            if column.respond_to?(:auto_increment?)
+              column.auto_increment?
+            end
+          end
+
+          if auto_key
+            result[pk.index(auto_key)] = last_inserted_id(value)
+          end
+          result
+        else
+          last_inserted_id(value)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/sqlserver/database_statements.rb

@@ -1,23 +1,44 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServer
-      module DatabaseStatements
-        def sql_for_insert(sql, pk, binds)
-          sql = if pk && self.class.use_output_inserted
-            # 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.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT #{quoted_pks.join(", ")}"
-          else
-            "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
-          end
-
-          # CPK
-          # super
-          [sql, binds]
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module DatabaseStatements
+        def sql_for_insert(sql, pk, binds)
+          if pk.nil?
+            table_name = query_requires_identity_insert?(sql)
+            pk = primary_key(table_name)
+          end
+
+          sql = if pk && use_output_inserted? && !database_prefix_remote_server?
+                  # CPK
+                  #quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
+                  quoted_pk = Array(pk).map {|subkey| SQLServer::Utils.extract_identifiers(subkey).quoted}
+
+                  table_name ||= get_table_name(sql)
+                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+                  if exclude_output_inserted
+                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? "bigint" : exclude_output_inserted
+                    # CPK
+                    # <<~SQL.squish
+                    #   DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
+                    #   #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
+                    #   SELECT CAST(#{quoted_pk.join(',')} AS #{id_sql_type}) FROM @ssaIdInsertTable
+                    # SQL
+                    <<~SQL.squish
+                      DECLARE @ssaIdInsertTable table (#{quoted_pk.map {|subkey| "#{subkey} #{id_sql_type}"}.join(", ")});
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk.join(', INSERTED.')} INTO @ssaIdInsertTable"}
+                      SELECT #{quoted_pk.map {|subkey| "CAST(#{subkey} AS #{id_sql_type}) #{subkey}"}.join(", ")} FROM @ssaIdInsertTable
+                    SQL
+                  else
+                    # CPK
+                    # sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk.join(', INSERTED.')}"
+                  end
+                else
+                  "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+                end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/core.rb

@@ -1,49 +1,49 @@
-module ActiveRecord
-  module Core
-    def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.deep_dup
-      # CPK
-      #@attributes.reset(@primary_key)
-      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
-
-      _run_initialize_callbacks
-
-      @new_record               = true
-      @destroyed                = false
-      @_start_transaction_state = nil
-      @transaction_state        = nil
-
-      super
-    end
-
-    module ClassMethods
-      def find(*ids) # :nodoc:
-        # We don't have cache keys for this stuff yet
-        return super unless ids.length == 1
-        return super if block_given? ||
-            primary_key.nil? ||
-            scope_attributes? ||
-            columns_hash.key?(inheritance_column) && !base_class?
-
-        # CPK
-        return super if self.composite?
-
-        id = ids.first
-
-        return super if StatementCache.unsupported_value?(id)
-
-        key = primary_key
-
-        statement = cached_find_by_statement(key) { |params|
-          where(key => params.bind).limit(1)
-        }
-
-        record = statement.execute([id], connection)&.first
-        unless record
-          raise RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
-        end
-        record
-      end
-    end
-  end
+module ActiveRecord
+  module Core
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      # CPK
+      #@attributes.reset(@primary_key)
+      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
+
+      _run_initialize_callbacks
+
+      @new_record               = true
+      @destroyed                = false
+      @_start_transaction_state = nil
+      @transaction_state        = nil
+
+      super
+    end
+
+    module ClassMethods
+      def find(*ids) # :nodoc:
+        # We don't have cache keys for this stuff yet
+        return super unless ids.length == 1
+        return super if block_given? ||
+            primary_key.nil? ||
+            scope_attributes? ||
+            columns_hash.key?(inheritance_column) && !base_class?
+
+        # CPK
+        return super if self.composite?
+
+        id = ids.first
+
+        return super if StatementCache.unsupported_value?(id)
+
+        key = primary_key
+
+        statement = cached_find_by_statement(key) { |params|
+          where(key => params.bind).limit(1)
+        }
+
+        record = statement.execute([id], connection)&.first
+        unless record
+          raise ::ActiveRecord::RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
+        end
+        record
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/persistence.rb

@@ -1,81 +1,82 @@
-module ActiveRecord
-  module Persistence
-    module ClassMethods
-      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
-            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
-          end
-        else
-          delete_by(primary_key => id_or_array)
-        end
-      end
-
-      def _update_record(values, constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-           constraints[key] = primary_key_values[i]
-          end
-        end
-
-        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
-
-        um = arel_table.where(
-          constraints.reduce(&:and)
-        ).compile_update(_substitute_values(values), primary_key)
-
-        connection.update(um, "#{self} Update")
-      end
-
-      def _delete_record(constraints) # :nodoc:
-        # CPK
-        if self.composite? && constraints[primary_key]
-          primary_key_values = constraints.delete(primary_key)
-          primary_key.each_with_index do |key, i|
-            constraints[key] = primary_key_values[i]
-          end
-        end
-
-        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
-
-        dm = Arel::DeleteManager.new
-        dm.from(arel_table)
-        dm.wheres = constraints
-
-        connection.delete(dm, "#{self} Destroy")
-      end
-    end
-
-    def _create_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_create(attribute_names)
-
-      new_id = self.class._insert_record(
-          attributes_with_values(attribute_names)
-      )
-
-      # CPK
-      if self.composite? && self.id.compact.empty?
-        self.id = self.id.zip(Array(new_id)).map {|id1, id2| (id1 || id2)}
-      else
-        self.id ||= new_id if self.class.primary_key
-      end
-
-      @new_record = false
-
-      yield(self) if block_given?
-
-      id
-    end
-  end
-end
+module ActiveRecord
+  module Persistence
+    module ClassMethods
+      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
+
+          # Delete should return the number of deleted records
+          id_or_array.map do |id|
+            # Is the passed in id actually a record?
+            id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
+            delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
+          end.sum
+        else
+          delete_by(primary_key => id_or_array)
+        end
+      end
+
+      def _update_record(values, constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+           constraints[key] = primary_key_values[i]
+          end
+        end
+
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        um = arel_table.where(
+          constraints.reduce(&:and)
+        ).compile_update(_substitute_values(values), primary_key)
+
+        connection.update(um, "#{self} Update")
+      end
+
+      def _delete_record(constraints) # :nodoc:
+        # CPK
+        if self.composite? && constraints[primary_key]
+          primary_key_values = constraints.delete(primary_key)
+          primary_key.each_with_index do |key, i|
+            constraints[key] = primary_key_values[i]
+          end
+        end
+
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        dm = Arel::DeleteManager.new
+        dm.from(arel_table)
+        dm.wheres = constraints
+
+        connection.delete(dm, "#{self} Destroy")
+      end
+    end
+
+    def _create_record(attribute_names = self.attribute_names)
+      attribute_names = attributes_for_create(attribute_names)
+
+      new_id = self.class._insert_record(
+          attributes_with_values(attribute_names)
+      )
+
+      # CPK
+      if self.composite?
+        self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
+      else
+        self.id ||= new_id if self.class.primary_key
+      end
+
+      @new_record = false
+
+      yield(self) if block_given?
+
+      id
+    end
+  end
+end

data/lib/composite_primary_keys/reflection.rb

@@ -1,29 +1,29 @@
-module ActiveRecord
-  module Reflection
-    class AbstractReflection
-      def join_scope(table, foreign_table, foreign_klass)
-        predicate_builder = predicate_builder(table)
-        scope_chain_items = join_scopes(table, predicate_builder)
-        klass_scope       = klass_join_scope(table, predicate_builder)
-
-        key         = join_keys.key
-        foreign_key = join_keys.foreign_key
-
-        # CPK
-        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
-        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-        klass_scope.where!(constraint)
-
-        if type
-          klass_scope.where!(type => foreign_klass.polymorphic_name)
-        end
-
-        if klass.finder_needs_type_condition?
-          klass_scope.where!(klass.send(:type_condition, table))
-        end
-
-        scope_chain_items.inject(klass_scope, &:merge!)
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Reflection
+    class AbstractReflection
+      def join_scope(table, foreign_table, foreign_klass)
+        predicate_builder = predicate_builder(table)
+        scope_chain_items = join_scopes(table, predicate_builder)
+        klass_scope       = klass_join_scope(table, predicate_builder)
+
+        key         = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        # CPK
+        #klass_scope.where!(table[key].eq(foreign_table[foreign_key]))
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+        klass_scope.where!(constraint)
+
+        if type
+          klass_scope.where!(type => foreign_klass.polymorphic_name)
+        end
+
+        if klass.finder_needs_type_condition?
+          klass_scope.where!(klass.send(:type_condition, table))
+        end
+
+        scope_chain_items.inject(klass_scope, &:merge!)
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/batches.rb

@@ -4,7 +4,7 @@ module CompositePrimaryKeys
       def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil)
         relation = self
         unless block_given?
-          return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
+          return ::ActiveRecord::Batches::BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
         end
 
         if arel.orders.present?

data/lib/composite_primary_keys/relation/calculations.rb

@@ -1,81 +1,81 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module Calculations
-      def aggregate_column(column_name)
-        # CPK
-        if column_name.kind_of?(Array)
-          column_name.map do |column|
-            @klass.arel_attribute(column_name)
-          end
-        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
-          @klass.arel_attribute(column_name)
-        else
-          Arel.sql(column_name == :all ? "*" : column_name.to_s)
-        end
-      end
-
-      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-        column_alias = column_name
-
-        # CPK
-        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
-        #   # Shortcut when limit is zero.
-        #   return 0 if limit_value == 0
-        #
-        #   query_builder = build_count_subquery(spawn, column_name, distinct)
-        if operation == "count"
-          relation = unscope(:order)
-          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)
-          relation.select_values = [select_value]
-
-          query_builder = relation.arel
-        end
-
-        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder, nil) }
-        row    = result.first
-        value  = row && row.values.first
-        type   = result.column_types.fetch(column_alias) do
-          type_for(column_name)
-        end
-
-        type_cast_calculated_value(value, type, operation)
-      end
-
-      def build_count_subquery(relation, column_name, distinct)
-        if column_name == :all
-          relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
-          if relation.select_values.first.is_a?(Array)
-            relation.select_values = relation.select_values.first.map do |column|
-              Arel::Attribute.new(@klass.unscoped.table, column)
-            end
-          end
-        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")
-          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
-        end
-
-        subquery = relation.arel.as(Arel.sql("subquery_for_count"))
-        select_value = operation_over_aggregate_column(column_alias || Arel.star, "count", false)
-
-        Arel::SelectManager.new(subquery).project(select_value)
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Calculations
+      def aggregate_column(column_name)
+        # CPK
+        if column_name.kind_of?(Array)
+          column_name.map do |column|
+            @klass.arel_attribute(column_name)
+          end
+        elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
+          @klass.arel_attribute(column_name)
+        else
+          Arel.sql(column_name == :all ? "*" : column_name.to_s)
+        end
+      end
+
+      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
+        column_alias = column_name
+
+        # CPK
+        # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
+        #   # Shortcut when limit is zero.
+        #   return 0 if limit_value == 0
+        #
+        #   query_builder = build_count_subquery(spawn, column_name, distinct)
+        if operation == "count"
+          relation = unscope(:order)
+          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)
+          relation.select_values = [select_value]
+
+          query_builder = relation.arel
+        end
+
+        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder, nil) }
+        row    = result.first
+        value  = row && row.values.first
+        type   = result.column_types.fetch(column_alias) do
+          type_for(column_name)
+        end
+
+        type_cast_calculated_value(value, type, operation)
+      end
+
+      def build_count_subquery(relation, column_name, distinct)
+        if column_name == :all
+          relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
+          if relation.select_values.first.is_a?(Array)
+            relation.select_values = relation.select_values.first.map do |column|
+              Arel::Attribute.new(@klass.unscoped.table, column)
+            end
+          end
+        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")
+          relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
+        end
+
+        subquery = relation.arel.as(Arel.sql("subquery_for_count"))
+        select_value = operation_over_aggregate_column(column_alias || Arel.star, "count", false)
+
+        Arel::SelectManager.new(subquery).project(select_value)
+      end
+    end
+  end
+end