Empact-ar-extensions 0.9.2

data/lib/ar-extensions/import/mysql.rb

@@ -0,0 +1,50 @@
+module ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter # :nodoc:
+
+  include ActiveRecord::Extensions::Import::ImportSupport  
+  include ActiveRecord::Extensions::Import::OnDuplicateKeyUpdateSupport
+    
+  # Returns a generated ON DUPLICATE KEY UPDATE statement given the passed
+  # in +args+. 
+  def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
+    sql = ' ON DUPLICATE KEY UPDATE '
+    arg = args.first
+    if arg.is_a?( Array )
+      sql << sql_for_on_duplicate_key_update_as_array( table_name, arg )
+    elsif arg.is_a?( Hash )
+      sql << sql_for_on_duplicate_key_update_as_hash( table_name, arg )
+    elsif arg.is_a?( String )
+      sql << arg
+    else
+      raise ArgumentError.new( "Expected Array or Hash" )
+    end
+    sql
+  end
+
+  def sql_for_on_duplicate_key_update_as_array( table_name, arr )  # :nodoc:
+    results = arr.map do |column|
+      qc = quote_column_name( column )
+      "#{table_name}.#{qc}=VALUES(#{qc})"        
+    end
+    results.join( ',' )
+  end
+  
+  def sql_for_on_duplicate_key_update_as_hash( table_name, hsh ) # :nodoc:
+    sql = ' ON DUPLICATE KEY UPDATE '
+    results = hsh.map do |column1, column2|
+      qc1 = quote_column_name( column1 )
+      qc2 = quote_column_name( column2 )
+      "#{table_name}.#{qc1}=VALUES( #{qc2} )"
+    end
+    results.join( ',')
+  end
+
+  #return true if the statement is a duplicate key record error
+  def duplicate_key_update_error?(exception)# :nodoc:
+    exception.is_a?(ActiveRecord::StatementInvalid) && exception.to_s.include?('Duplicate entry')
+  end
+
+end
+
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  include ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter
+end

data/lib/ar-extensions/import/sqlite.rb

@@ -0,0 +1,22 @@
+module ActiveRecord::Extensions::ConnectionAdapters::SQLiteAdapter # :nodoc:
+  include ActiveRecord::Extensions::Import::ImportSupport  
+  
+  def post_sql_statements( table_name, options )
+    []
+  end
+
+  def insert_many( sql, values, *args ) # :nodoc:
+    sql2insert = []
+    values.each do |value|
+      sql2insert << "#{sql} #{value};"
+    end
+    
+    raw_connection.transaction { |db| db.execute_batch(sql2insert.join("\n")) }
+    number_of_rows_inserted = sql2insert.size
+  end
+
+end
+
+ActiveRecord::ConnectionAdapters::SQLiteAdapter.class_eval do
+  include ActiveRecord::Extensions::ConnectionAdapters::SQLiteAdapter
+end

data/lib/ar-extensions/insert_select.rb

@@ -0,0 +1,178 @@
+# Insert records in bulk with a select statement
+#
+# == Parameters
+# * +options+ - the options used for the finder sql (select)
+#
+# === Options
+# Any valid finder options (options for <tt>ActiveRecord::Base.find(:all)</tt> )such as <tt>:joins</tt>, <tt>:conditions</tt>, <tt>:include</tt>, etc including:
+# * <tt>:from</tt> - the symbol, class name or class used for the finder SQL (select)
+# * <tt>:on_duplicate_key_update</tt> - an array of fields to update, or a custom string
+# * <tt>:select</tt> - An array of fields to select or custom string. The SQL will be sanitized and ? replaced with values as with <tt>:conditions</tt>.
+# * <tt>:ignore => true </tt> - will ignore any duplicates 
+# * <tt>:into</tt> - Specifies the columns for which data will be inserted. An array of fields to select or custom string.
+#
+# == Examples
+# Create cart items for all books for shopping cart <tt>@cart+
+# setting the +copies+ field to 1, the +updated_at+ field to Time.now and the +created_at+ field to the database function now()
+#  CartItem.insert_select(:from => :book,
+#                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now], 
+#                         :into => [:book_id, :shopping_cart_id, :copies, :updated_at, :created_at]})
+#                         
+# GENERATED SQL example (MySQL): 
+#  INSERT INTO `cart_items` ( `book_id`, `shopping_cart_id`, `copies`, `updated_at`, `created_at` ) 
+#  SELECT books.id, '134', 1, '2009-03-02 18:28:25', now() FROM `books`
+#
+# A similar example that 
+# * uses the class +Book+ instead of symbol <tt>:book</tt>
+# * a custom string (instead of an Array) for the <tt>:select</tt> of the +insert_options+
+# * Updates the +updated_at+ field of all existing cart item. This assumes there is a unique composite index on the +book_id+ and +shopping_cart_id+ fields
+#
+#  CartItem.insert_select(:from => Book,
+#                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now], 
+#                         :into => 'cart_items.book_id, shopping_cart_id, copies, updated_at, created_at',
+#                         :on_duplicate_key_update => [:updated_at]) 
+# GENERATED SQL example (MySQL):   
+#    INSERT INTO `cart_items` ( cart_items.book_id, shopping_cart_id, copies, updated_at, created_at ) 
+#    SELECT books.id, '138', 1, '2009-03-02 18:32:34', now() FROM `books` 
+#           ON DUPLICATE KEY UPDATE `cart_items`.`updated_at`=VALUES(`updated_at`)
+#
+#
+# Similar example ignoring duplicates
+#  CartItem.insert_select(:from => :book,
+#                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now], 
+#                         :into => [:book_id, :shopping_cart_id, :copies, :updated_at, :created_at],
+#                         :ignore => true)
+#
+# == Developers
+# * Blythe Dunham http://blythedunham.com
+#
+# == Homepage
+# * Project Site: http://www.continuousthinking.com/tags/arext
+# * Rubyforge Project: http://rubyforge.org/projects/arext
+# * Anonymous SVN: svn checkout svn://rubyforge.org/var/svn/arext
+#
+
+module ActiveRecord::Extensions::ConnectionAdapters; end
+
+module ActiveRecord::Extensions::InsertSelectSupport #:nodoc:
+  def supports_insert_select? #:nodoc:
+    true
+  end
+end
+
+class ActiveRecord::Base
+  
+  include ActiveRecord::Extensions::SqlGeneration
+
+  class << self
+    # Insert records in bulk with a select statement
+    #
+    # == Parameters
+    # * +options+ - the options used for the finder sql (select)
+    #
+    # === Options
+    # Any valid finder options (options for <tt>ActiveRecord::Base.find(:all)</tt> )such as <tt>:joins</tt>, <tt>:conditions</tt>, <tt>:include</tt>, etc including:
+    # * <tt>:from</tt> - the symbol, class name or class used for the finder SQL (select)
+    # * <tt>:on_duplicate_key_update</tt> - an array of fields to update, or a custom string
+    # * <tt>:select</tt> - An array of fields to select or custom string. The SQL will be sanitized and ? replaced with values as with <tt>:conditions</tt>.
+    # * <tt>:ignore => true </tt> - will ignore any duplicates
+    # * <tt>:into</tt> - Specifies the columns for which data will be inserted. An array of fields to select or custom string.
+    #
+    # == Examples
+    # Create cart items for all books for shopping cart <tt>@cart+
+    # setting the +copies+ field to 1, the +updated_at+ field to Time.now and the +created_at+ field to the database function now()
+    #  CartItem.insert_select(:from => :book,
+    #                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now],
+    #                         :into => [:book_id, :shopping_cart_id, :copies, :updated_at, :created_at]})
+    #
+    # GENERATED SQL example (MySQL):
+    #  INSERT INTO `cart_items` ( `book_id`, `shopping_cart_id`, `copies`, `updated_at`, `created_at` )
+    #  SELECT books.id, '134', 1, '2009-03-02 18:28:25', now() FROM `books`
+    #
+    # A similar example that
+    # * uses the class +Book+ instead of symbol <tt>:book</tt>
+    # * a custom string (instead of an Array) for the <tt>:select</tt> of the +insert_options+
+    # * Updates the +updated_at+ field of all existing cart item. This assumes there is a unique composite index on the +book_id+ and +shopping_cart_id+ fields
+    #
+    #  CartItem.insert_select(:from => Book,
+    #                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now],
+    #                         :into => 'cart_items.book_id, shopping_cart_id, copies, updated_at, created_at',
+    #                         :on_duplicate_key_update => [:updated_at])
+    # GENERATED SQL example (MySQL):
+    #    INSERT INTO `cart_items` ( cart_items.book_id, shopping_cart_id, copies, updated_at, created_at )
+    #    SELECT books.id, '138', 1, '2009-03-02 18:32:34', now() FROM `books`
+    #           ON DUPLICATE KEY UPDATE `cart_items`.`updated_at`=VALUES(`updated_at`)
+    #
+    #
+    # Similar example ignoring duplicates
+    #  CartItem.insert_select(:from => :book,
+    #                         :select => ['books.id, ?, ?, ?, now()', @cart.to_param, 1, Time.now],
+    #                         :into => [:book_id, :shopping_cart_id, :copies, :updated_at, :created_at],
+    #                         :ignore => true)
+    def insert_select(options={})
+      select_obj = options.delete(:from).to_s.classify.constantize
+      #TODO: add batch support for high volume inserts
+      #return insert_select_batch(select_obj, select_options, insert_options) if insert_options[:batch]
+      sql = construct_insert_select_sql(select_obj, options)
+      connection.insert(sql, "#{name} Insert Select #{select_obj}")
+    end
+
+    protected
+
+    def construct_insert_select_sql(select_obj, options)#:nodoc:
+      construct_ar_extension_sql(gather_insert_options(options), valid_insert_select_options) do |sql, into_op|
+        sql << " INTO #{quoted_table_name} "
+        sql << "( #{into_column_sql(options.delete(:into))} ) "
+        
+        #sanitize the select sql based on the select object
+        sql << select_obj.send(:finder_sql_to_string, sanitize_select_options(options))
+        sql
+      end
+    end
+    
+    #  return a list of the column names quoted accordingly
+    #  nil => All columns except primary key (auto update)
+    #  String => Exact String
+    #  Array
+    #    needs sanitation ["?, ?", 5, 'test'] => "5, 'test'"  or [":date", {:date => Date.today}] => "12-30-2006"]
+    #    list of strings or symbols returns quoted values [:start, :name] => `start`, `name` or ['abc'] => `start`
+    def select_column_sql(field_list=nil)#:nodoc:
+      if field_list.kind_of?(String)
+        field_list.dup
+      elsif ((field_list.kind_of?(Array) && field_list.first.is_a?(String)) &&
+             (field_list.last.is_a?(Hash) || field_list.first.include?('?')))
+        sanitize_sql(field_list)
+      else
+        field_list = field_list.blank? ? self.column_names - [self.primary_key] : [field_list].flatten
+        field_list.collect{|field| self.connection.quote_column_name(field.to_s) }.join(", ")
+      end
+    end
+
+    alias_method :into_column_sql, :select_column_sql
+    
+    #sanitize the select options for insert select
+    def sanitize_select_options(options)#:nodoc:
+      o = options.dup
+      select = o.delete :select
+      o[:override_select] = select ? select_column_sql(select) : ' * '
+      o
+    end
+
+
+    def valid_insert_select_options#:nodoc:
+      @@valid_insert_select_options ||= [:command, :into_pre, :into_post, 
+                                         :into_keywords, :ignore,
+                                         :on_duplicate_key_update]
+    end
+
+    #move all the insert options to a seperate map
+    def gather_insert_options(options)#:nodoc:
+      into_options = valid_insert_select_options.inject(:command => 'INSERT') do |map, o|
+        v = options.delete(o)
+        map[o] =  v if v
+        map
+      end
+    end
+
+  end
+end

data/lib/ar-extensions/insert_select/mysql.rb

@@ -0,0 +1,7 @@
+#insert select functionality is dependent on finder options and import
+require 'ar-extensions/finder_options/mysql'
+require 'ar-extensions/import/mysql'
+
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  include ActiveRecord::Extensions::InsertSelectSupport
+end

data/lib/ar-extensions/synchronize.rb

@@ -0,0 +1,30 @@
+module ActiveRecord # :nodoc:
+  class Base # :nodoc:
+      
+    # Synchronizes the passed in ActiveRecord instances with data
+    # from the database. This is like calling reload
+    # on an individual ActiveRecord instance but it is intended for use on
+    # multiple instances. 
+    #
+    # This uses one query for all instance updates and then updates existing
+    # instances rather sending one query for each instance
+    def self.synchronize(instances, key=self.primary_key)
+      return if instances.empty?
+      
+      keys = instances.map(&"#{key}".to_sym)
+      klass = instances.first.class
+      fresh_instances = klass.find( :all, :conditions=>{ key=>keys }, :order=>"#{key} ASC" )
+
+      instances.each_with_index do |instance, index|
+        instance.clear_aggregation_cache
+        instance.clear_association_cache
+        instance.instance_variable_set '@attributes', fresh_instances[index].attributes
+      end
+    end
+
+    # See ActiveRecord::ConnectionAdapters::AbstractAdapter.synchronize
+    def synchronize(instances, key=ActiveRecord::Base.primary_key)
+      self.class.synchronize(instances, key)
+    end
+  end
+end

data/lib/ar-extensions/temporary_table.rb

@@ -0,0 +1,131 @@
+module ActiveRecord::Extensions::TemporaryTableSupport # :nodoc:
+  def supports_temporary_tables? #:nodoc:
+    true
+  end
+end
+
+class ActiveRecord::Base
+  # Returns true if the underlying database connection supports temporary tables
+  def self.supports_temporary_tables?
+    connection.supports_temporary_tables?
+  rescue NoMethodError
+    false
+  end
+  
+  ######################################################################
+  # Creates a temporary table given the passed in options hash.  The
+  # temporary table is created based off from another table the
+  # current model class. This method returns the constant for the new
+  # new model. This can also be used with block form (see below).
+  # 
+  # == Parameters
+  # * options - the options hash used to define the temporary table. 
+  # 
+  # ==== Options
+  # <tt>:table_name</tt>::the desired name of the temporary table. If not supplied 
+  #   then a name of "temp_" + the current table_name of the current model 
+  #   will be used.
+  # <tt>:like</tt>:: the table model you want to base the temporary tables 
+  #   structure off from. If this is not supplied then the table_name of the 
+  #   current model will be used.
+  # <tt>:model_name</tt>:: the name of the model you want to use for the temporary 
+  #   table. This must be compliant with Ruby's naming conventions for 
+  #   constants. If this is not supplied a rails-generated table name will 
+  #   be created which is based off from the table_name of the temporary table. 
+  #   IE: Account.create_temporary_table creates the TempAccount model class
+  #
+  # ==== Example 1, using defaults
+  #
+  #  class Project < ActiveRecord::Base
+  #  end
+  #
+  #  > t = Project.create_temporary_table
+  #  > t.class
+  #  => "TempProject"
+  #  > t.superclass
+  #  => Project
+  #
+  # This creates a temporary table named 'temp_projects' and creates a constant
+  # name TempProject. The table structure is copied from the 'projects' table. 
+  # TempProject is a subclass of Project as you would expect.
+  #
+  # ==== Example 2, using <tt>:table_name</tt> and <tt>:model options</tt>
+  #
+  #   Project.create_temporary_table :table_name => 'my_projects', :model => 'MyProject'
+  #
+  # This creates a temporary table named 'my_projects' and creates a constant named
+  # MyProject. The table structure is copied from the 'projects' table.
+  #
+  # ==== Example 3, using <tt>:like</tt>
+  #
+  #   ActiveRecord::Base.create_temporary_table :like => Project 
+  #  
+  # This is the same as calling Project.create_temporary_table.
+  #
+  # ==== Example 4, using block form
+  #
+  #   Project.create_temporary_table do |t|
+  #     # ...
+  #   end
+  # 
+  # Using the block form will automatically drop the temporary table
+  # when the block exits. +t+ which is passed into the block is the temporary
+  # table class. In the above example +t+ equals TempProject. The block form
+  # can be used with all of the available options.
+  #
+  # === See
+  #
+  # * +drop+
+  #
+  ######################################################################
+  def self.create_temporary_table(opts={})
+    opts[:temporary]  ||= !opts[:permanent]
+    opts[:like]       ||= self
+    opts[:table_name] ||= "temp_#{self.table_name}"
+    opts[:model_name] ||= ActiveSupport::Inflector.classify(opts[:table_name])
+
+    if Object.const_defined?(opts[:model_name])
+      raise Exception, "Model #{opts[:model_name]} already exists!"
+    end
+
+    like_table_name = opts[:like].table_name || self.table_name
+
+    connection.execute <<-SQL
+      CREATE #{opts[:temporary] ? 'TEMPORARY' : ''} TABLE #{opts[:table_name]}
+        LIKE #{like_table_name}
+    SQL
+    
+    # Sample evaluation:
+    #
+    #   class ::TempFood < Food
+    #     set_table_name :temp_food
+    #
+    #     def self.drop
+    #       connection.execute "DROP TABLE temp_foo"
+    #       Object.send(:remove_const, self.name.to_sym)
+    #     end
+    #   end
+    class_eval(<<-RUBY, __FILE__, __LINE__)
+      class ::#{opts[:model_name]} < #{self.name}
+        set_table_name :#{opts[:table_name]}
+
+        def self.drop
+          connection.execute "DROP TABLE #{opts[:table_name]};"
+          Object.send(:remove_const, self.name.to_sym)
+        end
+      end
+    RUBY
+
+    model = Object.const_get(opts[:model_name])
+
+    if block_given?
+      begin
+        yield(model)
+      ensure
+        model.drop
+      end
+    else
+      return model
+    end
+  end
+end

data/lib/ar-extensions/temporary_table/mysql.rb

@@ -0,0 +1,3 @@
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  include ActiveRecord::Extensions::TemporaryTableSupport 
+end

data/lib/ar-extensions/union.rb

@@ -0,0 +1,204 @@
+module ActiveRecord::Extensions::Union#:nodoc:
+  module UnionSupport #:nodoc:
+    def supports_union? #:nodoc:
+      true
+    end
+  end
+end
+
+class ActiveRecord::Base
+  supports_extension :union
+
+  extend ActiveRecord::Extensions::SqlGeneration
+  class << self
+    # Find a union of two or more queries
+    # === Args
+    # Each argument is a hash map of options sent to <tt>:find :all</tt>
+    # including <tt>:conditions</tt>, <tt>:join</tt>, <tt>:group</tt>,
+    # <tt>:having</tt>, and <tt>:limit</tt>
+    #
+    # In addition the following options are accepted
+    # * <tt>:pre_sql</tt> inserts SQL before the SELECT statement of this protion of the +union+
+    # * <tt>:post_sql</tt> appends additional SQL to the end of the statement
+    # * <tt>:override_select</tt> is used to override the <tt>SELECT</tt> clause of eager loaded associations
+    #
+    # == Examples
+    # Find the union of a San Fran zipcode with a Seattle zipcode
+    #    union_args1 = {:conditions => ['zip_id = ?', 94010], :select => :phone_number_id}
+    #    union_args2 = {:conditions => ['zip_id = ?', 98102], :select => :phone_number_id}
+    #    Contact.find_union(union_args1, union_args2, ...)
+    #
+    #    SQL>  (SELECT phone_number_id FROM contacts WHERE zip_id = 94010) UNION
+    #          (SELECT phone_number_id FROM contacts WHERE zip_id = 98102) UNION ...
+    #
+    # == Global Options
+    # To specify global options that apply to the entire union, specify a hash as the
+    # first parameter with a key <tt>:union_options</tt>. Valid options include
+    # <tt>:group</tt>, <tt>:having</tt>, <tt>:order</tt>, and <tt>:limit</tt>
+    #
+    #
+    # Example:
+    #  Contact.find_union(:union_options => {:limit => 10, :order => 'created_on'},
+    #  union_args1, union_args2, ...)
+    #
+    #  SQL> ((select phone_number_id from contacts ...) UNION (select phone_number_id from contacts ...)) order by created_on limit 10
+    #
+    def find_union(*args)
+      supports_union!
+      find_by_sql(find_union_sql(*args))
+    end
+
+    # Count across a union of two or more queries
+    # === Args
+    # * +column_name+ - The column to count. Defaults to all ('*')
+    # * <tt>*args</tt> - Each additional argument is a hash map of options used by <tt>:find :all</tt>
+    # including <tt>:conditions</tt>, <tt>:join</tt>, <tt>:group</tt>,
+    # <tt>:having</tt>, and <tt>:limit</tt>
+    #
+    # In addition the following options are accepted
+    # * <tt>:pre_sql</tt> inserts SQL before the SELECT statement of this protion of the +union+
+    # * <tt>:post_sql</tt> appends additional SQL to the end of the statement
+    # * <tt>:override_select</tt> is used to override the <tt>SELECT</tt> clause of eager loaded associations
+    #
+    # Note that distinct is implied so a record that matches more than one
+    # portion of the union is counted only once.
+    #
+    # == Global Options
+    # To specify global options that apply to the entire union, specify a hash as the
+    # first parameter with a key <tt>:union_options</tt>. Valid options include
+    # <tt>:group</tt>, <tt>:having</tt>, <tt>:order</tt>, and <tt>:limit</tt>
+    #
+    # == Examples
+    # Count the number of people who live in Seattle and San Francisco
+    #  Contact.count_union(:phone_number_id,
+    #        {:conditions => ['zip_id = ?, 94010]'},
+    #        {:conditions => ['zip_id = ?', 98102]})
+    #  SQL> select count(*) from ((select phone_number_id from contacts ...) UNION (select phone_number_id from contacts ...)) as counter_tbl;
+    def count_union(column_name, *args)
+      supports_union!
+      count_val = calculate_union(:count, column_name, *args)
+      (args.length == 1 && args.first[:limit] && args.first[:limit].to_i < count_val) ? args.first[:limit].to_i : count_val
+    end
+
+    protected
+
+    #do a union of specified calculation. Only for simple calculations
+    def calculate_union(operation, column_name, *args)#:nodoc:
+      union_options = remove_union_options(args)
+
+
+      if args.length == 1
+        column_name     = '*' if column_name == :all
+        calculate(operation, column_name, args.first.update(union_options))
+
+      # For more than one map of options, count off the subquery of all the column_name fields unioned together
+      # For example, if column_name is phone_number_id the generated query is
+      #  Contact.calculate_union(:count, :phone_number_id, args)
+      #  SQL> select count(*) from
+      #     ((select phone_number_id from contacts ...)
+      #      UNION
+      #     (select phone_number_id from contacts ...)) as counter_tbl
+      else
+        column_name     = primary_key if column_name == :all
+        column          = column_for column_name
+        column_name     = "#{table_name}.#{column_name}" unless column_name.to_s.include?('.')
+
+        group_by = union_options.delete(:group)
+        having = union_options.delete(:having)
+        query_alias = union_options.delete(:query_alias)||"#{operation}_giraffe"
+
+
+        #aggregate_alias should be table_name_id
+        aggregate_alias = column_alias_for('', column_name)
+        #main alias is operation_table_name_id
+        main_aggregate_alias = column_alias_for(operation, column_name)
+
+        sql = "SELECT "
+        sql << (group_by ? "#{group_by}, #{operation}(#{aggregate_alias})" : "#{operation}(*)")
+        sql << " AS #{main_aggregate_alias}"
+        sql << " FROM ("
+
+        #by nature of the union the results will always be distinct, so remove distinct column here
+        sql << args.inject([]){|l, a|
+          calc = "(#{construct_calculation_sql_with_extension('', column_name, a)})"
+          #for group by we need to select the group by column also
+          calc.gsub!(" AS #{aggregate_alias}", " AS #{aggregate_alias}, #{group_by} ") if group_by
+          l <<  calc
+        }.join(" UNION ")
+
+        add_union_options!(sql, union_options)
+
+        sql << ") as #{query_alias}"
+
+        if group_by
+          #add groupings
+          sql << " GROUP BY #{group_by}"
+          sql << " HAVING #{having}" if having
+
+          calculated_data = connection.select_all(sql)
+
+          calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
+            key   = type_cast_calculated_value(row[group_by], column_for(group_by.to_s))
+            value = row[main_aggregate_alias]
+            all << [key, type_cast_calculated_value(value, column_for(column), operation)]
+          end
+
+        else
+          count_by_sql(sql)
+        end
+      end
+    end
+
+
+    #Add Global Union options
+    def add_union_options!(sql, options)#:nodoc:
+      sql << " GROUP BY #{options[:group]} " if options[:group]
+
+      if options[:order] || options[:limit]
+        scope = scope(:find)
+        add_order!(sql, options[:order], scope)
+        add_limit!(sql, options, scope)
+      end
+      sql
+    end
+
+    #Remove the global union options
+    def remove_union_options(args)#:nodoc:
+      args.first.is_a?(Hash) && args.first.has_key?(:union_options)  ? (args.shift)[:union_options] : {}
+    end
+
+    def construct_calculation_sql_with_extension(operation, column_name, options)
+      construct_ar_extension_sql(options.merge(:command => '', :keywords => nil, :distinct => nil)) {|sql, o|
+        calc_sql = construct_calculation_sql(operation, column_name, options)
+
+        #this is really gross but prevents us from rewriting construct_calculation_sql
+        calc_sql.gsub!(/^SELECT\s/, "SELECT #{options[:keywords]} ") if options[:keywords]
+
+        sql << calc_sql
+      }
+    end
+
+    # Return the sql for union of the query options specified on the command line
+    # If the first parameter is a map containing :union_options, use these
+    def find_union_sql(*args)#:nodoc:
+      options = remove_union_options(args)
+
+      if args.length == 1
+        return finder_sql_to_string(args.first.update(options))
+      end
+
+      sql = args.inject([]) do |sql_list, union_args|
+        part = union_args.merge(:force_eager_load => true,
+                                :override_select => union_args[:select]||"#{quoted_table_name}.*",
+                                :select => nil)
+        sql_list << "(#{finder_sql_to_string(part)})"
+        sql_list
+      end.join(" UNION ")
+
+
+      add_union_options!(sql, options)
+      sql
+    end
+  end
+end
+