ar-extensions 0.8.2 → 0.9.0

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

@@ -0,0 +1,7 @@
+# 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/create_and_update/mysql.rb'
+
+ActiveRecord::Base.send :include, ActiveRecord::Extensions::CreateAndUpdate

data/lib/ar-extensions/csv.rb

@@ -179,14 +179,37 @@ module ActiveRecord::Extensions::FindToCSV
 
     private
     
+    def add_to_csv_association_methods!(association_name)
+      association = self.send association_name
+      association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
+      association      
+    end
+    
+    def add_to_csv_association_data! data, to
+      if to.empty?
+        to.push( *data )
+      else
+        originals = to.dup
+        to.clear
+        data.each do |assoc_csv|
+          originals.each do |sibling|
+            to.push( sibling + assoc_csv )
+          end
+        end
+      end
+    end
+    
+    def to_csv_association_is_blank?(association)
+      association.nil? or (association.respond_to?( :empty? ) and association.empty?)      
+    end
+    
     def to_csv_data_for_included_associations( includes ) # :nodoc:
       get_class = proc { |str| Object.const_get( self.class.reflections[ str.to_sym ].class_name ) }
 
       case includes
       when Symbol
-        association = self.send( includes )
-        association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
-        if association.nil? or (association.respond_to?( :empty? ) and association.empty?)
+        association = add_to_csv_association_methods! includes
+        if to_csv_association_is_blank?(association)
           [ get_class.call( includes ).columns.map{ '' } ]
         else
           [ *association.to_csv_data ]
@@ -194,50 +217,27 @@ module ActiveRecord::Extensions::FindToCSV
       when Array
         siblings = []
         includes.each do |association_name|
-          association = self.send( association_name )
-          association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
-          if association.nil? or (association.respond_to?( :empty? ) and association.empty?)
+          association = add_to_csv_association_methods! association_name
+          if to_csv_association_is_blank?(association)
             association_data = [ get_class.call( association_name ).columns.map{ '' }  ]
           else
             association_data = association.to_csv_data
           end
 
-          if siblings.empty?
-            siblings.push( *association_data )
-          else
-            temp = []
-            association_data.each do |assoc_csv|
-              siblings.each do |sibling|
-                temp.push( sibling + assoc_csv )
-              end
-            end
-            siblings = temp            
-          end
+          add_to_csv_association_data! association_data, siblings
         end
         siblings
       when Hash
         sorted_includes = includes.sort_by{ |k| k.to_s }
         siblings = []
         sorted_includes.each do |(association_name,options)|
-          association = self.send( association_name )
-          association.send( :extend, ArrayInstanceMethods ) if association.is_a?( Array )
-          if association.nil? or (association.respond_to?( :empty ) and association.empty?)
+          association = add_to_csv_association_methods! association_name
+          if to_csv_association_is_blank?(association)
             association_data = [ get_class.call( association_name ).columns.map{ '' }  ]
           else
             association_data = association.to_csv_data( options )
           end
-
-          if siblings.empty?
-            siblings.push( *association_data )
-          else
-            temp = []
-            association_data.each do |assoc_csv|
-              siblings.each do |sibling|
-                temp.push( sibling + assoc_csv )
-              end
-            end
-            siblings = temp            
-          end
+          add_to_csv_association_data! association_data, siblings
         end
         siblings
       else

data/lib/ar-extensions/delete.rb

@@ -0,0 +1,143 @@
+module ActiveRecord::Extensions::Delete#:nodoc:
+  mattr_accessor :delete_batch_size
+  self.delete_batch_size = 15000
+
+  module DeleteSupport #:nodoc:
+    def supports_delete? #:nodoc:
+      true
+    end
+  end
+end
+
+class ActiveRecord::Base
+  supports_extension :delete
+  
+  class << self
+
+      # Delete all specified records with options
+      #
+      # == Parameters
+      # * +conditions+ - the conditions normally specified to +delete_all+
+      # * +options+ - hash map of additional parameters
+      #
+      # == Options
+      # * <tt>:limit</tt> - the maximum number of records to delete.
+      # * <tt>:batch</tt> - delete in batches specified to avoid database contention
+      # Multiple sql deletions are executed in order to avoid database contention
+      # This has no affect if used inside a transaction
+      #
+      # Delete up to 65 red tags
+      #  Tag.delete_all ['name like ?', '%red%'], :limit => 65
+      #
+      # Delete up to 65 red tags in batches of 20. This will execute up to
+      # 4 delete statements: 3 batches of 20 and the final batch of 5.
+      #  Tag.delete_all ['name like ?', '%red%'], :limit => 65, :batch => 20
+      def delete_all_with_extension(conditions = nil, options={})
+
+        #raise an error if delete is not supported and options are specified
+        supports_delete! if options.any?
+
+        #call the base method if no options specified
+        return delete_all_without_extension(conditions) unless options.any?
+
+        #batch delete
+        return delete_all_batch(conditions, options[:batch], options[:limit]) if options[:batch]
+
+        #regular delete with limit
+        connection.delete(delete_all_extension_sql(conditions, options), "#{name} Delete All")
+      end
+
+      alias_method_chain :delete_all, :extension
+
+
+      # Utility function to delete all but one of the duplicate records
+      # matching the fields specified. This method will make the records
+      # unique for the specified fields.
+      #
+      # == Options
+      # * <tt>:fields</tt> - the fields to match on
+      # * <tt>:conditions</tt> - additional conditions
+      # * <tt>:winner_clause</tt> - the part of the query specifying what wins. Default winner is that with the greatest id.
+      # * <tt>:query_field</tt> -> the field to use to determine the winner. Defaults to primary_key (id). The tables are aliased
+      #  to c1 and c2 respectively
+      # == Examples
+      # Make all the phone numbers of contacts unique by deleting the duplicates with the highest ids
+      #   Contacts.delete_duplicates(:fields=>['phone_number_id'])
+      #
+      # Delete all tags that are the same preserving the ones with the highest id
+      #   Tag.delete_duplicates :fields => [:name], :winner_clause => "c1.id < c2.id"
+      #
+      # Remove duplicate invitations (those that from the same person and to the same recipient)
+      # preseving the first ones inserted
+      #  Invitation.delete_duplicates :fields=>[:event_id, :from_id, :recipient_id]
+      def delete_duplicates(options={})
+        supports_delete!
+
+        options[:query_field]||= primary_key
+
+        query = "DELETE FROM"
+        query << " c1 USING #{quoted_table_name} c1, #{quoted_table_name} c2"
+        query << " WHERE ("
+        query << options[:fields].collect{|field| "c1.#{field} = c2.#{field}" }.join(" and ")
+        query << " and (#{sanitize_sql(options[:conditions])})" unless options[:conditions].blank?
+        query << " and "
+        query << (options[:winner_clause]||"c1.#{options[:query_field]} > c2.#{options[:query_field]}")
+        query << ")"
+
+        self.connection.execute(self.send(:sanitize_sql, query))
+      end
+
+      protected
+
+
+      # Delete all records specified in batches
+      #
+      # == Parameters
+      # * +conditions+ - the conditions normally specified to +delete_all+
+      # * +batch+ - the size of the batches to delete. defaults to 15000
+      # * +limit+ - the maximum number of records to delete
+      #
+      def delete_all_batch(conditions=nil, batch=nil, limit=nil)#:nodoc:
+
+        #update the batch size if batch is nil or true or 0
+        if batch.nil? || !batch.is_a?(Fixnum) || batch.to_i == 0
+          batch = ActiveRecord::Extensions::Delete.delete_batch_size
+        end
+
+
+        sql = delete_all_extension_sql(conditions, :limit => batch)
+        page_num = total = 0
+
+        loop {
+          page_num += 1
+
+          #if this is the last batch query and limit is set
+          #only delete the remainer
+          if limit && (total + batch > limit)
+             sql = delete_all_extension_sql(conditions, :limit => (limit - total))
+          end
+
+          count = connection.delete(sql, "#{name} Delete All Batch #{page_num}")
+          total += count
+
+          # Return if
+          #  * last query did not return the batch size (meaning nothing left to delete)
+          #  * we have reached our limit
+           if (count < batch) || (limit && (total >= limit))
+             return total
+           end
+        }
+      end
+
+      #generate the delete SQL with limit
+      def delete_all_extension_sql(conditions, options={})#:nodoc:
+        sql = "DELETE FROM #{quoted_table_name} "
+        add_conditions!(sql, conditions, scope(:find))
+        connection.add_limit_offset!(sql, options)
+        sql
+      end
+
+  end
+
+end
+

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

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

data/lib/ar-extensions/extensions.rb

@@ -315,7 +315,12 @@ module ActiveRecord::Extensions
         fieldname = caller.connection.quote_column_name( key )
         min = caller.connection.quote( val.first, caller.columns_hash[ key ] )
         max = caller.connection.quote( val.last, caller.columns_hash[ key ] )
-        str = "#{caller.quoted_table_name}.#{fieldname} #{match_data ? 'NOT ' : '' } BETWEEN #{min} AND #{max}"
+        str = if val.exclude_end?
+          "#{match_data ? 'NOT ' : '' }(#{caller.quoted_table_name}.#{fieldname} >= #{min} AND #{caller.quoted_table_name}.#{fieldname} < #{max})"
+        else 
+          "#{caller.quoted_table_name}.#{fieldname} #{match_data ? 'NOT ' : '' } BETWEEN #{min} AND #{max}"
+        end
+        
         return Result.new( str, nil )
       end
       nil      

data/lib/ar-extensions/finder_options.rb

@@ -0,0 +1,275 @@
+# ActiveRecord::Extensions::FinderOptions provides additional functionality to the ActiveRecord
+# ORM library created by DHH for Rails.
+#
+# == Using finder_sql_to_string
+# Expose the finder sql to a string. The options are identical to those accepted by <tt>find(:all, options)</tt>
+# the find method takes.
+# === Example:
+#   sql = Contact.finder_sql_to_string(:include => :primary_email_address)
+#   Contact.find_by_sql(sql + 'USE_INDEX(blah)')
+#
+# == Enhanced Finder Options
+# Add index hints, keywords, and pre and post SQL to the query without writing direct SQL
+# === Parameter options:
+# * <tt>:pre_sql</tt> appends SQL after the SELECT and before the selected columns
+#
+#  sql = Contact.find :first, :pre_sql => "HIGH_PRIORITY", :select => 'contacts.name', :conditions => 'id = 5'
+#  SQL> SELECT HIGH_PRIORITY contacts.name FROM `contacts` WHERE id = 5
+#
+# * <tt>:post_sql</tt> appends additional SQL to the end of the statement
+#  Contact.find :first, :post_sql => 'FOR UPDATE', :select => 'contacts.name', :conditions => 'id = 5'
+#  SQL> SELECT contacts.name FROM `contacts` where id == 5 FOR UPDATE
+#
+#  Book.find :all, :post_sql => 'USE_INDEX(blah)'
+#  SQL> SELECT books.* FROM `books` USE_INDEX(blah)
+#
+# * <tt>:override_select</tt> is used to override the <tt>SELECT</tt> clause of eager loaded associations
+# The <tt>:select</tt> option is ignored by the vanilla ActiveRecord when using eager loading with associations (when <tt>:include</tt> is used)
+# (refer to http://dev.rubyonrails.org/ticket/5371)
+# The <tt>:override_select</tt> options allows us to directly specify a <tt>SELECT</tt> clause without affecting the operations of legacy code  (ignore <tt>:select</tt>)
+# of the current code. Several plugins are available that enable select with eager loading
+# Several plugins exist to force <tt>:select</tt> to work with eager loading.
+# <tt>script/plugin install git://github.com/blythedunham/eload-select.git </tt>
+#
+# * <tt>:having</tt> only works when <tt>:group</tt> option is specified
+#  Book.find(:all, :select => 'count(*) as count_all, topic_id', :group => :topic_id, :having => 'count(*) > 1')
+#  SQL>SELECT count(*) as count_all, topic_id FROM `books`  GROUP BY topic_id HAVING count(*) > 1
+#
+# == 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
+#
+require 'active_record/version'
+module ActiveRecord::Extensions::FinderOptions
+  def self.included(base)
+
+    #alias and include only if not yet defined
+    unless base.respond_to?(:construct_finder_sql_ext)
+      base.extend ClassMethods
+      base.extend ActiveRecord::Extensions::SqlGeneration
+      base.extend HavingOptionBackCompatibility
+      base.extend ConstructSqlCompatibility
+
+      base.class_eval do
+        class << self
+          VALID_FIND_OPTIONS.concat([:pre_sql, :post_sql, :keywords, :ignore, :rollup, :override_select, :having, :index_hint])
+          alias_method              :construct_finder_sql, :construct_finder_sql_ext
+          alias_method_chain        :construct_finder_sql_with_included_associations, :ext
+        end
+      end
+    end
+  end
+
+  module ClassMethods
+    # Return a string containing the SQL used with the find(:all)
+    # The options are the same as those with find(:all)
+    #
+    # Additional parameter of
+    # <tt>:force_eager_load</tt> forces eager loading even if the
+    #  column is not referenced.
+    #
+    #   sql = Contact.finder_sql_to_string(:include => :primary_email_address)
+    #   Contact.find_by_sql(sql + 'USE_INDEX(blah)')
+    def finder_sql_to_string(options)
+      select_sql = self.send(
+        (use_eager_loading_sql?(options) ? :finder_sql_with_included_associations : :construct_finder_sql),
+        options.reject{|k,v| k == :force_eager_load}).strip
+    end
+
+    protected
+
+    # use eager loading sql (join associations) if inclu
+    def use_eager_loading_sql?(options)# :nodoc:
+      include_associations = merge_includes(scope(:find, :include), options[:include])
+      return ((include_associations.any?) &&
+          (options[:force_eager_load].is_a?(TrueClass) ||
+            references_eager_loaded_tables?(options)))
+    end
+
+    # construct_finder_sql is called when not using eager loading (:include option is NOT specified)
+    def construct_finder_sql_ext(options) # :nodoc:
+
+      #add piggy back option if plugin is installed
+      add_piggy_back!(options) if self.respond_to? :add_piggy_back!
+
+      scope = scope(:find)
+      sql = pre_sql_statements(options)
+      add_select_column_sql!(sql, options, scope)
+      add_from!(sql, options, scope)
+
+      sql << "#{options[:index_hint]} " if options[:index_hint]
+
+      add_joins!(sql, options[:joins], scope)
+      add_conditions!(sql, options[:conditions], scope)
+      add_group_with_having!(sql, options[:group], options[:having], scope)
+
+      add_order!(sql, options[:order], scope)
+      add_limit!(sql, options, scope)
+      add_lock!(sql, options, scope)
+
+      sql << post_sql_statements(options)
+      sql
+    end
+
+    #override the constructor for use with associations (:include option)
+    #directly use eager select if that plugin is loaded instead of this one
+    def construct_finder_sql_with_included_associations_with_ext(options, join_dependency)#:nodoc
+      scope = scope(:find)
+      sql = pre_sql_statements(options)
+
+      add_eager_selected_column_sql!(sql, options, scope, join_dependency)
+      add_from!(sql, options, scope)
+
+      sql << "#{options[:index_hint]} " if options[:index_hint]
+      sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+
+      add_joins!(sql, options[:joins], scope)
+      add_conditions!(sql, options[:conditions], scope)
+
+      add_limited_ids_condition!(sql, options_with_group(options), join_dependency) if !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
+
+      add_group_with_having!(sql, options[:group], options[:having], scope)
+      add_order!(sql, options[:order], scope)
+      add_limit!(sql, options, scope) if using_limitable_reflections?(join_dependency.reflections)
+      add_lock!(sql, options, scope)
+
+      sql << post_sql_statements(options)
+
+      return sanitize_sql(sql)
+    end
+
+    #generate the finder sql for use with associations (:include => :something)
+    def finder_sql_with_included_associations(options = {})#:nodoc
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
+      sql = construct_finder_sql_with_included_associations_with_ext(options, join_dependency)
+    end
+
+    #first use :override_select
+    #next use :construct_eload_select_sql if eload-select is loaded
+    #finally use normal column aliases
+    def add_eager_selected_column_sql!(sql, options, scope, join_dependency)#:nodoc:
+      if options[:override_select]
+        sql << options[:override_select]
+      elsif respond_to? :construct_eload_select_sql
+        sql << construct_eload_select_sql((scope && scope[:select]) || options[:select], join_dependency)
+      else
+        sql << column_aliases(join_dependency)
+      end
+    end
+
+    #simple select sql
+    def add_select_column_sql!(sql, options, scope = :auto)#:nodoc:
+      sql << "#{options[:select] || options[:override_select] || (scope && scope[:select]) || default_select(options[:joins] || (scope && scope[:joins]))}"
+    end
+
+    #from sql
+    def add_from!(sql, options, scope = :auto)#:nodoc:
+      sql << " FROM #{options[:from]  || (scope && scope[:from]) || quoted_table_name} "
+    end
+    
+    def options_with_group(options)#:nodoc:
+      options
+    end
+  end
+
+  #In Rails 2.0.0 add_joins! signature changed
+  #  Pre Rails 2.0.0: add_joins!(sql, options, scope)
+  #  After 2.0.0:     add_joins!(sql, options[:joins], scope)
+  module ConstructSqlCompatibility
+    def self.extended(base)
+      if ActiveRecord::VERSION::STRING < '2.0.0'
+        base.extend ClassMethods
+        base.class_eval do
+          class << self
+            alias_method_chain :add_joins!, :compatibility
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def add_joins_with_compatibility!(sql, options, scope = :auto)#:nodoc:
+        join_param = options.is_a?(Hash) ? options : { :joins => options }
+        add_joins_without_compatibility!(sql, join_param, scope)
+      end
+
+      #aliasing threw errors
+      def quoted_table_name#:nodoc:
+        self.table_name
+      end
+
+      #pre Rails 2.0.0 the order of the scope and options was different
+      def add_from!(sql, options, scope = :auto)#:nodoc:
+        sql << " FROM #{(scope && scope[:from]) || options[:from] || table_name} "
+      end
+
+      def add_select_column_sql!(sql, options, scope = :auto)#:nodoc:
+        sql << "#{options[:override_select] || (scope && scope[:select]) || options[:select] || '*'}"
+      end
+
+    end
+  end
+
+  # Before Version 2.3.0 there was no :having option
+  # Add this option to previous versions by overriding add_group!
+  # to accept a hash with keys :group and :having instead of just group
+  # this avoids having to completely rewrite dependent functions like
+  # construct_finder_sql_for_association_limiting
+
+  module HavingOptionBackCompatibility#:nodoc:
+    def self.extended(base)
+
+      #for previous versions define having
+      if ActiveRecord::VERSION::STRING < '2.3.0'
+        base.extend ClassMethods
+
+      #for 2.3.0+ alias our method to :add_group!
+      else
+        base.class_eval do
+          class << self
+            alias_method            :add_group_with_having!, :add_group!
+          end
+        end
+      end
+    end
+    
+    module ClassMethods#:nodoc:
+      #add_group! in version 2.3 adds having already
+      #copy that implementation
+      def add_group_with_having!(sql, group, having, scope =:auto)#:nodoc:
+        if group
+          sql << " GROUP BY #{group}"
+          sql << " HAVING #{sanitize_sql(having)}" if having
+        else
+          scope = scope(:find) if :auto == scope
+          if scope && (scoped_group = scope[:group])
+            sql << " GROUP BY #{scoped_group}"
+            sql << " HAVING #{sanitize_sql(scope[:having])}" if scope[:having]
+          end
+        end
+      end
+
+      def add_group!(sql, group_options, scope = :auto)#:nodoc:
+        group, having = if group_options.is_a?(Hash) && group_options.has_key?(:group)
+          [group_options[:group] , group_options[:having]]
+        else
+          [group_options, nil]
+        end
+        add_group_with_having!(sql, group, having, scope)
+      end
+
+      def options_with_group(options)#:nodoc:
+        if options[:group]
+          options.merge(:group => {:group => options[:group], :having => options[:having]})
+        else
+          options
+        end
+      end
+    end
+
+  end
+end