Class: ActiveRecord::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/activerecord-import/synchronize.rb,
lib/activerecord-import/import.rb,
lib/activerecord-import.rb

Overview

:nodoc:

Constant Summary collapse

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

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.establish_connection_with_activerecord_import(*args) ⇒ Object 



3
4
5
6
 
# File 'lib/activerecord-import.rb', line 3

def establish_connection_with_activerecord_import(*args)
  establish_connection_without_activerecord_import(*args)
  ActiveSupport.run_load_hooks(:active_record_connection_established, connection_pool)
end

.import(*args) ⇒ Object

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



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/activerecord-import/import.rb', line 162

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

.import_from_table(options) ⇒ Object

TODO import_from_table needs to be implemented.



229
230
 
# File 'lib/activerecord-import/import.rb', line 229

def import_from_table( options ) # :nodoc:
end

.import_with_validations(column_names, array_of_attributes, options = {}) ⇒ Object

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.



239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/activerecord-import/import.rb', line 239

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 = array_of_attributes.empty? ? 0 : import_without_validations_or_callbacks( column_names, array_of_attributes, options )
  ActiveRecord::Import::Result.new(failed_instances, num_inserts)
end

.import_without_validations_or_callbacks(column_names, array_of_attributes, options = {}) ⇒ Object

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.



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
 
# File 'lib/activerecord-import/import.rb', line 268

def import_without_validations_or_callbacks( column_names, array_of_attributes, options={} )
  columns = column_names.map { |name| columns_hash[name.to_s] }

  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

.supports_import? ⇒ Boolean

Returns true if the current database connection adapter supports import functionality, otherwise returns false.

Returns:

  • (Boolean) 


40
41
42
43
44
 
# File 'lib/activerecord-import/import.rb', line 40

def supports_import?
  connection.supports_import?
rescue NoMethodError
  false
end

.supports_on_duplicate_key_update? ⇒ Boolean

Returns true if the current database connection adapter supports on duplicate key update functionality, otherwise returns false.

Returns:

  • (Boolean) 


49
50
51
52
53
 
# File 'lib/activerecord-import/import.rb', line 49

def supports_on_duplicate_key_update?
  connection.supports_on_duplicate_key_update?
rescue NoMethodError
  false
end

.synchronize(instances, keys = [self.primary_key]) ⇒ Object

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



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/activerecord-import/synchronize.rb', line 24

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

Instance Method Details

#synchronize(instances, key = [ActiveRecord::Base.primary_key]) ⇒ Object

See ActiveRecord::ConnectionAdapters::AbstractAdapter.synchronize



51
52
53
 
# File 'lib/activerecord-import/synchronize.rb', line 51

def synchronize(instances, key=[ActiveRecord::Base.primary_key])
  self.class.synchronize(instances, key)
end