arperftoolkit_base 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Dr.-Ing. Stefan Kaes
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,109 @@
+AR Perf Toolkit Base
+ActiveRecord enhancements to optimize queries and insertion functionality. 
+Includes support for finder index hints, ignore and duplicate update, 
+insert select, record duplicate deletion, bulk insert, and eager loading of 
+selected columns.
+
+This has only been tested with MySQL.
+
+
+#########################################################################################
+Single Active Record Operations
+#########################################################################################
+The following methods are overwritten to accept a hash map parameter of options
+
+    * save
+    * create
+    * create!
+    * save!
+    * create_or_update
+
+Options:
+
+    * duplicate - On duplicate key update  update old rows on duplicate
+         Example: updates fields birthdate and email_address_id if a duplicate exists when the contact is created or updated
+         
+         contact.save :duplicate => [:birthdate, :email_address_id ]
+     Set the existing duplicate email address id to 5
+
+
+         contact.save :duplicate => 'email_address_id = 5'
+
+    * keyword(ignore) adds a keyword after mysql command (example INSERT IGNORE)
+          Example. Ignore a duplicate record.
+      contact.save :keywords => :ignore
+
+      command. The sql command to use. Example:  uses replace insead of insert
+      contact.save :command => :replace
+
+
+
+#########################################################################################
+Bulk Insert Operations
+#########################################################################################
+  * insert_all
+  * insert_select
+  
+insert_all(objs, options={})
+*Note* use instead of former upsert.
+
+Insert a group of records in one transaction.
+
+objs can be:
+
+    * Array of hash maps {:column_name => :value} where column_names are specified in the options[:select]
+
+EmailAddress.insert_all(
+[{:text => 'blythe@spongecell.com', :name =>'Blythe Dunham'},
+{:text => 'blythedunham@gmail.com', :name =>'Blythe Dunham'}], 
+{:select => [:text, :name] })
+
+    * Array of active records (slower)
+
+upsert_taggings << Tagging.new(:tag_id=>tag_id, :taggable_type=>child.to_s, :taggable_id=>record.id)
+
+Tagging.insert_all(upsert_taggings, :keywords => :ignore)
+
+Options
+
+    * skip_validation does not run valid? on each object
+    * duplicate
+    * keywords
+    * post_sql - sql appended to the end (indexes, rollup, etc)
+    * pre_sql - sql appended to the beginning (ex, priorities)
+    * command - choose the columns you wish to insert
+
+insert_select(select_obj, select_options, insert_options={})
+Insert records with a select statement
+   add all the books written by the author into the cart
+      Cart.insert_select Book, {:select => ['books.id, ?', Time.now], :conditions => ['books.author_id = ?', 1 }, {:select => [:book_id, :added-on]}
+        generated sql
+      INSERT INTO carts (`book_id`, `added_on`) SELECT books.id,  '2007-05-01 01:24:28' FROM books where books.author_id = 1
+     
+
+select_options
+
+    * select => select porition of query. like conditions (santizes sql)
+
+insert_options - See options of insert_all
+
+#########################################################################################
+Finder Operations
+#########################################################################################
+  * finder_sql_to_string - prints out the query to string
+  * find - enhanced to accept additional params for sql customization
+
+finder_sql_to_string
+Print out the sql that would be executed. Same signature as ActiveRecord::Base.find
+
+>> Contact.finder_sql_to_string :piggy =>  :primary_email_address
+
+=> "SELECT contacts.*, email_addresses.crypted_text AS primary_email_address_crypted_text FROM contacts   LEFT JOIN email_addresses ON email_addresses.id=contacts.email_address_id  "
+
+find
+
+Adds these options:
+
+    * post_sql - sql appended to the end (indexes, rollup, etc)
+    * pre_sql - sql appended to the beginning (ex, priorities)
+    * keywords

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+PKG_NAME           = "arperftoolkit_base"
+PKG_VERSION        = "0.0.1"
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = "eload_select"
+
+spec = Gem::Specification.new do |s|
+  s.name            = PKG_NAME
+  s.version         = PKG_VERSION
+  s.platform        = Gem::Platform::RUBY
+  s.summary         = "ActiveRecord enhancements to optimize queries and insertion functionality. Includes support for finder index hints, ignore and duplicate update, insert select, record duplicate deletion, bulk insert, and eager loading of selected columns."
+  s.files           = FileList["{lib,tasks}/**/*"].to_a + %w(init.rb LICENSE Rakefile README)
+  s.require_path    = "lib"
+  s.autorequire     = PKG_NAME
+  s.has_rdoc        = true
+  s.test_files      = nil
+  s.add_dependency    "rails", ">= 1.2.0"
+ 
+  s.author          = "Blythe Dunham"
+  s.email           = "blythe@spongecell.com"
+  s.homepage        = "http://spongetech.wordpress.com/"
+end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the ar_test plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << '.\lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the ar_test plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ArP'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+ 
+desc "Publish the API docs and gem"
+task :publish => [:pdoc, :release]
+
+desc "Publish the release files to RubyForge."
+task :release => [:gem, :package] do
+  require 'rubyforge'
+ 
+  options = {"cookie_jar" => RubyForge::COOKIE_F}
+  options["password"] = ENV["RUBY_FORGE_PASSWORD"] if ENV["RUBY_FORGE_PASSWORD"]
+  ruby_forge = RubyForge.new
+  ruby_forge.login
+ 
+  %w( gem tgz zip ).each do |ext|
+    file = "pkg/#{PKG_FILE_NAME}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+ 
+    ruby_forge.add_release(RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, file)
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'ar_perf_toolkit'

data/lib/ar_perf_toolkit.rb

@@ -0,0 +1,8 @@
+
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/insert'
+require File.dirname(__FILE__) + '/insert_bulk'
+
+ActiveRecord::Base.send(:include, ArPerfToolkit::Base)
+ActiveRecord::Base.send(:include, ArPerfToolkit::Insert)
+ActiveRecord::Base.send(:include, ArPerfToolkit::InsertBulk)

data/lib/base.rb

@@ -0,0 +1,138 @@
+
+# MONKEY MONKEY!!!! Move me to a better place and make me an optional param
+# 
+
+module ArPerfToolkit
+  module Base
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+      base.class_eval do
+        class << self
+          VALID_FIND_OPTIONS.concat([:pre_sql, :post_sql, :keywords])
+          alias_method :construct_finder_sql, :construct_finder_sql_x
+          alias_method_chain :construct_finder_sql_with_included_associations, :perf_options unless method_defined?(:construct_finder_sql_with_included_associations_with_options)
+        end
+      end
+    end
+    
+    module ClassMethods
+
+      # expose the finder sql to a string with the same options that 
+      # the find method takes. 
+      # 
+      #   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(((scoped?(:find, :include) || options[:include]) ?
+          :finder_sql_with_included_associations :
+          :construct_finder_sql), options)
+      end
+      
+      
+      #Construct keywords around sql
+      def construct_sql(options={}, valid_options = [], &block)
+        options.assert_valid_keys(:keywords, :command, :duplicate, :post_sql, :pre_sql, :select, *valid_options)
+        sql = ''
+        sql << (options[:pre_sql] + ' ') if options[:pre_sql]
+        sql << "#{options[:command]} "
+        add_keywords!(sql, options[:keywords]) if options[:keywords]
+        yield sql, options
+        add_duplicate!(sql, options[:duplicate]) if options[:duplicate]
+        sql << options[:post_sql] if options[:post_sql]
+        sql
+      end
+
+      def construct_finder_sql_x(options)
+        #add piggy back option if plugin is installed
+        add_piggy_back!(options) if self.respond_to? :add_piggy_back!
+        scope = scope(:find)
+        sql = "#{options[:pre_sql]} SELECT".strip
+        sql << " #{options[:keywords]}" if options[:keywords]
+        sql << " #{(scope && scope[:select]) || options[:select] || '*'} "
+        sql << "FROM #{(scope && scope[:from]) || options[:from] || table_name} "
+        
+        add_joins!(sql, options, scope)
+        add_conditions!(sql, options[:conditions], scope)
+      
+        sql << " GROUP BY #{options[:group]} " if options[:group]
+        sql << " ORDER BY #{options[:order]} " if options[:order]
+        
+        add_limit!(sql, options, scope)
+        sql << "#{options[:post_sql]}" if options[:post_sql]
+        sql
+      end
+  
+ 
+      
+      
+      #add a util method here until I find a better home for it.
+      #delete all the dups
+      #
+      #ex. 
+      #  Make all the phone numbers of contacts unique by deleting the 
+      # >>Contacts.delete_duplicates(:fields=>['phone_number_id'])
+      #
+      # :fields -> the fields to match on
+      # :conditions-> specify this to do it yourself.
+      # :additional_clause -> append something to the query, tho you could just use scope 
+      # :winner_clause-> the part of the query specifying what wins. Default is that with the greatest id.
+      # :query_field -> if you dont like id as the winner, specify another field
+      def delete_duplicates options={}
+    
+        query = options[:conditions] || "delete from " + table_name+" c1 using "+table_name+" c1, " +table_name+" c2 where (" +
+                options[:fields].collect{|field| ('c1.'+field.to_s+'=c2.'+field.to_s) }.join(" and ") +
+                (options[:additional_clause] ? 'and ('+options[:additional_clause]+') ' : '')+') and '+
+                (options[:winner_clause] || ('c1.'+(qf=(options[:query_field] || 'id').to_s) + '> c2.'+qf))
+        
+        self.connection.execute(self.sanitize_sql(query))
+      end
+      
+    protected
+      #add keywords like IGNORE or DELAYED
+      def add_keywords!(sql, keywords)
+        sql << (keywords.kind_of?(Array) ? keywords.collect{|kw| " #{kw} "}.join('') : " #{keywords} ")
+      end
+      
+      #duplicate can be expressed as a string: "field_name = 5"
+      #or an array of field names to update with new value
+      #[last_name, first_name] would update the dupe with the new last and first name
+      def add_duplicate!(sql, duplicate)
+        if duplicate
+          duplicate = [duplicate] if (duplicate.kind_of?(String) || duplicate.kind_of?(Symbol)) && !duplicate.to_s.include?('=')
+          sql << " ON DUPLICATE KEY UPDATE "
+          sql << (duplicate.kind_of?(Array) ? duplicate.collect{|val| 
+            val = self.connection.quote_column_name val.to_s
+            "#{val}=VALUES(#{val})" 
+          }.join(', ') : duplicate.to_s)
+        end
+        sql
+      end
+      
+      #generate the finder sql for use with associations (:include => :something)
+      def finder_sql_with_included_associations(options = {})
+        join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
+        sql = construct_finder_sql_with_included_associations(options, join_dependency)
+      end
+      
+      def construct_finder_sql_with_included_associations_x options, join_dependency
+        construct_finder_sql_block(options) do
+          construct_finder_sql_with_included_associations(options, join_dependency)
+        end
+      end
+      
+      def construct_finder_sql_with_included_associations_with_perf_options(options, join_dependency)
+        #use eager loading select if available
+        method = respond_to?(:construct_finder_sql_with_included_associations_with_eager_select) ? :construct_finder_sql_with_included_associations_with_eager_select : :construct_finder_sql_with_included_associations_without_perf_options
+        sql = send(method, options, join_dependency)
+        
+        #substitute pre_sql and keywords
+        sql.gsub!(/^\s*SELECT/, "#{options[:pre_sql]} SELECT #{options[:keywords]}" ) if options[:pre_sql] || options[:keywords]
+        
+        #substitue post sql
+        sql << " #{options[:post_sql]}" if options[:post_sql]
+        sql
+      end
+      
+    end#ClassMethods
+  end
+end

data/lib/insert.rb

@@ -0,0 +1,170 @@
+
+class Module
+  #support deprecated method_x commands
+  #alias method to method_without_arperf_options
+  #alias method_x to method
+  def alias_method_chain_arperf(methods)
+    methods = Array.new(methods)
+    methods.each do |target|
+      unless method_defined?("#{target}_without_arperf_options")
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        alias_method "#{aliased_target}_without_arperf_options#{punctuation}", target
+        alias_method target, "#{aliased_target}_x#{punctuation}"
+      end
+    end
+  end
+end
+
+module ArPerfToolkit
+  module Insert
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+      
+      #alias methods
+      base.class_eval do
+        alias_method_chain_arperf(%w(save update save! create_or_update))
+        class << self
+           alias_method_chain_arperf(%w(create create!))
+        end
+      end
+    end
+
+    module ClassMethods 
+      def create_ignore attributes = nil
+        create_x!(attributes, :keywords => 'IGNORE')
+      end
+      
+      # Creates an object, instantly saves it as a record (if the validation permits it), and returns it. If the save
+      # fails under validations, the unsaved object is still returned.
+      def create_x(attributes = nil, options={})
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr) }
+        else
+          object = new(attributes)
+          scope(:create).each { |att,value| object.send("#{att}=", value) } if scoped?(:create)
+          object.save_x options
+          object
+        end
+      end
+      
+      # Creates an object just like Base.create but calls save! instead of save
+      # so an exception is raised if the record is invalid.
+      def create_x!(attributes = nil,options={})
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr) }
+        else
+          attributes.reverse_merge!(scope(:create)) if scoped?(:create)
+
+          object = new(attributes)
+          object.save_x!(options)
+          object
+        end
+      end
+      
+    end#ClassMethods
+  
+    def save_ignore
+      save_x :keywords => 'IGNORE'
+    end
+        
+    def save_ignore!
+      save_ignore || raise(ActiveRecord::RecordNotSaved)
+    end
+    
+    def save_x(options={})
+      #invoke save_with_validation if the argument is not a hash
+      return save_without_arperf_options(options) unless options.is_a?(Hash)
+      
+      perform_validation = options.delete(:perform_validation)
+      if (perform_validation.is_a?(FalseClass)) || valid? 
+        raise ActiveRecord::ReadOnlyRecord if readonly?
+        create_or_update_x options
+      else
+        raise ActiveRecord::RecordInvalid.new(self) if perform_validation == :exception
+        false
+      end
+    end
+    
+    def save_x!(options={})
+      options[:perform_validation] = :exception
+      save_x(options) || raise(ActiveRecord::RecordNotSaved)
+    end
+    
+    def create_or_update_x options={}
+      return false if callback(:before_save) == false
+      options[:keywords] = 'IGNORE' if options.delete(:ignore).kind_of?(TrueClass)
+      result = 
+        if new_record? then 
+          create_x(options) 
+        else 
+          options.delete(:duplicate) 
+          update_x(options) 
+        end
+      callback(:after_save)
+      result
+    end
+    
+    #END _X STUFF. Remove this if we end up overwriting update and create directly
+    
+    # Updates the associated record with values matching those of the instance attributes.
+    def update_x options={}
+      return false if callback(:before_update) == false
+      insert_with_timestamps(false)
+      options[:command]||='UPDATE'
+      raise(ArgumentError, "Unknown key: duplicate") if options[:duplicate]
+      sql = self.class.construct_sql(options) do |sql, options|  
+        sql << "#{self.class.table_name} "
+        sql << "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
+               "WHERE (#{self.class.primary_key} = #{quote_value(id)}) "      
+      end
+      connection.update(sql, "#{self.class.name} UpdateX")
+      callback(:after_update)
+      return true
+    end
+    
+    # Creates a new record with values matching those of the instance attributes.
+    def create_x options={}
+      return false if callback(:before_create) == false
+      insert_with_timestamps(true)
+    
+      if self.id.nil? && connection.prefetch_primary_key?(self.class.table_name)
+        self.id = connection.next_sequence_value(self.class.sequence_name)
+      end
+      
+      options[:command]||='INSERT'
+      sql = self.class.construct_sql(options) do |sql, options| 
+        sql << "INTO #{self.class.table_name} (#{quoted_column_names.join(', ')}) "
+        sql << "VALUES(#{attributes_with_quotes.values.join(', ')})"
+      end
+      
+      self.id = connection.insert(sql, "#{self.class.name} CreateX ", 
+                      self.class.primary_key, self.id, self.class.sequence_name)
+    
+      @new_record = false
+      
+      callback(:after_create)   
+      return self.id != 0
+    end
+     
+    #Replace deletes the existing duplicate if it exists then adds
+    #this
+    def replace_x options={}
+      create_x(options.merge(:command => 'REPLACE'))
+    end
+      
+  protected
+    
+    #update timestamps
+    def insert_with_timestamps(bCreate=true)
+      if record_timestamps
+        t = ( self.class.default_timezone == :utc ? Time.now.utc : Time.now )
+        write_attribute('created_at', t) if bCreate && respond_to?(:created_at) && created_at.nil?
+        write_attribute('created_on', t) if bCreate && respond_to?(:created_on) && created_on.nil?
+      
+        write_attribute('updated_at', t) if respond_to?(:updated_at)
+        write_attribute('updated_on', t) if respond_to?(:updated_on)
+      end
+    end
+  
+  end
+end

data/lib/insert_bulk.rb

@@ -0,0 +1,131 @@
+
+module ArPerfToolkit
+  module InsertBulk
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+
+      
+      #Insert records with a select statement
+      #  add all the books written by the author into the cart
+      #Cart.insert_select Book, {:select => ['books.id, ?', Time.now], :conditions => ['books.author_id = ?', 1 }, {:select => [:book_id, :added-on]}
+      #  generated sql
+      #INSERT INTO carts (`book_id`, `added_on`) SELECT books.id,  '2007-05-01 01:24:28' FROM books where books.author_id = 1
+      def insert_select(select_obj, select_options, insert_options={})
+      
+        #santize and clean up the select columns. Cannot do * here because we need the columns in 
+        #a particular order
+        select_options[:select] = select_obj.send :select_columns, select_options[:select]
+        
+        #build the sql
+        sql = construct_sql({:command => 'INSERT'}.merge(insert_options)) do |sql, options|
+          sql << " INTO #{table_name} "
+          sql << "(%s) " % select_columns(insert_options[:select])
+          
+          sql << select_obj.send(:finder_sql_to_string, select_options)
+          
+        end
+        connection.insert(sql, "#{name} Insert Select #{select_obj}")
+      end
+      
+      #the raw sql for bulk insert sql
+      def insert_all_sql(objs, options={})
+        value_sql = options.delete(:value_sql)
+        sql = construct_sql({:command => 'INSERT'}.merge(options), [:skip_validation]) do |sql, options|
+          sql << " INTO #{table_name} "
+          sql << "(%s) " % select_columns(options[:select])
+          sql << "VALUES "
+          sql << (value_sql || insert_value_pairs(objs, options[:select], options[:skip_validation].kind_of?(TrueClass)))
+        end
+      end
+      
+      #Insert a group of records
+      #insert_all, Insert a whole bunch of records in one transaction 
+      # EmailAddress.insert_all([{:text => 'blythe@spongecell.com', :name =>'Blythe Dunham'},{:text => 'blythedunham@gmail.com', :name =>'Blythe Dunham'}], {:select => [:text, :name] })
+      # options
+      #  <tt>:skip_validation</tt> => does not run valid? on each object
+      #  <tt>:duplicate</tt> 
+      #  <tt>:keywords</tt>
+      #  <tt>:post_sql</tt>
+      #  <tt>:pre_sql</tt>
+      #  <tt>:command</tt>
+      #  <tt>:select => </tt>choose the columns you wish to insert
+      
+      def insert_all(objs, options={})
+        connection.insert(insert_all_sql(objs, options), "#{name} Insert All")
+      end
+
+      def update_all_x(updates, conditions = nil, options={})
+        raise(ArgumentError, "Unknown key: duplicate") if options[:duplicate]
+        
+        sql = construct_sql({:command => 'UPDATE'}.merge(options)) do |sql, options|
+          sql << "#{table_name} SET #{sanitize_sql(updates)} "
+          add_conditions!(sql, conditions, scope(:find))
+        end
+        
+        connection.update(sql, "#{name} Update #{options.inspect}")
+      end  
+      
+      def update_all_ignore updates, conditions = nil, options={}
+        update_all_x updates, conditions, options.update(:keywords => 'IGNORE')
+      end
+      
+    protected
+      #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_columns(field_list=nil)
+       if field_list.kind_of?(String)
+         field_list
+       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
+       
+      def quoted_list(list)
+        list.collect{|item| connection.quote(item)}.join(', ')
+      end
+       
+      #return a comma delimited list of value pairs
+      # ex. (`p1_val_attrib_1`, `p1_val_attrib_2 ...),  (`p2_val_attrib_1`, `p2_val_attrib_2 ...),
+      #objs can be either a hash map or an ActiveRecord derived object o442r an array of a hash map or ActiveRecord
+      def insert_value_pairs(objs, field_list, skip_validation=false)
+        raise Exception.new("No values to insert") if objs.blank?
+      
+        if objs.is_a?(Array) && objs.first.is_a?(Array) && !field_list.blank?
+          objs.collect{|obj| "(#{quoted_list(obj)})" }
+        else
+          [objs].flatten.inject([]){|list, obj|
+            obj= self.new(obj) if (obj.kind_of?(Hash))
+            raise ActiveRecord::RecordInvalid.new(obj) if !skip_validation && !obj.valid? 
+            list << "(%s)" % obj.send(:attributes_with_quotes_x, field_list)
+          }
+        end.join(", ")
+      end
+      
+    end#ClassMethods
+  protected
+    
+    #get all the attributes with quotes delimited by commas minus the ones in the included_attributes list
+    def attributes_with_quotes_x(included_attributes = nil)
+      insert_with_timestamps
+      
+      included_attributes = self.class.column_names - [self.class.primary_key] if included_attributes.blank?
+      
+      included_attributes.collect{ |column_name|            
+        #don't call attributes() here, it is slow and this method gets called a lot
+        quote_value(self.send(:read_attribute,column_name), column_for_attribute(column_name))
+      }.join(", ")  
+
+    end
+  
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: arperftoolkit_base
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-08-15 00:00:00 -03:00
+summary: ActiveRecord enhancements to optimize queries and insertion functionality. Includes support for finder index hints, ignore and duplicate update, insert select, record duplicate deletion, bulk insert, and eager loading of selected columns.
+require_paths: 
+- lib
+email: blythe@spongecell.com
+homepage: http://spongetech.wordpress.com/
+rubyforge_project: 
+description: 
+autorequire: arperftoolkit_base
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Blythe Dunham
+files: 
+- lib/ar_perf_toolkit.rb
+- lib/base.rb
+- lib/insert.rb
+- lib/insert_bulk.rb
+- init.rb
+- LICENSE
+- Rakefile
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: