ibm_db 5.6.1 → 5.7.0

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

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+class ActiveSchemaTest < ActiveRecord::AbstractMysqlTestCase
+  include ConnectionHelper
+
+  def setup
+    ActiveRecord::Base.lease_connection.send(:default_row_format)
+    ActiveRecord::Base.lease_connection.singleton_class.class_eval do
+      alias_method :execute_without_stub, :execute
+      def execute(sql, name = nil)
+        ActiveSupport::Notifications.instrumenter.instrument(
+          "sql.active_record",
+          sql: sql,
+          name: name,
+          connection: self) do
+          sql
+        end
+      end
+    end
+  end
+
+  teardown do
+    reset_connection
+  end
+
+  def test_add_index
+    expected = "CREATE INDEX `index_people_on_last_name` ON `people` (`last_name`)"
+    assert_equal expected, add_index(:people, :last_name, length: nil)
+
+    expected = "CREATE INDEX `index_people_on_last_name` ON `people` (`last_name`(10))"
+    assert_equal expected, add_index(:people, :last_name, length: 10)
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(15))"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15)
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: 15)
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`)"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15 })
+    assert_equal expected, add_index(:people, ["last_name", "first_name"], length: { last_name: 15 })
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(10))"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: { last_name: 15, first_name: 10 })
+    assert_equal expected, add_index(:people, ["last_name", :first_name], length: { last_name: 15, "first_name" => 10 })
+
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "CREATE #{type} INDEX `index_people_on_last_name` ON `people` (`last_name`)"
+      assert_equal expected, add_index(:people, :last_name, type: type)
+    end
+
+    %w(btree hash).each do |using|
+      expected = "CREATE INDEX `index_people_on_last_name` USING #{using} ON `people` (`last_name`)"
+      assert_equal expected, add_index(:people, :last_name, using: using)
+    end
+
+    expected = "CREATE INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10))"
+    assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree)
+
+    %i(default copy inplace instant).each do |algorithm|
+      expected = "CREATE INDEX `index_people_on_last_name` USING btree ON `people` (`last_name`(10)) ALGORITHM = #{algorithm.upcase}"
+      assert_equal expected, add_index(:people, :last_name, length: 10, using: :btree, algorithm: algorithm)
+    end
+
+    with_real_execute do
+      add_index(:people, :first_name)
+      assert index_exists?(:people, :first_name)
+
+      assert_nothing_raised do
+        add_index(:people, :first_name, if_not_exists: true)
+      end
+    end
+
+    assert_raise ArgumentError do
+      add_index(:people, :last_name, algorithm: :coyp)
+    end
+
+    expected = "CREATE INDEX `index_people_on_last_name_and_first_name` USING btree ON `people` (`last_name`(15), `first_name`(15))"
+    assert_equal expected, add_index(:people, [:last_name, :first_name], length: 15, using: :btree)
+  end
+
+  def test_index_in_create
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = /\ACREATE TABLE `people` \(#{type} INDEX `index_people_on_last_name` \(`last_name`\)\)/
+      actual = ActiveRecord::Base.lease_connection.create_table(:people, id: false) do |t|
+        t.index :last_name, type: type
+      end
+      assert_match expected, actual
+    end
+
+    expected = /\ACREATE TABLE `people` \(INDEX `index_people_on_last_name` USING btree \(`last_name`\(10\)\)\)/
+    actual = ActiveRecord::Base.lease_connection.create_table(:people, id: false) do |t|
+      t.index :last_name, length: 10, using: :btree
+    end
+    assert_match expected, actual
+  end
+
+  def test_index_in_bulk_change
+    %w(SPATIAL FULLTEXT UNIQUE).each do |type|
+      expected = "ALTER TABLE `people` ADD #{type} INDEX `index_people_on_last_name` (`last_name`)"
+      assert_queries_match(expected) do
+        ActiveRecord::Base.lease_connection.change_table(:people, bulk: true) do |t|
+          t.index :last_name, type: type
+        end
+      end
+    end
+
+    expected = "ALTER TABLE `people` ADD INDEX `index_people_on_last_name` USING btree (`last_name`(10)), ALGORITHM = COPY"
+    assert_queries_match(expected) do
+      ActiveRecord::Base.lease_connection.change_table(:people, bulk: true) do |t|
+        t.index :last_name, length: 10, using: :btree, algorithm: :copy
+      end
+    end
+  end
+
+  def test_drop_table
+    assert_equal "DROP TABLE `people`", drop_table(:people)
+  end
+
+  def test_drop_tables
+    assert_equal "DROP TABLE `people`, `sobrinho`", drop_table(:people, :sobrinho)
+  end
+
+  def test_create_mysql_database_with_encoding
+    if ActiveRecord::Base.lease_connection.send(:row_format_dynamic_by_default?)
+      assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8mb4`", create_database(:matt)
+    else
+      error = assert_raises(RuntimeError) { create_database(:matt) }
+      expected = "Configure a supported :charset and ensure innodb_large_prefix is enabled to support indexes on varchar(255) string columns."
+      assert_equal expected, error.message
+    end
+    assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, charset: "latin1")
+    assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT COLLATE `utf8mb4_bin`", create_database(:matt_aimonetti, collation: "utf8mb4_bin")
+  end
+
+  def test_recreate_mysql_database_with_encoding
+    create_database(:luca, charset: "latin1")
+    assert_equal "CREATE DATABASE `luca` DEFAULT CHARACTER SET `latin1`", recreate_database(:luca, charset: "latin1")
+  end
+
+  def test_add_column
+    assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
+  end
+
+  def test_add_column_with_limit
+    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, limit: 32)
+  end
+
+  def test_drop_table_with_specific_database
+    assert_equal "DROP TABLE `otherdb`.`people`", drop_table("otherdb.people")
+  end
+
+  def test_drop_tables_with_specific_database
+    assert_equal "DROP TABLE `otherdb`.`people`, `otherdb`.`sobrinho`", drop_table("otherdb.people", "otherdb.sobrinho")
+  end
+
+  def test_add_timestamps
+    with_real_execute do
+      ActiveRecord::Base.lease_connection.create_table :delete_me
+      ActiveRecord::Base.lease_connection.add_timestamps :delete_me, null: true
+      assert column_exists?("delete_me", "updated_at", "datetime")
+      assert column_exists?("delete_me", "created_at", "datetime")
+    ensure
+      ActiveRecord::Base.lease_connection.drop_table :delete_me rescue nil
+    end
+  end
+
+  def test_remove_timestamps
+    with_real_execute do
+      ActiveRecord::Base.lease_connection.create_table :delete_me do |t|
+        t.timestamps null: true
+      end
+      ActiveRecord::Base.lease_connection.remove_timestamps :delete_me, null: true
+      assert_not column_exists?("delete_me", "updated_at", "datetime")
+      assert_not column_exists?("delete_me", "created_at", "datetime")
+    ensure
+      ActiveRecord::Base.lease_connection.drop_table :delete_me rescue nil
+    end
+  end
+
+  def test_indexes_in_create
+    expected = /\ACREATE TEMPORARY TABLE `temp` \(INDEX `index_temp_on_zip` \(`zip`\)\)(?: ROW_FORMAT=DYNAMIC)? AS SELECT id, name, zip FROM a_really_complicated_query/
+    actual = ActiveRecord::Base.lease_connection.create_table(:temp, temporary: true, as: "SELECT id, name, zip FROM a_really_complicated_query") do |t|
+      t.index :zip
+    end
+
+    assert_match expected, actual
+  end
+
+  private
+    def with_real_execute
+      ActiveRecord::Base.lease_connection.singleton_class.class_eval do
+        alias_method :execute_with_stub, :execute
+        remove_method :execute
+        alias_method :execute, :execute_without_stub
+      end
+
+      yield
+    ensure
+      ActiveRecord::Base.lease_connection.singleton_class.class_eval do
+        remove_method :execute
+        alias_method :execute, :execute_with_stub
+      end
+    end
+
+    def method_missing(...)
+      ActiveRecord::Base.lease_connection.public_send(...)
+    end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/ddl_helper"
+
+class AdapterPreventWritesTest < ActiveRecord::AbstractMysqlTestCase
+  include DdlHelper
+
+  def setup
+    @conn = ActiveRecord::Base.lease_connection
+  end
+
+  def test_errors_when_an_insert_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.insert("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+      end
+    end
+  end
+
+  def test_errors_when_an_update_query_is_called_while_preventing_writes
+    @conn.insert("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.update("UPDATE `engines` SET `engines`.`car_id` = '9989' WHERE `engines`.`car_id` = '138853948594'")
+      end
+    end
+  end
+
+  def test_errors_when_a_delete_query_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.execute("DELETE FROM `engines` where `engines`.`car_id` = '138853948594'")
+      end
+    end
+  end
+
+  def test_errors_when_a_replace_query_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_raises(ActiveRecord::ReadOnlyError) do
+        @conn.execute("REPLACE INTO `engines` SET `engines`.`car_id` = '249823948'")
+      end
+    end
+  end
+
+  def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 1, @conn.execute("SELECT `engines`.* FROM `engines` WHERE `engines`.`car_id` = '138853948594'").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_show_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 2, @conn.execute("SHOW FULL FIELDS FROM `engines`").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_set_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_nothing_raised { @conn.execute("SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci") }
+    end
+  end
+
+  def test_doesnt_error_when_a_describe_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 2, @conn.execute("DESCRIBE engines").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_desc_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 2, @conn.execute("DESC engines").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_read_query_with_leading_chars_is_called_while_preventing_writes
+    @conn.execute("INSERT INTO `engines` (`car_id`) VALUES ('138853948594')")
+
+    ActiveRecord::Base.while_preventing_writes do
+      assert_equal 1, @conn.execute("/*action:index*/(\n( SELECT `engines`.* FROM `engines` WHERE `engines`.`car_id` = '138853948594' ) )").entries.count
+    end
+  end
+
+  def test_doesnt_error_when_a_use_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      db_name = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").database
+      assert_nothing_raised { @conn.execute("USE #{db_name}") }
+    end
+  end
+
+  def test_doesnt_error_when_a_kill_query_is_called_while_preventing_writes
+    ActiveRecord::Base.while_preventing_writes do
+      conn_id = @conn.execute("SELECT CONNECTION_ID() as connection_id").to_a[0][0]
+      assert_raises(ActiveRecord::QueryCanceled) do
+        @conn.execute("KILL QUERY #{conn_id}")
+      end
+    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/abstract_mysql_adapter/auto_increment_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class AutoIncrementTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  def setup
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  def teardown
+    @connection.drop_table :auto_increments, if_exists: true
+  end
+
+  def test_auto_increment_without_primary_key
+    @connection.create_table :auto_increments, id: false, force: true do |t|
+      t.integer :id, null: false, auto_increment: true
+      t.index :id
+    end
+    output = dump_table_schema("auto_increments")
+    assert_match(/t\.integer\s+"id",\s+null: false,\s+auto_increment: true$/, output)
+  end
+
+  def test_auto_increment_with_composite_primary_key
+    @connection.create_table :auto_increments, primary_key: [:id, :created_at], force: true do |t|
+      t.integer :id, null: false, auto_increment: true
+      t.datetime :created_at, null: false
+    end
+    output = dump_table_schema("auto_increments")
+    assert_match(/t\.integer\s+"id",\s+null: false,\s+auto_increment: true$/, output)
+  end
+
+  def test_auto_increment_false_with_custom_primary_key
+    @connection.create_table :auto_increments, id: false, force: :cascade do |t|
+      t.primary_key :id, auto_increment: false
+    end
+
+    assert_not_predicate @connection.columns(:auto_increments).first, :auto_increment?
+  end
+
+  def test_auto_increment_false_with_create_table
+    @connection.create_table :auto_increments, auto_increment: false, force: :cascade
+
+    assert_not_predicate @connection.columns(:auto_increments).first, :auto_increment?
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/topic"
+require "models/post"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractMysqlAdapter
+      class BindParameterTest < ActiveRecord::AbstractMysqlTestCase
+        fixtures :topics, :posts
+
+        def test_update_question_marks
+          str       = "foo?bar"
+          x         = Topic.first
+          x.title   = str
+          x.content = str
+          x.save!
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_create_question_marks
+          str = "foo?bar"
+          x   = Topic.create!(title: str, content: str)
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_update_null_bytes
+          str       = "foo\0bar"
+          x         = Topic.first
+          x.title   = str
+          x.content = str
+          x.save!
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_create_null_bytes
+          str = "foo\0bar"
+          x   = Topic.create!(title: str, content: str)
+          x.reload
+          assert_equal str, x.title
+          assert_equal str, x.content
+        end
+
+        def test_where_with_string_for_string_column_using_bind_parameters
+          assert_quoted_as "'Welcome to the weblog'", "Welcome to the weblog", match: 1
+        end
+
+        def test_where_with_integer_for_string_column_using_bind_parameters
+          assert_quoted_as "'0'", 0
+        end
+
+        def test_where_with_float_for_string_column_using_bind_parameters
+          assert_quoted_as "'0.0'", 0.0
+        end
+
+        def test_where_with_boolean_for_string_column_using_bind_parameters
+          assert_quoted_as "'0'", false
+        end
+
+        def test_where_with_decimal_for_string_column_using_bind_parameters
+          assert_quoted_as "'0.0'", BigDecimal(0)
+        end
+
+        def test_where_with_rational_for_string_column_using_bind_parameters
+          assert_quoted_as "'0.0'", Rational(0)
+        end
+
+        private
+          def assert_quoted_as(expected, value, match: 0)
+            relation = Post.where("title = ?", value)
+            assert_equal(
+              %{SELECT `posts`.* FROM `posts` WHERE (title = #{expected})},
+              relation.to_sql,
+            )
+            if match == 0
+              assert_empty relation.to_a
+            else
+              assert_equal match, relation.count
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class CaseSensitivityTest < ActiveRecord::AbstractMysqlTestCase
+  class CollationTest < ActiveRecord::Base
+  end
+
+  repair_validations(CollationTest)
+
+  def test_columns_include_collation_different_from_table
+    assert_equal "utf8mb4_bin", CollationTest.columns_hash["string_cs_column"].collation
+    assert_equal "utf8mb4_general_ci", CollationTest.columns_hash["string_ci_column"].collation
+  end
+
+  def test_case_sensitive
+    assert_not_predicate CollationTest.columns_hash["string_ci_column"], :case_sensitive?
+    assert_predicate CollationTest.columns_hash["string_cs_column"], :case_sensitive?
+  end
+
+  def test_case_insensitive_comparison_for_ci_column
+    CollationTest.validates_uniqueness_of(:string_ci_column, case_sensitive: false)
+    CollationTest.create!(string_ci_column: "A")
+    invalid = CollationTest.new(string_ci_column: "a")
+    queries = capture_sql { invalid.save }
+    ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
+    assert_no_match(/lower/i, ci_uniqueness_query)
+  end
+
+  def test_case_insensitive_comparison_for_cs_column
+    CollationTest.validates_uniqueness_of(:string_cs_column, case_sensitive: false)
+    CollationTest.create!(string_cs_column: "A")
+    invalid = CollationTest.new(string_cs_column: "a")
+    queries = capture_sql { invalid.save }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
+    assert_match(/lower/i, cs_uniqueness_query)
+  end
+
+  def test_case_sensitive_comparison_for_ci_column
+    CollationTest.validates_uniqueness_of(:string_ci_column, case_sensitive: true)
+    CollationTest.create!(string_ci_column: "A")
+    invalid = CollationTest.new(string_ci_column: "A")
+    queries = capture_sql { invalid.save }
+    ci_uniqueness_query = queries.detect { |q| q.match(/string_ci_column/) }
+    assert_match(/binary/i, ci_uniqueness_query)
+  end
+
+  def test_case_sensitive_comparison_for_cs_column
+    CollationTest.validates_uniqueness_of(:string_cs_column, case_sensitive: true)
+    CollationTest.create!(string_cs_column: "A")
+    invalid = CollationTest.new(string_cs_column: "A")
+    queries = capture_sql { invalid.save }
+    cs_uniqueness_query = queries.detect { |q| q.match(/string_cs_column/) }
+    assert_no_match(/binary/i, cs_uniqueness_query)
+  end
+
+  def test_case_sensitive_comparison_for_binary_column
+    CollationTest.validates_uniqueness_of(:binary_column, case_sensitive: true)
+    CollationTest.create!(binary_column: "A")
+    invalid = CollationTest.new(binary_column: "A")
+    queries = capture_sql { invalid.save }
+    bin_uniqueness_query = queries.detect { |q| q.match(/binary_column/) }
+    assert_no_match(/\bBINARY\b/, bin_uniqueness_query)
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class CharsetCollationTest < ActiveRecord::AbstractMysqlTestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table :charset_collations, id: { type: :string, collation: "utf8mb4_bin" }, force: true do |t|
+      t.string :string_ascii_bin, charset: "ascii", collation: "ascii_bin"
+      t.text :text_ucs2_unicode_ci, charset: "ucs2", collation: "ucs2_unicode_ci"
+    end
+  end
+
+  teardown do
+    @connection.drop_table :charset_collations, if_exists: true
+  end
+
+  test "string column with charset and collation" do
+    column = @connection.columns(:charset_collations).find { |c| c.name == "string_ascii_bin" }
+    assert_equal :string, column.type
+    assert_equal "ascii_bin", column.collation
+  end
+
+  test "text column with charset and collation" do
+    column = @connection.columns(:charset_collations).find { |c| c.name == "text_ucs2_unicode_ci" }
+    assert_equal :text, column.type
+    assert_equal "ucs2_unicode_ci", column.collation
+  end
+
+  test "add column with charset and collation" do
+    @connection.add_column :charset_collations, :title, :string, charset: "utf8mb4", collation: "utf8mb4_bin"
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "title" }
+    assert_equal :string, column.type
+    assert_equal "utf8mb4_bin", column.collation
+  end
+
+  test "change column with charset and collation" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :text, charset: "utf8mb4", collation: "utf8mb4_general_ci"
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+    assert_equal :text, column.type
+    assert_equal "utf8mb4_general_ci", column.collation
+  end
+
+  test "change column doesn't preserve collation for string to binary types" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :binary
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+
+    assert_equal :binary, column.type
+    assert_nil column.collation
+  end
+
+  test "change column doesn't preserve collation for string to non-string types" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :int
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+
+    assert_equal :integer, column.type
+    assert_nil column.collation
+  end
+
+  test "change column preserves collation for string to text" do
+    @connection.add_column :charset_collations, :description, :string, charset: "utf8mb4", collation: "utf8mb4_unicode_ci"
+    @connection.change_column :charset_collations, :description, :text
+
+    column = @connection.columns(:charset_collations).find { |c| c.name == "description" }
+    assert_equal :text, column.type
+    assert_equal "utf8mb4_unicode_ci", column.collation
+  end
+
+  test "schema dump includes collation" do
+    output = dump_table_schema("charset_collations")
+    assert_match %r/create_table "charset_collations", id: { type: :string, collation: "utf8mb4_bin" }/, output
+    assert_match %r{t\.string\s+"string_ascii_bin",\s+collation: "ascii_bin"$}, output
+    assert_match %r{t\.text\s+"text_ucs2_unicode_ci",\s+collation: "ucs2_unicode_ci"$}, output
+  end
+end