ibm_db 5.6.1-arm64-darwin-24

data/test/cases/migration/column_attributes_test.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "cases/migration/helper"
+
+module ActiveRecord
+  class Migration
+    class ColumnAttributesTest < ActiveRecord::TestCase
+      include ActiveRecord::Migration::TestHelper
+
+      self.use_transactional_tests = false
+
+      def test_add_column_newline_default
+        string = "foo\nbar"
+        add_column "test_models", "command", :string, default: string
+        TestModel.reset_column_information
+
+        assert_equal string, TestModel.new.command
+      end
+
+      def test_add_remove_single_field_using_string_arguments
+        assert_no_column TestModel, :last_name
+
+        add_column "test_models", "last_name", :string
+        assert_column TestModel, :last_name
+
+        remove_column "test_models", "last_name"
+        assert_no_column TestModel, :last_name
+      end
+
+      def test_add_remove_single_field_using_symbol_arguments
+        assert_no_column TestModel, :last_name
+
+        add_column :test_models, :last_name, :string
+        assert_column TestModel, :last_name
+
+        remove_column :test_models, :last_name
+        assert_no_column TestModel, :last_name
+      end
+
+      def test_add_column_without_limit
+        # TODO: limit: nil should work with all adapters.
+        skip "MySQL wrongly enforces a limit of 255" if current_adapter?(:Mysql2Adapter)
+        add_column :test_models, :description, :string, limit: nil
+        TestModel.reset_column_information
+        assert_nil TestModel.columns_hash["description"].limit
+      end
+
+      if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+        def test_unabstracted_database_dependent_types
+          add_column :test_models, :intelligence_quotient, :smallint
+          TestModel.reset_column_information
+          assert_match(/smallint/, TestModel.columns_hash["intelligence_quotient"].sql_type)
+        end
+      end
+
+      unless current_adapter?(:SQLite3Adapter)
+        # We specifically do a manual INSERT here, and then test only the SELECT
+        # functionality. This allows us to more easily catch INSERT being broken,
+        # but SELECT actually working fine.
+        def test_native_decimal_insert_manual_vs_automatic
+          correct_value = "0012345678901234567890.0123456789".to_d
+
+          connection.add_column "test_models", "wealth", :decimal, precision: "30", scale: "10"
+
+          # Do a manual insertion
+          if current_adapter?(:OracleAdapter)
+            connection.execute "insert into test_models (id, wealth) values (people_seq.nextval, 12345678901234567890.0123456789)"
+          else
+            connection.execute "insert into test_models (wealth) values (12345678901234567890.0123456789)"
+          end
+
+          # SELECT
+          row = TestModel.first
+          assert_kind_of BigDecimal, row.wealth
+
+          # If this assert fails, that means the SELECT is broken!
+          assert_equal correct_value, row.wealth
+
+          # Reset to old state
+          TestModel.delete_all
+
+          # Now use the Rails insertion
+          TestModel.create wealth: BigDecimal("12345678901234567890.0123456789")
+
+          # SELECT
+          row = TestModel.first
+          assert_kind_of BigDecimal, row.wealth
+
+          # If these asserts fail, that means the INSERT (create function, or cast to SQL) is broken!
+          assert_equal correct_value, row.wealth
+        end
+      end
+
+      def test_add_column_with_precision_and_scale
+        connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
+
+        wealth_column = TestModel.columns_hash["wealth"]
+        assert_equal 9, wealth_column.precision
+        assert_equal 7, wealth_column.scale
+      end
+
+      # Test SQLite3 adapter specifically for decimal types with precision and scale
+      # attributes, since these need to be maintained in schema but aren't actually
+      # used in SQLite3 itself
+      if current_adapter?(:SQLite3Adapter)
+        def test_change_column_with_new_precision_and_scale
+          connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
+
+          connection.change_column "test_models", "wealth", :decimal, precision: 12, scale: 8
+          TestModel.reset_column_information
+
+          wealth_column = TestModel.columns_hash["wealth"]
+          assert_equal 12, wealth_column.precision
+          assert_equal 8, wealth_column.scale
+        end
+
+        def test_change_column_preserve_other_column_precision_and_scale
+          connection.add_column "test_models", "last_name", :string
+          connection.add_column "test_models", "wealth", :decimal, precision: 9, scale: 7
+
+          wealth_column = TestModel.columns_hash["wealth"]
+          assert_equal 9, wealth_column.precision
+          assert_equal 7, wealth_column.scale
+
+          connection.change_column "test_models", "last_name", :string, null: false
+          TestModel.reset_column_information
+
+          wealth_column = TestModel.columns_hash["wealth"]
+          assert_equal 9, wealth_column.precision
+          assert_equal 7, wealth_column.scale
+        end
+      end
+
+      unless current_adapter?(:SQLite3Adapter)
+        def test_native_types
+          add_column "test_models", "first_name", :string
+          add_column "test_models", "last_name", :string
+          add_column "test_models", "bio", :text
+          add_column "test_models", "age", :integer
+          add_column "test_models", "height", :float
+          add_column "test_models", "wealth", :decimal, precision: "30", scale: "10"
+          add_column "test_models", "birthday", :datetime
+          add_column "test_models", "favorite_day", :date
+          add_column "test_models", "moment_of_truth", :datetime
+          add_column "test_models", "male", :boolean
+
+          TestModel.create first_name: "bob", last_name: "bobsen",
+            bio: "I was born ....", age: 18, height: 1.78,
+            wealth: BigDecimal("12345678901234567890.0123456789"),
+            birthday: 18.years.ago, favorite_day: 10.days.ago,
+            moment_of_truth: "1782-10-10 21:40:18", male: true
+
+          bob = TestModel.first
+          assert_equal "bob", bob.first_name
+          assert_equal "bobsen", bob.last_name
+          assert_equal "I was born ....", bob.bio
+          assert_equal 18, bob.age
+
+          # Test for 30 significant digits (beyond the 16 of float), 10 of them
+          # after the decimal place.
+
+          assert_equal BigDecimal("0012345678901234567890.0123456789"), bob.wealth
+
+          assert_equal true, bob.male?
+
+          assert_equal String, bob.first_name.class
+          assert_equal String, bob.last_name.class
+          assert_equal String, bob.bio.class
+          assert_kind_of Integer, bob.age
+          assert_equal Time, bob.birthday.class
+          assert_equal Date, bob.favorite_day.class
+          assert_instance_of TrueClass, bob.male?
+          assert_kind_of BigDecimal, bob.wealth
+        end
+      end
+
+      if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+        def test_out_of_range_limit_should_raise
+          assert_raise(ArgumentError) { add_column :test_models, :integer_too_big, :integer, limit: 10 }
+          assert_raise(ArgumentError) { add_column :test_models, :text_too_big, :text, limit: 0xfffffffff }
+          assert_raise(ArgumentError) { add_column :test_models, :binary_too_big, :binary, limit: 0xfffffffff }
+        end
+      end
+    end
+  end
+end

data/test/cases/migration/column_positioning_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class ColumnPositioningTest < ActiveRecord::TestCase
+      attr_reader :connection
+      alias :conn :connection
+
+      def setup
+        super
+
+        @connection = ActiveRecord::Base.connection
+
+        connection.create_table :testings, id: false do |t|
+          t.column :first, :integer
+          t.column :second, :integer
+          t.column :third, :integer
+        end
+      end
+
+      teardown do
+        connection.drop_table :testings rescue nil
+        ActiveRecord::Base.primary_key_prefix_type = nil
+      end
+
+      if current_adapter?(:Mysql2Adapter)
+        def test_column_positioning
+          assert_equal %w(first second third), conn.columns(:testings).map(&:name)
+        end
+
+        def test_add_column_with_positioning
+          conn.add_column :testings, :new_col, :integer
+          assert_equal %w(first second third new_col), conn.columns(:testings).map(&:name)
+        end
+
+        def test_add_column_with_positioning_first
+          conn.add_column :testings, :new_col, :integer, first: true
+          assert_equal %w(new_col first second third), conn.columns(:testings).map(&:name)
+        end
+
+        def test_add_column_with_positioning_after
+          conn.add_column :testings, :new_col, :integer, after: :first
+          assert_equal %w(first new_col second third), conn.columns(:testings).map(&:name)
+        end
+
+        def test_change_column_with_positioning
+          conn.change_column :testings, :second, :integer, first: true
+          assert_equal %w(second first third), conn.columns(:testings).map(&:name)
+
+          conn.change_column :testings, :second, :integer, after: :third
+          assert_equal %w(first third second), conn.columns(:testings).map(&:name)
+        end
+
+        def test_add_reference_with_positioning_first
+          conn.add_reference :testings, :new, polymorphic: true, first: true
+          assert_equal %w(new_id new_type first second third), conn.columns(:testings).map(&:name)
+        end
+
+        def test_add_reference_with_positioning_after
+          conn.add_reference :testings, :new, polymorphic: true, after: :first
+          assert_equal %w(first new_id new_type second third), conn.columns(:testings).map(&:name)
+        end
+      end
+    end
+  end
+end

data/test/cases/migration/columns_test.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require "cases/migration/helper"
+
+module ActiveRecord
+  class Migration
+    class ColumnsTest < ActiveRecord::TestCase
+      include ActiveRecord::Migration::TestHelper
+
+      self.use_transactional_tests = false
+
+      # FIXME: this is more of an integration test with AR::Base and the
+      # schema modifications.  Maybe we should move this?
+      def test_add_rename
+        add_column "test_models", "girlfriend", :string
+        TestModel.reset_column_information
+
+        TestModel.create girlfriend: "bobette"
+
+        rename_column "test_models", "girlfriend", "exgirlfriend"
+
+        TestModel.reset_column_information
+        bob = TestModel.first
+
+        assert_equal "bobette", bob.exgirlfriend
+      end
+
+      # FIXME: another integration test.  We should decouple this from the
+      # AR::Base implementation.
+      def test_rename_column_using_symbol_arguments
+        add_column :test_models, :first_name, :string
+
+        TestModel.create first_name: "foo"
+
+        rename_column :test_models, :first_name, :nick_name
+        TestModel.reset_column_information
+        assert_includes TestModel.column_names, "nick_name"
+        assert_equal ["foo"], TestModel.all.map(&:nick_name)
+      end
+
+      # FIXME: another integration test.  We should decouple this from the
+      # AR::Base implementation.
+      def test_rename_column
+        add_column "test_models", "first_name", "string"
+
+        TestModel.create first_name: "foo"
+
+        rename_column "test_models", "first_name", "nick_name"
+        TestModel.reset_column_information
+        assert_includes TestModel.column_names, "nick_name"
+        assert_equal ["foo"], TestModel.all.map(&:nick_name)
+      end
+
+      def test_rename_column_preserves_default_value_not_null
+        add_column "test_models", "salary", :integer, default: 70000
+
+        default_before = connection.columns("test_models").find { |c| c.name == "salary" }.default
+        assert_equal "70000", default_before
+
+        rename_column "test_models", "salary", "annual_salary"
+
+        assert_includes TestModel.column_names, "annual_salary"
+        default_after = connection.columns("test_models").find { |c| c.name == "annual_salary" }.default
+        assert_equal "70000", default_after
+      end
+
+      if current_adapter?(:Mysql2Adapter)
+        def test_mysql_rename_column_preserves_auto_increment
+          rename_column "test_models", "id", "id_test"
+          assert_predicate connection.columns("test_models").find { |c| c.name == "id_test" }, :auto_increment?
+          TestModel.reset_column_information
+        ensure
+          rename_column "test_models", "id_test", "id"
+        end
+      end
+
+      def test_rename_nonexistent_column
+        exception = if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
+          ActiveRecord::StatementInvalid
+        else
+          ActiveRecord::ActiveRecordError
+        end
+
+        assert_raise(exception) do
+          rename_column "test_models", "nonexistent", "should_fail"
+        end
+      end
+
+      def test_rename_column_with_sql_reserved_word
+        add_column "test_models", "first_name", :string
+        rename_column "test_models", "first_name", "group"
+
+        assert_includes TestModel.column_names, "group"
+      end
+
+      def test_rename_column_with_an_index
+        add_column "test_models", :hat_name, :string
+        add_index :test_models, :hat_name
+
+        assert_equal 1, connection.indexes("test_models").size
+        rename_column "test_models", "hat_name", "name"
+
+        assert_equal ["index_test_models_on_name"], connection.indexes("test_models").map(&:name)
+      end
+
+      def test_rename_column_with_multi_column_index
+        add_column "test_models", :hat_size, :integer
+        add_column "test_models", :hat_style, :string, limit: 100
+        add_index "test_models", ["hat_style", "hat_size"], unique: true
+
+        rename_column "test_models", "hat_size", "size"
+        assert_equal ["index_test_models_on_hat_style_and_size"], connection.indexes("test_models").map(&:name)
+
+        rename_column "test_models", "hat_style", "style"
+        assert_equal ["index_test_models_on_style_and_size"], connection.indexes("test_models").map(&:name)
+      end
+
+      def test_rename_column_does_not_rename_custom_named_index
+        add_column "test_models", :hat_name, :string
+        add_index :test_models, :hat_name, name: "idx_hat_name"
+
+        assert_equal 1, connection.indexes("test_models").size
+        rename_column "test_models", "hat_name", "name"
+        assert_equal ["idx_hat_name"], connection.indexes("test_models").map(&:name)
+      end
+
+      def test_remove_column_with_index
+        add_column "test_models", :hat_name, :string
+        add_index :test_models, :hat_name
+
+        assert_equal 1, connection.indexes("test_models").size
+        remove_column("test_models", "hat_name")
+        assert_equal 0, connection.indexes("test_models").size
+      end
+
+      def test_remove_column_with_multi_column_index
+        # MariaDB starting with 10.2.8
+        # Dropping a column that is part of a multi-column UNIQUE constraint is not permitted.
+        skip if current_adapter?(:Mysql2Adapter) && connection.mariadb? && connection.database_version >= "10.2.8"
+
+        add_column "test_models", :hat_size, :integer
+        add_column "test_models", :hat_style, :string, limit: 100
+        add_index "test_models", ["hat_style", "hat_size"], unique: true
+
+        assert_equal 1, connection.indexes("test_models").size
+        remove_column("test_models", "hat_size")
+
+        # Every database and/or database adapter has their own behavior
+        # if it drops the multi-column index when any of the indexed columns dropped by remove_column.
+        if current_adapter?(:PostgreSQLAdapter, :OracleAdapter, :IBM_DBAdapter)
+          assert_equal [], connection.indexes("test_models").map(&:name)
+        else
+          assert_equal ["index_test_models_on_hat_style_and_hat_size"], connection.indexes("test_models").map(&:name)
+        end
+      end
+
+      def test_change_type_of_not_null_column
+        change_column "test_models", "updated_at", :datetime, null: false
+        change_column "test_models", "updated_at", :datetime, null: false
+
+        TestModel.reset_column_information
+        assert_equal false, TestModel.columns_hash["updated_at"].null
+      ensure
+        change_column "test_models", "updated_at", :datetime, null: true
+      end
+
+      def test_change_column_nullability
+        add_column "test_models", "funny", :boolean
+        assert TestModel.columns_hash["funny"].null, "Column 'funny' must initially allow nulls"
+
+        change_column "test_models", "funny", :boolean, null: false, default: true
+
+        TestModel.reset_column_information
+        assert_not TestModel.columns_hash["funny"].null, "Column 'funny' must *not* allow nulls at this point"
+
+        change_column "test_models", "funny", :boolean, null: true
+        TestModel.reset_column_information
+        assert TestModel.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point"
+      end
+
+      def test_change_column
+        add_column "test_models", "age", :integer
+        add_column "test_models", "approved", :boolean, default: true
+
+        old_columns = connection.columns(TestModel.table_name)
+
+        assert old_columns.find { |c| c.name == "age" && c.type == :integer }
+
+        change_column "test_models", "age", :string
+
+        new_columns = connection.columns(TestModel.table_name)
+
+        assert_not new_columns.find { |c| c.name == "age" && c.type == :integer }
+        assert new_columns.find { |c| c.name == "age" && c.type == :string }
+
+        old_columns = connection.columns(TestModel.table_name)
+        assert old_columns.find { |c|
+          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
+          c.name == "approved" && c.type == :boolean && default == true
+        }
+
+        change_column :test_models, :approved, :boolean, default: false
+        new_columns = connection.columns(TestModel.table_name)
+
+        assert_not new_columns.find { |c|
+          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
+          c.name == "approved" && c.type == :boolean && default == true
+        }
+        assert new_columns.find { |c|
+          default = connection.lookup_cast_type_from_column(c).deserialize(c.default)
+          c.name == "approved" && c.type == :boolean && default == false
+        }
+        change_column :test_models, :approved, :boolean, default: true
+      end
+
+      def test_change_column_with_nil_default
+        add_column "test_models", "contributor", :boolean, default: true
+        assert_predicate TestModel.new, :contributor?
+
+        change_column "test_models", "contributor", :boolean, default: nil
+        TestModel.reset_column_information
+        assert_not_predicate TestModel.new, :contributor?
+        assert_nil TestModel.new.contributor
+      end
+
+      def test_change_column_to_drop_default_with_null_false
+        add_column "test_models", "contributor", :boolean, default: true, null: false
+        assert_predicate TestModel.new, :contributor?
+
+        change_column "test_models", "contributor", :boolean, default: nil, null: false
+        TestModel.reset_column_information
+        assert_not_predicate TestModel.new, :contributor?
+        assert_nil TestModel.new.contributor
+      end
+
+      def test_change_column_with_new_default
+        add_column "test_models", "administrator", :boolean, default: true
+        assert_predicate TestModel.new, :administrator?
+
+        change_column "test_models", "administrator", :boolean, default: false
+        TestModel.reset_column_information
+        assert_not_predicate TestModel.new, :administrator?
+      end
+
+      def test_change_column_with_custom_index_name
+        add_column "test_models", "category", :string
+        add_index :test_models, :category, name: "test_models_categories_idx"
+
+        assert_equal ["test_models_categories_idx"], connection.indexes("test_models").map(&:name)
+        change_column "test_models", "category", :string, null: false, default: "article"
+
+        assert_equal ["test_models_categories_idx"], connection.indexes("test_models").map(&:name)
+      end
+
+      def test_change_column_with_long_index_name
+        table_name_prefix = "test_models_"
+        long_index_name = table_name_prefix + ("x" * (connection.index_name_length - table_name_prefix.length))
+        add_column "test_models", "category", :string
+        add_index :test_models, :category, name: long_index_name
+
+        change_column "test_models", "category", :string, null: false, default: "article"
+
+        assert_equal [long_index_name], connection.indexes("test_models").map(&:name)
+      end
+
+      def test_change_column_default
+        add_column "test_models", "first_name", :string
+        connection.change_column_default "test_models", "first_name", "Tester"
+
+        assert_equal "Tester", TestModel.new.first_name
+      end
+
+      def test_change_column_default_to_null
+        add_column "test_models", "first_name", :string
+        connection.change_column_default "test_models", "first_name", nil
+        assert_nil TestModel.new.first_name
+      end
+
+      def test_change_column_default_with_from_and_to
+        add_column "test_models", "first_name", :string
+        connection.change_column_default "test_models", "first_name", from: nil, to: "Tester"
+
+        assert_equal "Tester", TestModel.new.first_name
+      end
+
+      def test_remove_column_no_second_parameter_raises_exception
+        assert_raise(ArgumentError) { connection.remove_column("funny") }
+      end
+
+      def test_removing_and_renaming_column_preserves_custom_primary_key
+        connection.create_table "my_table", primary_key: "my_table_id", force: true do |t|
+          t.integer "col_one"
+          t.string "col_two", limit: 128, null: false
+        end
+
+        remove_column("my_table", "col_two")
+        rename_column("my_table", "col_one", "col_three")
+
+        assert_equal "my_table_id", connection.primary_key("my_table")
+      ensure
+        connection.drop_table(:my_table) rescue nil
+      end
+
+      def test_column_with_index
+        connection.create_table "my_table", force: true do |t|
+          t.string :item_number, index: true
+        end
+
+        assert connection.index_exists?("my_table", :item_number, name: :index_my_table_on_item_number)
+      ensure
+        connection.drop_table(:my_table) rescue nil
+      end
+
+      def test_add_column_without_column_name
+        e = assert_raise ArgumentError do
+          connection.create_table "my_table", force: true do |t|
+            t.timestamp
+          end
+        end
+        assert_equal "Missing column name(s) for timestamp", e.message
+      ensure
+        connection.drop_table :my_table, if_exists: true
+      end
+    end
+  end
+end