activerecord 2.3.18 → 3.2.22

data/lib/active_record/associations/association_proxy.rb

@@ -1,288 +0,0 @@
-module ActiveRecord
-  module Associations
-    # This is the root class of all association proxies:
-    #
-    #   AssociationProxy
-    #     BelongsToAssociation
-    #       HasOneAssociation
-    #     BelongsToPolymorphicAssociation
-    #     AssociationCollection
-    #       HasAndBelongsToManyAssociation
-    #       HasManyAssociation
-    #         HasManyThroughAssociation
-    #            HasOneThroughAssociation
-    #
-    # Association proxies in Active Record are middlemen between the object that
-    # holds the association, known as the <tt>@owner</tt>, and the actual associated
-    # object, known as the <tt>@target</tt>. The kind of association any proxy is
-    # about is available in <tt>@reflection</tt>. That's an instance of the class
-    # ActiveRecord::Reflection::AssociationReflection.
-    #
-    # For example, given
-    #
-    #   class Blog < ActiveRecord::Base
-    #     has_many :posts
-    #   end
-    #
-    #   blog = Blog.find(:first)
-    #
-    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
-    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
-    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
-    #
-    # This class has most of the basic instance methods removed, and delegates
-    # unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
-    # corner case, it even removes the +class+ method and that's why you get
-    #
-    #   blog.posts.class # => Array
-    #
-    # though the object behind <tt>blog.posts</tt> is not an Array, but an
-    # ActiveRecord::Associations::HasManyAssociation.
-    #
-    # The <tt>@target</tt> object is not \loaded until needed. For example,
-    #
-    #   blog.posts.count
-    #
-    # is computed directly through SQL and does not trigger by itself the
-    # instantiation of the actual post records.
-    class AssociationProxy #:nodoc:
-      alias_method :proxy_respond_to?, :respond_to?
-      alias_method :proxy_extend, :extend
-      delegate :to_param, :to => :proxy_target
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
-
-      def initialize(owner, reflection)
-        @owner, @reflection = owner, reflection
-        reflection.check_validity!
-        Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
-        reset
-      end
-
-      # Returns the owner of the proxy.
-      def proxy_owner
-        @owner
-      end
-
-      # Returns the reflection object that represents the association handled
-      # by the proxy.
-      def proxy_reflection
-        @reflection
-      end
-
-      # Returns the \target of the proxy, same as +target+.
-      def proxy_target
-        @target
-      end
-
-      # Does the proxy or its \target respond to +symbol+?
-      def respond_to?(*args)
-        proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
-      end
-
-      # Forwards <tt>===</tt> explicitly to the \target because the instance method
-      # removal above doesn't catch it. Loads the \target if needed.
-      def ===(other)
-        load_target
-        other === @target
-      end
-
-      # Returns the name of the table of the related class:
-      #
-      #   post.comments.aliased_table_name # => "comments"
-      #
-      def aliased_table_name
-        @reflection.klass.table_name
-      end
-
-      # Returns the SQL string that corresponds to the <tt>:conditions</tt>
-      # option of the macro, if given, or +nil+ otherwise.
-      def conditions
-        @conditions ||= interpolate_sql(@reflection.sanitized_conditions) if @reflection.sanitized_conditions
-      end
-      alias :sql_conditions :conditions
-
-      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
-      def reset
-        @loaded = false
-        @target = nil
-      end
-
-      # Reloads the \target and returns +self+ on success.
-      def reload
-        reset
-        load_target
-        self unless @target.nil?
-      end
-
-      # Has the \target been already \loaded?
-      def loaded?
-        @loaded
-      end
-
-      # Asserts the \target has been loaded setting the \loaded flag to +true+.
-      def loaded
-        @loaded = true
-      end
-
-      # Returns the target of this proxy, same as +proxy_target+.
-      def target
-        @target
-      end
-
-      # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
-      def target=(target)
-        @target = target
-        loaded
-      end
-
-      # Forwards the call to the target. Loads the \target if needed.
-      def inspect
-        load_target
-        @target.inspect
-      end
-
-      def send(method, *args)
-        if proxy_respond_to?(method)
-          super
-        else
-          load_target
-          @target.send(method, *args)
-        end
-      end
-
-      protected
-        # Does the association have a <tt>:dependent</tt> option?
-        def dependent?
-          @reflection.options[:dependent]
-        end
-
-        # Returns a string with the IDs of +records+ joined with a comma, quoted
-        # if needed. The result is ready to be inserted into a SQL IN clause.
-        #
-        #   quoted_record_ids(records) # => "23,56,58,67"
-        #
-        def quoted_record_ids(records)
-          records.map { |record| record.quoted_id }.join(',')
-        end
-
-        def interpolate_sql(sql, record = nil)
-          @owner.send(:interpolate_sql, sql, record)
-        end
-
-        # Forwards the call to the reflection class.
-        def sanitize_sql(sql, table_name = @reflection.klass.quoted_table_name)
-          @reflection.klass.send(:sanitize_sql, sql, table_name)
-        end
-
-        # Assigns the ID of the owner to the corresponding foreign key in +record+.
-        # If the association is polymorphic the type of the owner is also set.
-        def set_belongs_to_association_for(record)
-          if @reflection.options[:as]
-            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
-            record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
-          else
-            unless @owner.new_record?
-              primary_key = @reflection.options[:primary_key] || :id
-              record[@reflection.primary_key_name] = @owner.send(primary_key)
-            end
-          end
-        end
-
-        # Merges into +options+ the ones coming from the reflection.
-        def merge_options_from_reflection!(options)
-          options.reverse_merge!(
-            :group   => @reflection.options[:group],
-            :having  => @reflection.options[:having],
-            :limit   => @reflection.options[:limit],
-            :offset  => @reflection.options[:offset],
-            :joins   => @reflection.options[:joins],
-            :include => @reflection.options[:include],
-            :select  => @reflection.options[:select],
-            :readonly  => @reflection.options[:readonly]
-          )
-        end
-
-        # Forwards +with_scope+ to the reflection.
-        def with_scope(*args, &block)
-          @reflection.klass.send :with_scope, *args, &block
-        end
-
-      private
-        # Forwards any missing method call to the \target.
-        def method_missing(method, *args, &block)
-          if load_target
-            if @target.respond_to?(method)
-              @target.send(method, *args, &block)
-            else
-              super
-            end
-          end
-        end
-
-        # Loads the \target if needed and returns it.
-        #
-        # This method is abstract in the sense that it relies on +find_target+,
-        # which is expected to be provided by descendants.
-        #
-        # If the \target is already \loaded it is just returned. Thus, you can call
-        # +load_target+ unconditionally to get the \target.
-        #
-        # ActiveRecord::RecordNotFound is rescued within the method, and it is
-        # not reraised. The proxy is \reset and +nil+ is the return value.
-        def load_target
-          return nil unless defined?(@loaded)
-
-          if !loaded? and (!@owner.new_record? || foreign_key_present)
-            @target = find_target
-          end
-
-          @loaded = true
-          @target
-        rescue ActiveRecord::RecordNotFound
-          reset
-        end
-
-        # Can be overwritten by associations that might have the foreign key
-        # available for an association without having the object itself (and
-        # still being a new record). Currently, only +belongs_to+ presents
-        # this scenario (both vanilla and polymorphic).
-        def foreign_key_present
-          false
-        end
-
-        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
-        # the kind of the class of the associated objects. Meant to be used as
-        # a sanity check when you are about to assign an associated record.
-        def raise_on_type_mismatch(record)
-          unless record.is_a?(@reflection.klass) || record.is_a?(@reflection.class_name.constantize)
-            message = "#{@reflection.class_name}(##{@reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
-            raise ActiveRecord::AssociationTypeMismatch, message
-          end
-        end
-
-        # Array#flatten has problems with recursive arrays. Going one level
-        # deeper solves the majority of the problems.
-        def flatten_deeper(array)
-          array.collect { |element| (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element }.flatten
-        end
-
-        # Returns the ID of the owner, quoted if needed.
-        def owner_quoted_id
-          @owner.quoted_id
-        end
-
-        def set_inverse_instance(record, instance)
-          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
-          inverse_relationship = @reflection.inverse_of
-          unless inverse_relationship.nil?
-            record.send(:"set_#{inverse_relationship.name}_target", instance)
-          end
-        end
-
-        # Override in subclasses
-        def we_can_set_the_inverse_on_this?(record)
-          false
-        end
-    end
-  end
-end

data/lib/active_record/batches.rb

@@ -1,85 +0,0 @@
-module ActiveRecord
-  module Batches # :nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # When processing large numbers of records, it's often a good idea to do
-    # so in batches to prevent memory ballooning.
-    module ClassMethods
-      # Yields each record that was found by the find +options+. The find is
-      # performed by find_in_batches with a batch size of 1000 (or as
-      # specified by the <tt>:batch_size</tt> option).
-      #
-      # Example:
-      #
-      #   Person.find_each(:conditions => "age > 21") do |person|
-      #     person.party_all_night!
-      #   end
-      #
-      # Note: This method is only intended to use for batch processing of
-      # large amounts of records that wouldn't fit in memory all at once. If
-      # you just need to loop over less than 1000 records, it's probably
-      # better just to use the regular find methods.
-      def find_each(options = {})
-        find_in_batches(options) do |records|
-          records.each { |record| yield record }
-        end
-
-        self
-      end
-
-      # Yields each batch of records that was found by the find +options+ as
-      # an array. The size of each batch is set by the <tt>:batch_size</tt>
-      # option; the default is 1000.
-      #
-      # You can control the starting point for the batch processing by
-      # supplying the <tt>:start</tt> option. This is especially useful if you
-      # want multiple workers dealing with the same processing queue. You can
-      # make worker 1 handle all the records between id 0 and 10,000 and
-      # worker 2 handle from 10,000 and beyond (by setting the <tt>:start</tt>
-      # option on that worker).
-      #
-      # It's not possible to set the order. That is automatically set to
-      # ascending on the primary key ("id ASC") to make the batch ordering
-      # work. This also mean that this method only works with integer-based
-      # primary keys. You can't set the limit either, that's used to control
-      # the the batch sizes.
-      #
-      # Example:
-      #
-      #   Person.find_in_batches(:conditions => "age > 21") do |group|
-      #     sleep(50) # Make sure it doesn't get too crowded in there!
-      #     group.each { |person| person.party_all_night! }
-      #   end
-      def find_in_batches(options = {})
-        raise "You can't specify an order, it's forced to be #{batch_order}" if options[:order]
-        raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit]
-
-        start = options.delete(:start).to_i
-        batch_size = options.delete(:batch_size) || 1000
-
-        proxy = scoped(options.merge(:order => batch_order, :limit => batch_size))
-        records = proxy.find(:all, :conditions => [ "#{table_name}.#{primary_key} >= ?", start ])
-
-        while records.any?
-          yield records
-
-          break if records.size < batch_size
-          
-          last_value = records.last.id
-          
-          raise "You must include the primary key if you define a select" unless last_value.present?
-          
-          records = proxy.find(:all, :conditions => [ "#{table_name}.#{primary_key} > ?", last_value ])
-        end
-      end
-
-
-      private
-        def batch_order
-          "#{table_name}.#{primary_key} ASC"
-        end
-    end
-  end
-end

data/lib/active_record/calculations.rb

@@ -1,321 +0,0 @@
-module ActiveRecord
-  module Calculations #:nodoc:
-    CALCULATIONS_OPTIONS = [:conditions, :joins, :order, :select, :group, :having, :distinct, :limit, :offset, :include, :from]
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      # Count operates using three different approaches.
-      #
-      # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
-      # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
-      # * Count using options will find the row count matched by the options used.
-      #
-      # The third approach, count using options, accepts an option hash as the only parameter. The options are:
-      #
-      # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
-      # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
-      #   or named associations in the same form used for the <tt>:include</tt> option, which will perform an INNER JOIN on the associated table(s).
-      #   If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
-      #   Pass <tt>:readonly => false</tt> to override.
-      # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
-      #   to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
-      #   See eager loading under Associations.
-      # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
-      # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-      # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, want to do a join but not
-      #   include the joined columns.
-      # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
-      # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
-      #   of a database view).
-      #
-      # Examples for counting all:
-      #   Person.count         # returns the total count of all people
-      #
-      # Examples for counting by column:
-      #   Person.count(:age)  # returns the total count of all people whose age is present in database
-      #
-      # Examples for count with options:
-      #   Person.count(:conditions => "age > 26")
-      #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
-      #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
-      #   Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
-      #   Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
-      #
-      # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.  Use Person.count instead.
-      def count(*args)
-        calculate(:count, *construct_count_options_from_args(*args))
-      end
-
-      # Calculates the average value on a given column. The value is returned as
-      # a float, or +nil+ if there's no row. See +calculate+ for examples with
-      # options.
-      #
-      #   Person.average('age') # => 35.8
-      def average(column_name, options = {})
-        calculate(:avg, column_name, options)
-      end
-
-      # Calculates the minimum value on a given column.  The value is returned
-      # with the same data type of the column, or +nil+ if there's no row. See
-      # +calculate+ for examples with options.
-      #
-      #   Person.minimum('age') # => 7
-      def minimum(column_name, options = {})
-        calculate(:min, column_name, options)
-      end
-
-      # Calculates the maximum value on a given column. The value is returned
-      # with the same data type of the column, or +nil+ if there's no row. See
-      # +calculate+ for examples with options.
-      #
-      #   Person.maximum('age') # => 93
-      def maximum(column_name, options = {})
-        calculate(:max, column_name, options)
-      end
-
-      # Calculates the sum of values on a given column. The value is returned
-      # with the same data type of the column, 0 if there's no row. See
-      # +calculate+ for examples with options.
-      #
-      #   Person.sum('age') # => 4562
-      def sum(column_name, options = {})
-        calculate(:sum, column_name, options)
-      end
-
-      # This calculates aggregate values in the given column.  Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
-      # Options such as <tt>:conditions</tt>, <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
-      #
-      # There are two basic forms of output:
-      #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float for AVG, and the given column's type for everything else.
-      #   * Grouped values: This returns an ordered hash of the values and groups them by the <tt>:group</tt> option.  It takes either a column name, or the name
-      #     of a belongs_to association.
-      #
-      #       values = Person.maximum(:age, :group => 'last_name')
-      #       puts values["Drake"]
-      #       => 43
-      #
-      #       drake  = Family.find_by_last_name('Drake')
-      #       values = Person.maximum(:age, :group => :family) # Person belongs_to :family
-      #       puts values[drake]
-      #       => 43
-      #
-      #       values.each do |family, max_age|
-      #       ...
-      #       end
-      #
-      # Options:
-      # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
-      # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything, the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
-      # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id". (Rarely needed).
-      #   The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
-      # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
-      # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-      # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
-      #   include the joined columns.
-      # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
-      #
-      # Examples:
-      #   Person.calculate(:count, :all) # The same as Person.count
-      #   Person.average(:age) # SELECT AVG(age) FROM people...
-      #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for everyone with a last name other than 'Drake'
-      #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
-      #   Person.sum("2 * age")
-      def calculate(operation, column_name, options = {})
-        validate_calculation_options(operation, options)
-        column_name     = options[:select] if options[:select]
-        column_name     = '*' if column_name == :all
-        column          = column_for column_name
-        catch :invalid_query do
-          if options[:group]
-            return execute_grouped_calculation(operation, column_name, column, options)
-          else
-            return execute_simple_calculation(operation, column_name, column, options)
-          end
-        end
-        0
-      end
-
-      protected
-        def construct_count_options_from_args(*args)
-          options     = {}
-          column_name = :all
-          
-          # We need to handle
-          #   count()
-          #   count(:column_name=:all)
-          #   count(options={})
-          #   count(column_name=:all, options={})
-          case args.size
-          when 1
-            args[0].is_a?(Hash) ? options = args[0] : column_name = args[0]
-          when 2
-            column_name, options = args
-          else
-            raise ArgumentError, "Unexpected parameters passed to count(): #{args.inspect}"
-          end if args.size > 0
-          
-          [column_name, options]
-        end
-
-        def construct_calculation_sql(operation, column_name, options) #:nodoc:
-          operation = operation.to_s.downcase
-          options = options.symbolize_keys
-
-          scope           = scope(:find)
-          merged_includes = merge_includes(scope ? scope[:include] : [], options[:include])
-          aggregate_alias = column_alias_for(operation, column_name)
-          column_name     = "#{connection.quote_table_name(table_name)}.#{column_name}" if column_names.include?(column_name.to_s)
-
-          if operation == 'count'
-            if merged_includes.any?
-              options[:distinct] = true
-              column_name = options[:select] || [connection.quote_table_name(table_name), primary_key] * '.'
-            end
-
-            if options[:distinct]
-              use_workaround = !connection.supports_count_distinct?
-            end
-          end
-
-          if options[:distinct] && column_name.to_s !~ /\s*DISTINCT\s+/i
-            distinct = 'DISTINCT ' 
-          end
-          sql = "SELECT #{operation}(#{distinct}#{column_name}) AS #{aggregate_alias}"
-
-          # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
-          sql = "SELECT COUNT(*) AS #{aggregate_alias}" if use_workaround
-
-          options[:group_fields].each_index{|i| sql << ", #{options[:group_fields][i]} AS #{options[:group_aliases][i]}" } if options[:group]
-          if options[:from]
-            sql << " FROM #{options[:from]} "
-          elsif scope && scope[:from] && !use_workaround
-            sql << " FROM #{scope[:from]} "
-          else
-            sql << " FROM (SELECT #{distinct}#{column_name}" if use_workaround
-            sql << " FROM #{connection.quote_table_name(table_name)} "
-          end
-
-          joins = ""
-          add_joins!(joins, options[:joins], scope)
-
-          if merged_includes.any?
-            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, joins)
-            sql << join_dependency.join_associations.collect{|join| join.association_join }.join
-          end
-
-          sql << joins unless joins.blank?
-
-          add_conditions!(sql, options[:conditions], scope)
-          add_limited_ids_condition!(sql, options, join_dependency) if join_dependency && !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
-
-          if options[:group]
-            group_key = connection.adapter_name == 'FrontBase' ?  :group_aliases : :group_fields
-            sql << " GROUP BY #{options[group_key].join(',')} "
-          end
-
-          if options[:group] && options[:having]
-            having = sanitize_sql_for_conditions(options[:having])
-
-            # FrontBase requires identifiers in the HAVING clause and chokes on function calls
-            if connection.adapter_name == 'FrontBase'
-              having.downcase!
-              having.gsub!(/#{operation}\s*\(\s*#{column_name}\s*\)/, aggregate_alias)
-            end
-
-            sql << " HAVING #{having} "
-          end
-
-          sql << " ORDER BY #{options[:order]} "       if options[:order]
-          add_limit!(sql, options, scope)
-          sql << ") #{aggregate_alias}_subquery" if use_workaround
-          sql
-        end
-
-        def execute_simple_calculation(operation, column_name, column, options) #:nodoc:
-          value = connection.select_value(construct_calculation_sql(operation, column_name, options))
-          type_cast_calculated_value(value, column, operation)
-        end
-
-        def execute_grouped_calculation(operation, column_name, column, options) #:nodoc:
-          group_attr    = options[:group]
-          association   = reflect_on_association(group_attr.to_s.to_sym)
-          associated    = association && association.macro == :belongs_to # only count belongs_to associations
-          group_fields  = Array(associated ? association.primary_key_name : group_attr)
-          group_aliases = []
-          group_columns = {}
-          
-          group_fields.each do |field|
-            group_aliases << column_alias_for(field)
-            group_columns[column_alias_for(field)] = column_for(field)
-          end
-
-          sql             = construct_calculation_sql(operation, column_name, options.merge(:group_fields => group_fields, :group_aliases => group_aliases))
-          calculated_data = connection.select_all(sql)
-          aggregate_alias = column_alias_for(operation, column_name)
-
-          if association
-            key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-            key_records = association.klass.base_class.find(key_ids)
-            key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
-          end
-
-          calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
-            key   = group_aliases.map{|group_alias| type_cast_calculated_value(row[group_alias], group_columns[group_alias])}
-            key   = key.first if key.size == 1
-            key   = key_records[key] if associated
-            value = row[aggregate_alias]
-            all[key] = type_cast_calculated_value(value, column, operation)
-            all
-          end
-        end
-
-      private
-        def validate_calculation_options(operation, options = {})
-          options.assert_valid_keys(CALCULATIONS_OPTIONS)
-        end
-
-        # Converts the given keys to the value that the database adapter returns as
-        # a usable column name:
-        #
-        #   column_alias_for("users.id")                 # => "users_id"
-        #   column_alias_for("sum(id)")                  # => "sum_id"
-        #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
-        #   column_alias_for("count(*)")                 # => "count_all"
-        #   column_alias_for("count", "id")              # => "count_id"
-        def column_alias_for(*keys)
-          table_name = keys.join(' ')
-          table_name.downcase!
-          table_name.gsub!(/\*/, 'all')
-          table_name.gsub!(/\W+/, ' ')
-          table_name.strip!
-          table_name.gsub!(/ +/, '_')
-
-          connection.table_alias_for(table_name)
-        end
-
-        def column_for(field)
-          field_name = field.to_s.split('.').last
-          columns.detect { |c| c.name.to_s == field_name }
-        end
-
-        def type_cast_calculated_value(value, column, operation = nil)
-          if value.is_a?(String) || value.nil?
-            case operation.to_s.downcase
-            when 'count' then value.to_i
-            when 'sum'   then type_cast_using_column(value || '0', column)
-            when 'avg' then value.try(:to_d)
-            else type_cast_using_column(value, column)
-            end
-          else
-            value
-          end
-        end
-
-        def type_cast_using_column(value, column)
-          column ? column.type_cast(value) : value
-        end
-    end
-  end
-end