activerecord-import-in4systems 0.2.10

data/README.markdown

@@ -0,0 +1,24 @@
+# activerecord-import
+
+activerecord-import is a library for bulk inserting data using ActiveRecord. 
+
+For more information on activerecord-import please see its wiki: https://github.com/zdennis/activerecord-import/wiki
+
+# License
+
+This is licensed under the ruby license. 
+
+# Author
+
+Zach Dennis (zach.dennis@gmail.com)
+
+# Contributors
+
+* Blythe Dunham
+* Gabe da Silveira
+* Henry Work
+* James Herdman
+* Marcus Crafter
+* Thibaud Guillaume-Gentil
+* Mark Van Holstyn 
+* Victor Costan

data/Rakefile

@@ -0,0 +1,74 @@
+require "bundler"
+Bundler.setup
+
+require 'rake'
+require 'rake/testtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "activerecord-import"
+    gem.summary = %Q{Bulk-loading extension for ActiveRecord}
+    gem.description = %Q{Extraction of the ActiveRecord::Base#import functionality from ar-extensions for Rails 3 and beyond}
+    gem.email = "zach.dennis@gmail.com"
+    gem.homepage = "http://github.com/zdennis/activerecord-import"
+    gem.authors = ["Zach Dennis"]
+    gem.files = FileList["VERSION", "Rakefile", "README*", "lib/**/*"]
+
+    bundler = Bundler.load
+    bundler.dependencies_for(:default).each do |dependency|
+      gem.add_dependency dependency.name, *dependency.requirements_list
+    end
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+namespace :display do
+  task :notice do
+    puts
+    puts "To run tests you must supply the adapter, see rake -T for more information."
+    puts
+  end
+end
+task :default => ["display:notice"]
+
+ADAPTERS = %w(mysql mysql2 jdbcmysql postgresql sqlite3 seamless_database_pool)
+ADAPTERS.each do |adapter|
+  namespace :test do
+    desc "Runs #{adapter} database tests."
+    Rake::TestTask.new(adapter) do |t|
+      # FactoryGirl has an issue with warnings, so turn off, so noisy
+      # t.warning = true
+      t.test_files = FileList["test/adapters/#{adapter}.rb", "test/*_test.rb", "test/active_record/*_test.rb", "test/#{adapter}/**/*_test.rb"]
+    end
+    task adapter
+  end
+end
+
+begin
+  require 'rcov/rcovtask'
+  adapter = ENV['ARE_DB']
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = ["test/adapters/#{adapter}.rb", "test/*_test.rb", "test/#{adapter}/**/*_test.rb"]
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install rcov"
+  end
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "activerecord-import #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.10

data/lib/activerecord-import.rb

@@ -0,0 +1,16 @@
+class ActiveRecord::Base
+  class << self
+    def establish_connection_with_activerecord_import(*args)
+      establish_connection_without_activerecord_import(*args)
+      ActiveSupport.run_load_hooks(:active_record_connection_established, connection_pool)
+    end
+    alias_method_chain :establish_connection, :activerecord_import
+  end
+end
+
+ActiveSupport.on_load(:active_record_connection_established) do |connection_pool|
+  if !ActiveRecord.const_defined?(:Import) || !ActiveRecord::Import.respond_to?(:load_from_connection_pool)
+    require File.join File.dirname(__FILE__),  "activerecord-import/base"
+  end
+  ActiveRecord::Import.load_from_connection_pool connection_pool
+end

data/lib/activerecord-import/active_record/adapters/abstract_adapter.rb

@@ -0,0 +1,10 @@
+require "activerecord-import/adapters/abstract_adapter"
+
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    class AbstractAdapter # :nodoc:
+      extend ActiveRecord::Import::AbstractAdapter::ClassMethods
+      include ActiveRecord::Import::AbstractAdapter::InstanceMethods
+    end
+  end
+end

data/lib/activerecord-import/active_record/adapters/jdbcmysql_adapter.rb

@@ -0,0 +1,6 @@
+require "active_record/connection_adapters/mysql_adapter"
+require "activerecord-import/adapters/mysql_adapter"
+
+class ActiveRecord::ConnectionAdapters::MysqlAdapter
+  include ActiveRecord::Import::MysqlAdapter
+end

data/lib/activerecord-import/active_record/adapters/mysql2_adapter.rb

@@ -0,0 +1,6 @@
+require "active_record/connection_adapters/mysql2_adapter"
+require "activerecord-import/adapters/mysql_adapter"
+
+class ActiveRecord::ConnectionAdapters::Mysql2Adapter
+  include ActiveRecord::Import::MysqlAdapter
+end

data/lib/activerecord-import/active_record/adapters/mysql_adapter.rb

@@ -0,0 +1,6 @@
+require "active_record/connection_adapters/mysql_adapter"
+require "activerecord-import/adapters/mysql_adapter"
+
+class ActiveRecord::ConnectionAdapters::MysqlAdapter
+  include ActiveRecord::Import::MysqlAdapter
+end

data/lib/activerecord-import/active_record/adapters/postgresql_adapter.rb

@@ -0,0 +1,7 @@
+require "active_record/connection_adapters/postgresql_adapter"
+require "activerecord-import/adapters/postgresql_adapter"
+
+class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+  include ActiveRecord::Import::PostgreSQLAdapter
+end
+

data/lib/activerecord-import/active_record/adapters/seamless_database_pool_adapter.rb

@@ -0,0 +1,7 @@
+require "seamless_database_pool"
+require "active_record/connection_adapters/seamless_database_pool_adapter"
+require "activerecord-import/adapters/mysql_adapter"
+
+class ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter
+  include ActiveRecord::Import::MysqlAdapter
+end

data/lib/activerecord-import/active_record/adapters/sqlanywhere_adapter.rb

@@ -0,0 +1,7 @@
+require "active_record/connection_adapters/sqlanywhere_adapter"
+require "activerecord-import/adapters/sqlanywhere_adapter"
+
+class ActiveRecord::ConnectionAdapters::SqlanywhereAdapter
+  include ActiveRecord::Import::SqlanywhereAdapter
+end
+

data/lib/activerecord-import/active_record/adapters/sqlanywhere_jdbc_in4systems_adapter.rb

@@ -0,0 +1,7 @@
+require "active_record/connection_adapters/sqlanywhere_jdbc_in4systems_adapter"
+require "activerecord-import/adapters/sqlanywhere_jdbc_in4systems_adapter"
+
+class ActiveRecord::ConnectionAdapters::SQLAnywhereJdbcIn4systemsAdapter
+  include ActiveRecord::Import::SQLAnywhereJdbcIn4systemsAdapter
+end
+

data/lib/activerecord-import/active_record/adapters/sqlite3_adapter.rb

@@ -0,0 +1,7 @@
+require "active_record/connection_adapters/sqlite3_adapter"
+require "activerecord-import/adapters/sqlite3_adapter"
+
+class ActiveRecord::ConnectionAdapters::Sqlite3Adapter
+  include ActiveRecord::Import::Sqlite3Adapter
+end
+

data/lib/activerecord-import/adapters/abstract_adapter.rb

@@ -0,0 +1,119 @@
+module ActiveRecord::Import::AbstractAdapter
+  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.
+    
+  module ClassMethods
+    def get_insert_value_sets( values, sql_size, max_bytes ) # :nodoc:
+      value_sets = []          
+      arr, current_arr_values_size, current_size = [], 0, 0
+      values.each_with_index do |val,i|
+        comma_bytes = arr.size
+        sql_size_thus_far = sql_size + current_size + val.size + comma_bytes
+        if NO_MAX_PACKET == max_bytes or sql_size_thus_far <= max_bytes
+          current_size += val.bytesize            
+          arr << val
+        else
+          value_sets << arr
+          arr = [ val ]
+          current_size = val.bytesize
+        end
+      
+        # if we're on the last iteration push whatever we have in arr to value_sets
+        value_sets << arr if i == (values.size-1)
+      end
+      [ *value_sets ]
+    end
+  end
+  
+  module InstanceMethods
+    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:
+      # the number of inserts default
+      number_of_inserts = 0
+    
+      base_sql,post_sql = if sql.is_a?( String )
+        [ sql, '' ]
+      elsif sql.is_a?( Array )
+        [ sql.shift, sql.join( ' ' ) ]
+      end
+    
+      sql_size = QUERY_OVERHEAD + base_sql.size + post_sql.size 
+
+      # the number of bytes the requested insert statement values will take up
+      values_in_bytes = values.sum {|value| value.bytesize }
+    
+      # the number of bytes (commas) it will take to comma separate our values
+      comma_separated_bytes = values.size-1
+    
+      # the total number of bytes required if this statement is one statement
+      total_bytes = sql_size + values_in_bytes + comma_separated_bytes
+    
+      max = max_allowed_packet
+    
+      # if we can insert it all as one statement
+      if NO_MAX_PACKET == max or total_bytes < max
+        number_of_inserts += 1
+        sql2insert = base_sql + values.join( ',' ) + post_sql
+        insert( sql2insert, *args )
+      else
+        value_sets = self.class.get_insert_value_sets( values, sql_size, max )
+        value_sets.each do |values|
+          number_of_inserts += 1
+          sql2insert = base_sql + values.join( ',' ) + post_sql
+          insert( sql2insert, *args )
+        end
+      end
+
+      number_of_inserts
+    end
+
+    def pre_sql_statements(options)
+      sql = []
+      sql << options[:pre_sql] if options[:pre_sql]
+      sql << options[:command] if options[:command]
+      sql << "IGNORE" if options[:ignore]
+
+      #add keywords like IGNORE or DELAYED
+      if options[:keywords].is_a?(Array)
+        sql.concat(options[:keywords])
+      elsif options[:keywords]
+        sql << options[:keywords].to_s
+      end
+
+      sql
+    end
+
+    # Synchronizes the passed in ActiveRecord instances with the records in
+    # the database by calling +reload+ on each instance.
+    def after_import_synchronize( instances )
+      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
+
+      #custom user post_sql
+      post_sql_statements << options[:post_sql] if options[:post_sql]
+
+      #with rollup
+      post_sql_statements << rollup_sql if options[:rollup]
+
+      post_sql_statements
+    end
+
+    # Returns the maximum number of bytes that the server will allow
+    # in a single packet
+    def max_allowed_packet
+      NO_MAX_PACKET
+    end
+  end
+end

data/lib/activerecord-import/adapters/mysql_adapter.rb

@@ -0,0 +1,55 @@
+module ActiveRecord::Import::MysqlAdapter
+  include ActiveRecord::Import::ImportSupport  
+  include ActiveRecord::Import::OnDuplicateKeyUpdateSupport
+
+  # Returns the maximum number of bytes that the server will allow
+  # in a single packet
+  def max_allowed_packet # :nodoc:
+    @max_allowed_packet ||= begin
+      result = execute( "SHOW VARIABLES like 'max_allowed_packet';" )
+      # original Mysql gem responds to #fetch_row while Mysql2 responds to #first
+      val = result.respond_to?(:fetch_row) ? result.fetch_row[1] : result.first[1]
+      val.to_i
+    end
+  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:
+    sql = ' ON DUPLICATE KEY UPDATE '
+    arg = args.first
+    if arg.is_a?( Array )
+      sql << sql_for_on_duplicate_key_update_as_array( table_name, arg )
+    elsif arg.is_a?( Hash )
+      sql << sql_for_on_duplicate_key_update_as_hash( table_name, arg )
+    elsif arg.is_a?( String )
+      sql << arg
+    else
+      raise ArgumentError.new( "Expected Array or Hash" )
+    end
+    sql
+  end
+
+  def sql_for_on_duplicate_key_update_as_array( table_name, arr )  # :nodoc:
+    results = arr.map do |column|
+      qc = quote_column_name( column )
+      "#{table_name}.#{qc}=VALUES(#{qc})"
+    end
+    results.join( ',' )
+  end
+
+  def sql_for_on_duplicate_key_update_as_hash( table_name, hsh ) # :nodoc:
+    sql = ' ON DUPLICATE KEY UPDATE '
+    results = hsh.map do |column1, column2|
+      qc1 = quote_column_name( column1 )
+      qc2 = quote_column_name( column2 )
+      "#{table_name}.#{qc1}=VALUES( #{qc2} )"
+    end
+    results.join( ',')
+  end
+
+  #return true if the statement is a duplicate key record error
+  def duplicate_key_update_error?(exception)# :nodoc:
+    exception.is_a?(ActiveRecord::StatementInvalid) && exception.to_s.include?('Duplicate entry')
+  end
+end

data/lib/activerecord-import/adapters/postgresql_adapter.rb

@@ -0,0 +1,7 @@
+module ActiveRecord::Import::PostgreSQLAdapter
+  include ActiveRecord::Import::ImportSupport
+
+  def next_value_for_sequence(sequence_name)
+    %{nextval('#{sequence_name}')}
+  end
+end

data/lib/activerecord-import/adapters/sqlanywhere_adapter.rb

@@ -0,0 +1,7 @@
+module ActiveRecord::Import::SqlanywhereAdapter
+  include ActiveRecord::Import::ImportSupport
+  
+  def next_value_for_sequence(sequence_name)
+    %{nextval('#{sequence_name}')}
+  end  
+end

data/lib/activerecord-import/adapters/sqlanywhere_jdbc_in4systems_adapter.rb

@@ -0,0 +1,7 @@
+module ActiveRecord::Import::SqlanywhereJdbcIn4systemsAdapter
+  include ActiveRecord::Import::ImportSupport
+  
+  def next_value_for_sequence(sequence_name)
+    %{nextval('#{sequence_name}')}
+  end  
+end

data/lib/activerecord-import/adapters/sqlite3_adapter.rb

@@ -0,0 +1,5 @@
+module ActiveRecord::Import::Sqlite3Adapter
+  def next_value_for_sequence(sequence_name)
+    %{nextval('#{sequence_name}')}
+  end
+end

data/lib/activerecord-import/base.rb

@@ -0,0 +1,24 @@
+require "pathname"
+require "active_record"
+require "active_record/version"
+
+module ActiveRecord::Import
+  AdapterPath = File.join File.expand_path(File.dirname(__FILE__)), "/active_record/adapters"
+
+  # Loads the import functionality for a specific database adapter
+  def self.require_adapter(adapter)
+    require File.join(AdapterPath,"/abstract_adapter")
+    require File.join(AdapterPath,"/#{adapter}_adapter")
+  end
+
+  # Loads the import functionality for the passed in ActiveRecord connection
+  def self.load_from_connection_pool(connection_pool)
+    require_adapter connection_pool.spec.config[:adapter]
+  end
+end
+
+
+this_dir = Pathname.new File.dirname(__FILE__)
+require this_dir.join("import").to_s
+require this_dir.join("active_record/adapters/abstract_adapter").to_s
+require this_dir.join("synchronize").to_s

data/lib/activerecord-import/import.rb

@@ -0,0 +1,372 @@
+require "ostruct"
+
+module ActiveRecord::Import::ConnectionAdapters ; end
+
+module ActiveRecord::Import #:nodoc:
+  class Result < Struct.new(:failed_instances, :num_inserts)
+  end
+
+  module ImportSupport #:nodoc:
+    def supports_import? #:nodoc:
+      true
+    end
+  end
+  
+  module OnDuplicateKeyUpdateSupport #:nodoc:
+    def supports_on_duplicate_key_update? #:nodoc:
+      true
+    end
+  end
+
+  class MissingColumnError < StandardError
+    def initialize(name, index)
+      super "Missing column for value <#{name}> at index #{index}"
+    end
+  end
+end
+
+class ActiveRecord::Base
+  class << self
+
+    # use tz as set in ActiveRecord::Base
+    tproc = lambda do
+      ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+    end
+    
+    AREXT_RAILS_COLUMNS = {
+      :create => { "created_on" => tproc ,
+                   "created_at" => tproc },
+      :update => { "updated_on" => tproc ,
+                   "updated_at" => tproc }
+    }
+    AREXT_RAILS_COLUMN_NAMES = AREXT_RAILS_COLUMNS[:create].keys + AREXT_RAILS_COLUMNS[:update].keys
+  
+    # Returns true if the current database connection adapter
+    # supports import functionality, otherwise returns false.
+    def supports_import?
+      connection.supports_import?
+    rescue NoMethodError
+      false
+    end
+
+    # Returns true if the current database connection adapter
+    # supports on duplicate key update functionality, otherwise
+    # returns false.
+    def supports_on_duplicate_key_update?
+      connection.supports_on_duplicate_key_update?
+    rescue NoMethodError
+      false
+    end
+    
+    # Imports a collection of values to the database.  
+    #
+    # This is more efficient than using ActiveRecord::Base#create or
+    # ActiveRecord::Base#save multiple times. This method works well if
+    # you want to create more than one record at a time and do not care
+    # about having ActiveRecord objects returned for each record
+    # inserted. 
+    #
+    # This can be used with or without validations. It does not utilize
+    # the ActiveRecord::Callbacks during creation/modification while
+    # performing the import.
+    #
+    # == Usage
+    #  Model.import array_of_models
+    #  Model.import column_names, array_of_values
+    #  Model.import column_names, array_of_values, options
+    # 
+    # ==== Model.import array_of_models
+    # 
+    # With this form you can call _import_ passing in an array of model
+    # objects that you want updated.
+    #
+    # ==== Model.import column_names, array_of_values
+    #
+    # The first parameter +column_names+ is an array of symbols or
+    # strings which specify the columns that you want to update.
+    #
+    # The second parameter, +array_of_values+, is an array of
+    # arrays. Each subarray is a single set of values for a new
+    # record. The order of values in each subarray should match up to
+    # the order of the +column_names+.
+    #
+    # ==== Model.import column_names, array_of_values, options
+    #
+    # The first two parameters are the same as the above form. The third
+    # parameter, +options+, is a hash. This is optional. Please see
+    # below for what +options+ are available.
+    #
+    # == Options
+    # * +validate+ - true|false, tells import whether or not to use \
+    #    ActiveRecord validations. Validations are enforced by default.
+    # * +on_duplicate_key_update+ - an Array or Hash, tells import to \
+    #    use MySQL's ON DUPLICATE KEY UPDATE ability. See On Duplicate\
+    #    Key Update below.
+    # * +synchronize+ - an array of ActiveRecord instances for the model
+    #   that you are currently importing data into. This synchronizes
+    #   existing model instances in memory with updates from the import.
+    # * +timestamps+ - true|false, tells import to not add timestamps \
+    #   (if false) even if record timestamps is disabled in ActiveRecord::Base
+    #
+    # == Examples  
+    #  class BlogPost < ActiveRecord::Base ; end
+    #  
+    #  # Example using array of model objects
+    #  posts = [ BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT',
+    #            BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT2',
+    #            BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT3' ]
+    #  BlogPost.import posts
+    #
+    #  # Example using column_names and array_of_values
+    #  columns = [ :author_name, :title ]
+    #  values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
+    #  BlogPost.import columns, values 
+    #
+    #  # Example using column_names, array_of_value and options
+    #  columns = [ :author_name, :title ]
+    #  values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
+    #  BlogPost.import( columns, values, :validate => false  )
+    #
+    #  # Example synchronizing existing instances in memory
+    #  post = BlogPost.find_by_author_name( 'zdennis' )
+    #  puts post.author_name # => 'zdennis'
+    #  columns = [ :author_name, :title ]
+    #  values = [ [ 'yoda', 'test post' ] ]
+    #  BlogPost.import posts, :synchronize=>[ post ]
+    #  puts post.author_name # => 'yoda'
+    #
+    #  # Example synchronizing unsaved/new instances in memory by using a uniqued imported field
+    #  posts = [BlogPost.new(:title => "Foo"), BlogPost.new(:title => "Bar")]
+    #  BlogPost.import posts, :synchronize => posts
+    #  puts posts.first.new_record? # => false
+    #
+    # == On Duplicate Key Update (MySQL only)
+    #
+    # The :on_duplicate_key_update option can be either an Array or a Hash. 
+    # 
+    # ==== Using an Array
+    #
+    # The :on_duplicate_key_update option can be an array of column
+    # names. The column names are the only fields that are updated if
+    # a duplicate record is found. Below is an example:
+    #
+    #   BlogPost.import columns, values, :on_duplicate_key_update=>[ :date_modified, :content, :author ]
+    #
+    # ====  Using A Hash
+    #
+    # The :on_duplicate_key_update option can be a hash of column name
+    # to model attribute name mappings. This gives you finer grained
+    # control over what fields are updated with what attributes on your
+    # model. Below is an example:
+    #   
+    #   BlogPost.import columns, attributes, :on_duplicate_key_update=>{ :title => :title } 
+    #  
+    # = Returns
+    # This returns an object which responds to +failed_instances+ and +num_inserts+.
+    # * failed_instances - an array of objects that fails validation and were not committed to the database. An empty array if no validation is performed.
+    # * num_inserts - the number of insert statements it took to import the data
+    def import( *args )
+      options = { :validate=>true, :timestamps=>true }
+      options.merge!( args.pop ) if args.last.is_a? Hash
+
+      is_validating = options.delete( :validate )
+
+      # assume array of model objects
+      if args.last.is_a?( Array ) and args.last.first.is_a? ActiveRecord::Base
+        if args.length == 2
+          models = args.last
+          column_names = args.first
+        else
+          models = args.first
+          column_names = self.column_names.dup
+        end
+        
+        array_of_attributes = models.map do |model|
+          # this next line breaks sqlite.so with a segmentation fault
+          # if model.new_record? || options[:on_duplicate_key_update]
+            column_names.map do |name|
+              model.send( "#{name}_before_type_cast" )
+            end
+          # end
+        end
+        # supports empty array
+      elsif args.last.is_a?( Array ) and args.last.empty?
+        return ActiveRecord::Import::Result.new([], 0) if args.last.empty?
+        # supports 2-element array and array
+      elsif args.size == 2 and args.first.is_a?( Array ) and args.last.is_a?( Array )
+        column_names, array_of_attributes = args
+      else
+        raise ArgumentError.new( "Invalid arguments!" )
+      end
+
+      # dup the passed in array so we don't modify it unintentionally
+      array_of_attributes = array_of_attributes.dup
+
+      # Force the primary key col into the insert if it's not
+      # on the list and we are using a sequence and stuff a nil
+      # value for it into each row so the sequencer will fire later
+      if !column_names.include?(primary_key) && sequence_name && connection.prefetch_primary_key?
+         column_names << primary_key
+         array_of_attributes.each { |a| a << nil }
+      end
+
+      # record timestamps unless disabled in ActiveRecord::Base
+      if record_timestamps && options.delete( :timestamps )
+         add_special_rails_stamps column_names, array_of_attributes, options
+      end
+
+      return_obj = if is_validating
+        import_with_validations( column_names, array_of_attributes, options )
+      else
+        num_inserts = import_without_validations_or_callbacks( column_names, array_of_attributes, options )
+        ActiveRecord::Import::Result.new([], num_inserts)
+      end
+
+      if options[:synchronize]
+        sync_keys = options[:synchronize_keys] || [self.primary_key]
+        synchronize( options[:synchronize], sync_keys)
+      end
+
+      return_obj.num_inserts = 0 if return_obj.num_inserts.nil?
+      return_obj
+    end
+    
+    # TODO import_from_table needs to be implemented. 
+    def import_from_table( options ) # :nodoc:
+    end
+    
+    # Imports the passed in +column_names+ and +array_of_attributes+
+    # given the passed in +options+ Hash with validations. Returns an
+    # object with the methods +failed_instances+ and +num_inserts+.
+    # +failed_instances+ is an array of instances that failed validations. 
+    # +num_inserts+ is the number of inserts it took to import the data. See
+    # ActiveRecord::Base.import for more information on
+    # +column_names+, +array_of_attributes+ and +options+.
+    def import_with_validations( column_names, array_of_attributes, options={} )
+      failed_instances = []
+    
+      # create instances for each of our column/value sets
+      arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )    
+
+      # keep track of the instance and the position it is currently at. if this fails
+      # validation we'll use the index to remove it from the array_of_attributes
+      arr.each_with_index do |hsh,i|
+        instance = new do |model|
+          hsh.each_pair{ |k,v| model.send("#{k}=", v) }
+        end
+        if not instance.valid?
+          array_of_attributes[ i ] = nil
+          failed_instances << instance
+        end    
+      end
+      array_of_attributes.compact!
+
+      num_inserts = if array_of_attributes.empty? || options[:all_or_none] && failed_instances.any?
+                      0
+                    else
+                      import_without_validations_or_callbacks( column_names, array_of_attributes, options )
+                    end
+      ActiveRecord::Import::Result.new(failed_instances, num_inserts)
+    end
+    
+    # Imports the passed in +column_names+ and +array_of_attributes+
+    # given the passed in +options+ Hash. This will return the number
+    # of insert operations it took to create these records without
+    # validations or callbacks. See ActiveRecord::Base.import for more
+    # information on +column_names+, +array_of_attributes_ and
+    # +options+.
+    def import_without_validations_or_callbacks( column_names, array_of_attributes, options={} )
+      columns = column_names.each_with_index.map do |name, i|
+        column = columns_hash[name.to_s]
+
+        raise ActiveRecord::Import::MissingColumnError.new(name.to_s, i) if column.nil?
+
+        column
+      end
+
+      columns_sql = "(#{column_names.map{|name| connection.quote_column_name(name) }.join(',')})"
+      insert_sql = "INSERT #{options[:ignore] ? 'IGNORE ':''}INTO #{quoted_table_name} #{columns_sql} VALUES "
+      values_sql = values_sql_for_columns_and_attributes(columns, array_of_attributes)
+      if not supports_import?
+        number_inserted = 0
+        values_sql.each do |values|
+          connection.execute(insert_sql + values)
+          number_inserted += 1
+        end
+      else
+        # generate the sql
+        post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
+        
+        # perform the inserts
+        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
+
+    private
+
+    # Returns SQL the VALUES for an INSERT statement given the passed in +columns+
+    # and +array_of_attributes+.
+    def values_sql_for_columns_and_attributes(columns, array_of_attributes)   # :nodoc:
+      array_of_attributes.map do |arr|
+        my_values = arr.each_with_index.map do |val,j|
+          column = columns[j]
+
+          if val.nil? && !sequence_name.blank? && column.name == primary_key
+             connection.next_value_for_sequence(sequence_name)
+          else
+            connection.quote(column.type_cast(val), column)
+          end
+        end
+        "(#{my_values.join(',')})"
+      end
+    end
+
+    def add_special_rails_stamps( column_names, array_of_attributes, options )
+      AREXT_RAILS_COLUMNS[:create].each_pair do |key, blk|
+        if self.column_names.include?(key)
+          value = blk.call
+          if index=column_names.index(key)
+             # replace every instance of the array of attributes with our value
+             array_of_attributes.each{ |arr| arr[index] = value }
+          else
+            column_names << key
+            array_of_attributes.each { |arr| arr << value }
+          end
+        end
+      end
+
+      AREXT_RAILS_COLUMNS[:update].each_pair do |key, blk|
+        if self.column_names.include?(key)
+          value = blk.call
+          if index=column_names.index(key)
+             # replace every instance of the array of attributes with our value
+             array_of_attributes.each{ |arr| arr[index] = value }
+          else
+            column_names << key
+            array_of_attributes.each { |arr| arr << value }
+          end
+          
+          if supports_on_duplicate_key_update?
+            if options[:on_duplicate_key_update]
+              options[:on_duplicate_key_update] << key.to_sym if options[:on_duplicate_key_update].is_a?(Array)
+              options[:on_duplicate_key_update][key.to_sym] = key.to_sym if options[:on_duplicate_key_update].is_a?(Hash)
+            else
+              options[:on_duplicate_key_update] = [ key.to_sym ]
+            end
+          end
+        end
+      end
+    end
+    
+    # Returns an Array of Hashes for the passed in +column_names+ and +array_of_attributes+.
+    def validations_array_for_column_names_and_attributes( column_names, array_of_attributes ) # :nodoc:
+      array_of_attributes.map do |attributes|
+        Hash[attributes.each_with_index.map {|attr, c| [column_names[c], attr] }]
+      end
+    end
+    
+  end
+end

data/lib/activerecord-import/mysql.rb

@@ -0,0 +1,8 @@
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/mysql2.rb

@@ -0,0 +1,8 @@
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/postgresql.rb

@@ -0,0 +1,8 @@
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/sqlanywhere.rb

@@ -0,0 +1,8 @@
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/sqlanywhere_jdbc_in4systems.rb

@@ -0,0 +1,8 @@
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/sqlite3.rb

@@ -0,0 +1,8 @@
+warn <<-MSG
+[DEPRECATION] loading activerecord-import via 'require "activerecord-import/<adapter-name>"'
+  is deprecated. Update to autorequire using 'require "activerecord-import"'. See
+  http://github.com/zdennis/activerecord-import/wiki/Requiring for more information
+MSG
+
+require File.expand_path(File.join(File.dirname(__FILE__),  "/../activerecord-import"))
+

data/lib/activerecord-import/synchronize.rb

@@ -0,0 +1,55 @@
+module ActiveRecord # :nodoc:
+  class Base # :nodoc:
+      
+    # Synchronizes the passed in ActiveRecord instances with data
+    # from the database. This is like calling reload on an individual
+    # ActiveRecord instance but it is intended for use on multiple instances. 
+    # 
+    # This uses one query for all instance updates and then updates existing
+    # instances rather sending one query for each instance
+    #
+    # == Examples
+    # # Synchronizing existing models by matching on the primary key field
+    # posts = Post.find_by_author("Zach")
+    # <.. out of system changes occur to change author name from Zach to Zachary..>
+    # Post.synchronize posts
+    # posts.first.author # => "Zachary" instead of Zach
+    # 
+    # # Synchronizing using custom key fields
+    # posts = Post.find_by_author("Zach")
+    # <.. out of system changes occur to change the address of author 'Zach' to 1245 Foo Ln ..>
+    # Post.synchronize posts, [:name] # queries on the :name column and not the :id column
+    # posts.first.address # => "1245 Foo Ln" instead of whatever it was
+    #
+    def self.synchronize(instances, keys=[self.primary_key])
+      return if instances.empty?
+
+      conditions = {}
+      order = ""
+      
+      key_values = keys.map { |key| instances.map(&"#{key}".to_sym) }
+      keys.zip(key_values).each { |key, values| conditions[key] = values }
+      order = keys.map{ |key| "#{key} ASC" }.join(",")
+      
+      klass = instances.first.class
+
+      fresh_instances = klass.find( :all, :conditions=>conditions, :order=>order )
+      instances.each do |instance|
+        matched_instance = fresh_instances.detect do |fresh_instance|
+          keys.all?{ |key| fresh_instance.send(key) == instance.send(key) }
+        end
+        
+        if matched_instance
+          instance.clear_aggregation_cache
+          instance.clear_association_cache
+          instance.instance_variable_set '@attributes', matched_instance.attributes
+        end
+      end
+    end
+
+    # See ActiveRecord::ConnectionAdapters::AbstractAdapter.synchronize
+    def synchronize(instances, key=[ActiveRecord::Base.primary_key])
+      self.class.synchronize(instances, key)
+    end
+  end
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-import-in4systems
+version: !ruby/object:Gem::Version
+  version: 0.2.10
+  prerelease: 
+platform: ruby
+authors:
+- Zach Dennis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-sqlanywhere-adapter-in4systems
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-sqlanywhere-jdbc-in4systems-adapter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Extraction of the ActiveRecord::Base#import functionality from ar-extensions
+  for Rails 3 and beyond
+email: zach.dennis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- README.markdown
+- Rakefile
+- VERSION
+- lib/activerecord-import.rb
+- lib/activerecord-import/active_record/adapters/abstract_adapter.rb
+- lib/activerecord-import/active_record/adapters/jdbcmysql_adapter.rb
+- lib/activerecord-import/active_record/adapters/mysql2_adapter.rb
+- lib/activerecord-import/active_record/adapters/mysql_adapter.rb
+- lib/activerecord-import/active_record/adapters/postgresql_adapter.rb
+- lib/activerecord-import/active_record/adapters/sqlanywhere_adapter.rb
+- lib/activerecord-import/active_record/adapters/sqlanywhere_jdbc_in4systems_adapter.rb
+- lib/activerecord-import/active_record/adapters/seamless_database_pool_adapter.rb
+- lib/activerecord-import/active_record/adapters/sqlite3_adapter.rb
+- lib/activerecord-import/adapters/abstract_adapter.rb
+- lib/activerecord-import/adapters/mysql_adapter.rb
+- lib/activerecord-import/adapters/postgresql_adapter.rb
+- lib/activerecord-import/adapters/sqlanywhere_adapter.rb
+- lib/activerecord-import/adapters/sqlanywhere_jdbc_in4systems_adapter.rb
+- lib/activerecord-import/adapters/sqlite3_adapter.rb
+- lib/activerecord-import/base.rb
+- lib/activerecord-import/import.rb
+- lib/activerecord-import/mysql.rb
+- lib/activerecord-import/mysql2.rb
+- lib/activerecord-import/postgresql.rb
+- lib/activerecord-import/sqlanywhere.rb
+- lib/activerecord-import/sqlanywhere_jdbc_in4systems.rb
+- lib/activerecord-import/sqlite3.rb
+- lib/activerecord-import/synchronize.rb
+homepage: http://github.com/zdennis/activerecord-import
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Bulk-loading extension for ActiveRecord
+test_files: []