ibm_db 5.6.1 → 5.7.0

data/test/cases/adapters/abstract_mysql_adapter/table_options_test.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class TableOptionsTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    @connection.drop_table "mysql_table_options", if_exists: true
+  end
+
+  test "table options with ENGINE" do
+    @connection.create_table "mysql_table_options", force: true, options: "ENGINE=MyISAM"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?, options: "ENGINE=MyISAM", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "table options with ROW_FORMAT" do
+    @connection.create_table "mysql_table_options", force: true, options: "ROW_FORMAT=REDUNDANT"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?, options: "ENGINE=InnoDB ROW_FORMAT=REDUNDANT", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "table options with CHARSET" do
+    @connection.create_table "mysql_table_options", force: true, options: "CHARSET=latin1"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "latin1"(?:, collation: "\w+")?, force: :cascade/
+    assert_match expected, output
+  end
+
+  test "table options with COLLATE" do
+    @connection.create_table "mysql_table_options", force: true, options: "COLLATE=utf8mb4_bin"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4", collation: "utf8mb4_bin", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "charset and collation options" do
+    @connection.create_table "mysql_table_options", force: true, charset: "utf8mb4", collation: "utf8mb4_bin"
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4", collation: "utf8mb4_bin"(:?, options: "ENGINE=InnoDB ROW_FORMAT=DYNAMIC")?, force: :cascade/
+    assert_match expected, output
+  end
+
+  test "charset and partitioned table options" do
+    @connection.create_table "mysql_table_options", primary_key: ["id", "account_id"], charset: "utf8mb4", collation: "utf8mb4_bin", options: "ENGINE=InnoDB\n/*!50100 PARTITION BY HASH (`account_id`)\nPARTITIONS 128 */", force: :cascade do |t|
+      t.bigint "id", null: false, auto_increment: true
+      t.bigint "account_id", null: false, unsigned: true
+    end
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", primary_key: \["id", "account_id"\], charset: "utf8mb4", collation: "utf8mb4_bin", options: "ENGINE=InnoDB\\n(\/\*!50100)? PARTITION BY HASH \(`account_id`\)\\nPARTITIONS 128( \*\/)?", force: :cascade/
+    assert_match expected, output
+  end
+
+  test "schema dump works with NO_TABLE_OPTIONS sql mode" do
+    skip "As of MySQL 5.7.22, NO_TABLE_OPTIONS is deprecated. It will be removed in a future version of MySQL." if @connection.database_version >= "5.7.22"
+
+    old_sql_mode = @connection.query_value("SELECT @@SESSION.sql_mode")
+    new_sql_mode = old_sql_mode + ",NO_TABLE_OPTIONS"
+
+    begin
+      @connection.execute("SET @@SESSION.sql_mode='#{new_sql_mode}'")
+
+      @connection.create_table "mysql_table_options", force: true
+      output = dump_table_schema("mysql_table_options")
+      assert_no_match %r{options:}, output
+    ensure
+      @connection.execute("SET @@SESSION.sql_mode='#{old_sql_mode}'")
+    end
+  end
+end
+
+class DefaultEngineOptionTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+  self.use_transactional_tests = false
+
+  def setup
+    @logger_was  = ActiveRecord::Base.logger
+    @log         = StringIO.new
+    @verbose_was = ActiveRecord::Migration.verbose
+    ActiveRecord::Base.logger = ActiveSupport::Logger.new(@log)
+    ActiveRecord::Migration.verbose = false
+  end
+
+  def teardown
+    ActiveRecord::Base.logger       = @logger_was
+    ActiveRecord::Migration.verbose = @verbose_was
+    ActiveRecord::Base.lease_connection.drop_table "mysql_table_options", if_exists: true
+    ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions rescue nil
+  end
+
+  test "new migrations do not contain default ENGINE=InnoDB option" do
+    ActiveRecord::Base.lease_connection.create_table "mysql_table_options", force: true
+
+    assert_no_match %r{ENGINE=InnoDB}, @log.string
+
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?(:?, options: "ENGINE=InnoDB ROW_FORMAT=DYNAMIC")?, force: :cascade/
+    assert_match expected, output
+  end
+
+  test "legacy migrations contain default ENGINE=InnoDB option" do
+    migration = Class.new(ActiveRecord::Migration[5.1]) do
+      def migrate(x)
+        create_table "mysql_table_options", force: true
+      end
+    end.new
+
+    pool = ActiveRecord::Base.connection_pool
+    ActiveRecord::Migrator.new(:up, [migration], pool.schema_migration, pool.internal_metadata).migrate
+
+    assert_match %r{ENGINE=InnoDB}, @log.string
+
+    output = dump_table_schema("mysql_table_options")
+    expected = /create_table "mysql_table_options", charset: "utf8mb4"(?:, collation: "\w+")?, force: :cascade/
+    assert_match expected, output
+  end
+end

data/test/cases/adapters/abstract_mysql_adapter/transaction_test.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  class TransactionTest < ActiveRecord::AbstractMysqlTestCase
+    self.use_transactional_tests = false
+
+    class Sample < ActiveRecord::Base
+      self.table_name = "samples"
+    end
+
+    setup do
+      @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
+      Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
+
+      connection = ActiveRecord::Base.lease_connection
+      connection.clear_cache!
+
+      connection.transaction do
+        connection.drop_table "samples", if_exists: true
+        connection.create_table("samples") do |t|
+          t.integer "value"
+        end
+      end
+
+      Sample.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "raises Deadlocked when a deadlock is encountered" do
+      connection = Sample.lease_connection
+      assert_raises(ActiveRecord::Deadlocked) do
+        barrier = Concurrent::CyclicBarrier.new(2)
+
+        s1 = Sample.create value: 1
+        s2 = Sample.create value: 2
+
+        thread = Thread.new do
+          Sample.transaction do
+            s1.lock!
+            barrier.wait
+            s2.update value: 1
+          end
+        end
+
+        begin
+          Sample.transaction do
+            s2.lock!
+            barrier.wait
+            s1.update value: 2
+          end
+        ensure
+          thread.join
+        end
+      end
+      assert_predicate connection, :active?
+    end
+
+    test "raises LockWaitTimeout when lock wait timeout exceeded" do
+      assert_raises(ActiveRecord::LockWaitTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.lease_connection.execute("SET innodb_lock_wait_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.lease_connection.execute("SET innodb_lock_wait_timeout = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+    end
+
+    test "raises StatementTimeout when statement timeout exceeded" do
+      skip unless ActiveRecord::Base.lease_connection.show_variable("max_execution_time")
+      error = assert_raises(ActiveRecord::StatementTimeout) do
+        s = Sample.create!(value: 1)
+        latch1 = Concurrent::CountDownLatch.new
+        latch2 = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch1.count_down
+            latch2.wait
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch1.wait
+            Sample.lease_connection.execute("SET max_execution_time = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.lease_connection.execute("SET max_execution_time = DEFAULT")
+          latch2.count_down
+          thread.join
+        end
+      end
+      assert_kind_of ActiveRecord::QueryAborted, error
+    end
+
+    test "raises QueryCanceled when canceling statement due to user request" do
+      error = assert_raises(ActiveRecord::QueryCanceled) do
+        s = Sample.create!(value: 1)
+        latch = Concurrent::CountDownLatch.new
+
+        thread = Thread.new do
+          Sample.transaction do
+            Sample.lock.find(s.id)
+            latch.count_down
+            sleep(0.5)
+            conn = Sample.lease_connection
+            pid = conn.query_value("SELECT id FROM information_schema.processlist WHERE info LIKE '% FOR UPDATE'")
+            conn.execute("KILL QUERY #{pid}")
+          end
+        end
+
+        begin
+          Sample.transaction do
+            latch.wait
+            Sample.lock.find(s.id)
+          end
+        ensure
+          thread.join
+        end
+      end
+      assert_kind_of ActiveRecord::QueryAborted, error
+    end
+
+    test "reconnect preserves isolation level" do
+      pool = Sample.connection_pool
+      @connection = Sample.lease_connection
+
+      Sample.transaction do
+        @connection.materialize_transactions
+        # Double check that the INSERT isn't seen with default isolation level
+        assert_no_difference -> { Sample.count } do
+          Thread.new do
+            Sample.create!(value: 1)
+          end.join
+        end
+      end
+
+      Sample.transaction(isolation: :read_committed) do
+        @connection.materialize_transactions
+        # Double check that the INSERT is seen with :read_committed
+        assert_difference -> { Sample.count }, +1 do
+          Thread.new do
+            Sample.create!(value: 1)
+          end.join
+        end
+      end
+
+      first_begin_failed = false
+      @connection.singleton_class.define_method(:perform_query) do |raw_connection, sql, *args, **kwargs|
+        # Simulates the first BEGIN attempt failing
+        if sql.include?("BEGIN") && !first_begin_failed
+          first_begin_failed = true
+          raise ActiveRecord::ConnectionFailed, "Simulated failure"
+        end
+        super(raw_connection, sql, *args, **kwargs)
+      end
+
+      Sample.transaction(isolation: :read_committed) do
+        @connection.materialize_transactions
+        # Indirectly check that the retried transaction is READ COMMITTED
+        assert_difference -> { Sample.count }, +1 do
+          Thread.new do
+            Sample.create!(value: 1)
+          end.join
+        end
+      end
+
+      assert first_begin_failed
+    ensure
+      pool.remove(@connection) # We're monkey patching the instance, we shouldn't re-use it
+      @connection&.disconnect!
+      Sample.release_connection
+    end
+  end
+end

data/test/cases/adapters/abstract_mysql_adapter/unsigned_type_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class UnsignedTypeTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+  self.use_transactional_tests = false
+
+  class UnsignedType < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table("unsigned_types", force: true) do |t|
+      t.integer :unsigned_integer, unsigned: true
+      t.bigint  :unsigned_bigint,  unsigned: true
+      t.float   :unsigned_float,   unsigned: true
+      t.decimal :unsigned_decimal, unsigned: true, precision: 10, scale: 2
+      t.column  :unsigned_zerofill, "int unsigned zerofill"
+    end
+  end
+
+  teardown do
+    @connection.drop_table "unsigned_types", if_exists: true
+  end
+
+  test "unsigned int max value is in range" do
+    assert expected = UnsignedType.create(unsigned_integer: 4294967295)
+    assert_equal expected, UnsignedType.find_by(unsigned_integer: 4294967295)
+  end
+
+  test "minus value is out of range" do
+    assert_raise(ActiveModel::RangeError) do
+      UnsignedType.create(unsigned_integer: -10)
+    end
+    assert_raise(ActiveModel::RangeError) do
+      UnsignedType.create(unsigned_bigint: -10)
+    end
+    assert_raise(ActiveRecord::RangeError) do
+      UnsignedType.create(unsigned_float: -10.0)
+    end
+    assert_raise(ActiveRecord::RangeError) do
+      UnsignedType.create(unsigned_decimal: -10.0)
+    end
+  end
+
+  test "schema definition can use unsigned as the type" do
+    @connection.change_table("unsigned_types") do |t|
+      t.unsigned_integer :unsigned_integer_t
+      t.unsigned_bigint  :unsigned_bigint_t
+    end
+
+    @connection.columns("unsigned_types").select { |c| /^unsigned_/.match?(c.name) }.each do |column|
+      assert_predicate column, :unsigned?
+    end
+  end
+
+  test "deprecate unsigned_float and unsigned_decimal" do
+    @connection.change_table("unsigned_types") do |t|
+      assert_deprecated(ActiveRecord.deprecator) do
+        t.unsigned_float :unsigned_float_t
+      end
+      assert_deprecated(ActiveRecord.deprecator) do
+        t.unsigned_decimal :unsigned_decimal_t
+      end
+    end
+  end
+
+  test "schema dump includes unsigned option" do
+    schema = dump_table_schema "unsigned_types"
+    assert_match %r{t\.integer\s+"unsigned_integer",\s+unsigned: true$}, schema
+    assert_match %r{t\.bigint\s+"unsigned_bigint",\s+unsigned: true$}, schema
+    assert_match %r{t\.float\s+"unsigned_float",\s+unsigned: true$}, schema
+    assert_match %r{t\.decimal\s+"unsigned_decimal",\s+precision: 10,\s+scale: 2,\s+unsigned: true$}, schema
+  end
+end

data/test/cases/adapters/abstract_mysql_adapter/virtual_column_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+  class VirtualColumnTest < ActiveRecord::AbstractMysqlTestCase
+    include SchemaDumpingHelper
+
+    self.use_transactional_tests = false
+
+    class VirtualColumn < ActiveRecord::Base
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :virtual_columns, force: true do |t|
+        t.string   :name
+        t.virtual  :upper_name,  type: :string,  as: "UPPER(`name`)"
+        t.virtual  :name_length, type: :integer, as: "LENGTH(`name`)", stored: true
+        t.virtual  :name_octet_length, type: :integer, as: "OCTET_LENGTH(`name`)", stored: true
+        t.json     :profile
+        t.virtual  :profile_email, type: :string, as: "json_extract(`profile`,_utf8mb4'$.email')", stored: true
+        t.datetime :time
+        t.virtual  :time_mirror, type: :datetime, as: "`time`"
+      end
+      VirtualColumn.create(name: "Rails")
+    end
+
+    def teardown
+      @connection.drop_table :virtual_columns, if_exists: true
+      VirtualColumn.reset_column_information
+    end
+
+    def test_virtual_column
+      column = VirtualColumn.columns_hash["upper_name"]
+      assert_predicate column, :virtual?
+      assert_match %r{\bVIRTUAL\b}, column.extra
+      assert_equal "RAILS", VirtualColumn.take.upper_name
+    end
+
+    def test_stored_column
+      column = VirtualColumn.columns_hash["name_length"]
+      assert_predicate column, :virtual?
+      assert_match %r{\b(?:STORED|PERSISTENT)\b}, column.extra
+      assert_equal 5, VirtualColumn.take.name_length
+    end
+
+    def test_change_table
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :lower_name, type: :string, as: "LOWER(name)"
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["lower_name"]
+      assert_predicate column, :virtual?
+      assert_match %r{\bVIRTUAL\b}, column.extra
+      assert_equal "rails", VirtualColumn.take.lower_name
+    end
+
+    def test_schema_dumping
+      output = dump_table_schema("virtual_columns")
+      assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "(?:UPPER|UCASE)\(`name`\)"$/i, output)
+      assert_match(/t\.virtual\s+"name_length",\s+type: :integer,\s+as: "(?:octet_length|length)\(`name`\)",\s+stored: true$/i, output)
+      assert_match(/t\.virtual\s+"name_octet_length",\s+type: :integer,\s+as: "(?:octet_length|length)\(`name`\)",\s+stored: true$/i, output)
+      assert_match(/t\.virtual\s+"profile_email",\s+type: :string,\s+as: "json_extract\(`profile`,\w*?'\$\.email'\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"time_mirror",\s+type: :datetime,\s+as: "`time`"$/i, output[/^.*time_mirror.*$/])
+    end
+  end
+end

data/test/cases/adapters/abstract_mysql_adapter/warnings_test.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_support/error_reporter/test_helper"
+
+class WarningsTest < ActiveRecord::AbstractMysqlTestCase
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+    @original_db_warnings_action = :ignore
+  end
+
+  test "db_warnings_action :raise on warning" do
+    with_db_warnings_action(:raise) do
+      error = assert_raises(ActiveRecord::SQLWarning) do
+        @connection.execute('SELECT 1 + "foo"')
+      end
+
+      assert_equal @connection.pool, error.connection_pool
+    end
+  end
+
+  test "db_warnings_action :ignore on warning" do
+    with_db_warnings_action(:ignore) do
+      result = @connection.execute('SELECT 1 + "foo"')
+      assert_equal [1], result.to_a.first
+    end
+  end
+
+  test "db_warnings_action :log on warning" do
+    with_db_warnings_action(:log) do
+      mysql_warning = "[ActiveRecord::SQLWarning] Truncated incorrect DOUBLE value: 'foo' (1292)"
+
+      assert_called_with(ActiveRecord::Base.logger, :warn, [mysql_warning]) do
+        @connection.execute('SELECT 1 + "foo"')
+      end
+    end
+  end
+
+  test "db_warnings_action :report on warning" do
+    with_db_warnings_action(:report) do
+      error_reporter = ActiveSupport::ErrorReporter.new
+      subscriber = ActiveSupport::ErrorReporter::TestHelper::ErrorSubscriber.new
+
+      Rails.define_singleton_method(:error) { error_reporter }
+      Rails.error.subscribe(subscriber)
+
+      @connection.execute('SELECT 1 + "foo"')
+
+      warning_event, * = subscriber.events.first
+
+      assert_kind_of ActiveRecord::SQLWarning, warning_event
+      assert_equal "Truncated incorrect DOUBLE value: 'foo'", warning_event.message
+    end
+  end
+
+  test "db_warnings_action custom proc on warning" do
+    warning_message = nil
+    warning_level = nil
+    warning_action = ->(warning) do
+      warning_message = warning.message
+      warning_level = warning.level
+    end
+
+    with_db_warnings_action(warning_action) do
+      @connection.execute('SELECT 1 + "foo"')
+
+      assert_equal "Truncated incorrect DOUBLE value: 'foo'", warning_message
+      assert_equal "Warning", warning_level
+    end
+  end
+
+  test "db_warnings_action allows a list of warnings to ignore" do
+    with_db_warnings_action(:raise, [/Truncated incorrect DOUBLE value/]) do
+      result = @connection.execute('SELECT 1 + "foo"')
+
+      assert_equal [1], result.to_a.first
+    end
+  end
+
+  test "db_warnings_action allows a list of codes to ignore" do
+    with_db_warnings_action(:raise, ["1292"]) do
+      result = @connection.execute('SELECT 1 + "foo"')
+
+      assert_equal [1], result.to_a.first
+    end
+  end
+
+  test "db_warnings_action ignores note level warnings" do
+    with_db_warnings_action(:raise) do
+      result = @connection.execute("DROP TABLE IF EXISTS non_existent_table")
+
+      assert_equal [], result.to_a
+    end
+  end
+
+  test "db_warnings_action handles when warning_count does not match returned warnings" do
+    with_db_warnings_action(:raise) do
+      # force warnings to 1, but SHOW WARNINGS will return [].
+      @connection.raw_connection.stub(:warning_count, 1) do
+        error = assert_raises(ActiveRecord::SQLWarning) do
+          @connection.execute('SELECT "x"')
+        end
+
+        expected = "Query had warning_count=1 but ‘SHOW WARNINGS’ did not return the warnings. Check MySQL logs or database configuration."
+        assert_equal expected, error.message
+      end
+    end
+  end
+end

data/test/cases/adapters/mysql2/check_constraint_quoting_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_check_constraints?
+  class Mysql2CheckConstraintQuotingTest < ActiveRecord::Mysql2TestCase
+    include SchemaDumpingHelper
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table "trades", force: true do |t|
+        t.string :name
+      end
+    end
+
+    teardown do
+      @connection.drop_table "trades", if_exists: true rescue nil
+    end
+
+    def test_check_constraint_no_duplicate_expression_quoting
+      @connection.add_check_constraint :trades, "name != 'forbidden_string'"
+
+      check_constraints = @connection.check_constraints("trades")
+      assert_equal 1, check_constraints.size
+
+      expression = check_constraints.first.expression
+      if ActiveRecord::Base.lease_connection.mariadb?
+        assert_equal "`name` <> 'forbidden_string'", expression
+      else
+        assert_equal "`name` <> _utf8mb4'forbidden_string'", expression
+      end
+    end
+  end
+end