Class: ActiveRecord::Base
- Inherits:
-
Object
- Object
- ActiveRecord::Base
- Defined in:
- lib/activerecord-import/synchronize.rb,
lib/activerecord-import/import.rb
Overview
:nodoc:
Class Method Summary collapse
-
.import(*args) ⇒ Object
Imports a collection of values to the database.
-
.import!(*args) ⇒ Object
Imports a collection of values if all values are valid.
- .import_helper(*args) ⇒ Object
-
.import_with_validations(column_names, array_of_attributes, options = {}) ⇒ Object
Imports the passed in
column_names
andarray_of_attributes
given the passed inoptions
Hash with validations. -
.import_without_validations_or_callbacks(column_names, array_of_attributes, options = {}) ⇒ Object
Imports the passed in
column_names
andarray_of_attributes
given the passed inoptions
Hash. -
.support_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.
-
.supports_import?(*args) ⇒ Boolean
Returns true if the current database connection adapter supports import functionality, otherwise returns false.
-
.supports_on_duplicate_key_update? ⇒ Boolean
Returns true if the current database connection adapter supports on duplicate key update functionality, otherwise returns false.
-
.synchronize(instances, keys = [primary_key]) ⇒ Object
Synchronizes the passed in ActiveRecord instances with data from the database.
Instance Method Summary collapse
-
#synchronize(instances, key = [ActiveRecord::Base.primary_key]) ⇒ Object
See ActiveRecord::ConnectionAdapters::AbstractAdapter.synchronize.
Class Method Details
.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,
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 useActiveRecord validations. Validations are enforced by default.
-
ignore
- true|false, an alias for on_duplicate_key_ignore. -
on_duplicate_key_ignore
- true|false, tells import to discardrecords 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
- an Array or Hash, tells import touse MySQL's ON DUPLICATE KEY UPDATE or Postgres 9.5+ 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
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 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 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+)
The :on_duplicate_key_update option can be an Array or a Hash with up to three attributes, :conflict_target (and optionally :index_predicate) or :constraint_name, and :columns.
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 ] }
:columns
The :columns attribute can be either an Array or a Hash.
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.
378 379 380 381 382 383 384 385 386 387 388 |
# File 'lib/activerecord-import/import.rb', line 378 def import(*args) if args.first.is_a?( Array ) && args.first.first.is_a?(ActiveRecord::Base) = {} .merge!( args.pop ) if args.last.is_a?(Hash) models = args.first import_helper(models, ) else import_helper(*args) end end |
.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.
393 394 395 396 397 398 399 |
# File 'lib/activerecord-import/import.rb', line 393 def import!(*args) = args.last.is_a?( Hash ) ? args.pop : {} [:validate] = true [:raise_error] = true import(*args, ) end |
.import_helper(*args) ⇒ Object
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 |
# File 'lib/activerecord-import/import.rb', line 401 def import_helper( *args ) = { validate: true, timestamps: true } .merge!( args.pop ) if args.last.is_a? Hash # making sure that current model's primary key is used [:primary_key] = primary_key # Don't modify incoming arguments if [:on_duplicate_key_update] && [:on_duplicate_key_update].duplicable? [:on_duplicate_key_update] = [:on_duplicate_key_update].dup end is_validating = [:validate] is_validating = true unless [:validate_with_context].nil? # 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 = self.column_names.dup end if models.first.id.nil? && column_names.include?(primary_key) && columns_hash[primary_key].type == :uuid column_names.delete(primary_key) end stored_attrs = respond_to?(:stored_attributes) ? stored_attributes : {} default_values = column_defaults array_of_attributes = models.map do |model| column_names.map do |name| is_stored_attr = stored_attrs.any? && stored_attrs.key?(name.to_sym) if is_stored_attr || default_values[name].is_a?(Hash) model.read_attribute(name.to_s) else model.read_attribute_before_type_cast(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 else array_of_hashes = args.first column_names = array_of_hashes.first.keys end array_of_attributes = array_of_hashes.map do |h| 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(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 = {} # record timestamps unless disabled in ActiveRecord::Base if && .delete( :timestamps ) = add_special_rails_stamps column_names, array_of_attributes, end return_obj = if is_validating if models import_with_validations( column_names, array_of_attributes, ) do |validator, failed| models.each_with_index do |model, i| model = model.dup if [:recursive] next if validator.valid_model? model raise(ActiveRecord::RecordInvalid, model) if [:raise_error] array_of_attributes[i] = nil failed << model end end else import_with_validations( column_names, array_of_attributes, ) end else (num_inserts, ids) = import_without_validations_or_callbacks( column_names, array_of_attributes, ) ActiveRecord::Import::Result.new([], num_inserts, ids) end if [:synchronize] sync_keys = [:synchronize_keys] || [primary_key] synchronize( [: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 && support_setting_primary_key_of_imported_objects? if [:recursive] || !([:ignore] || [:on_duplicate_key_ignore]) set_attributes_and_mark_clean(models, return_obj, ) end # if there are auto-save associations on the models we imported that are new, import them as well import_associations(models, .dup) if [:recursive] end return_obj 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
.
542 543 544 545 546 547 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 |
# File 'lib/activerecord-import/import.rb', line 542 def import_with_validations( column_names, array_of_attributes, = {} ) failed_instances = [] validator = ActiveRecord::Import::Validator.new() if block_given? yield validator, failed_instances 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 model = new arr.each_with_index do |hsh, i| hsh.each_pair { |k, v| model[k] = v } next if validator.valid_model? model raise(ActiveRecord::RecordInvalid, model) if [:raise_error] array_of_attributes[i] = nil failure = model.dup failure.errors.send(:initialize_dup, model.errors) failed_instances << failure end end array_of_attributes.compact! num_inserts, ids = if array_of_attributes.empty? || [:all_or_none] && failed_instances.any? [0, []] else import_without_validations_or_callbacks( column_names, array_of_attributes, ) end ActiveRecord::Import::Result.new(failed_instances, num_inserts, ids) 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
.
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 |
# File 'lib/activerecord-import/import.rb', line 583 def import_without_validations_or_callbacks( column_names, array_of_attributes, = {} ) 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 = 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( ) 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 = [] if supports_import? # generate the sql post_sql_statements = connection.post_sql_statements( quoted_table_name, ) batch_size = [: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, , "#{self.class.name} Create Many Without Validations Or Callbacks" ) number_inserted += result[0] ids += result[1] end else transaction(requires_new: true) do values_sql.each do |values| ids << connection.insert(insert_sql + values) number_inserted += 1 end end end [number_inserted, ids] end |
.support_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
170 171 172 |
# File 'lib/activerecord-import/import.rb', line 170 def support_setting_primary_key_of_imported_objects? connection.respond_to?(:support_setting_primary_key_of_imported_objects?) && connection.support_setting_primary_key_of_imported_objects? end |
.supports_import?(*args) ⇒ Boolean
Returns true if the current database connection adapter supports import functionality, otherwise returns false.
156 157 158 |
# File 'lib/activerecord-import/import.rb', line 156 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.
163 164 165 |
# File 'lib/activerecord-import/import.rb', line 163 def supports_on_duplicate_key_update? connection.supports_on_duplicate_key_update? 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.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_aggregation_cache instance.send :clear_association_cache 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 |