class ActiveRecord::Base

* num_inserts - the number of insert statements it took to import the data
* failed_instances - an array of objects that fails validation and were not committed to the database. An empty array if no validation is performed.
This returns an object which responds to +failed_instances+ and +num_inserts+.
= Returns

BlogPost.import columns, attributes, :on_duplicate_key_update=>{ :title => :title }

model. Below is an example:
control over what fields are updated with what attributes on your
to model attribute name mappings. This gives you finer grained
The :on_duplicate_key_update option can be a hash of column name

==== Using A Hash

BlogPost.import columns, values, :on_duplicate_key_update=>[ :date_modified, :content, :author ]

a duplicate record is found. Below is an example:
names. The column names are the only fields that are updated if
The :on_duplicate_key_update option can be an array of column

==== Using an Array

The :on_duplicate_key_update option can be either an Array or a Hash.

== On Duplicate Key Update (MySQL only)

puts posts.first.new_record? # => false
BlogPost.import posts, :synchronize => posts
posts = [BlogPost.new(:title => "Foo"), BlogPost.new(:title => "Bar")]
# Example synchronizing unsaved/new instances in memory by using a uniqued imported field

puts post.author_name # => 'yoda'
BlogPost.import posts, :synchronize=>[ post ]
values = [ [ 'yoda', 'test post' ] ]
columns = [ :author_name, :title ]
puts post.author_name # => 'zdennis'
post = BlogPost.find_by_author_name( 'zdennis' )
# Example synchronizing existing instances in memory

BlogPost.import( columns, values, :validate => false )
values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
columns = [ :author_name, :title ]
# Example using column_names, array_of_value and options

BlogPost.import columns, values
values = [ [ 'zdennis', 'test post' ], [ 'jdoe', 'another test post' ] ]
columns = [ :author_name, :title ]
# Example using column_names and array_of_values

BlogPost.import posts
BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT3' ]
BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT2',
posts = [ BlogPost.new :author_name=>'Zach Dennis', :title=>'AREXT',
# Example using array of model objects

class BlogPost < ActiveRecord::Base ; end
== Examples

(if false) even if record timestamps is disabled in ActiveRecord::Base
* +timestamps+ - true|false, tells import to not add timestamps \
existing model instances in memory with updates from the import.
that you are currently importing data into. This synchronizes
* +synchronize+ - an array of ActiveRecord instances for the model
Key Update below.
use MySQL's ON DUPLICATE KEY UPDATE ability. See On Duplicate\
* +on_duplicate_key_update+ - an Array or Hash, tells import to \
ActiveRecord validations. Validations are enforced by default.
* +validate+ - true|false, tells import whether or not to use \
== Options

below for what +options+ are available.
parameter, +options+, is a hash. This is optional. Please see
The first two parameters are the same as the above form. The third

==== Model.import column_names, array_of_values, options

the order of the +column_names+.
record. The order of values in each subarray should match up to
arrays. Each subarray is a single set of values for a new
The second parameter, +array_of_values+, is an array of

strings which specify the columns that you want to update.
The first parameter +column_names+ is an array of symbols or

==== Model.import column_names, array_of_values

objects that you want updated.
With this form you can call _import_ passing in an array of model

==== Model.import array_of_models

Model.import column_names, array_of_values, options
Model.import column_names, array_of_values
Model.import array_of_models
== Usage

performing the import.
the ActiveRecord::Callbacks during creation/modification while
This can be used with or without validations. It does not utilize

inserted.
about having ActiveRecord objects returned for each record
you want to create more than one record at a time and do not care
ActiveRecord::Base#save multiple times. This method works well if
This is more efficient than using ActiveRecord::Base#create or

Imports a collection of values to the database.

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