activerecord 3.2.14.rc2 → 3.2.14

data/lib/active_record/core.rb.orig

@@ -1,452 +0,0 @@
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/object/duplicable'
-require 'thread'
-
-module ActiveRecord
-  module Core
-    extend ActiveSupport::Concern
-
-    included do
-      ##
-      # :singleton-method:
-      #
-      # Accepts a logger conforming to the interface of Log4r which is then
-      # passed on to any new database connections made and which can be
-      # retrieved on both a class and instance level by calling +logger+.
-      mattr_accessor :logger, instance_writer: false
-
-      ##
-      # :singleton-method:
-      # Contains the database configuration - as is typically stored in config/database.yml -
-      # as a Hash.
-      #
-      # For example, the following database.yml...
-      #
-      #   development:
-      #     adapter: sqlite3
-      #     database: db/development.sqlite3
-      #
-      #   production:
-      #     adapter: sqlite3
-      #     database: db/production.sqlite3
-      #
-      # ...would result in ActiveRecord::Base.configurations to look like this:
-      #
-      #   {
-      #      'development' => {
-      #         'adapter'  => 'sqlite3',
-      #         'database' => 'db/development.sqlite3'
-      #      },
-      #      'production' => {
-      #         'adapter'  => 'sqlite3',
-      #         'database' => 'db/production.sqlite3'
-      #      }
-      #   }
-      mattr_accessor :configurations, instance_writer: false
-      self.configurations = {}
-
-      ##
-      # :singleton-method:
-      # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
-      # dates and times from the database. This is set to :utc by default.
-      mattr_accessor :default_timezone, instance_writer: false
-      self.default_timezone = :utc
-
-      ##
-      # :singleton-method:
-      # Specifies the format to use when dumping the database schema with Rails'
-      # Rakefile. If :sql, the schema is dumped as (potentially database-
-      # specific) SQL statements. If :ruby, the schema is dumped as an
-      # ActiveRecord::Schema file which can be loaded into any database that
-      # supports migrations. Use :ruby if you want to have different database
-      # adapters for, e.g., your development and test environments.
-      mattr_accessor :schema_format, instance_writer: false
-      self.schema_format = :ruby
-
-      ##
-      # :singleton-method:
-      # Specify whether or not to use timestamps for migration versions
-      mattr_accessor :timestamped_migrations, instance_writer: false
-      self.timestamped_migrations = true
-
-<<<<<<< HEAD
-      ##
-      # :singleton-method:
-      # Disable implicit join references. This feature was deprecated with Rails 4.
-      # If you don't make use of implicit references but still see deprecation warnings
-      # you can disable the feature entirely. This will be the default with Rails 4.1.
-      mattr_accessor :disable_implicit_join_references, instance_writer: false
-      self.disable_implicit_join_references = false
-
-      class_attribute :connection_handler, instance_writer: false
-      self.connection_handler = ConnectionAdapters::ConnectionHandler.new
-=======
-      class_attribute :default_connection_handler, instance_writer: false
-      
-      def self.connection_handler
-        Thread.current[:active_record_connection_handler] || self.default_connection_handler
-      end
-
-      def self.connection_handler=(handler)
-        Thread.current[:active_record_connection_handler] = handler
-      end
-
-      self.default_connection_handler = ConnectionAdapters::ConnectionHandler.new
->>>>>>> SamSaffron/master
-    end
-
-    module ClassMethods
-      def inherited(child_class) #:nodoc:
-        child_class.initialize_generated_modules
-        super
-      end
-
-      def initialize_generated_modules
-        @attribute_methods_mutex = Mutex.new
-
-        # force attribute methods to be higher in inheritance hierarchy than other generated methods
-        generated_attribute_methods.const_set(:AttrNames, Module.new {
-          def self.const_missing(name)
-            const_set(name, [name.to_s.sub(/ATTR_/, '')].pack('h*').freeze)
-          end
-        })
-
-        generated_feature_methods
-      end
-
-      def generated_feature_methods
-        @generated_feature_methods ||= begin
-          mod = const_set(:GeneratedFeatureMethods, Module.new)
-          include mod
-          mod
-        end
-      end
-
-      # Returns a string like 'Post(id:integer, title:string, body:text)'
-      def inspect
-        if self == Base
-          super
-        elsif abstract_class?
-          "#{super}(abstract)"
-        elsif table_exists?
-          attr_list = columns.map { |c| "#{c.name}: #{c.type}" } * ', '
-          "#{super}(#{attr_list})"
-        else
-          "#{super}(Table doesn't exist)"
-        end
-      end
-
-      # Overwrite the default class equality method to provide support for association proxies.
-      def ===(object)
-        object.is_a?(self)
-      end
-
-      # Returns an instance of <tt>Arel::Table</tt> loaded with the current table name.
-      #
-      #   class Post < ActiveRecord::Base
-      #     scope :published_and_commented, published.and(self.arel_table[:comments_count].gt(0))
-      #   end
-      def arel_table
-        @arel_table ||= Arel::Table.new(table_name, arel_engine)
-      end
-
-      # Returns the Arel engine.
-      def arel_engine
-        @arel_engine ||= begin
-          if Base == self || connection_handler.retrieve_connection_pool(self)
-            self
-          else
-            superclass.arel_engine
-          end
-       end
-      end
-
-      private
-
-      def relation #:nodoc:
-        relation = Relation.new(self, arel_table)
-
-        if finder_needs_type_condition?
-          relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
-        else
-          relation
-        end
-      end
-    end
-
-    # New objects can be instantiated as either empty (pass no construction parameter) or pre-set with
-    # attributes but not yet saved (pass a hash with key names matching the associated table column names).
-    # In both instances, valid attribute keys are determined by the column names of the associated table --
-    # hence you can't have attributes that aren't part of the table columns.
-    #
-    # ==== Example:
-    #   # Instantiates a single new object
-    #   User.new(first_name: 'Jamie')
-    def initialize(attributes = nil)
-      defaults = self.class.column_defaults.dup
-      defaults.each { |k, v| defaults[k] = v.dup if v.duplicable? }
-
-      @attributes   = self.class.initialize_attributes(defaults)
-      @columns_hash = self.class.column_types.dup
-
-      init_internals
-      ensure_proper_type
-      populate_with_current_scope_attributes
-
-      assign_attributes(attributes) if attributes
-
-      yield self if block_given?
-      run_callbacks :initialize unless _initialize_callbacks.empty?
-    end
-
-    # Initialize an empty model object from +coder+. +coder+ must contain
-    # the attributes necessary for initializing an empty model object. For
-    # example:
-    #
-    #   class Post < ActiveRecord::Base
-    #   end
-    #
-    #   post = Post.allocate
-    #   post.init_with('attributes' => { 'title' => 'hello world' })
-    #   post.title # => 'hello world'
-    def init_with(coder)
-      @attributes   = self.class.initialize_attributes(coder['attributes'])
-      @columns_hash = self.class.column_types.merge(coder['column_types'] || {})
-
-      init_internals
-
-      @new_record = false
-
-      run_callbacks :find
-      run_callbacks :initialize
-
-      self
-    end
-
-    ##
-    # :method: clone
-    # Identical to Ruby's clone method.  This is a "shallow" copy.  Be warned that your attributes are not copied.
-    # That means that modifying attributes of the clone will modify the original, since they will both point to the
-    # same attributes hash. If you need a copy of your attributes hash, please use the #dup method.
-    #
-    #   user = User.first
-    #   new_user = user.clone
-    #   user.name               # => "Bob"
-    #   new_user.name = "Joe"
-    #   user.name               # => "Joe"
-    #
-    #   user.object_id == new_user.object_id            # => false
-    #   user.name.object_id == new_user.name.object_id  # => true
-    #
-    #   user.name.object_id == user.dup.name.object_id  # => false
-
-    ##
-    # :method: dup
-    # Duped objects have no id assigned and are treated as new records. Note
-    # that this is a "shallow" copy as it copies the object's attributes
-    # only, not its associations. The extent of a "deep" copy is application
-    # specific and is therefore left to the application to implement according
-    # to its need.
-    # The dup method does not preserve the timestamps (created|updated)_(at|on).
-
-    ##
-    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
-      @attributes[self.class.primary_key] = nil
-
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
-
-      @changed_attributes = {}
-      self.class.column_defaults.each do |attr, orig_value|
-        @changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
-      end
-
-      @aggregation_cache = {}
-      @association_cache = {}
-      @attributes_cache  = {}
-
-      @new_record  = true
-
-      ensure_proper_type
-      super
-    end
-
-    # Populate +coder+ with attributes about this record that should be
-    # serialized. The structure of +coder+ defined in this method is
-    # guaranteed to match the structure of +coder+ passed to the +init_with+
-    # method.
-    #
-    # Example:
-    #
-    #   class Post < ActiveRecord::Base
-    #   end
-    #   coder = {}
-    #   Post.new.encode_with(coder)
-    #   coder # => {"attributes" => {"id" => nil, ... }}
-    def encode_with(coder)
-      coder['attributes'] = attributes
-    end
-
-    # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
-    # is of the same type and +self+ has an ID and it is equal to +comparison_object.id+.
-    #
-    # Note that new records are different from any other record by definition, unless the
-    # other record is the receiver itself. Besides, if you fetch existing records with
-    # +select+ and leave the ID out, you're on your own, this predicate will return false.
-    #
-    # Note also that destroying a record preserves its ID in the model instance, so deleted
-    # models are still comparable.
-    def ==(comparison_object)
-      super ||
-        comparison_object.instance_of?(self.class) &&
-        id.present? &&
-        comparison_object.id == id
-    end
-    alias :eql? :==
-
-    # Delegates to id in order to allow two records of the same type and id to work with something like:
-    #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
-    def hash
-      id.hash
-    end
-
-    # Freeze the attributes hash such that associations are still accessible, even on destroyed records.
-    def freeze
-      @attributes.freeze
-      self
-    end
-
-    # Returns +true+ if the attributes hash has been frozen.
-    def frozen?
-      @attributes.frozen?
-    end
-
-    # Allows sort on objects
-    def <=>(other_object)
-      if other_object.is_a?(self.class)
-        self.to_key <=> other_object.to_key
-      end
-    end
-
-    # Returns +true+ if the record is read only. Records loaded through joins with piggy-back
-    # attributes will be marked as read only since they cannot be saved.
-    def readonly?
-      @readonly
-    end
-
-    # Marks this record as read only.
-    def readonly!
-      @readonly = true
-    end
-
-    # Returns the connection currently associated with the class. This can
-    # also be used to "borrow" the connection to do database work that isn't
-    # easily done without going straight to SQL.
-    def connection
-      ActiveSupport::Deprecation.warn("#connection is deprecated in favour of accessing it via the class")
-      self.class.connection
-    end
-
-    # Returns the contents of the record as a nicely formatted string.
-    def inspect
-      inspection = if @attributes
-                     self.class.column_names.collect { |name|
-                       if has_attribute?(name)
-                         "#{name}: #{attribute_for_inspect(name)}"
-                       end
-                     }.compact.join(", ")
-                   else
-                     "not initialized"
-                   end
-      "#<#{self.class} #{inspection}>"
-    end
-
-    # Returns a hash of the given methods with their names as keys and returned values as values.
-    def slice(*methods)
-      Hash[methods.map { |method| [method, public_send(method)] }].with_indifferent_access
-    end
-
-    def set_transaction_state(state) # :nodoc:
-      @transaction_state = state
-    end
-
-    def has_transactional_callbacks? # :nodoc:
-      !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_create_callbacks.empty?
-    end
-
-    private
-
-    # Updates the attributes on this particular ActiveRecord object so that
-    # if it is associated with a transaction, then the state of the AR object
-    # will be updated to reflect the current state of the transaction
-    #
-    # The @transaction_state variable stores the states of the associated
-    # transaction. This relies on the fact that a transaction can only be in
-    # one rollback or commit (otherwise a list of states would be required)
-    # Each AR object inside of a transaction carries that transaction's
-    # TransactionState.
-    #
-    # This method checks to see if the ActiveRecord object's state reflects
-    # the TransactionState, and rolls back or commits the ActiveRecord object
-    # as appropriate.
-    #
-    # Since ActiveRecord objects can be inside multiple transactions, this
-    # method recursively goes through the parent of the TransactionState and
-    # checks if the ActiveRecord object reflects the state of the object.
-    def sync_with_transaction_state
-      update_attributes_from_transaction_state(@transaction_state, 0)
-    end
-
-    def update_attributes_from_transaction_state(transaction_state, depth)
-      if transaction_state && !has_transactional_callbacks?
-        unless @reflects_state[depth]
-          if transaction_state.committed?
-            committed!
-          elsif transaction_state.rolledback?
-            rolledback!
-          end
-          @reflects_state[depth] = true
-        end
-
-        if transaction_state.parent && !@reflects_state[depth+1]
-          update_attributes_from_transaction_state(transaction_state.parent, depth+1)
-        end
-      end
-    end
-
-    # Under Ruby 1.9, Array#flatten will call #to_ary (recursively) on each of the elements
-    # of the array, and then rescues from the possible NoMethodError. If those elements are
-    # ActiveRecord::Base's, then this triggers the various method_missing's that we have,
-    # which significantly impacts upon performance.
-    #
-    # So we can avoid the method_missing hit by explicitly defining #to_ary as nil here.
-    #
-    # See also http://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary.html
-    def to_ary # :nodoc:
-      nil
-    end
-
-    def init_internals
-      pk = self.class.primary_key
-      @attributes[pk] = nil unless @attributes.key?(pk)
-
-      @aggregation_cache        = {}
-      @association_cache        = {}
-      @attributes_cache         = {}
-      @previously_changed       = {}
-      @changed_attributes       = {}
-      @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
-  end
-end

data/lib/active_record/relation/calculations.rb.orig

@@ -1,378 +0,0 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/try'
-
-module ActiveRecord
-  module Calculations
-    # 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")
-    #
-    #   # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job)
-    #
-    #   # finds the number of rows matching the conditions and joins.
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000",
-    #                :joins => "LEFT JOIN jobs on jobs.person_id = person.id")
-    #
-    #   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(column_name = nil, options = {})
-      column_name, options = nil, column_name if column_name.is_a?(Hash)
-      calculate(:count, column_name, options)
-    end
-
-    # Calculates the average value on a given column. Returns +nil+ if there's
-    # no row. See +calculate+ for examples with options.
-    #
-    #   Person.average('age') # => 35.8
-    def average(column_name, options = {})
-      calculate(:average, 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(:minimum, 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(:maximum, 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(*args)
-      if block_given?
-        self.to_a.sum(*args) {|*block_args| yield(*block_args)}
-      else
-        calculate(:sum, *args)
-      end
-    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'
-    #
-    #   # Selects the minimum age for any family without any minors
-    #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name)
-    #
-    #   Person.sum("2 * age")
-    def calculate(operation, column_name, options = {})
-      if options.except(:distinct).present?
-        apply_finder_options(options.except(:distinct)).calculate(operation, column_name, :distinct => options[:distinct])
-      else
-        relation = with_default_scope
-
-        if relation.equal?(self)
-          if eager_loading? || (includes_values.present? && references_eager_loaded_tables?)
-            construct_relation_for_association_calculations.calculate(operation, column_name, options)
-          else
-            perform_calculation(operation, column_name, options)
-          end
-        else
-          relation.calculate(operation, column_name, options)
-        end
-      end
-    rescue ThrowResult
-      0
-    end
-
-    # This method is designed to perform select by a single column as direct SQL query
-    # Returns <tt>Array</tt> with values of the specified column name
-    # The values has same data type as column.
-    #
-    # Examples:
-    #
-    #   Person.pluck(:id) # SELECT people.id FROM people
-    #   Person.uniq.pluck(:role) # SELECT DISTINCT role FROM people
-    #   Person.where(:confirmed => true).limit(5).pluck(:id)
-    #
-    def pluck(column_name)
-<<<<<<< HEAD
-      if column_name.is_a?(Symbol) && column_names.include?(column_name.to_s)
-        column_name = "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column_name)}"
-      else
-        column_name = column_name.to_s
-      end
-
-      relation = clone
-      relation.select_values = [column_name]
-      klass.connection.select_all(relation.arel).map! do |attributes|
-=======
-      column_name = column_name.to_s
-      klass.connection.select_all(select(column_name).arel).map! do |attributes|
->>>>>>> parent of 7240202... Merge pull request #8209 from senny/backport_8176
-        klass.type_cast_attribute(attributes.keys.first, klass.initialize_attributes(attributes))
-      end
-    end
-
-    private
-
-    def perform_calculation(operation, column_name, options = {})
-      operation = operation.to_s.downcase
-
-      # If #count is used in conjuction with #uniq it is considered distinct. (eg. relation.uniq.count)
-      distinct = options[:distinct] || self.uniq_value
-
-      if operation == "count"
-        column_name ||= (select_for_count || :all)
-
-        unless arel.ast.grep(Arel::Nodes::OuterJoin).empty?
-          distinct = true
-        end
-
-        column_name = primary_key if column_name == :all && distinct
-
-        distinct = nil if column_name =~ /\s*DISTINCT\s+/i
-      end
-
-      if @group_values.any?
-        execute_grouped_calculation(operation, column_name, distinct)
-      else
-        execute_simple_calculation(operation, column_name, distinct)
-      end
-    end
-
-    def aggregate_column(column_name)
-      if @klass.column_names.include?(column_name.to_s)
-        Arel::Attribute.new(@klass.unscoped.table, column_name)
-      else
-        Arel.sql(column_name == :all ? "*" : column_name.to_s)
-      end
-    end
-
-    def operation_over_aggregate_column(column, operation, distinct)
-      operation == 'count' ? column.count(distinct) : column.send(operation)
-    end
-
-    def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-      # Postgresql doesn't like ORDER BY when there are no GROUP BY
-      relation = reorder(nil)
-
-      if operation == "count" && (relation.limit_value || relation.offset_value)
-        # Shortcut when limit is zero.
-        return 0 if relation.limit_value == 0
-
-        query_builder = build_count_subquery(relation, column_name, distinct)
-      else
-        column = aggregate_column(column_name)
-
-        select_value = operation_over_aggregate_column(column, operation, distinct)
-
-        relation.select_values = [select_value]
-
-        query_builder = relation.arel
-      end
-
-      type_cast_calculated_value(@klass.connection.select_value(query_builder), column_for(column_name), operation)
-    end
-
-    def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
-      group_attrs = @group_values
-
-      if group_attrs.first.respond_to?(:to_sym)
-        association  = @klass.reflect_on_association(group_attrs.first.to_sym)
-        associated   = group_attrs.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
-        group_fields = Array(associated ? association.foreign_key : group_attrs)
-      else
-        group_fields = group_attrs
-      end
-
-      group_aliases = group_fields.map { |field| column_alias_for(field) }
-      group_columns = group_aliases.zip(group_fields).map { |aliaz,field|
-        [aliaz, column_for(field)]
-      }
-
-      group = @klass.connection.adapter_name == 'FrontBase' ? group_aliases : group_fields
-
-      if operation == 'count' && column_name == :all
-        aggregate_alias = 'count_all'
-      else
-        aggregate_alias = column_alias_for(operation, column_name)
-      end
-
-      select_values = [
-        operation_over_aggregate_column(
-          aggregate_column(column_name),
-          operation,
-          distinct).as(aggregate_alias)
-      ]
-      select_values += @select_values unless @having_values.empty?
-
-      select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
-        if field.respond_to?(:as)
-          field.as(aliaz)
-        else
-          "#{field} AS #{aliaz}"
-        end
-      }
-
-      relation = except(:group).group(group)
-      relation.select_values = select_values
-
-      calculated_data = @klass.connection.select_all(relation)
-
-      if association
-        key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-        key_records = association.klass.base_class.find(key_ids)
-        key_records = Hash[key_records.map { |r| [r.id, r] }]
-      end
-
-      ActiveSupport::OrderedHash[calculated_data.map do |row|
-        key = group_columns.map { |aliaz, column|
-          type_cast_calculated_value(row[aliaz], column)
-        }
-        key = key.first if key.size == 1
-        key = key_records[key] if associated
-        [key, type_cast_calculated_value(row[aggregate_alias], column_for(column_name), operation)]
-      end]
-    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)
-      keys.map! {|k| k.respond_to?(:to_sql) ? k.to_sql : k}
-      table_name = keys.join(' ')
-      table_name.downcase!
-      table_name.gsub!(/\*/, 'all')
-      table_name.gsub!(/\W+/, ' ')
-      table_name.strip!
-      table_name.gsub!(/ +/, '_')
-
-      @klass.connection.table_alias_for(table_name)
-    end
-
-    def column_for(field)
-      field_name = field.respond_to?(:name) ? field.name.to_s : field.to_s.split('.').last
-      @klass.columns.detect { |c| c.name.to_s == field_name }
-    end
-
-    def type_cast_calculated_value(value, column, operation = nil)
-      case operation
-        when 'count'   then value.to_i
-        when 'sum'     then type_cast_using_column(value || '0', column)
-        when 'average' then value.respond_to?(:to_d) ? value.to_d : value
-        else type_cast_using_column(value, column)
-      end
-    end
-
-    def type_cast_using_column(value, column)
-      column ? column.type_cast(value) : value
-    end
-
-    def select_for_count
-      if @select_values.present?
-        select = @select_values.join(", ")
-        select if select !~ /(,|\*)/
-      end
-    end
-
-    def build_count_subquery(relation, column_name, distinct)
-      column_alias = Arel.sql('count_column')
-      subquery_alias = Arel.sql('subquery_for_count')
-
-      aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
-      relation.select_values = [aliased_column]
-      subquery = relation.arel.as(subquery_alias)
-
-      sm = Arel::SelectManager.new relation.engine
-      select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
-      sm.project(select_value).from(subquery)
-    end
-  end
-end