ibm_db 5.6.1-arm64-darwin-24

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

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+
+class Mysql2AdapterTest < ActiveRecord::Mysql2TestCase
+  include DdlHelper
+
+  def setup
+    @conn = ActiveRecord::Base.connection
+    @connection_handler = ActiveRecord::Base.connection_handler
+  end
+
+  def test_connection_error
+    assert_raises ActiveRecord::ConnectionNotEstablished do
+      ActiveRecord::Base.mysql2_connection(socket: File::NULL)
+    end
+  end
+
+  def test_reconnection_error
+    fake_connection = Class.new do
+      def query_options
+        {}
+      end
+
+      def query(*)
+      end
+
+      def close
+      end
+    end.new
+    @conn = ActiveRecord::ConnectionAdapters::Mysql2Adapter.new(
+      fake_connection,
+      ActiveRecord::Base.logger,
+      nil,
+      { socket: File::NULL }
+    )
+    assert_raises ActiveRecord::ConnectionNotEstablished do
+      @conn.reconnect!
+    end
+  end
+
+  def test_exec_query_nothing_raises_with_no_result_queries
+    assert_nothing_raised do
+      with_example_table do
+        @conn.exec_query("INSERT INTO ex (number) VALUES (1)")
+        @conn.exec_query("DELETE FROM ex WHERE number = 1")
+      end
+    end
+  end
+
+  def test_database_exists_returns_false_if_database_does_not_exist
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    config = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
+    assert_not ActiveRecord::ConnectionAdapters::Mysql2Adapter.database_exists?(config),
+      "expected database to not exist"
+  end
+
+  def test_database_exists_returns_true_when_the_database_exists
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    assert ActiveRecord::ConnectionAdapters::Mysql2Adapter.database_exists?(db_config.configuration_hash),
+      "expected database #{db_config.database} to exist"
+  end
+
+  def test_columns_for_distinct_zero_orders
+    assert_equal "posts.id",
+      @conn.columns_for_distinct("posts.id", [])
+  end
+
+  def test_columns_for_distinct_one_order
+    assert_equal "posts.created_at AS alias_0, posts.id",
+      @conn.columns_for_distinct("posts.id", ["posts.created_at desc"])
+  end
+
+  def test_columns_for_distinct_few_orders
+    assert_equal "posts.created_at AS alias_0, posts.position AS alias_1, posts.id",
+      @conn.columns_for_distinct("posts.id", ["posts.created_at desc", "posts.position asc"])
+  end
+
+  def test_columns_for_distinct_with_case
+    assert_equal(
+      "CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END AS alias_0, posts.id",
+      @conn.columns_for_distinct("posts.id",
+        ["CASE WHEN author.is_active THEN UPPER(author.name) ELSE UPPER(author.email) END"])
+    )
+  end
+
+  def test_columns_for_distinct_blank_not_nil_orders
+    assert_equal "posts.created_at AS alias_0, posts.id",
+      @conn.columns_for_distinct("posts.id", ["posts.created_at desc", "", "   "])
+  end
+
+  def test_columns_for_distinct_with_arel_order
+    Arel::Table.engine = nil # should not rely on the global Arel::Table.engine
+
+    order = Arel.sql("posts.created_at").desc
+    assert_equal "posts.created_at AS alias_0, posts.id",
+      @conn.columns_for_distinct("posts.id", [order])
+  ensure
+    Arel::Table.engine = ActiveRecord::Base
+  end
+
+  def test_errors_for_bigint_fks_on_integer_pk_table_in_alter_table
+    # table old_cars has primary key of integer
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.add_reference :engines, :old_car
+      @conn.add_foreign_key :engines, :old_cars
+    end
+
+    assert_match(
+      %r/Column `old_car_id` on table `engines` does not match column `id` on `old_cars`, which has type `int(\(11\))?`\./,
+      error.message
+    )
+    assert_match(
+      %r/To resolve this issue, change the type of the `old_car_id` column on `engines` to be :integer\. \(For example `t.integer :old_car_id`\)\./,
+      error.message
+    )
+    assert_not_nil error.cause
+  ensure
+    @conn.execute("ALTER TABLE engines DROP COLUMN old_car_id") rescue nil
+  end
+
+  def test_errors_for_bigint_fks_on_integer_pk_table_in_create_table
+    # table old_cars has primary key of integer
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.execute(<<~SQL)
+        CREATE TABLE activerecord_unittest.foos (
+          id bigint NOT NULL AUTO_INCREMENT PRIMARY KEY,
+          old_car_id bigint,
+          INDEX index_foos_on_old_car_id (old_car_id),
+          CONSTRAINT fk_rails_ff771f3c96 FOREIGN KEY (old_car_id) REFERENCES old_cars (id)
+        )
+      SQL
+    end
+
+    assert_match(
+      %r/Column `old_car_id` on table `foos` does not match column `id` on `old_cars`, which has type `int(\(11\))?`\./,
+      error.message
+    )
+    assert_match(
+      %r/To resolve this issue, change the type of the `old_car_id` column on `foos` to be :integer\. \(For example `t.integer :old_car_id`\)\./,
+      error.message
+    )
+    assert_not_nil error.cause
+  ensure
+    @conn.drop_table :foos, if_exists: true
+  end
+
+  def test_errors_for_integer_fks_on_bigint_pk_table_in_create_table
+    # table old_cars has primary key of bigint
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.execute(<<~SQL)
+        CREATE TABLE activerecord_unittest.foos (
+          id bigint NOT NULL AUTO_INCREMENT PRIMARY KEY,
+          car_id int,
+          INDEX index_foos_on_car_id (car_id),
+          CONSTRAINT fk_rails_ff771f3c96 FOREIGN KEY (car_id) REFERENCES cars (id)
+        )
+      SQL
+    end
+
+    assert_match(
+      %r/Column `car_id` on table `foos` does not match column `id` on `cars`, which has type `bigint(\(20\))?`\./,
+      error.message
+    )
+    assert_match(
+      %r/To resolve this issue, change the type of the `car_id` column on `foos` to be :bigint\. \(For example `t.bigint :car_id`\)\./,
+      error.message
+    )
+    assert_not_nil error.cause
+  ensure
+    @conn.drop_table :foos, if_exists: true
+  end
+
+  def test_errors_for_bigint_fks_on_string_pk_table_in_create_table
+    # table old_cars has primary key of string
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.execute(<<~SQL)
+        CREATE TABLE activerecord_unittest.foos (
+          id bigint NOT NULL AUTO_INCREMENT PRIMARY KEY,
+          subscriber_id bigint,
+          INDEX index_foos_on_subscriber_id (subscriber_id),
+          CONSTRAINT fk_rails_ff771f3c96 FOREIGN KEY (subscriber_id) REFERENCES subscribers (nick)
+        )
+      SQL
+    end
+
+    assert_includes error.message, <<~MSG.squish
+      Column `subscriber_id` on table `foos` does not match column `nick` on `subscribers`,
+      which has type `varchar(255)`. To resolve this issue, change the type of the `subscriber_id`
+      column on `foos` to be :string. (For example `t.string :subscriber_id`).
+    MSG
+    assert_not_nil error.cause
+  ensure
+    @conn.drop_table :foos, if_exists: true
+  end
+
+  def test_read_timeout_exception
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+
+    ActiveRecord::Base.establish_connection(
+      db_config.configuration_hash.merge("read_timeout" => 1)
+    )
+
+    error = assert_raises(ActiveRecord::AdapterTimeout) do
+      ActiveRecord::Base.connection.execute("SELECT SLEEP(2)")
+    end
+    assert_kind_of ActiveRecord::QueryAborted, error
+
+    assert_equal Mysql2::Error::TimeoutError, error.cause.class
+  ensure
+    ActiveRecord::Base.establish_connection :arunit
+  end
+
+  def test_statement_timeout_error_codes
+    raw_conn = @conn.raw_connection
+    assert_raises(ActiveRecord::StatementTimeout) do
+      raw_conn.stub(:query, ->(_sql) { raise Mysql2::Error.new("fail", 50700, ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::ER_FILSORT_ABORT) }) {
+        @conn.execute("SELECT 1")
+      }
+    end
+
+    assert_raises(ActiveRecord::StatementTimeout) do
+      raw_conn.stub(:query, ->(_sql) { raise Mysql2::Error.new("fail", 50700, ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::ER_QUERY_TIMEOUT) }) {
+        @conn.execute("SELECT 1")
+      }
+    end
+  end
+
+  private
+    def with_example_table(definition = "id int auto_increment primary key, number int, data varchar(255)", &block)
+      super(@conn, "ex", definition, &block)
+    end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  class Mysql2NestedDeadlockTest < ActiveRecord::Mysql2TestCase
+    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.connection
+      connection.clear_cache!
+
+      connection.create_table("samples", force: true) do |t|
+        t.integer "value"
+      end
+
+      Sample.reset_column_information
+    end
+
+    teardown do
+      ActiveRecord::Base.clear_active_connections!
+      ActiveRecord::Base.connection.drop_table "samples", if_exists: true
+
+      Thread.abort_on_exception = @abort
+      Thread.report_on_exception = @original_report_on_exception
+    end
+
+    test "deadlock correctly raises Deadlocked inside nested SavepointTransaction" do
+      assert_raises(ActiveRecord::Deadlocked) do
+        barrier = Concurrent::CyclicBarrier.new(2)
+
+        s1 = Sample.create value: 1
+        s2 = Sample.create value: 2
+
+        begin
+          thread = Thread.new do
+            Sample.transaction(requires_new: false) do
+              Sample.transaction(requires_new: true) do
+                s1.lock!
+                barrier.wait
+                s2.update value: 1
+              end
+            end
+          end
+
+          begin
+            Sample.transaction(requires_new: false) do
+              Sample.transaction(requires_new: true) do
+                s2.lock!
+                barrier.wait
+                s1.update value: 2
+              end
+            end
+          ensure
+            thread.join
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          if /SAVEPOINT active_record_. does not exist/ =~ e.to_s
+            flunk "ROLLBACK TO SAVEPOINT query issued for savepoint that no longer exists due to deadlock: #{e}"
+          else
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+if supports_optimizer_hints?
+  class Mysql2OptimzerHintsTest < ActiveRecord::Mysql2TestCase
+    fixtures :posts
+
+    def test_optimizer_hints
+      assert_sql(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain, "| index | index_posts_on_author_id | index_posts_on_author_id |"
+      end
+    end
+
+    def test_optimizer_hints_with_count_subquery
+      assert_sql(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+        posts = posts.select(:id).where(author_id: [0, 1]).limit(5)
+        assert_equal 5, posts.count
+      end
+    end
+
+    def test_optimizer_hints_is_sanitized
+      assert_sql(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        posts = Post.optimizer_hints("/*+ NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_includes posts.explain, "| index | index_posts_on_author_id | index_posts_on_author_id |"
+      end
+
+      assert_sql(%r{\ASELECT /\*\+  `posts`\.\*,  \*/}) do
+        posts = Post.optimizer_hints("**// `posts`.*, //**")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        assert_equal({ "id" => 1 }, posts.first.as_json)
+      end
+    end
+
+    def test_optimizer_hints_with_unscope
+      assert_sql(%r{\ASELECT `posts`\.`id`}) do
+        posts = Post.optimizer_hints("/*+ NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id) */")
+        posts = posts.select(:id).where(author_id: [0, 1])
+        posts.unscope(:optimizer_hints).load
+      end
+    end
+
+    def test_optimizer_hints_with_or
+      assert_sql(%r{\ASELECT /\*\+ NO_RANGE_OPTIMIZATION\(posts index_posts_on_author_id\) \*/}) do
+        Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+          .or(Post.all).load
+      end
+
+      queries = capture_sql do
+        Post.optimizer_hints("NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)")
+          .or(Post.optimizer_hints("NO_ICP(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_includes queries.first, "NO_RANGE_OPTIMIZATION(posts index_posts_on_author_id)"
+      assert_not_includes queries.first, "NO_ICP(posts)"
+
+      queries = capture_sql do
+        Post.all.or(Post.optimizer_hints("NO_ICP(posts)")).load
+      end
+      assert_equal 1, queries.length
+      assert_not_includes queries.first, "NO_ICP(posts)"
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+require "cases/helper"
+
+# a suite of tests to ensure the ConnectionAdapters#MysqlAdapter can handle tables with
+# reserved word names (ie: group, order, values, etc...)
+class Mysql2ReservedWordTest < ActiveRecord::Mysql2TestCase
+  class Group < ActiveRecord::Base
+    Group.table_name = 'group'
+    belongs_to :select
+    has_one :values
+  end
+
+  class Select < ActiveRecord::Base
+    Select.table_name = 'select'
+    has_many :groups
+  end
+
+  class Values < ActiveRecord::Base
+    Values.table_name = 'values'
+  end
+
+  class Distinct < ActiveRecord::Base
+    Distinct.table_name = 'distinct'
+    has_and_belongs_to_many :selects
+    has_many :values, :through => :groups
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    # we call execute directly here (and do similar below) because ActiveRecord::Base#create_table()
+    # will fail with these table names if these test cases fail
+
+    create_tables_directly 'group'=>'id int auto_increment primary key, `order` varchar(255), select_id int',
+      'select'=>'id int auto_increment primary key',
+      'values'=>'id int auto_increment primary key, group_id int',
+      'distinct'=>'id int auto_increment primary key',
+      'distinct_select'=>'distinct_id int, select_id int'
+  end
+
+  teardown do
+    drop_tables_directly ['group', 'select', 'values', 'distinct', 'distinct_select', 'order']
+  end
+
+  # create tables with reserved-word names and columns
+  def test_create_tables
+    assert_nothing_raised {
+      @connection.create_table :order do |t|
+        t.column :group, :string
+      end
+    }
+  end
+
+  # rename tables with reserved-word names
+  def test_rename_tables
+    assert_nothing_raised { @connection.rename_table(:group, :order) }
+  end
+
+  # alter column with a reserved-word name in a table with a reserved-word name
+  def test_change_columns
+    assert_nothing_raised { @connection.change_column_default(:group, :order, 'whatever') }
+    #the quoting here will reveal any double quoting issues in change_column's interaction with the column method in the adapter
+    assert_nothing_raised { @connection.change_column('group', 'order', :Int, :default => 0) }
+    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
+  end
+
+  # introspect table with reserved word name
+  def test_introspect
+    assert_nothing_raised { @connection.columns(:group) }
+    assert_nothing_raised { @connection.indexes(:group) }
+  end
+
+  #fixtures
+  self.use_instantiated_fixtures = true
+  self.use_transactional_tests = false
+
+  #activerecord model class with reserved-word table name
+  def test_activerecord_model
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    x = nil
+    assert_nothing_raised { x = Group.new }
+    x.order = 'x'
+    assert_nothing_raised { x.save }
+    x.order = 'y'
+    assert_nothing_raised { x.save }
+    assert_nothing_raised { Group.find_by_order('y') }
+    assert_nothing_raised { Group.find(1) }
+  end
+
+  # has_one association with reserved-word table name
+  def test_has_one_associations
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    v = nil
+    assert_nothing_raised { v = Group.find(1).values }
+    assert_equal 2, v.id
+  end
+
+  # belongs_to association with reserved-word table name
+  def test_belongs_to_associations
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    gs = nil
+    assert_nothing_raised { gs = Select.find(2).groups }
+    assert_equal gs.length, 2
+    assert(gs.collect(&:id).sort == [2, 3])
+  end
+
+  # has_and_belongs_to_many with reserved-word table name
+  def test_has_and_belongs_to_many
+    create_test_fixtures :select, :distinct, :group, :values, :distinct_select
+    s = nil
+    assert_nothing_raised { s = Distinct.find(1).selects }
+    assert_equal s.length, 2
+    assert(s.collect(&:id).sort == [1, 2])
+  end
+
+  # activerecord model introspection with reserved-word table and column names
+  def test_activerecord_introspection
+    assert_nothing_raised { Group.table_exists? }
+    assert_nothing_raised { Group.columns }
+  end
+
+  # Calculations
+  def test_calculations_work_with_reserved_words
+    assert_nothing_raised { Group.count }
+  end
+
+  def test_associations_work_with_reserved_words
+    assert_nothing_raised { Select.all.merge!(:includes => [:groups]).to_a }
+  end
+
+  #the following functions were added to DRY test cases
+
+  private
+  # custom fixture loader, uses FixtureSet#create_fixtures and appends base_path to the current file's path
+  def create_test_fixtures(*fixture_names)
+    ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT + "/reserved_words", fixture_names)
+  end
+
+  # custom drop table, uses execute on connection to drop a table if it exists. note: escapes table_name
+  def drop_tables_directly(table_names, connection = @connection)
+    table_names.each do |name|
+      connection.drop_table name, if_exists: true
+    end
+  end
+
+  # custom create table, uses execute on connection to create a table, note: escapes table_name, does NOT escape columns
+  def create_tables_directly(tables, connection = @connection)
+    tables.each do |table_name, column_properties|
+      connection.execute("CREATE TABLE `#{table_name}` ( #{column_properties} )")
+    end
+  end
+
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
+  self.use_transactional_tests = false
+
+  def test_renaming_index_on_foreign_key
+    connection.add_index "engines", "car_id"
+    connection.add_foreign_key :engines, :cars, name: "fk_engines_cars"
+
+    connection.rename_index("engines", "index_engines_on_car_id", "idx_renamed")
+    assert_equal ["idx_renamed"], connection.indexes("engines").map(&:name)
+  ensure
+    connection.remove_foreign_key :engines, name: "fk_engines_cars"
+  end
+
+  def test_initializes_schema_migrations_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      table_name = ActiveRecord::SchemaMigration.table_name
+      connection.drop_table table_name, if_exists: true
+
+      ActiveRecord::SchemaMigration.create_table
+
+      assert connection.column_exists?(table_name, :version, :string)
+    end
+  end
+
+  def test_initializes_internal_metadata_for_encoding_utf8mb4
+    with_encoding_utf8mb4 do
+      table_name = ActiveRecord::InternalMetadata.table_name
+      connection.drop_table table_name, if_exists: true
+
+      ActiveRecord::InternalMetadata.create_table
+
+      assert connection.column_exists?(table_name, :key, :string)
+    end
+  ensure
+    ActiveRecord::InternalMetadata[:environment] = connection.migration_context.current_environment
+  end
+
+  private
+    def with_encoding_utf8mb4
+      database_name = connection.current_database
+      database_info = connection.select_one("SELECT * FROM information_schema.schemata WHERE schema_name = '#{database_name}'")
+
+      original_charset = database_info["DEFAULT_CHARACTER_SET_NAME"]
+      original_collation = database_info["DEFAULT_COLLATION_NAME"]
+
+      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET utf8mb4")
+
+      yield
+    ensure
+      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET #{original_charset} COLLATE #{original_collation}")
+    end
+
+    def connection
+      @connection ||= ActiveRecord::Base.connection
+    end
+
+    def execute(sql)
+      connection.execute(sql)
+    end
+end