switchman 3.0.0 → 3.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb89193fead8142e30280a6ab2706f6e9af798ff18820fa144be3dd9ac77591f
-  data.tar.gz: e1157f5656f06ae9bdb7c62a2c9ae1611e2073cf47ca4278bae8605296603d21
+  metadata.gz: 326fba116e3a3801cdd40b47ede332a372dab86522cbeaab1a3b6b361eccce1f
+  data.tar.gz: 190457646d607aa444dbff867c67c5cd854817e8105efab44dd00fc782d1f21e
 SHA512:
-  metadata.gz: fbb9b4d9385dad87ba827400dc9245085c31e133d2445daf64b3d3e81f3102c189f8feafb328d085649146c8ccd2782fd7ba3cb410c262d06a31e014175cac99
-  data.tar.gz: 55c8010cbc73d112262d674d131b1fe0acbd39b5b482e73b9b7165aac23a25a93d5bbca4320a56b97450f68af8526045aede39c13cfb3426189073acba8f6a3f
+  metadata.gz: 3843b4407a36b8f7f3aff2381dc6ee2e5f886169349794e679759a6d13d96b52e96e832caf78728f20df7d1d017701d7e7d8847c8a4620cd6b669ba8f25e9cc6
+  data.tar.gz: 8e667cd250473f5b885fea29888454a186bafa9f694138bf0cf9f6761962ef4bf2a85b595a9cd7d26fb3f6532b4b8b8be9d6362c01329a63f94272f63ee55b4b

data/app/models/switchman/shard.rb

@@ -39,12 +39,17 @@ module Switchman
           # the first time we need a dummy dummy for re-entrancy to avoid looping on ourselves
           @default ||= default
 
-          # Now find the actual record, if it exists; rescue the fake default if the table doesn't exist
+          # Now find the actual record, if it exists
           @default = begin
             find_cached('default_shard') { Shard.where(default: true).take } || default
+          # If we are *super* early in boot, the connection pool won't exist; we don't want to fill in the default shard yet
+          rescue ::ActiveRecord::ConnectionNotEstablished
+            nil
+          # rescue the fake default if the table doesn't exist
           rescue
             default
           end
+          return default unless @default
 
           # make sure this is not erroneously cached
           @default.database_server.remove_instance_variable(:@primary_shard) if @default.database_server.instance_variable_defined?(:@primary_shard)
@@ -59,34 +64,38 @@ module Switchman
 
       def current(klass = ::ActiveRecord::Base)
         klass ||= ::ActiveRecord::Base
-        klass.connection_pool.shard
+        klass.current_switchman_shard
       end
 
       def activate(shards)
         activated_classes = activate!(shards)
         yield
       ensure
-        activated_classes.each do |klass|
-          klass.connection_pool.shard_stack.pop
+        activated_classes&.each do |klass|
           klass.connected_to_stack.pop
         end
       end
 
       def activate!(shards)
-        activated_classes = []
+        activated_classes = nil
         shards.each do |klass, shard|
           next if klass == UnshardedRecord
 
           next unless klass.current_shard != shard.database_server.id.to_sym ||
-                      klass.connection_pool.shard != shard
+                      klass.current_switchman_shard != shard
 
-          activated_classes << klass
-          klass.connected_to_stack << { shard: shard.database_server.id.to_sym, klasses: [klass] }
-          klass.connection_pool.shard_stack << shard
+          (activated_classes ||= []) << klass
+          klass.connected_to_stack << { shard: shard.database_server.id.to_sym, klasses: [klass], switchman_shard: shard }
         end
         activated_classes
       end
 
+      def active_shards
+        sharded_models.map do |klass|
+          [klass, current(klass)]
+        end.compact.to_h
+      end
+
       def lookup(id)
         id_i = id.to_i
         return current if id_i == current.id || id == 'self'
@@ -103,6 +112,11 @@ module Switchman
         cached_shards[id]
       end
 
+      def preload_cache
+        cached_shards.reverse_merge!(active_shards.values.index_by(&:id))
+        cached_shards.reverse_merge!(all.index_by(&:id))
+      end
+
       def clear_cache
         cached_shards.clear
       end
@@ -111,14 +125,13 @@ module Switchman
       #
       # * +shards+ - an array or relation of Shards to iterate over
       # * +classes+ - an array of classes to activate
-      #    parallel: - true/false to execute in parallel, or a integer of how many
-      #                sub-processes per database server. Note that parallel
-      #                invocation currently uses forking, so should be used sparingly
-      #                because errors are not raised, and you cannot get results back
-      #    max_procs: - only run this many parallel processes at a time
+      #    parallel: - true/false to execute in parallel, or an integer of how many
+      #                sub-processes. Note that parallel invocation currently uses
+      #                forking, so should be used sparingly because you cannot get
+      #                results back
       #    exception: - :ignore, :raise, :defer (wait until the end and raise the first
       #                error), or a proc
-      def with_each_shard(*args, parallel: false, max_procs: nil, exception: :raise, &block)
+      def with_each_shard(*args, parallel: false, exception: :raise, &block)
         raise ArgumentError, "wrong number of arguments (#{args.length} for 0...2)" if args.length > 2
 
         return Array.wrap(yield) unless default.is_a?(Shard)
@@ -133,14 +146,13 @@ module Switchman
           scope, classes = args
         end
 
-        parallel = 1 if parallel == true
+        parallel = [Environment.cpu_count || 2, 2].min if parallel == true
         parallel = 0 if parallel == false || parallel.nil?
 
         scope ||= Shard.all
         scope = scope.order(::Arel.sql('database_server_id IS NOT NULL, database_server_id, id')) if ::ActiveRecord::Relation === scope && scope.order_values.empty?
 
-        if parallel.positive?
-          max_procs = determine_max_procs(max_procs, parallel)
+        if parallel > 1
           if ::ActiveRecord::Relation === scope
             # still need a post-uniq, cause the default database server could be NULL or Rails.env in the db
             database_servers = scope.reorder('database_server_id').select(:database_server_id).distinct.
@@ -148,39 +160,11 @@ module Switchman
             # nothing to do
             return if database_servers.count.zero?
 
-            parallel = [(max_procs.to_f / database_servers.count).ceil, parallel].min if max_procs
-
-            scopes = database_servers.map do |server|
-              server_scope = server.shards.merge(scope)
-              if parallel == 1
-                subscopes = [server_scope]
-              else
-                subscopes = []
-                total = server_scope.count
-                ranges = []
-                server_scope.find_ids_in_ranges(batch_size: (total.to_f / parallel).ceil) do |min, max|
-                  ranges << [min, max]
-                end
-                # create a half-open range on the last one
-                ranges.last[1] = nil
-                ranges.each do |min, max|
-                  subscope = server_scope.where('id>=?', min)
-                  subscope = subscope.where('id<=?', max) if max
-                  subscopes << subscope
-                end
-              end
-              [server, subscopes]
-            end.to_h
+            scopes = database_servers.to_h do |server|
+              [server, server.shards.merge(scope)]
+            end
           else
             scopes = scope.group_by(&:database_server)
-            if parallel > 1
-              parallel = [(max_procs.to_f / scopes.count).ceil, parallel].min if max_procs
-              scopes = scopes.map do |(server, shards)|
-                [server, shards.in_groups(parallel, false).compact]
-              end.to_h
-            else
-              scopes = scopes.map { |(server, shards)| [server, [shards]] }.to_h
-            end
           end
 
           exception_pipes = []
@@ -206,80 +190,83 @@ module Switchman
           end
 
           # only one process; don't bother forking
-          if scopes.length == 1 && parallel == 1
-            return with_each_shard(scopes.first.last.first, classes, exception: exception,
-                                   &block)
-          end
+          return with_each_shard(scopes.first.last, classes, exception: exception, &block) if scopes.length == 1
 
           # clear connections prior to forking (no more queries will be executed in the parent,
           # and we want them gone so that we don't accidentally use them post-fork doing something
           # silly like dealloc'ing prepared statements)
           ::ActiveRecord::Base.clear_all_connections!
 
-          scopes.each do |server, subscopes|
-            subscopes.each_with_index do |subscope, idx|
-              name = if subscopes.length > 1
-                       "#{server.id} #{idx + 1}"
-                     else
-                       server.id
-                     end
-
-              exception_pipe = IO.pipe
-              exception_pipes << exception_pipe
-              pid, io_in, io_out, io_err = Open4.pfork4(lambda do
-                Switchman.config[:on_fork_proc]&.call
-
-                # set a pretty name for the process title, up to 128 characters
-                # (we don't actually know the limit, depending on how the process
-                # was started)
-                # first, simplify the binary name by stripping directories,
-                # then truncate arguments as necessary
-                bin = File.basename($0) # Process.argv0 doesn't work on Ruby 2.5 (https://bugs.ruby-lang.org/issues/15887)
-                max_length = 128 - bin.length - name.length - 3
-                args = ARGV.join(' ')
-                args = args[0..max_length] if max_length >= 0
-                new_title = [bin, args, name].join(' ')
-                Process.setproctitle(new_title)
-
-                with_each_shard(subscope, classes, exception: exception, &block)
-                exception_pipe.last.close
-              rescue => e
-                begin
-                  dumped = Marshal.dump(e)
-                rescue
-                  # couldn't dump the exception; create a copy with just
-                  # the message and the backtrace
-                  e2 = e.class.new(e.message)
-                  e2.set_backtrace(e.backtrace)
-                  e2.instance_variable_set(:@active_shards, e.instance_variable_get(:@active_shards))
-                  dumped = Marshal.dump(e2)
-                end
-                exception_pipe.last.set_encoding(dumped.encoding)
-                exception_pipe.last.write(dumped)
-                exception_pipe.last.flush
-                exception_pipe.last.close
-                exit! 1
-              end)
+          scopes.each do |server, subscope|
+            name = server.id
+
+            exception_pipe = IO.pipe
+            exception_pipes << exception_pipe
+            pid, io_in, io_out, io_err = Open4.pfork4(lambda do
+              Switchman.config[:on_fork_proc]&.call
+
+              # set a pretty name for the process title, up to 128 characters
+              # (we don't actually know the limit, depending on how the process
+              # was started)
+              # first, simplify the binary name by stripping directories,
+              # then truncate arguments as necessary
+              bin = File.basename($0) # Process.argv0 doesn't work on Ruby 2.5 (https://bugs.ruby-lang.org/issues/15887)
+              max_length = 128 - bin.length - name.length - 3
+              args = ARGV.join(' ')
+              args = args[0..max_length] if max_length >= 0
+              new_title = [bin, args, name].join(' ')
+              Process.setproctitle(new_title)
+
+              with_each_shard(subscope, classes, exception: exception, &block)
               exception_pipe.last.close
-              pids << pid
-              io_in.close # don't care about writing to stdin
-              out_fds << io_out
-              err_fds << io_err
-              pid_to_name_map[pid] = name
-              fd_to_name_map[io_out] = name
-              fd_to_name_map[io_err] = name
-
-              while max_procs && pids.count >= max_procs
-                while max_procs && out_fds.count >= max_procs
-                  # wait for output if we've hit the max_procs limit
-                  wait_for_output.call
-                end
-                # we've gotten all the output from one fd so wait for its child process to exit
-                found_pid, status = Process.wait2
-                pids.delete(found_pid)
-                errors << pid_to_name_map[found_pid] if status.exitstatus != 0
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              begin
+                dumped = Marshal.dump(e)
+                dumped = nil if dumped.length > 64 * 1024
+              rescue
+                dumped = nil
+              end
+
+              if dumped.nil?
+                # couldn't dump the exception; create a copy with just
+                # the message and the backtrace
+                e2 = e.class.new(e.message)
+                backtrace = e.backtrace
+                # truncate excessively long backtraces
+                backtrace = backtrace[0...25] + ['...'] + backtrace[-25..] if backtrace.length > 50
+                e2.set_backtrace(backtrace)
+                e2.instance_variable_set(:@active_shards, e.instance_variable_get(:@active_shards))
+                dumped = Marshal.dump(e2)
               end
+              exception_pipe.last.set_encoding(dumped.encoding)
+              exception_pipe.last.write(dumped)
+              exception_pipe.last.flush
+              exception_pipe.last.close
+              exit! 1
+            end)
+            exception_pipe.last.close
+            pids << pid
+            io_in.close # don't care about writing to stdin
+            out_fds << io_out
+            err_fds << io_err
+            pid_to_name_map[pid] = name
+            fd_to_name_map[io_out] = name
+            fd_to_name_map[io_err] = name
+
+            while pids.count >= parallel
+              while out_fds.count >= parallel
+                # wait for output if we've hit the parallel limit
+                wait_for_output.call
+              end
+              # we've gotten all the output from one fd so wait for its child process to exit
+              found_pid, status = Process.wait2
+              pids.delete(found_pid)
+              errors << pid_to_name_map[found_pid] if status.exitstatus != 0
             end
+            # we've gotten all the output from one fd so wait for its child process to exit
+            found_pid, status = Process.wait2
+            pids.delete(found_pid)
+            errors << pid_to_name_map[found_pid] if status.exitstatus != 0
           end
 
           wait_for_output.call while out_fds.any? || err_fds.any?
@@ -402,7 +389,7 @@ module Switchman
           signed_id_operation(local_id) do |id|
             return nil if id > IDS_PER_SHARD
 
-            $1.to_i * IDS_PER_SHARD + id
+            ($1.to_i * IDS_PER_SHARD) + id
           end
         when Integer, /^-?\d+$/
           any_id.to_i
@@ -480,23 +467,6 @@ module Switchman
         shard || source_shard || Shard.current
       end
 
-      # given the provided option, determines whether we need to (and whether
-      # it's possible) to determine a reasonable default.
-      def determine_max_procs(max_procs_input, parallel_input = 2)
-        max_procs = nil
-        if max_procs_input
-          max_procs = max_procs_input.to_i
-          max_procs = nil if max_procs.zero?
-        else
-          return 1 if parallel_input.nil? || parallel_input < 1
-
-          cpus = Environment.cpu_count
-          max_procs = cpus * parallel_input if cpus&.positive?
-        end
-
-        max_procs
-      end
-
       private
 
       def add_sharded_model(klass)
@@ -505,7 +475,7 @@ module Switchman
       end
 
       def initialize_sharding
-        full_connects_to_hash = DatabaseServer.all.map { |db| [db.id.to_sym, db.connects_to_hash] }.to_h
+        full_connects_to_hash = DatabaseServer.all.to_h { |db| [db.id.to_sym, db.connects_to_hash] }
         sharded_models.each do |klass|
           connects_to_hash = full_connects_to_hash.deep_dup
           if klass == UnshardedRecord
@@ -596,6 +566,10 @@ module Switchman
       Shard.default
     end
 
+    def original_id
+      id
+    end
+
     def activate(*classes, &block)
       shards = hashify_classes(classes)
       Shard.activate(shards, &block)
@@ -668,7 +642,7 @@ module Switchman
       return nil unless local_id
 
       self.class.signed_id_operation(local_id) do |abs_id|
-        abs_id + id * IDS_PER_SHARD
+        abs_id + (id * IDS_PER_SHARD)
       end
     end
 
@@ -690,6 +664,7 @@ module Switchman
         Switchman.cache.delete(['shard', id].join('/'))
         Switchman.cache.delete('default_shard') if default?
       end
+      self.class.clear_cache
     end
 
     def default_name

data/db/migrate/20180828183945_add_default_shard_index.rb

@@ -2,7 +2,7 @@
 
 class AddDefaultShardIndex < ActiveRecord::Migration[4.2]
   def change
-    Switchman::Shard.where(default: nil).update_all(default: false)
+    Switchman::Shard.where(default: nil).update_all(default: false) if Switchman::Shard.current.default?
     change_column_default :switchman_shards, :default, false
     change_column_null :switchman_shards, :default, false
     options = if connection.adapter_name == 'PostgreSQL'
@@ -10,6 +10,6 @@ class AddDefaultShardIndex < ActiveRecord::Migration[4.2]
               else
                 {}
               end
-    add_index :switchman_shards, :default, options
+    add_index :switchman_shards, :default, **options
   end
 end

data/db/migrate/20180828192111_add_timestamps_to_shards.rb

@@ -4,7 +4,7 @@ class AddTimestampsToShards < ActiveRecord::Migration[4.2]
   disable_ddl_transaction!
 
   def change
-    add_timestamps :switchman_shards, null: true
+    add_timestamps :switchman_shards, null: true, if_not_exists: true
     now = Time.now.utc
     Switchman::Shard.update_all(updated_at: now, created_at: now) if Switchman::Shard.current.default?
     change_column_null :switchman_shards, :updated_at, false

data/lib/switchman/active_record/abstract_adapter.rb

@@ -40,15 +40,6 @@ module Switchman
       ensure
         @last_query_at = Time.now
       end
-
-      private
-
-      def id_value_for_database(value)
-        return super unless value.class.sharded_primary_key?
-
-        # do this the Rails 4.2 way, so that if Shard.current != self.shard, the id gets transposed
-        quote(value.id)
-      end
     end
   end
 end

data/lib/switchman/active_record/association.rb

@@ -85,7 +85,7 @@ module Switchman
         # Copypasta from Activerecord but with added global_id_for goodness.
         def records_for(ids)
           scope.where(association_key_name => ids).load do |record|
-            global_key = if record.class.connection_classes == UnshardedRecord
+            global_key = if model.connection_classes == UnshardedRecord
                            convert_key(record[association_key_name])
                          else
                            Shard.global_id_for(record[association_key_name], record.shard)

data/lib/switchman/active_record/attribute_methods.rb

@@ -40,7 +40,11 @@ module Switchman
           if sharded_column?(attr_name)
             owner << <<-RUBY
               def global_#{attr_name}
-                ::Switchman::Shard.global_id_for(original_#{attr_name}, shard)
+                raw_value = original_#{attr_name}
+                return nil if raw_value.nil?
+                return raw_value if raw_value > ::Switchman::Shard::IDS_PER_SHARD
+
+                ::Switchman::Shard.global_id_for(raw_value, shard)
               end
             RUBY
           else
@@ -52,7 +56,9 @@ module Switchman
           if sharded_column?(attr_name)
             owner << <<-RUBY
               def local_#{attr_name}
-                ::Switchman::Shard.local_id_for(original_#{attr_name}).first
+                raw_value = original_#{attr_name}
+                return nil if raw_value.nil?
+                return raw_value % ::Switchman::Shard::IDS_PER_SHARD
               end
             RUBY
           else
@@ -104,7 +110,22 @@ module Switchman
               alias_method 'original_#{attr_name}', '#{attr_name}'
               # and replace with one that transposes the id
               def #{attr_name}
-                ::Switchman::Shard.relative_id_for(original_#{attr_name}, shard, ::Switchman::Shard.current(#{connection_classes_code_for_reflection(reflection)}))
+                raw_value = original_#{attr_name}
+                return nil if raw_value.nil?
+
+                abs_raw_value = raw_value.abs
+                current_shard = ::Switchman::Shard.current(#{connection_classes_code_for_reflection(reflection)})
+                same_shard = shard == current_shard
+                return raw_value if same_shard && abs_raw_value < ::Switchman::Shard::IDS_PER_SHARD
+
+                value_shard_id = abs_raw_value / ::Switchman::Shard::IDS_PER_SHARD
+                # this is a stupid case when someone stuffed a global id for the current shard in instead
+                # of a local id
+                return raw_value % ::Switchman::Shard::IDS_PER_SHARD if value_shard_id == current_shard.id
+                return raw_value if !same_shard && abs_raw_value > ::Switchman::Shard::IDS_PER_SHARD
+                return shard.global_id_for(raw_value) if !same_shard && abs_raw_value < ::Switchman::Shard::IDS_PER_SHARD
+
+                ::Switchman::Shard.relative_id_for(raw_value, shard, current_shard)
               end
 
               alias_method 'original_#{attr_name}=', '#{attr_name}='
@@ -141,6 +162,54 @@ module Switchman
         self.class.define_attribute_methods
         super
       end
+
+      # these are called if the specific methods haven't been defined yet
+      def attribute(attr_name)
+        return super unless self.class.sharded_column?(attr_name)
+
+        reflection = self.class.send(:reflection_for_integer_attribute, attr_name)
+        ::Switchman::Shard.relative_id_for(super, shard, ::Switchman::Shard.current(connection_classes_for_reflection(reflection)))
+      end
+
+      def attribute=(attr_name, new_value)
+        unless self.class.sharded_column?(attr_name)
+          super
+          return
+        end
+
+        reflection = self.class.send(:reflection_for_integer_attribute, attr_name)
+        super(::Switchman::Shard.relative_id_for(new_value, ::Switchman::Shard.current(connection_classes_for_reflection(reflection)), shard))
+      end
+
+      def global_attribute(attr_name)
+        if self.class.sharded_column?(attr_name)
+          ::Switchman::Shard.global_id_for(attribute(attr_name), shard)
+        else
+          attribute(attr_name)
+        end
+      end
+
+      def local_attribute(attr_name)
+        if self.class.sharded_column?(attr_name)
+          ::Switchman::Shard.local_id_for(attribute(attr_name), shard).first
+        else
+          attribute(attr_name)
+        end
+      end
+
+      private
+
+      def connection_classes_for_reflection(reflection)
+        if reflection
+          if reflection.options[:polymorphic]
+            read_attribute(reflection.foreign_type)&.constantize&.connection_classes
+          else
+            reflection.klass.connection_classes
+          end
+        else
+          self.class.connection_classes
+        end
+      end
     end
   end
 end

data/lib/switchman/active_record/base.rb

@@ -77,17 +77,27 @@ module Switchman
 
           default_shard
         end
+
+        def current_switchman_shard
+          connected_to_stack.reverse_each do |hash|
+            return hash[:switchman_shard] if hash[:switchman_shard] && hash[:klasses].include?(connection_classes)
+          end
+
+          Shard.default
+        end
       end
 
-      def self.included(klass)
+      def self.prepended(klass)
         klass.singleton_class.prepend(ClassMethods)
-        klass.set_callback(:initialize, :before) do
-          @shard ||= if self.class.sharded_primary_key?
-                       Shard.shard_for(self[self.class.primary_key], Shard.current(self.class.connection_classes))
-                     else
-                       Shard.current(self.class.connection_classes)
-                     end
-        end
+      end
+
+      def _run_initialize_callbacks
+        @shard ||= if self.class.sharded_primary_key?
+                     Shard.shard_for(self[self.class.primary_key], Shard.current(self.class.connection_classes))
+                   else
+                     Shard.current(self.class.connection_classes)
+                   end
+        super
       end
 
       def shard
@@ -107,12 +117,12 @@ module Switchman
 
       def save(*, **)
         @shard_set_in_stone = true
-        (self.class.current_scope || self.class.default_scoped).shard(shard, :implicit).scoping { super }
+        super
       end
 
       def save!(*, **)
         @shard_set_in_stone = true
-        (self.class.current_scope || self.class.default_scoped).shard(shard, :implicit).scoping { super }
+        super
       end
 
       def destroy
@@ -134,6 +144,12 @@ module Switchman
         end
       end
 
+      def with_transaction_returning_status
+        shard.activate(self.class.connection_classes) do
+          super
+        end
+      end
+
       def hash
         self.class.sharded_primary_key? ? self.class.hash ^ global_id.hash : super
       end
@@ -149,19 +165,20 @@ module Switchman
         copy
       end
 
-      def quoted_id
-        return super unless self.class.sharded_primary_key?
+      def update_columns(*)
+        db = shard.database_server
+        return db.unguard { super } if ::GuardRail.environment != db.guard_rail_environment
 
-        # do this the Rails 4.2 way, so that if Shard.current != self.shard, the id gets transposed
-        self.class.connection.quote(id)
+        super
       end
 
-      def update_columns(*)
-        db = Shard.current(self.class.connection_classes).database_server
-        if ::GuardRail.environment == db.guard_rail_environment
-          super
+      def id_for_database
+        if self.class.sharded_primary_key?
+          # It's an int, so so it's safe to just return it without passing it through anything else
+          # In theory we should do `@attributes[@primary_key].type.serialize(id)`, but that seems to have surprising side-effects
+          id
         else
-          db.unguard { super }
+          super
         end
       end
 
@@ -172,7 +189,7 @@ module Switchman
         if reflection
           if reflection.options[:polymorphic]
             begin
-              read_attribute(reflection.foreign_type)&.constantize&.connection_classes
+              read_attribute(reflection.foreign_type)&.constantize&.connection_classes || ::ActiveRecord::Base
             rescue NameError
               # in case someone is abusing foreign_type to not point to an actual class
               ::ActiveRecord::Base
@@ -182,7 +199,7 @@ module Switchman
             reflection.klass.connection_classes
           end
         else
-          connection_classes
+          self.class.connection_classes
         end
       end
     end

data/lib/switchman/active_record/calculations.rb

@@ -50,7 +50,7 @@ module Switchman
 
       def calculate_simple_average(column_name, distinct)
         # See activerecord#execute_simple_calculation
-        relation = reorder(nil)
+        relation = except(:order)
         column = aggregate_column(column_name)
         relation.select_values = [operation_over_aggregate_column(column, 'average', distinct).as('average'),
                                   operation_over_aggregate_column(column, 'count', distinct).as('count')]
@@ -83,7 +83,7 @@ module Switchman
           if opts[:association]
             key_ids     = calculated_data.collect { |row| row[opts[:group_aliases].first] }
             key_records = opts[:association].klass.base_class.where(id: key_ids)
-            key_records = key_records.map { |r| [Shard.relative_id_for(r, shard, target_shard), r] }.to_h
+            key_records = key_records.to_h { |r| [Shard.relative_id_for(r, shard, target_shard), r] }
           end
 
           calculated_data.map do |row|