Class: ActiveRecord::Base

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

Overview

:nodoc:

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.bulk_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_models
Model.import array_of_hash_objects
Model.import column_names, array_of_hash_objects
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. It skips the uniqueness validation for performance reasons. You can find more details here: github.com/zdennis/activerecord-import/issues/228

  • ignore - true|false, an alias for on_duplicate_key_ignore.

  • on_duplicate_key_ignore - true|false, tells import to discard records that contain duplicate keys. For Postgres 9.5+ it adds ON CONFLICT DO NOTHING, for MySQL it uses INSERT IGNORE, and for SQLite it uses INSERT OR IGNORE. Cannot be enabled on a recursive import. For database adapters that normally support setting primary keys on imported objects, this option prevents that from occurring.

  • on_duplicate_key_update - :all, an Array, or Hash, tells import to use MySQL's ON DUPLICATE KEY UPDATE or Postgres/SQLite ON CONFLICT DO 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

  • recursive - true|false, tells import to import all has_many/has_one associations if the adapter supports setting the primary keys of the newly imported objects. PostgreSQL only.

  • batch_size - an integer value to specify the max number of records to include per insert. Defaults to the total number of records to import.

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 array_of_hash_objects
# NOTE: column_names will be determined by using the keys of the first hash in the array. If later hashes in the
# array have different keys an exception will be raised. If you have hashes to import with different sets of keys
# we recommend grouping these into batches before importing.
values = [ {author_name: 'zdennis', title: 'test post'} ], [ {author_name: 'jdoe', title: 'another test post'} ] ]
BlogPost.import values

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

# 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.where(author_name: 'zdennis').first
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, synchronize_keys: [:title]
puts posts.first.persisted? # => true

On Duplicate Key Update (MySQL)

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

Using :all

The :on_duplicate_key_update option can be set to :all. All columns other than the primary key are updated. If a list of column names is supplied, only those columns will be updated. Below is an example:

BlogPost.import columns, values, on_duplicate_key_update: :all

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 names 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 }

On Duplicate Key Update (Postgres 9.5+ and SQLite 3.24+)

The :on_duplicate_key_update option can be :all, an Array, or a Hash with up to three attributes, :conflict_target (and optionally :index_predicate) or :constraint_name (Postgres), and :columns.

Using :all

The :on_duplicate_key_update option can be set to :all. All columns other than the primary key are updated. If a list of column names is supplied, only those columns will be updated. Below is an example:

BlogPost.import columns, values, on_duplicate_key_update: :all

Using an Array

The :on_duplicate_key_update option can be an array of column names. This option only handles inserts that conflict with the primary key. If a table does not have a primary key, this will not work. 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 with up to three attributes, :conflict_target (and optionally :index_predicate) or :constraint_name, and :columns. Unlike MySQL, Postgres requires the conflicting constraint to be explicitly specified. Using this option allows you to specify a constraint other than the primary key.

:conflict_target

The :conflict_target attribute specifies the columns that make up the conflicting unique constraint and can be a single column or an array of column names. This attribute is ignored if :constraint_name is included, but it is the preferred method of identifying a constraint. It will default to the primary key. Below is an example:

BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: [ :author_id, :slug ], columns: [ :date_modified ] }
:index_predicate

The :index_predicate attribute optionally specifies a WHERE condition on :conflict_target, which is required for matching against partial indexes. This attribute is ignored if :constraint_name is included. Below is an example:

BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: [ :author_id, :slug ], index_predicate: 'status <> 0', columns: [ :date_modified ] }
:constraint_name

The :constraint_name attribute explicitly identifies the conflicting unique index by name. Postgres documentation discourages using this method of identifying an index unless absolutely necessary. Below is an example:

BlogPost.import columns, values, on_duplicate_key_update: { constraint_name: :blog_posts_pkey, columns: [ :date_modified ] }
:condition

The :condition attribute optionally specifies a WHERE condition on :conflict_action. Only rows for which this expression returns true will be updated. Note that it's evaluated last, after a conflict has been identified as a candidate to update. Below is an example:

BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: [ :author_id ], condition: "blog_posts.title NOT LIKE '%sample%'", columns: [ :author_name ] }
:columns

The :columns attribute can be either :all, an Array, or a Hash.

Using :all

The :columns attribute can be :all. All columns other than the primary key will be updated. If a list of column names is supplied, only those columns will be updated. Below is an example:

BlogPost.import columns, values, on_duplicate_key_update: { conflict_target: :slug, columns: :all }
Using an Array

The :columns attribute 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: { conflict_target: :slug, columns: [ :date_modified, :content, :author ] }
Using a Hash

The :columns option can be a hash of column names 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: { conflict_target: :slug, columns: { 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

  • ids - the primary keys of the imported ids if the adapter supports it, otherwise an empty array.

  • results - import results if the adapter supports it, otherwise an empty array.


523
524
525
526
527
528
529
530
531
532
533
# File 'lib/activerecord-import/import.rb', line 523

def bulk_import(*args)
  if args.first.is_a?( Array ) && args.first.first.is_a?(ActiveRecord::Base)
    options = {}
    options.merge!( args.pop ) if args.last.is_a?(Hash)

    models = args.first
    import_helper(models, options)
  else
    import_helper(*args)
  end
end

.bulk_import!(*args) ⇒ Object

Imports a collection of values if all values are valid. Import fails at the first encountered validation error and raises ActiveRecord::RecordInvalid with the failed instance.


539
540
541
542
543
544
545
# File 'lib/activerecord-import/import.rb', line 539

def bulk_import!(*args)
  options = args.last.is_a?( Hash ) ? args.pop : {}
  options[:validate] = true
  options[:raise_error] = true

  bulk_import(*args, options)
end

.establish_connection_with_activerecord_import(*args) ⇒ Object Also known as: establish_connection


250
251
252
253
254
# File 'lib/activerecord-import/import.rb', line 250

def establish_connection_with_activerecord_import(*args)
  conn = establish_connection_without_activerecord_import(*args)
  ActiveRecord::Import.load_from_connection_pool connection_pool
  conn
end

.import_helper(*args) ⇒ Object


548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
# File 'lib/activerecord-import/import.rb', line 548

def import_helper( *args )
  options = { validate: true, timestamps: true }
  options.merge!( args.pop ) if args.last.is_a? Hash
  # making sure that current model's primary key is used
  options[:primary_key] = primary_key
  options[:locking_column] = locking_column if attribute_names.include?(locking_column)

  is_validating = options[:validate_with_context].present? ? true : options[:validate]
  validator = ActiveRecord::Import::Validator.new(self, options)

  # assume array of model objects
  if args.last.is_a?( Array ) && args.last.first.is_a?(ActiveRecord::Base)
    if args.length == 2
      models = args.last
      column_names = args.first.dup
    else
      models = args.first
      column_names = if connection.respond_to?(:supports_virtual_columns?) && connection.supports_virtual_columns?
        columns.reject(&:virtual?).map(&:name)
      else
        self.column_names.dup
      end
    end

    if models.first.id.nil?
      Array(primary_key).each do |c|
        if column_names.include?(c) && columns_hash[c].type == :uuid
          column_names.delete(c)
        end
      end
    end

    update_attrs = if record_timestamps && options[:timestamps]
      if respond_to?(:timestamp_attributes_for_update, true)
        send(:timestamp_attributes_for_update).map(&:to_sym)
      else
        new.send(:timestamp_attributes_for_update_in_model)
      end
    end

    array_of_attributes = []

    models.each do |model|
      if supports_setting_primary_key_of_imported_objects?
        load_association_ids(model)
      end

      if is_validating && !validator.valid_model?(model)
        raise(ActiveRecord::RecordInvalid, model) if options[:raise_error]
        next
      end

      array_of_attributes << column_names.map do |name|
        if model.persisted? &&
           update_attrs && update_attrs.include?(name.to_sym) &&
           !model.send("#{name}_changed?")
          nil
        else
          model.read_attribute(name.to_s)
        end
      end
    end
    # supports array of hash objects
  elsif args.last.is_a?( Array ) && args.last.first.is_a?(Hash)
    if args.length == 2
      array_of_hashes = args.last
      column_names = args.first.dup
      allow_extra_hash_keys = true
    else
      array_of_hashes = args.first
      column_names = array_of_hashes.first.keys
      allow_extra_hash_keys = false
    end

    array_of_attributes = array_of_hashes.map do |h|
      error_message = validate_hash_import(h, column_names, allow_extra_hash_keys)

      raise ArgumentError, error_message if error_message

      column_names.map do |key|
        h[key]
      end
    end
    # supports empty array
  elsif args.last.is_a?( Array ) && args.last.empty?
    return ActiveRecord::Import::Result.new([], 0, [])
    # supports 2-element array and array
  elsif args.size == 2 && args.first.is_a?( Array ) && args.last.is_a?( Array )

    unless args.last.first.is_a?(Array)
      raise ArgumentError, "Last argument should be a two dimensional array '[[]]'. First element in array was a #{args.last.first.class}"
    end

    column_names, array_of_attributes = args

    # dup the passed args so we don't modify unintentionally
    column_names = column_names.dup
    array_of_attributes = array_of_attributes.map(&:dup)
  else
    raise ArgumentError, "Invalid arguments!"
  end

  # 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
  symbolized_column_names = Array(column_names).map(&:to_sym)
  symbolized_primary_key = Array(primary_key).map(&:to_sym)

  if !symbolized_primary_key.to_set.subset?(symbolized_column_names.to_set) && connection.prefetch_primary_key? && sequence_name
    column_count = column_names.size
    column_names.concat(Array(primary_key)).uniq!
    columns_added = column_names.size - column_count
    new_fields = Array.new(columns_added)
    array_of_attributes.each { |a| a.concat(new_fields) }
  end

  # Don't modify incoming arguments
  on_duplicate_key_update = options[:on_duplicate_key_update]
  if on_duplicate_key_update
    updatable_columns = symbolized_column_names.reject { |c| symbolized_primary_key.include? c }
    options[:on_duplicate_key_update] = if on_duplicate_key_update.is_a?(Hash)
      on_duplicate_key_update.each_with_object({}) do |(k, v), duped_options|
        duped_options[k] = if k == :columns && v == :all
          updatable_columns
        elsif v.duplicable?
          v.dup
        else
          v
        end
      end
    elsif on_duplicate_key_update == :all
      updatable_columns
    elsif on_duplicate_key_update.duplicable?
      on_duplicate_key_update.dup
    else
      on_duplicate_key_update
    end
  end

  timestamps = {}

  # record timestamps unless disabled in ActiveRecord::Base
  if record_timestamps && options[:timestamps]
    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 ) do |failed_instances|
      if models
        models.each { |m| failed_instances << m if m.errors.any? }
      else
        # 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|
          model = new
          hsh.each_pair { |k, v| model[k] = v }
          next if validator.valid_model?(model)
          raise(ActiveRecord::RecordInvalid, model) if options[:raise_error]
          array_of_attributes[i] = nil
          failure = model.dup
          failure.errors.send(:initialize_dup, model.errors)
          failed_instances << failure
        end
        array_of_attributes.compact!
      end
    end
  else
    import_without_validations_or_callbacks( column_names, array_of_attributes, options )
  end

  if options[:synchronize]
    sync_keys = options[:synchronize_keys] || Array(primary_key)
    synchronize( options[:synchronize], sync_keys)
  end
  return_obj.num_inserts = 0 if return_obj.num_inserts.nil?

  # if we have ids, then set the id on the models and mark the models as clean.
  if models && supports_setting_primary_key_of_imported_objects?
    set_attributes_and_mark_clean(models, return_obj, timestamps, options)

    # if there are auto-save associations on the models we imported that are new, import them as well
    import_associations(models, options.dup) if options[:recursive]
  end

  return_obj
end

.import_with_validations(column_names, array_of_attributes, options = {}) {|failed_instances| ... } ⇒ 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.

Yields:

  • (failed_instances)

745
746
747
748
749
750
751
752
753
754
755
756
# File 'lib/activerecord-import/import.rb', line 745

def import_with_validations( column_names, array_of_attributes, options = {} )
  failed_instances = []

  yield failed_instances if block_given?

  result = if options[:all_or_none] && failed_instances.any?
    ActiveRecord::Import::Result.new([], 0, [], [])
  else
    import_without_validations_or_callbacks( column_names, array_of_attributes, options )
  end
  ActiveRecord::Import::Result.new(failed_instances, result.num_inserts, result.ids, result.results)
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.


764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
# File 'lib/activerecord-import/import.rb', line 764

def import_without_validations_or_callbacks( column_names, array_of_attributes, options = {} )
  return ActiveRecord::Import::Result.new([], 0, [], []) if array_of_attributes.empty?

  column_names = column_names.map(&:to_sym)
  scope_columns, scope_values = scope_attributes.to_a.transpose

  unless scope_columns.blank?
    scope_columns.zip(scope_values).each do |name, value|
      name_as_sym = name.to_sym
      next if column_names.include?(name_as_sym)

      is_sti = (name_as_sym == inheritance_column.to_sym && self < base_class)
      value = Array(value).first if is_sti

      column_names << name_as_sym
      array_of_attributes.each { |attrs| attrs << value }
    end
  end

  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(',')})"
  pre_sql_statements = connection.pre_sql_statements( options )
  insert_sql = ['INSERT', pre_sql_statements, "INTO #{quoted_table_name} #{columns_sql} VALUES "]
  insert_sql = insert_sql.flatten.join(' ')
  values_sql = values_sql_for_columns_and_attributes(columns, array_of_attributes)

  number_inserted = 0
  ids = []
  results = []
  if supports_import?
    # generate the sql
    post_sql_statements = connection.post_sql_statements( quoted_table_name, options )

    batch_size = options[:batch_size] || values_sql.size
    values_sql.each_slice(batch_size) do |batch_values|
      # perform the inserts
      result = connection.insert_many( [insert_sql, post_sql_statements].flatten,
        batch_values,
        options,
        "#{model_name} Create Many Without Validations Or Callbacks" )
      number_inserted += result.num_inserts
      ids += result.ids
      results += result.results
    end
  else
    transaction(requires_new: true) do
      values_sql.each do |values|
        ids << connection.insert(insert_sql + values)
        number_inserted += 1
      end
    end
  end
  ActiveRecord::Import::Result.new([], number_inserted, ids, results)
end

.supports_import?(*args) ⇒ Boolean

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

Returns:

  • (Boolean)

261
262
263
# File 'lib/activerecord-import/import.rb', line 261

def supports_import?(*args)
  connection.respond_to?(:supports_import?) && connection.supports_import?(*args)
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)

268
269
270
# File 'lib/activerecord-import/import.rb', line 268

def supports_on_duplicate_key_update?
  connection.respond_to?(:supports_on_duplicate_key_update?) && connection.supports_on_duplicate_key_update?
end

.supports_setting_primary_key_of_imported_objects?Boolean

returns true if the current database connection adapter supports setting the primary key of bulk imported models, otherwise returns false

Returns:

  • (Boolean)

275
276
277
# File 'lib/activerecord-import/import.rb', line 275

def supports_setting_primary_key_of_imported_objects?
  connection.respond_to?(:supports_setting_primary_key_of_imported_objects?) && connection.supports_setting_primary_key_of_imported_objects?
end

.synchronize(instances, keys = [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.where(author: “Zach”).first <.. 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.where(author: “Zach”).first <.. 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


23
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
49
50
51
52
53
54
55
56
57
58
59
# File 'lib/activerecord-import/synchronize.rb', line 23

def self.synchronize(instances, keys = [primary_key])
  return if instances.empty?

  conditions = {}

  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.unscoped.where(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

    next unless matched_instance

    instance.send :clear_association_cache
    instance.send :clear_aggregation_cache if instance.respond_to?(:clear_aggregation_cache, true)
    instance.instance_variable_set :@attributes, matched_instance.instance_variable_get(:@attributes)

    if instance.respond_to?(:clear_changes_information)
      instance.clear_changes_information                      # Rails 4.2 and higher
    else
      instance.instance_variable_set :@attributes_cache, {}   # Rails 4.0, 4.1
      instance.changed_attributes.clear                       # Rails 3.2
      instance.previous_changes.clear
    end

    # Since the instance now accurately reflects the record in
    # the database, ensure that instance.persisted? is true.
    instance.instance_variable_set '@new_record', false
    instance.instance_variable_set '@destroyed', false
  end
end

Instance Method Details

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

See ActiveRecord::ConnectionAdapters::AbstractAdapter.synchronize


62
63
64
# File 'lib/activerecord-import/synchronize.rb', line 62

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