ibm_db 5.2.0-x86-mingw32 → 5.4.0-x86-mingw32

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

@@ -1,6 +1,10 @@
+# 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"
@@ -16,9 +20,9 @@ class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
       table_name = ActiveRecord::SchemaMigration.table_name
       connection.drop_table table_name, if_exists: true
 
-      connection.initialize_schema_migrations_table
+      ActiveRecord::SchemaMigration.create_table
 
-      assert connection.column_exists?(table_name, :version, :string, collation: 'utf8_general_ci')
+      assert connection.column_exists?(table_name, :version, :string)
     end
   end
 
@@ -27,33 +31,34 @@ class SchemaMigrationsTest < ActiveRecord::Mysql2TestCase
       table_name = ActiveRecord::InternalMetadata.table_name
       connection.drop_table table_name, if_exists: true
 
-      connection.initialize_internal_metadata_table
+      ActiveRecord::InternalMetadata.create_table
 
-      assert connection.column_exists?(table_name, :key, :string, collation: 'utf8_general_ci')
+      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}'")
 
-  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"]
 
-    original_charset = database_info["DEFAULT_CHARACTER_SET_NAME"]
-    original_collation = database_info["DEFAULT_COLLATION_NAME"]
+      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET utf8mb4")
 
-    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
+      yield
+    ensure
+      execute("ALTER DATABASE #{database_name} DEFAULT CHARACTER SET #{original_charset} COLLATE #{original_collation}")
+    end
 
-  def connection
-    @connection ||= ActiveRecord::Base.connection
-  end
+    def connection
+      @connection ||= ActiveRecord::Base.connection
+    end
 
-  def execute(sql)
-    connection.execute(sql)
-  end
+    def execute(sql)
+      connection.execute(sql)
+    end
 end

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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/post'
-require 'models/comment'
+require "models/post"
+require "models/comment"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -9,14 +11,14 @@ module ActiveRecord
 
       def setup
         @connection = ActiveRecord::Base.connection
-        db          = Post.connection_pool.spec.config[:database]
+        db          = Post.connection_pool.db_config.database
         table       = Post.table_name
         @db_name    = db
 
         @omgpost = Class.new(ActiveRecord::Base) do
           self.inheritance_column = :disabled
           self.table_name = "#{db}.#{table}"
-          def self.name; 'Post'; end
+          def self.name; "Post"; end
         end
       end
 
@@ -31,15 +33,15 @@ module ActiveRecord
           t.float :float_25, limit: 25
         end
 
-        column_no_limit = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_no_limit' }
-        column_short = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_short' }
-        column_long = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_long' }
+        column_no_limit = @connection.columns(:mysql_doubles).find { |c| c.name == "float_no_limit" }
+        column_short = @connection.columns(:mysql_doubles).find { |c| c.name == "float_short" }
+        column_long = @connection.columns(:mysql_doubles).find { |c| c.name == "float_long" }
 
-        column_23 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_23' }
-        column_24 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_24' }
-        column_25 = @connection.columns(:mysql_doubles).find { |c| c.name == 'float_25' }
+        column_23 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_23" }
+        column_24 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_24" }
+        column_25 = @connection.columns(:mysql_doubles).find { |c| c.name == "float_25" }
 
-        # Mysql floats are precision 0..24, Mysql doubles are precision 25..53
+        # MySQL floats are precision 0..24, MySQL doubles are precision 25..53
         assert_equal 24, column_no_limit.limit
         assert_equal 24, column_short.limit
         assert_equal 53, column_long.limit
@@ -56,7 +58,7 @@ module ActiveRecord
       end
 
       def test_primary_key
-        assert_equal 'id', @omgpost.primary_key
+        assert_equal "id", @omgpost.primary_key
       end
 
       def test_data_source_exists?
@@ -65,22 +67,22 @@ module ActiveRecord
       end
 
       def test_data_source_exists_wrong_schema
-        assert(!@connection.data_source_exists?("#{@db_name}.zomg"), "data_source should not exist")
+        assert_not(@connection.data_source_exists?("#{@db_name}.zomg"), "data_source should not exist")
       end
 
       def test_dump_indexes
-        index_a_name = 'index_key_tests_on_snack'
-        index_b_name = 'index_key_tests_on_pizza'
-        index_c_name = 'index_key_tests_on_awesome'
+        index_a_name = "index_key_tests_on_snack"
+        index_b_name = "index_key_tests_on_pizza"
+        index_c_name = "index_key_tests_on_awesome"
 
-        table = 'key_tests'
+        table = "key_tests"
 
         indexes = @connection.indexes(table).sort_by(&:name)
-        assert_equal 3,indexes.size
+        assert_equal 3, indexes.size
 
-        index_a = indexes.select{|i| i.name == index_a_name}[0]
-        index_b = indexes.select{|i| i.name == index_b_name}[0]
-        index_c = indexes.select{|i| i.name == index_c_name}[0]
+        index_a = indexes.select { |i| i.name == index_a_name }[0]
+        index_b = indexes.select { |i| i.name == index_b_name }[0]
+        index_c = indexes.select { |i| i.name == index_c_name }[0]
         assert_equal :btree, index_a.using
         assert_nil index_a.type
         assert_equal :btree, index_b.using
@@ -121,6 +123,6 @@ class Mysql2AnsiQuotesTest < ActiveRecord::Mysql2TestCase
   def test_foreign_keys_method_with_ansi_quotes
     fks = @connection.foreign_keys("lessons_students")
     assert_equal([["lessons_students", "students", :cascade]],
-                 fks.map {|fk| [fk.from_table, fk.to_table, fk.on_delete] })
+                 fks.map { |fk| [fk.from_table, fk.to_table, fk.on_delete] })
   end
 end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+class Mysql2SetTest < ActiveRecord::Mysql2TestCase
+  include SchemaDumpingHelper
+
+  class SetTest < ActiveRecord::Base
+  end
+
+  def setup
+    SetTest.connection.create_table :set_tests, id: false, force: true do |t|
+      t.column :set_column, "set('text','blob','tiny','medium','long','unsigned','bigint')"
+    end
+  end
+
+  def test_should_not_be_unsigned
+    column = SetTest.columns_hash["set_column"]
+    assert_not_predicate column, :unsigned?
+  end
+
+  def test_should_not_be_bigint
+    column = SetTest.columns_hash["set_column"]
+    assert_not_predicate column, :bigint?
+  end
+
+  def test_schema_dumping
+    schema = dump_table_schema "set_tests"
+    assert_match %r{t\.column "set_column", "set\('text','blob','tiny','medium','long','unsigned','bigint'\)"$}, schema
+  end
+end

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

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'models/topic'
-require 'models/reply'
+require "models/topic"
+require "models/reply"
 
 class Mysql2StoredProcedureTest < ActiveRecord::Mysql2TestCase
   fixtures :topics
 
   def setup
     @connection = ActiveRecord::Base.connection
-    unless ActiveRecord::Base.connection.version >= '5.6.0'
+    unless ActiveRecord::Base.connection.database_version >= "5.6.0"
       skip("no stored procedure support")
     end
   end
@@ -15,21 +17,21 @@ class Mysql2StoredProcedureTest < ActiveRecord::Mysql2TestCase
   # Test that MySQL allows multiple results for stored procedures
   #
   # In MySQL 5.6, CLIENT_MULTI_RESULTS is enabled by default.
-  # http://dev.mysql.com/doc/refman/5.6/en/call.html
+  # https://dev.mysql.com/doc/refman/en/call.html
   def test_multi_results
-    rows = @connection.select_rows('CALL ten();')
+    rows = @connection.select_rows("CALL ten();")
     assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
     assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_rows'"
   end
 
   def test_multi_results_from_select_one
-    row = @connection.select_one('CALL topics(1);')
-    assert_equal 'David', row['author_name']
+    row = @connection.select_one("CALL topics(1);")
+    assert_equal "David", row["author_name"]
     assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select_one'"
   end
 
   def test_multi_results_from_find_by_sql
-    topics = Topic.find_by_sql 'CALL topics(3);'
+    topics = Topic.find_by_sql "CALL topics(3);"
     assert_equal 3, topics.size
     assert @connection.active?, "Bad connection use by 'Mysql2Adapter.select'"
   end

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

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Mysql2SqlTypesTest < ActiveRecord::Mysql2TestCase
   def test_binary_types
-    assert_equal 'varbinary(64)', type_to_sql(:binary, 64)
-    assert_equal 'varbinary(4095)', type_to_sql(:binary, 4095)
-    assert_equal 'blob', type_to_sql(:binary, 4096)
-    assert_equal 'blob', type_to_sql(:binary)
+    assert_equal "varbinary(64)", type_to_sql(:binary, 64)
+    assert_equal "varbinary(4095)", type_to_sql(:binary, 4095)
+    assert_equal "blob", type_to_sql(:binary, 4096)
+    assert_equal "blob", type_to_sql(:binary)
   end
 
-  def type_to_sql(*args)
-    ActiveRecord::Base.connection.type_to_sql(*args)
+  def type_to_sql(type, limit = nil)
+    ActiveRecord::Base.connection.type_to_sql(type, limit: limit)
   end
 end

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

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "cases/helper"
-require 'support/schema_dumping_helper'
+require "support/schema_dumping_helper"
 
 class Mysql2TableOptionsTest < ActiveRecord::Mysql2TestCase
   include SchemaDumpingHelper
+  self.use_transactional_tests = false
 
   def setup
     @connection = ActiveRecord::Base.connection
@@ -15,28 +18,108 @@ class Mysql2TableOptionsTest < ActiveRecord::Mysql2TestCase
   test "table options with ENGINE" do
     @connection.create_table "mysql_table_options", force: true, options: "ENGINE=MyISAM"
     output = dump_table_schema("mysql_table_options")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{ENGINE=MyISAM}, 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")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{ROW_FORMAT=REDUNDANT}, 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=utf8mb4"
+    @connection.create_table "mysql_table_options", force: true, options: "CHARSET=latin1"
     output = dump_table_schema("mysql_table_options")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{CHARSET=utf8mb4}, options
+    expected = /create_table "mysql_table_options", charset: "latin1", 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")
-    options = %r{create_table "mysql_table_options", force: :cascade, options: "(?<options>.*)"}.match(output)[:options]
-    assert_match %r{COLLATE=utf8mb4_bin}, 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", 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 Mysql2DefaultEngineOptionTest < ActiveRecord::Mysql2TestCase
+  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.connection.drop_table "mysql_table_options", if_exists: true
+    ActiveRecord::SchemaMigration.delete_all rescue nil
+  end
+
+  test "new migrations do not contain default ENGINE=InnoDB option" do
+    ActiveRecord::Base.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+")?, 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
+
+    ActiveRecord::Migrator.new(:up, [migration], ActiveRecord::Base.connection.schema_migration).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/mysql2/transaction_test.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/connection_helper"
+
+module ActiveRecord
+  class Mysql2TransactionTest < 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.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.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
+      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
+    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.connection.execute("SET innodb_lock_wait_timeout = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.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.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.connection.execute("SET max_execution_time = 1")
+            Sample.lock.find(s.id)
+          end
+        ensure
+          Sample.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.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
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 require "support/schema_dumping_helper"
 
@@ -15,6 +17,7 @@ class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
       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
 
@@ -34,10 +37,10 @@ class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
     assert_raise(ActiveModel::RangeError) do
       UnsignedType.create(unsigned_bigint: -10)
     end
-    assert_raise(ActiveRecord::StatementInvalid) do
+    assert_raise(ActiveRecord::RangeError) do
       UnsignedType.create(unsigned_float: -10.0)
     end
-    assert_raise(ActiveRecord::StatementInvalid) do
+    assert_raise(ActiveRecord::RangeError) do
       UnsignedType.create(unsigned_decimal: -10.0)
     end
   end
@@ -48,19 +51,18 @@ class Mysql2UnsignedTypeTest < ActiveRecord::Mysql2TestCase
       t.unsigned_bigint  :unsigned_bigint_t
       t.unsigned_float   :unsigned_float_t
       t.unsigned_decimal :unsigned_decimal_t, precision: 10, scale: 2
-      t.column :unsigned_zerofill, "int unsigned zerofill"
     end
 
-    @connection.columns("unsigned_types").select { |c| /^unsigned_/ === c.name }.each do |column|
-      assert column.unsigned?
+    @connection.columns("unsigned_types").select { |c| /^unsigned_/.match?(c.name) }.each do |column|
+      assert_predicate column, :unsigned?
     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+limit: 24,\s+unsigned: true$}, schema
-    assert_match %r{t.decimal\s+"unsigned_decimal",\s+precision: 10,\s+scale: 2,\s+unsigned: true$}, schema
+    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