ar-extensions 0.7.0 → 0.8.0

data/Rakefile

@@ -14,8 +14,12 @@ end
 
 ADAPTERS = %w( mysql postgresql sqlite sqlite3 oracle )
 
-namespace :db do
+desc "Packages a rubygem"
+task "pkg" do
+  
+end
 
+namespace :db do
   namespace :test do
     ADAPTERS.each do |adapter|
       desc "builds test database for #{adapter}"
@@ -25,21 +29,17 @@ namespace :db do
       end
     end
   end
-
 end
 
 namespace :test do
-  
   ADAPTERS.each do |adapter|
     desc "test base extensions for #{adapter}"
     task adapter do |t|
       ENV['ARE_DB'] = adapter
-      Rake::Task[ 'boot' ].invoke
-      
       task = Rake::Task[ "db:test:prepare_#{adapter}" ]
-			begin
+      begin
         task = false  if SchemaInfo::VERSION == SchemaInfo.find( :first ).version
-		  rescue Exception => ex        
+      rescue Exception => ex        
       end
       task.invoke if task
         
@@ -48,7 +48,6 @@ namespace :test do
   end
   
   namespace :activerecord do
-
     ADAPTERS.each do |adapter|
       desc "runs ActiveRecord unit tests for #{adapter} with ActiveRecord::Extensions"
       task adapter.to_sym do |t|
@@ -67,9 +66,6 @@ namespace :test do
         Dir.chdir( old_dir )
         ENV['RUBYOPT'] = old_env
       end      
-  
     end  
-          
   end    
-
- end
+end

data/db/migrate/generic_schema.rb

@@ -5,6 +5,11 @@ ActiveRecord::Schema.define do
   end
   SchemaInfo.create :version=>SchemaInfo::VERSION
 
+  create_table :group, :force => true do |t|
+    t.column :order, :string
+    t.timestamps
+  end
+
   create_table :topics, :force=>true do |t|
     t.column :title, :string, :null=>false
     t.column :author_name, :string
@@ -48,11 +53,12 @@ ActiveRecord::Schema.define do
     t.column :title, :string, :null=>false
     t.column :publisher, :string, :null=>false
     t.column :author_name, :string, :null=>false
-    t.column :created_at, :time
+    t.column :created_at, :datetime
     t.column :created_on, :datetime
-    t.column :updated_at, :time
+    t.column :updated_at, :datetime
     t.column :updated_on, :datetime
     t.column :topic_id, :integer
+    t.column :for_sale, :boolean, :default => true
   end  
 
   create_table :languages, :force=>true do |t|

data/db/migrate/mysql_schema.rb

@@ -24,6 +24,7 @@ ActiveRecord::Schema.define do
     t.column :updated_at, :datetime
     t.column :updated_on, :datetime
     t.column :topic_id, :integer
+    t.column :for_sale, :boolean, :default => true
   end
   execute "ALTER TABLE books ADD FULLTEXT( `title`, `publisher`, `author_name` )"
 

data/db/migrate/oracle_schema.rb

@@ -0,0 +1,5 @@
+ActiveRecord::Schema.define do
+ 
+  execute "CREATE SEQUENCE books_seq START_WITH 1"
+
+end

data/db/migrate/version.rb

@@ -1,4 +1,4 @@
 class SchemaInfo < ActiveRecord::Base
   set_table_name 'schema_info'
-  VERSION = 8
+  VERSION = 10
 end

data/init.rb

@@ -1,34 +1,13 @@
 require 'ostruct'
 begin ; require 'active_record' ; rescue LoadError; require 'rubygems'; require 'active_record'; end
 
-dir = File.dirname( __FILE__ )
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'version' ) )
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'extensions' ) )
-
-begin 
-  require 'faster_csv' 
-  require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'csv' ) )
-rescue LoadError
-  STDERR.puts "FasterCSV is not installed. CSV functionality will not be included."
-end
-
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'foreign_keys' ) )
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'fulltext' ) )
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'fulltext', 'mysql' ) )
-
-db_adapters_path = File.expand_path( File.join(  dir, 'lib/ar-extensions', 'adapters' ) )
-
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'import' ) )
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'import', 'mysql' ) )
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'import', 'postgresql' ) )
-
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'finders' ) )
-
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'synchronize' ) )
-
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'temporary_table' ) )
-require File.expand_path( File.join(  dir, 'lib/ar-extensions', 'temporary_table', 'mysql' ) )
-
-require File.expand_path( File.join(  db_adapters_path, 'abstract_adapter' ) )
-require File.expand_path( File.join(  db_adapters_path,'mysql_adapter' ) )
-
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
+require 'ar-extensions/version'
+require 'ar-extensions/extensions'
+require 'ar-extensions/foreign_keys'
+require 'ar-extensions/fulltext'
+require 'ar-extensions/import'
+require 'ar-extensions/finders'
+require 'ar-extensions/synchronize'
+require 'ar-extensions/temporary_table'
+require 'ar-extensions/adapters/abstract_adapter'

data/lib/ar-extensions/adapters/abstract_adapter.rb

@@ -4,6 +4,10 @@ module ActiveRecord # :nodoc:
       NO_MAX_PACKET = 0
       QUERY_OVERHEAD = 8 #This was shown to be true for MySQL, but it's not clear where the overhead is from.
       
+      def next_value_for_sequence(sequence_name)
+        %{#{sequence_name}.nextval}
+      end
+      
       # +sql+ can be a single string or an array. If it is an array all 
       # elements that are in position >= 1 will be appended to the final SQL.
       def insert_many( sql, values, *args ) # :nodoc:
@@ -52,6 +56,35 @@ module ActiveRecord # :nodoc:
         instances.each { |e| e.reload }
       end
 
+      # Returns an array of post SQL statements given the passed in options.
+      def post_sql_statements( table_name, options ) # :nodoc:
+        post_sql_statements = []
+        if options[:on_duplicate_key_update]
+          post_sql_statements << sql_for_on_duplicate_key_update( table_name, options[:on_duplicate_key_update] )
+        end
+        post_sql_statements
+      end
+
+
+      # Generates the INSERT statement used in insert multiple value sets.
+      def multiple_value_sets_insert_sql(table_name, column_names, options) # :nodoc:
+        "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{table_name} (#{column_names.join(',')}) VALUES "
+      end  
+  
+      # Returns SQL the VALUES for an INSERT statement given the passed in +columns+ 
+      # and +array_of_attributes+.
+      def values_sql_for_column_names_and_attributes( columns, array_of_attributes )   # :nodoc:
+        values = []
+        array_of_attributes.each do |arr|
+          my_values = []
+          arr.each_with_index do |val,j|
+            my_values << quote( val, columns[j] )
+          end
+          values << my_values
+        end   
+        values_arr = values.map{ |arr| '(' + arr.join( ',' ) + ')' }
+      end
+
       # Returns the sum of the sizes of the passed in objects. This should
       # probably be moved outside this class, but to where?
       def self.sum_sizes( *objects ) # :nodoc:

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

@@ -0,0 +1,8 @@
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+  # Returns the maximum number of bytes that the server will allow
+  # in a single packet
+  def max_allowed_packet # :nodoc:
+    result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
+    result.fetch_row[1].to_i
+  end
+end

data/lib/ar-extensions/adapters/oracle.rb

@@ -1,9 +1,14 @@
 module ActiveRecord # :nodoc:
   module ConnectionAdapters # :nodoc:
     class OracleAdapter # :nodoc:
-       def supports_import?
-         true
-       end
+      
+      def next_value_for_sequence(sequence_name)
+        %{#{sequence_name}.nextval}
+      end
+      
+      def supports_import?
+        true
+      end
     end
   end
 end

data/lib/ar-extensions/adapters/postgresql.rb

@@ -1,7 +1,9 @@
 module ActiveRecord # :nodoc:
   module ConnectionAdapters # :nodoc:
     class PostgreSQLAdapter # :nodoc:
-    
+      def next_value_for_sequence(sequence_name)
+        %{nextval('#{sequence_name}')}
+      end
     end
   end
 end

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

@@ -0,0 +1,7 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class SqliteAdapter # :nodoc:
+
+    end
+  end
+end

data/lib/ar-extensions/csv.rb

@@ -1,6 +1,11 @@
+begin 
+  require 'faster_csv'
+  require 'ar-extensions/csv'
+rescue LoadError => ex
+  STDERR.puts "FasterCSV is not installed. CSV functionality will not be included."
+  raise ex
+end
 
-require 'faster_csv'
-require 'ostruct'
 
 # Adds CSV export options to ActiveRecord::Base models. 
 #

data/lib/ar-extensions/extensions.rb

@@ -46,7 +46,7 @@ require 'forwardable'
 #      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.table_name}.#{fieldname} #{match_data ? 'NOT ' : '' } BETWEEN #{min} AND #{max}"
+#      str = "#{caller.quoted_table_name}.#{fieldname} #{match_data ? 'NOT ' : '' } BETWEEN #{min} AND #{max}"
 #      Result.new( str, nil )
 #   end
 #
@@ -180,7 +180,7 @@ module ActiveRecord::Extensions
       if val.is_a?( Array )
         match_data = key.to_s.match( NOT_EQUAL_RGX )
         key = match_data.captures[0] if match_data
-        str = "#{caller.table_name}.#{caller.connection.quote_column_name( key )} " +
+        str = "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( key )} " +
           (match_data ? 'NOT ' : '') + "IN( ? )"
         return Result.new( str, val )
       end
@@ -206,6 +206,7 @@ module ActiveRecord::Extensions
   class Comparison
 
     SUFFIX_MAP = { 'eq'=>'=', 'lt'=>'<', 'lte'=>'<=', 'gt'=>'>', 'gte'=>'>=', 'ne'=>'!=', 'not'=>'!=' }
+    ACCEPTABLE_COMPARISONS = [ String, Numeric, Time, DateTime ]
     
     def self.process( key, val, caller )
       process_without_suffix( key, val, caller ) || process_with_suffix( key, val, caller )
@@ -214,21 +215,21 @@ module ActiveRecord::Extensions
     def self.process_without_suffix( key, val, caller )
       return nil unless caller.columns_hash.has_key?( key )
       if val.nil?
-        str = "#{caller.table_name}.#{caller.connection.quote_column_name( key )} IS NULL"
+        str = "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( key )} is ?"
       else
-        str = "#{caller.table_name}.#{caller.connection.quote_column_name( key )}=?" 
+        str = "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( key )}=?" 
       end
       Result.new( str, val )
     end
 
-    def self.process_with_suffix( key, val, caller )
-      return nil unless val.is_a?( String ) or val.is_a?( Numeric )
+    def self.process_with_suffix( key, val, caller ) 
+      return nil unless ACCEPTABLE_COMPARISONS.find{ |klass| val.is_a?(klass) }
       SUFFIX_MAP.each_pair do |k,v|
         match_data = key.to_s.match( /(.+)_#{k}$/ )
         if match_data
           fieldname = match_data.captures[0]
           return nil unless caller.columns_hash.has_key?( fieldname )
-          str = "#{caller.table_name}.#{caller.connection.quote_column_name( fieldname )} " +
+          str = "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( fieldname )} " +
             "#{v} #{caller.connection.quote( val, caller.columns_hash[ fieldname ] )} "
           return Result.new( str, nil )
         end
@@ -254,30 +255,35 @@ module ActiveRecord::Extensions
     LIKE_RGX = /(.+)_(like|contains)$/
     STARTS_WITH_RGX = /(.+)_starts_with$/
     ENDS_WITH_RGX =  /(.+)_ends_with$/
-    
     def self.process( key, val, caller )
       values = [*val]
       case key.to_s
       when LIKE_RGX
         str = values.collect do |v|
-           "#{caller.table_name}.#{caller.connection.quote_column_name( $1 )} LIKE " +
+          "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( $1 )} LIKE " +
             "#{caller.connection.quote( '%%' + v + '%%', caller.columns_hash[ $1 ] )} "
         end
       when STARTS_WITH_RGX
         str = values.collect do |v|
-           "#{caller.table_name}.#{caller.connection.quote_column_name( $1 )} LIKE " +
+           "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( $1 )} LIKE " +
             "#{caller.connection.quote( v + '%%', caller.columns_hash[ $1 ] )} "
         end
       when ENDS_WITH_RGX
         str = values.collect do |v|
-           "#{caller.table_name}.#{caller.connection.quote_column_name( $1 )} LIKE " +
+           "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( $1 )} LIKE " +
             "#{caller.connection.quote( '%%' + v, caller.columns_hash[ $1 ] )} "
         end
       else
         return nil
       end
 
-      return Result.new( str.join(' OR '), nil)
+      str = str.join(' OR ')
+      result_values = []
+      str.gsub!(/'((%%)?([^\?]*\?[^%]*|[^%]*%[^%]*)(%%)?)'/) do |match|
+        result_values << $2
+        '?'
+      end
+      return Result.new(str , result_values)
     end
   end
 
@@ -308,7 +314,7 @@ 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.table_name}.#{fieldname} #{match_data ? 'NOT ' : '' } BETWEEN #{min} AND #{max}"
+        str = "#{caller.quoted_table_name}.#{fieldname} #{match_data ? 'NOT ' : '' } BETWEEN #{min} AND #{max}"
         return Result.new( str, nil )
       end
       nil      
@@ -375,7 +381,7 @@ module ActiveRecord::Extensions
     def self.process( key, val, caller )
       return nil unless val.is_a?( Regexp )
       r = field_result( key, caller )
-      Result.new( "#{caller.table_name}.#{r.fieldname} #{r.negate? ? 'NOT ':''} REGEXP ?", val )
+      Result.new( "#{caller.quoted_table_name}.#{r.fieldname} #{r.negate? ? 'NOT ':''} REGEXP ?", val )
     end
     
   end
@@ -390,7 +396,7 @@ module ActiveRecord::Extensions
     def self.process( key, val, caller )
       return nil unless val.is_a?( Regexp )
       r = field_result( key, caller )
-      return Result.new( "#{caller.table_name}.#{r.fieldname} #{r.negate? ? '!~ ':'~'} ?", val )
+      return Result.new( "#{caller.quoted_table_name}.#{r.fieldname} #{r.negate? ? '!~ ':'~'} ?", val )
     end
 
   end
@@ -403,7 +409,7 @@ module ActiveRecord::Extensions
     def self.process( key, val, caller )
       return nil unless val.is_a?( Regexp )
       r = field_result( key, caller )
-      return Result.new( "#{r.negate? ? ' NOT ':''} REGEXP_LIKE(#{caller.table_name}.#{r.fieldname} , ?)", val )
+      return Result.new( "#{r.negate? ? ' NOT ':''} REGEXP_LIKE(#{caller.quoted_table_name}.#{r.fieldname} , ?)", val )
     end
 
   end
@@ -453,9 +459,9 @@ module ActiveRecord::Extensions
     def self.process_without_suffix( key, val, caller )
       return nil unless caller.columns_hash.has_key?( key )
       if val.nil?
-        str = "#{caller.table_name}.#{caller.connection.quote_column_name( key )} IS NULL"
+        str = "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( key )} IS NULL"
       else
-        str = "#{caller.table_name}.#{caller.connection.quote_column_name( key )}=" +
+        str = "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( key )}=" +
           "#{caller.connection.quote( val.to_s(:db), caller.columns_hash[ key ] )} "
       end
       Result.new( str, nil )
@@ -467,7 +473,7 @@ module ActiveRecord::Extensions
         if match_data
           fieldname = match_data.captures[0]
           return nil unless caller.columns_hash.has_key?( fieldname )
-          str = "#{caller.table_name}.#{caller.connection.quote_column_name( fieldname )} " +
+          str = "#{caller.quoted_table_name}.#{caller.connection.quote_column_name( fieldname )} " +
             "#{v} #{caller.connection.quote( val.to_s(:db), caller.columns_hash[ fieldname ] )} "
           return Result.new( str, nil )
         end

data/lib/ar-extensions/finders.rb

@@ -19,7 +19,7 @@ class ActiveRecord::Base
     
     alias :sanitize_sql_orig :sanitize_sql
     def sanitize_sql( arg ) # :nodoc:
-      return sanitize_sql_orig( arg ) if arg.nil?
+      return if arg.blank? # don't process arguments like [], {}, "" or nil
       if arg.respond_to?( :to_sql )
         arg = sanitize_sql_by_way_of_duck_typing( arg )
       elsif arg.is_a?( Hash )
@@ -35,7 +35,8 @@ class ActiveRecord::Base
     end
 
     def sanitize_sql_from_string_and_hash( arr ) # :nodoc:
-      return arr if arr.first =~ /\:[\w]+/        
+      return arr if arr.first =~ /\:[\w]+/
+      return arr if arr.last.empty? # skip empty hash conditions, ie: :conditions => ["", {}]
       arr2 = sanitize_sql_from_hash( arr.last )
       if arr2.empty?
         conditions = arr.first
@@ -48,7 +49,8 @@ class ActiveRecord::Base
     
     def sanitize_sql_from_hash( hsh ) #:nodoc:
       conditions, values = [], []
-      
+      hsh = expand_hash_conditions_for_aggregates(hsh) # introduced in Rails 2.0.2
+
       hsh.each_pair do |key,val|
         if val.respond_to?( :to_sql )  
           conditions << sanitize_sql_by_way_of_duck_typing( val ) 
@@ -57,10 +59,19 @@ class ActiveRecord::Base
           sql = nil
           result = ActiveRecord::Extensions.process( key, val, self )
           if result
-            conditions << result.sql if result.sql
-            values.push( result.value ) if result.value
+            conditions << result.sql
+            values.push( result.value ) 
           else
-            conditions << "#{table_name}.#{connection.quote_column_name(key.to_s)} #{attribute_condition( val )} "
+            # Extract table name from qualified attribute names.
+            attr = key.to_s
+            if attr.include?('.')
+              table_name, attr = attr.split('.', 2)
+              table_name = connection.quote_table_name(table_name)
+            else
+              table_name = quoted_table_name
+            end
+            
+            conditions << "#{table_name}.#{connection.quote_column_name(attr)} #{attribute_condition( val )} "
             values << val
           end
         end

data/lib/ar-extensions/fulltext.rb

@@ -51,7 +51,6 @@ class ActiveRecord::Base
     rescue NoMethodError
       false
     end
-  
   end
 
 end

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

@@ -35,7 +35,7 @@ class ActiveRecord::Extensions::FullTextSearching::MySQLFullTextExtension
 end
 ActiveRecord::Extensions.register ActiveRecord::Extensions::FullTextSearching::MySQLFullTextExtension.new, :adapters=>[:mysql]
 
-class ActiveRecord::ConnectionAdapters::MysqlAdapter # :nodoc:
+ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
   include ActiveRecord::Extensions::FullTextSearching::FullTextSupport
 
   def register_fulltext_extension( fulltext_key, options ) # :nodoc:

data/lib/ar-extensions/import.rb

@@ -262,29 +262,29 @@ class ActiveRecord::Base
         array_of_attributes.each do |arr|
           my_values = []
           arr.each_with_index do |val,j|
-            if sequence_name && column_names[j] == primary_key && val.nil?
-               my_values << "#{sequence_name}.nextval"
+            if !sequence_name.blank? && column_names[j] == primary_key && val.nil?
+               my_values << connection.next_value_for_sequence(sequence_name)
             else
                my_values << connection.quote( val, columns[j] )
             end
           end
-          insert_statements << "INSERT INTO #{self.table_name} #{columns_sql} VALUES(" + my_values.join( ',' ) + ")"
-           number_inserted = number_inserted + connection.execute( insert_statements.last )
+          insert_statements << "INSERT INTO #{quoted_table_name} #{columns_sql} VALUES(" + my_values.join( ',' ) + ")"
+          connection.execute( insert_statements.last )
+          number_inserted += 1
         end
-        return number_inserted
       else
-        
         # generate the sql
-        insert_sql = connection.multiple_value_sets_insert_sql( table_name, escaped_column_names, options )
+        insert_sql = connection.multiple_value_sets_insert_sql( quoted_table_name, escaped_column_names, options )
         values_sql = connection.values_sql_for_column_names_and_attributes( columns, array_of_attributes )
-        post_sql_statements = connection.post_sql_statements( table_name, options )
+        post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
         
         # perform the inserts
-        number_of_inserts = connection.insert_many( 
-                                                   [ insert_sql, post_sql_statements ].flatten, 
-                                                   values_sql,
-                                                   "#{self.class.name} Create Many Without Validations Or Callbacks" )
+        number_inserted = connection.insert_many( [ insert_sql, post_sql_statements ].flatten, 
+                                                  values_sql,
+                                                  "#{self.class.name} Create Many Without Validations Or Callbacks" )
       end
+      
+      number_inserted
     end
     
     # Returns an array of quoted column names

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

@@ -2,20 +2,7 @@ module ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter # :nodoc:
 
   include ActiveRecord::Extensions::Import::ImportSupport  
   include ActiveRecord::Extensions::Import::OnDuplicateKeyUpdateSupport
-  
-  # Returns an array of post SQL statements given the passed in options.
-  def post_sql_statements( table_name, options ) # :nodoc:
-    post_sql_statements = []
-    if options[:on_duplicate_key_update]
-      post_sql_statements << sql_for_on_duplicate_key_update( table_name, options[:on_duplicate_key_update] )
-    end
-    post_sql_statements
-  end
-  
-  def multiple_value_sets_insert_sql( table_name, column_names, options ) # :nodoc:    
-    "INSERT #{options[:ignore] ? 'IGNORE ':''} INTO #{table_name} (#{column_names.join(',')}) VALUES "
-  end
-  
+    
   # Returns a generated ON DUPLICATE KEY UPDATE statement given the passed
   # in +args+. 
   def sql_for_on_duplicate_key_update( table_name, *args ) # :nodoc:
@@ -32,39 +19,25 @@ module ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter # :nodoc:
   end
 
   def sql_for_on_duplicate_key_update_as_array( table_name, arr )  # :nodoc:
-    qt = quote_column_name( table_name )
     results = arr.map do |column|
       qc = quote_column_name( column )
-      "#{qt}.#{qc}=VALUES(#{qc})"        
+      "#{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 '
-    qt = quote_column_name( table_name )
     results = hsh.map do |column1, column2|
       qc1 = quote_column_name( column1 )
       qc2 = quote_column_name( column2 )
-      "#{qt}.#{qc1}=VALUES( #{qc2} )"
+      "#{table_name}.#{qc1}=VALUES( #{qc2} )"
     end
     results.join( ',')
   end  
 
-  # Returns SQL the VALUES for an INSERT statement given the passed in +columns+ 
-  # and +array_of_attributes+.
-  def values_sql_for_column_names_and_attributes( columns, array_of_attributes )   # :nodoc:
-    values = []
-    array_of_attributes.each do |arr|
-      my_values = []
-      arr.each_with_index do |val,j|
-        my_values << quote( val, columns[j] )
-      end
-      values << my_values
-    end   
-    values_arr = values.map{ |arr| '(' + arr.join( ',' ) + ')' }
-  end
-    
 end
 
-ActiveRecord::ConnectionAdapters::MysqlAdapter.send( 'include', ActiveRecord::Extensions::ConnectionAdapters::MysqlAdapter )
+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/synchronize.rb

@@ -8,7 +8,7 @@ module ActiveRecord # :nodoc:
     #
     # 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=ActiveRecord::Base.primary_key)
+    def self.synchronize(instances, key=self.primary_key)
       return if instances.empty?
       
       keys = instances.map(&"#{key}".to_sym)

data/lib/ar-extensions/temporary_table.rb

@@ -87,7 +87,6 @@ class ActiveRecord::Base
 				end"
 
     @@temporary_table_hsh[ model = Object.const_get( model_name ) ] = true
-
     if block_given?
       yield model
       model.drop

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

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

metadata

@@ -1,39 +1,41 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
 name: ar-extensions
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
-date: 2007-07-21 00:00:00 -04:00
-summary: Extends ActiveRecord functionality.
-require_paths: 
-- lib
-email: zach.dennis@gmail.com
-homepage: http://www.continuousthinking.com/tags/arext
-rubyforge_project: arext
-description: Extends ActiveRecord functionality by adding better finder/query support, as well as supporting mass data import, foreign key, CSV and temporary tables
-autorequire: ar-extensions.rb
-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: 
+  version: 0.8.0
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Zach Dennis
 - Mark Van Holstyn
+autorequire: ar-extensions.rb
+bindir: bin
+cert_chain: []
+
+date: 2008-08-06 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.14.1
+    version: 
+description: Extends ActiveRecord functionality by adding better finder/query support, as well as supporting mass data import, foreign key, CSV and temporary tables
+email: zach.dennis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
 files: 
 - init.rb
 - db/migrate
 - db/migrate/generic_schema.rb
 - db/migrate/mysql_schema.rb
+- db/migrate/oracle_schema.rb
 - db/migrate/version.rb
 - Rakefile
 - ChangeLog
@@ -43,9 +45,10 @@ files:
 - config/mysql.schema
 - config/postgresql.schema
 - lib/ar-extensions/adapters/abstract_adapter.rb
-- lib/ar-extensions/adapters/mysql_adapter.rb
+- lib/ar-extensions/adapters/mysql.rb
 - lib/ar-extensions/adapters/oracle.rb
 - lib/ar-extensions/adapters/postgresql.rb
+- lib/ar-extensions/adapters/sqlite.rb
 - lib/ar-extensions/csv.rb
 - lib/ar-extensions/extensions.rb
 - lib/ar-extensions/finders.rb
@@ -54,32 +57,39 @@ files:
 - lib/ar-extensions/fulltext.rb
 - lib/ar-extensions/import/mysql.rb
 - lib/ar-extensions/import/postgresql.rb
+- lib/ar-extensions/import/sqlite.rb
 - lib/ar-extensions/import.rb
 - lib/ar-extensions/synchronize.rb
 - lib/ar-extensions/temporary_table/mysql.rb
 - lib/ar-extensions/temporary_table.rb
 - lib/ar-extensions/version.rb
 - lib/ar-extensions.rb
-test_files: []
-
+has_rdoc: true
+homepage: http://www.continuousthinking.com/tags/arext
+post_install_message: 
 rdoc_options: 
 - --main
 - README
-extra_rdoc_files: 
-- README
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activerecord
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.14.1
-    version: 
+rubyforge_project: arext
+rubygems_version: 1.1.0
+signing_key: 
+specification_version: 2
+summary: Extends ActiveRecord functionality.
+test_files: []
+

data/lib/ar-extensions/adapters/mysql_adapter.rb

@@ -1,14 +0,0 @@
-module ActiveRecord # :nodoc:
-  module ConnectionAdapters # :nodoc:
-    class MysqlAdapter # :nodoc:
-           
-      # Returns the maximum number of bytes that the server will allow
-      # in a single packet
-      def max_allowed_packet # :nodoc:
-        result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
-        result.fetch_row[1].to_i
-      end
-    
-    end #end MysqlAdapter
-  end #end ConnectionAdapters
-end #end ActiveRecord