ibm_db 5.2.0 → 5.3.2

data/test/cases/insert_all_test.rb

@@ -0,0 +1,489 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/author"
+require "models/book"
+require "models/cart"
+require "models/speedometer"
+require "models/subscription"
+require "models/subscriber"
+
+class ReadonlyNameBook < Book
+  attr_readonly :name
+end
+
+class InsertAllTest < ActiveRecord::TestCase
+  fixtures :books
+
+  def setup
+    Arel::Table.engine = nil # should not rely on the global Arel::Table.engine
+  end
+
+  def teardown
+    Arel::Table.engine = ActiveRecord::Base
+  end
+
+  def test_insert
+    skip unless supports_insert_on_duplicate_skip?
+
+    id = 1_000_000
+
+    assert_difference "Book.count", +1 do
+      Book.insert({ id: id, name: "Rework", author_id: 1 })
+    end
+
+    Book.upsert({ id: id, name: "Remote", author_id: 1 })
+
+    assert_equal "Remote", Book.find(id).name
+  end
+
+  def test_insert!
+    assert_difference "Book.count", +1 do
+      Book.insert!({ name: "Rework", author_id: 1 })
+    end
+  end
+
+  def test_insert_all
+    assert_difference "Book.count", +10 do
+      Book.insert_all! [
+        { name: "Rework", author_id: 1 },
+        { name: "Patterns of Enterprise Application Architecture", author_id: 1 },
+        { name: "Design of Everyday Things", author_id: 1 },
+        { name: "Practical Object-Oriented Design in Ruby", author_id: 1 },
+        { name: "Clean Code", author_id: 1 },
+        { name: "Ruby Under a Microscope", author_id: 1 },
+        { name: "The Principles of Product Development Flow", author_id: 1 },
+        { name: "Peopleware", author_id: 1 },
+        { name: "About Face", author_id: 1 },
+        { name: "Eloquent Ruby", author_id: 1 },
+      ]
+    end
+  end
+
+  def test_insert_all_should_handle_empty_arrays
+    assert_raise ArgumentError do
+      Book.insert_all! []
+    end
+  end
+
+  def test_insert_all_raises_on_duplicate_records
+    assert_raise ActiveRecord::RecordNotUnique do
+      Book.insert_all! [
+        { name: "Rework", author_id: 1 },
+        { name: "Patterns of Enterprise Application Architecture", author_id: 1 },
+        { name: "Agile Web Development with Rails", author_id: 1 },
+      ]
+    end
+  end
+
+  def test_insert_all_returns_ActiveRecord_Result
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }]
+    assert_kind_of ActiveRecord::Result, result
+  end
+
+  def test_insert_all_returns_primary_key_if_returning_is_supported
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }]
+    assert_equal %w[ id ], result.columns
+  end
+
+  def test_insert_all_returns_nothing_if_returning_is_empty
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: []
+    assert_equal [], result.columns
+  end
+
+  def test_insert_all_returns_nothing_if_returning_is_false
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: false
+    assert_equal [], result.columns
+  end
+
+  def test_insert_all_returns_requested_fields
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: [:id, :name]
+    assert_equal %w[ Rework ], result.pluck("name")
+  end
+
+  def test_insert_all_can_skip_duplicate_records
+    skip unless supports_insert_on_duplicate_skip?
+
+    assert_no_difference "Book.count" do
+      Book.insert_all [{ id: 1, name: "Agile Web Development with Rails" }]
+    end
+  end
+
+  def test_insert_all_with_skip_duplicates_and_autonumber_id_not_given
+    skip unless supports_insert_on_duplicate_skip?
+
+    assert_difference "Book.count", 1 do
+      # These two books are duplicates according to an index on %i[author_id name]
+      # but their IDs are not specified so they will be assigned different IDs
+      # by autonumber. We will get an exception from MySQL if we attempt to skip
+      # one of these records by assigning its ID.
+      Book.insert_all [
+        { author_id: 8, name: "Refactoring" },
+        { author_id: 8, name: "Refactoring" }
+      ]
+    end
+  end
+
+  def test_insert_all_with_skip_duplicates_and_autonumber_id_given
+    skip unless supports_insert_on_duplicate_skip?
+
+    assert_difference "Book.count", 1 do
+      Book.insert_all [
+        { id: 200, author_id: 8, name: "Refactoring" },
+        { id: 201, author_id: 8, name: "Refactoring" }
+      ]
+    end
+  end
+
+  def test_skip_duplicates_strategy_does_not_secretly_upsert
+    skip unless supports_insert_on_duplicate_skip?
+
+    book = Book.create!(author_id: 8, name: "Refactoring", format: "EXPECTED")
+
+    assert_no_difference "Book.count" do
+      Book.insert({ author_id: 8, name: "Refactoring", format: "UNEXPECTED" })
+    end
+
+    assert_equal "EXPECTED", book.reload.format
+  end
+
+  def test_insert_all_will_raise_if_duplicates_are_skipped_only_for_a_certain_conflict_target
+    skip unless supports_insert_on_duplicate_skip? && supports_insert_conflict_target?
+
+    assert_raise ActiveRecord::RecordNotUnique do
+      Book.insert_all [{ id: 1, name: "Agile Web Development with Rails" }],
+        unique_by: :index_books_on_author_id_and_name
+    end
+  end
+
+  def test_insert_all_and_upsert_all_with_index_finding_options
+    skip unless supports_insert_conflict_target?
+
+    assert_difference "Book.count", +4 do
+      Book.insert_all [{ name: "Rework", author_id: 1 }], unique_by: :isbn
+      Book.insert_all [{ name: "Remote", author_id: 1 }], unique_by: %i( author_id name )
+      Book.insert_all [{ name: "Renote", author_id: 1 }], unique_by: :index_books_on_isbn
+      Book.insert_all [{ name: "Recoat", author_id: 1 }], unique_by: :id
+    end
+
+    assert_raise ActiveRecord::RecordNotUnique do
+      Book.upsert_all [{ name: "Rework", author_id: 1 }], unique_by: :isbn
+    end
+  end
+
+  def test_insert_all_and_upsert_all_with_expression_index
+    skip unless supports_expression_index? && supports_insert_conflict_target?
+
+    book = Book.create!(external_id: "abc")
+
+    assert_no_difference "Book.count" do
+      Book.insert_all [{ external_id: "ABC" }], unique_by: :index_books_on_lower_external_id
+    end
+
+    Book.upsert_all [{ external_id: "Abc" }], unique_by: :index_books_on_lower_external_id
+
+    assert_equal "Abc", book.reload.external_id
+  end
+
+  def test_insert_all_and_upsert_all_raises_when_index_is_missing
+    skip unless supports_insert_conflict_target?
+
+    [ :cats, %i( author_id isbn ), :author_id ].each do |missing_or_non_unique_by|
+      error = assert_raises ArgumentError do
+        Book.insert_all [{ name: "Rework", author_id: 1 }], unique_by: missing_or_non_unique_by
+      end
+      assert_match "No unique index", error.message
+
+      error = assert_raises ArgumentError do
+        Book.upsert_all [{ name: "Rework", author_id: 1 }], unique_by: missing_or_non_unique_by
+      end
+      assert_match "No unique index", error.message
+    end
+  end
+
+  def test_insert_all_and_upsert_all_works_with_composite_primary_keys_when_unique_by_is_provided
+    skip unless supports_insert_conflict_target?
+
+    assert_difference "Cart.count", 2 do
+      Cart.insert_all [{ id: 1, shop_id: 1, title: "My cart" }], unique_by: [:shop_id, :id]
+
+      Cart.upsert_all [{ id: 3, shop_id: 2, title: "My other cart" }], unique_by: [:shop_id, :id]
+    end
+
+    error = assert_raises ArgumentError do
+      Cart.insert_all! [{ id: 2, shop_id: 1, title: "My cart" }]
+    end
+    assert_match "No unique index found for id", error.message
+  end
+
+  def test_insert_all_and_upsert_all_works_with_composite_primary_keys_when_unique_by_is_not_provided
+    skip unless supports_insert_on_duplicate_skip? && !supports_insert_conflict_target?
+
+    assert_difference "Cart.count", 3 do
+      Cart.insert_all [{ id: 1, shop_id: 1, title: "My cart" }]
+
+      Cart.insert_all! [{ id: 2, shop_id: 1, title: "My cart 2" }]
+
+      Cart.upsert_all [{ id: 3, shop_id: 2, title: "My other cart" }]
+    end
+  end
+
+  def test_insert_logs_message_including_model_name
+    skip unless supports_insert_conflict_target?
+
+    capture_log_output do |output|
+      Book.insert({ name: "Rework", author_id: 1 })
+      assert_match "Book Insert", output.string
+    end
+  end
+
+  def test_insert_all_logs_message_including_model_name
+    skip unless supports_insert_conflict_target?
+
+    capture_log_output do |output|
+      Book.insert_all [{ name: "Remote", author_id: 1 }, { name: "Renote", author_id: 1 }]
+      assert_match "Book Bulk Insert", output.string
+    end
+  end
+
+  def test_upsert_logs_message_including_model_name
+    skip unless supports_insert_on_duplicate_update?
+
+    capture_log_output do |output|
+      Book.upsert({ name: "Remote", author_id: 1 })
+      assert_match "Book Upsert", output.string
+    end
+  end
+
+  def test_upsert_all_logs_message_including_model_name
+    skip unless supports_insert_on_duplicate_update?
+
+    capture_log_output do |output|
+      Book.upsert_all [{ name: "Remote", author_id: 1 }, { name: "Renote", author_id: 1 }]
+      assert_match "Book Bulk Upsert", output.string
+    end
+  end
+
+  def test_upsert_all_updates_existing_records
+    skip unless supports_insert_on_duplicate_update?
+
+    new_name = "Agile Web Development with Rails, 4th Edition"
+    Book.upsert_all [{ id: 1, name: new_name }]
+    assert_equal new_name, Book.find(1).name
+  end
+
+  def test_upsert_all_updates_existing_record_by_primary_key
+    skip unless supports_insert_conflict_target?
+
+    Book.upsert_all [{ id: 1, name: "New edition" }], unique_by: :id
+
+    assert_equal "New edition", Book.find(1).name
+  end
+
+  def test_upsert_all_does_notupdates_existing_record_by_when_there_is_no_key
+    skip unless supports_insert_on_duplicate_update? && !supports_insert_conflict_target?
+
+    Speedometer.create!(speedometer_id: "s3", name: "Very fast")
+
+    Speedometer.upsert_all [{ speedometer_id: "s3", name: "New Speedometer" }]
+
+    assert_equal "Very fast", Speedometer.find("s3").name
+  end
+
+  def test_upsert_all_updates_existing_record_by_configured_primary_key_fails_when_database_supports_insert_conflict_target
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target?
+
+    error = assert_raises ArgumentError do
+      Speedometer.upsert_all [{ speedometer_id: "s1", name: "New Speedometer" }]
+    end
+    assert_match "No unique index found for speedometer_id", error.message
+  end
+
+  def test_upsert_all_does_not_update_readonly_attributes
+    skip unless supports_insert_on_duplicate_update?
+
+    new_name = "Agile Web Development with Rails, 4th Edition"
+    ReadonlyNameBook.upsert_all [{ id: 1, name: new_name }]
+    assert_not_equal new_name, Book.find(1).name
+  end
+
+  def test_upsert_all_does_not_update_primary_keys
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target?
+
+    Book.upsert_all [{ id: 101, name: "Perelandra", author_id: 7 }]
+    Book.upsert_all [{ id: 103, name: "Perelandra", author_id: 7, isbn: "1974522598" }],
+      unique_by: :index_books_on_author_id_and_name
+
+    book = Book.find_by(name: "Perelandra")
+    assert_equal 101, book.id, "Should not have updated the ID"
+    assert_equal "1974522598", book.isbn, "Should have updated the isbn"
+  end
+
+  def test_upsert_all_does_not_perform_an_upsert_if_a_partial_index_doesnt_apply
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target? && supports_partial_index?
+
+    Book.upsert_all [{ name: "Out of the Silent Planet", author_id: 7, isbn: "1974522598", published_on: Date.new(1938, 4, 1) }]
+    Book.upsert_all [{ name: "Perelandra", author_id: 7, isbn: "1974522598" }],
+      unique_by: :index_books_on_isbn
+
+    assert_equal ["Out of the Silent Planet", "Perelandra"], Book.where(isbn: "1974522598").order(:name).pluck(:name)
+  end
+
+  def test_upsert_all_does_not_touch_updated_at_when_values_do_not_change
+    skip unless supports_insert_on_duplicate_update?
+
+    updated_at = Time.now.utc - 5.years
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_at: updated_at }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1) }]
+
+    assert_in_delta updated_at, Book.find(101).updated_at, 1
+  end
+
+  def test_upsert_all_touches_updated_at_and_updated_on_when_values_change
+    skip unless supports_insert_on_duplicate_update?
+
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_at: 5.years.ago, updated_on: 5.years.ago }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 8) }]
+
+    assert_equal Time.now.year, Book.find(101).updated_at.year
+    assert_equal Time.now.year, Book.find(101).updated_on.year
+  end
+
+  def test_upsert_all_uses_given_updated_at_over_implicit_updated_at
+    skip unless supports_insert_on_duplicate_update?
+
+    updated_at = Time.now.utc - 1.year
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_at: 5.years.ago }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 8), updated_at: updated_at }]
+
+    assert_in_delta updated_at, Book.find(101).updated_at, 1
+  end
+
+  def test_upsert_all_uses_given_updated_on_over_implicit_updated_on
+    skip unless supports_insert_on_duplicate_update?
+
+    updated_on = Time.now.utc.to_date - 30
+    Book.insert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 1), updated_on: 5.years.ago }]
+    Book.upsert_all [{ id: 101, name: "Out of the Silent Planet", published_on: Date.new(1938, 4, 8), updated_on: updated_on }]
+
+    assert_equal updated_on, Book.find(101).updated_on
+  end
+
+  def test_insert_all_raises_on_unknown_attribute
+    assert_raise ActiveRecord::UnknownAttributeError do
+      Book.insert_all! [{ unknown_attribute: "Test" }]
+    end
+  end
+
+  def test_upsert_all_works_with_partitioned_indexes
+    skip unless supports_insert_on_duplicate_update? && supports_insert_conflict_target? && supports_partitioned_indexes?
+
+    require "models/measurement"
+
+    Measurement.upsert_all([{ city_id: "1", logdate: 1.days.ago, peaktemp: 1, unitsales: 1 },
+                            { city_id: "2", logdate: 2.days.ago, peaktemp: 2, unitsales: 2 },
+                            { city_id: "2", logdate: 3.days.ago, peaktemp: 0, unitsales: 0 }],
+                            unique_by: %i[logdate city_id])
+    assert_equal [[1.day.ago.to_date, 1, 1]],
+                 Measurement.where(city_id: 1).pluck(:logdate, :peaktemp, :unitsales)
+    assert_equal [[2.days.ago.to_date, 2, 2], [3.days.ago.to_date, 0, 0]],
+                 Measurement.where(city_id: 2).pluck(:logdate, :peaktemp, :unitsales)
+  end
+
+  def test_insert_all_with_enum_values
+    Book.insert_all! [{ status: :published, isbn: "1234566", name: "Rework", author_id: 1 },
+                      { status: :proposed, isbn: "1234567", name: "Remote", author_id: 2 }]
+    assert_equal ["published", "proposed"], Book.where(isbn: ["1234566", "1234567"]).order(:id).pluck(:status)
+  end
+
+  def test_insert_all_on_relation
+    author = Author.create!(name: "Jimmy")
+
+    assert_difference "author.books.count", +1 do
+      author.books.insert_all!([{ name: "My little book", isbn: "1974522598" }])
+    end
+  end
+
+  def test_insert_all_on_relation_precedence
+    author = Author.create!(name: "Jimmy")
+    second_author = Author.create!(name: "Bob")
+
+    assert_difference "author.books.count", +1 do
+      author.books.insert_all!([{ name: "My little book", isbn: "1974522598", author_id: second_author.id }])
+    end
+  end
+
+  def test_insert_all_create_with
+    assert_difference "Book.where(format: 'X').count", +2 do
+      Book.create_with(format: "X").insert_all!([ { name: "A" }, { name: "B" } ])
+    end
+  end
+
+  def test_insert_all_has_many_through
+    book = Book.first
+    assert_raise(ArgumentError) { book.subscribers.insert_all!([ { nick: "Jimmy" } ]) }
+  end
+
+  def test_upsert_all_on_relation
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Jimmy")
+
+    assert_difference "author.books.count", +1 do
+      author.books.upsert_all([{ name: "My little book", isbn: "1974522598" }])
+    end
+  end
+
+  def test_upsert_all_on_relation_precedence
+    skip unless supports_insert_on_duplicate_update?
+
+    author = Author.create!(name: "Jimmy")
+    second_author = Author.create!(name: "Bob")
+
+    assert_difference "author.books.count", +1 do
+      author.books.upsert_all([{ name: "My little book", isbn: "1974522598", author_id: second_author.id }])
+    end
+  end
+
+  def test_upsert_all_create_with
+    skip unless supports_insert_on_duplicate_update?
+
+    assert_difference "Book.where(format: 'X').count", +2 do
+      Book.create_with(format: "X").upsert_all([ { name: "A" }, { name: "B" } ])
+    end
+  end
+
+  def test_upsert_all_has_many_through
+    book = Book.first
+    assert_raise(ArgumentError) { book.subscribers.upsert_all([ { nick: "Jimmy" } ]) }
+  end
+
+  def test_upsert_all_with_unique_by_fails_cleanly_for_adapters_not_supporting_insert_conflict_target
+    skip if supports_insert_conflict_target?
+
+    error = assert_raises ArgumentError do
+      Book.upsert_all [{ name: "Rework", author_id: 1 }], unique_by: :isbn
+    end
+    assert_match "#{ActiveRecord::Base.connection.class} does not support :unique_by", error.message
+  end
+
+  private
+    def capture_log_output
+      output = StringIO.new
+      old_logger, ActiveRecord::Base.logger = ActiveRecord::Base.logger, ActiveSupport::Logger.new(output)
+
+      begin
+        yield output
+      ensure
+        ActiveRecord::Base.logger = old_logger
+      end
+    end
+end

data/test/cases/instrumentation_test.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/book"
+
+module ActiveRecord
+  class InstrumentationTest < ActiveRecord::TestCase
+    def setup
+      ActiveRecord::Base.connection.schema_cache.add(Book.table_name)
+    end
+
+    def test_payload_name_on_load
+      Book.create(name: "test book")
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        if event.payload[:sql].match "SELECT"
+          assert_equal "Book Load", event.payload[:name]
+        end
+      end
+      Book.first
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_name_on_create
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        if event.payload[:sql].match "INSERT"
+          assert_equal "Book Create", event.payload[:name]
+        end
+      end
+      Book.create(name: "test book")
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_name_on_update
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        if event.payload[:sql].match "UPDATE"
+          assert_equal "Book Update", event.payload[:name]
+        end
+      end
+      book = Book.create(name: "test book", format: "paperback")
+      book.update_attribute(:format, "ebook")
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_name_on_update_all
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        if event.payload[:sql].match "UPDATE"
+          assert_equal "Book Update All", event.payload[:name]
+        end
+      end
+      Book.create(name: "test book", format: "paperback")
+      Book.update_all(format: "ebook")
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_name_on_destroy
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        if event.payload[:sql].match "DELETE"
+          assert_equal "Book Destroy", event.payload[:name]
+        end
+      end
+      book = Book.create(name: "test book")
+      book.destroy
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_connection_with_query_cache_disabled
+      connection = Book.connection
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        assert_equal connection, event.payload[:connection]
+      end
+      Book.first
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+
+    def test_payload_connection_with_query_cache_enabled
+      connection = Book.connection
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        assert_equal connection, event.payload[:connection]
+      end
+      Book.cache do
+        Book.first
+        Book.first
+      end
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
+  end
+end