ar-extensions 0.8.2 → 0.9.0

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

@@ -0,0 +1,6 @@
+# Although the finder options actually override ActiveRecord::Base functionality instead of
+# connector functionality, the methods are included here to keep the syntax of 0.8.0 intact
+#
+# To include finder options, use:
+# require 'ar-extensions/finder_options/mysql.rb'
+ActiveRecord::Base.send :include, ActiveRecord::Extensions::FinderOptions

data/lib/ar-extensions/finders.rb

@@ -1,3 +1,8 @@
+require 'active_record/version'
+
+
+
+
 module ActiveRecord::ConnectionAdapters::Quoting
 
   alias :quote_before_arext :quote
@@ -10,6 +15,7 @@ module ActiveRecord::ConnectionAdapters::Quoting
   end
 end
 
+unless  ActiveRecord::VERSION::STRING < '2.0.2'
 class ActiveRecord::Base
 
   class << self
@@ -71,7 +77,6 @@ class ActiveRecord::Base
             else
               table_name = quoted_table_name
             end
-
             # ActiveRecord in 2.3.1 changed the method signature for
             # the method attribute_condition
             if ActiveRecord::VERSION::STRING < '2.3.1'
@@ -92,3 +97,4 @@ class ActiveRecord::Base
   end
   
 end
+end

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

@@ -12,6 +12,8 @@ module ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter # :nodoc:
       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
@@ -34,7 +36,12 @@ module ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter # :nodoc:
       "#{table_name}.#{qc1}=VALUES( #{qc2} )"
     end
     results.join( ',')
-  end  
+  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
 

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/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
+