ibm_db 5.6.1 → 5.7.0

data/test/cases/migration/rename_table_test.rb

@@ -21,21 +21,20 @@ module ActiveRecord
         super
       end
 
-      unless current_adapter?(:OracleAdapter)
-        def test_rename_table_should_work_with_reserved_words
-          renamed = false
+      def test_rename_table_should_work_with_reserved_words
+        renamed = false
 
-          add_column :test_models, :url, :string
-          connection.rename_table :references, :old_references
-          connection.rename_table :test_models, :references
+        connection.rename_table :references, :old_references
+        connection.rename_table :test_models, :references
 
-          renamed = true
+        renamed = true
 
-          # Using explicit id in insert for compatibility across all databases
-          connection.execute "INSERT INTO 'references' (url, created_at, updated_at) VALUES ('http://rubyonrails.com', 0, 0)"
-          assert_equal "http://rubyonrails.com", connection.select_value("SELECT url FROM 'references' WHERE id=1")
-        ensure
-          return unless renamed
+        # Using explicit id in insert for compatibility across all databases
+        table_name = connection.quote_table_name("references")
+        connection.execute "INSERT INTO #{table_name} (id, url) VALUES (123, 'http://rubyonrails.com')"
+        assert_equal "http://rubyonrails.com", connection.select_value("SELECT url FROM #{table_name} WHERE id=123")
+      ensure
+        if renamed
           connection.rename_table :references, :test_models
           connection.rename_table :old_references, :references
         end
@@ -49,6 +48,22 @@ module ActiveRecord
         assert_equal "http://www.foreverflying.com/octopus-black7.jpg", connection.select_value("SELECT url FROM octopi WHERE id=1")
       end
 
+      def test_rename_table_raises_for_long_table_names
+        name_limit = connection.table_name_length
+        long_name = "a" * (name_limit + 1)
+        short_name = "a" * name_limit
+
+        error = assert_raises(ArgumentError) do
+          connection.rename_table :test_models, long_name
+        end
+        assert_equal "Table name '#{long_name}' is too long; the limit is #{name_limit} characters", error.message
+
+        connection.rename_table :test_models, short_name
+        assert connection.table_exists?(short_name)
+      ensure
+        connection.drop_table short_name, if_exists: true
+      end
+
       def test_rename_table_with_an_index
         add_index :test_models, :url
 
@@ -62,54 +77,24 @@ module ActiveRecord
         assert_equal "index_octopi_on_url", index.name
       end
 
-      def test_rename_table_does_not_rename_custom_named_index
-        add_index :test_models, :url, name: "special_url_idx"
+      def test_rename_table_with_long_table_name_and_index
+        long_name = "a" * connection.table_name_length
 
-        rename_table :test_models, :octopi
+        add_index :test_models, :url
+        rename_table :test_models, long_name
 
-        assert_equal ["special_url_idx"], connection.indexes(:octopi).map(&:name)
+        index = connection.indexes(long_name).first
+        assert_includes index.columns, "url"
+      ensure
+        rename_table long_name, :test_models
       end
 
-      if current_adapter?(:PostgreSQLAdapter)
-        def test_rename_table_for_postgresql_should_also_rename_default_sequence
-          rename_table :test_models, :octopi
-
-          pk, seq = connection.pk_and_sequence_for("octopi")
-
-          assert_equal ConnectionAdapters::PostgreSQL::Name.new("public", "octopi_#{pk}_seq"), seq
-        end
+      def test_rename_table_does_not_rename_custom_named_index
+        add_index :test_models, :url, name: "special_url_idx"
 
-        def test_renaming_table_renames_primary_key
-          connection.create_table :cats, id: :uuid, default: "uuid_generate_v4()"
-          rename_table :cats, :felines
-
-          assert connection.table_exists? :felines
-          assert_not connection.table_exists? :cats
-
-          primary_key_name = connection.select_values(<<~SQL, "SCHEMA")[0]
-            SELECT c.relname
-              FROM pg_class c
-              JOIN pg_index i
-                ON c.oid = i.indexrelid
-             WHERE i.indisprimary
-               AND i.indrelid = 'felines'::regclass
-          SQL
-
-          assert_equal "felines_pkey", primary_key_name
-        ensure
-          connection.drop_table :cats, if_exists: true
-          connection.drop_table :felines, if_exists: true
-        end
+        rename_table :test_models, :octopi
 
-        def test_renaming_table_doesnt_attempt_to_rename_non_existent_sequences
-          connection.create_table :cats, id: :uuid, default: "uuid_generate_v4()"
-          assert_nothing_raised { rename_table :cats, :felines }
-          assert connection.table_exists? :felines
-          assert_not connection.table_exists? :cats
-        ensure
-          connection.drop_table :cats, if_exists: true
-          connection.drop_table :felines, if_exists: true
-        end
+        assert_equal ["special_url_idx"], connection.indexes(:octopi).map(&:name)
       end
     end
   end

data/test/cases/migration/schema_definitions_test.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class SchemaDefinitionsTest < ActiveRecord::TestCase
+      attr_reader :connection
+
+      def setup
+        @connection = ActiveRecord::Base.lease_connection
+      end
+
+      def test_build_create_table_definition_with_block
+        td = connection.build_create_table_definition :test do |t|
+          t.column :foo, :string
+        end
+
+        id_column = td.columns.find { |col| col.name == "id" }
+        assert_predicate id_column, :present?
+
+        foo_column = td.columns.find { |col| col.name == "foo" }
+        assert_predicate foo_column, :present?
+      end
+
+      def test_build_create_table_definition_without_block
+        td = connection.build_create_table_definition(:test)
+
+        id_column = td.columns.find { |col| col.name == "id" }
+        assert_predicate id_column, :present?
+      end
+
+      def test_build_create_join_table_definition_with_block
+        assert connection.table_exists?(:posts)
+        assert connection.table_exists?(:comments)
+
+        join_td = connection.build_create_join_table_definition(:posts, :comments) do |t|
+          t.column :another_col, :string
+        end
+
+        assert_equal :comments_posts, join_td.name
+        assert_equal ["another_col", "comment_id", "post_id"], join_td.columns.map(&:name).sort
+      end
+
+      def test_build_create_join_table_definition_without_block
+        assert connection.table_exists?(:posts)
+        assert connection.table_exists?(:comments)
+
+        join_td = connection.build_create_join_table_definition(:posts, :comments)
+
+        assert_equal :comments_posts, join_td.name
+        assert_equal ["comment_id", "post_id"], join_td.columns.map(&:name).sort
+      end
+
+      def test_build_create_index_definition
+        connection.create_table(:test) do |t|
+          t.column :foo, :string
+        end
+        create_index = connection.build_create_index_definition(:test, :foo)
+
+        assert_equal "index_test_on_foo", create_index.index.name
+      ensure
+        connection.drop_table(:test) if connection.table_exists?(:test)
+      end
+
+      if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+        def test_build_create_index_definition_for_existing_index
+          connection.create_table(:test) do |t|
+            t.column :foo, :string
+          end
+          connection.add_index(:test, :foo)
+
+          create_index = connection.build_create_index_definition(:test, :foo, if_not_exists: true)
+          assert_nil create_index
+        ensure
+          connection.drop_table(:test) if connection.table_exists?(:test)
+        end
+      end
+
+      unless current_adapter?(:SQLite3Adapter)
+        def test_build_change_column_definition
+          connection.create_table(:test) do |t|
+            t.column :foo, :string
+          end
+
+          change_cd = connection.build_change_column_definition(:test, :foo, :integer)
+          change_col = change_cd.column
+          assert_equal "foo", change_col.name.to_s
+        ensure
+          connection.drop_table(:test) if connection.table_exists?(:test)
+        end
+
+        def test_build_change_column_default_definition
+          connection.create_table(:test) do |t|
+            t.column :foo, :string
+          end
+
+          change_default_cd = connection.build_change_column_default_definition(:test, :foo, "new")
+          assert_equal "new", change_default_cd.default
+
+          change_col = change_default_cd.column
+          assert_equal "foo", change_col.name.to_s
+        ensure
+          connection.drop_table(:test) if connection.table_exists?(:test)
+        end
+      end
+    end
+  end
+end

data/test/cases/migration/unique_constraint_test.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_unique_constraints?
+  module ActiveRecord
+    class Migration
+      class UniqueConstraintTest < ActiveRecord::TestCase
+        include SchemaDumpingHelper
+
+        class Section < ActiveRecord::Base
+        end
+
+        setup do
+          @connection = ActiveRecord::Base.lease_connection
+          @connection.create_table "sections", force: true do |t|
+            t.integer "position", null: false
+          end
+        end
+
+        teardown do
+          @connection.drop_table "sections", if_exists: true
+        end
+
+        def test_unique_constraints
+          skip "DB2 does not provide PostgreSQL-style unique constraint metadata fixtures" if current_adapter?(:IBM_DBAdapter)
+
+          unique_constraints = @connection.unique_constraints("test_unique_constraints")
+
+          expected_constraints = [
+            {
+              name: "test_unique_constraints_position_deferrable_false",
+              deferrable: false,
+              column: ["position_1"]
+            }, {
+              name: "test_unique_constraints_position_deferrable_immediate",
+              deferrable: :immediate,
+              column: ["position_2"]
+            }, {
+              name: "test_unique_constraints_position_deferrable_deferred",
+              deferrable: :deferred,
+              column: ["position_3"]
+            }, {
+              name: "test_unique_constraints_position_nulls_not_distinct",
+              nulls_not_distinct: true,
+              column: ["position_4"]
+            }
+          ]
+
+          assert_equal expected_constraints.size, unique_constraints.size
+
+          expected_nulls_not_distinct = expected_constraints.pop
+
+          expected_constraints.each do |expected_constraint|
+            constraint = unique_constraints.find { |constraint| constraint.name == expected_constraint[:name] }
+            assert_equal "test_unique_constraints", constraint.table_name
+            assert_equal expected_constraint[:name], constraint.name
+            assert_equal expected_constraint[:column], constraint.column
+            assert_equal expected_constraint[:deferrable], constraint.deferrable
+          end
+
+          if supports_nulls_not_distinct?
+            constraint = unique_constraints.find { |constraint| constraint.name == expected_nulls_not_distinct[:name] }
+            assert_equal "test_unique_constraints", constraint.table_name
+            assert_equal expected_nulls_not_distinct[:name], constraint.name
+            assert_equal expected_nulls_not_distinct[:column], constraint.column
+            assert_equal expected_nulls_not_distinct[:nulls_not_distinct], constraint.nulls_not_distinct
+          end
+        end
+
+        def test_unique_constraints_scoped_to_schemas
+          skip "DB2 CREATE SCHEMA requires privileges not available for this test user" if current_adapter?(:IBM_DBAdapter)
+
+          @connection.add_unique_constraint :sections, [:position]
+
+          assert_no_changes -> { @connection.unique_constraints("sections").size } do
+            @connection.create_schema "test_schema"
+            @connection.create_table "test_schema.sections" do |t|
+              t.integer :position
+            end
+            @connection.add_unique_constraint "test_schema.sections", [:position]
+          end
+        ensure
+          @connection.drop_schema "test_schema"
+        end
+
+        def test_add_unique_constraint_without_deferrable
+          @connection.add_unique_constraint :sections, [:position]
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal false, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_false
+          @connection.add_unique_constraint :sections, [:position], deferrable: false
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal false, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_immediate
+          skip "DB2 adapter does not expose deferrable state for unique constraints" if current_adapter?(:IBM_DBAdapter)
+
+          @connection.add_unique_constraint :sections, [:position], deferrable: :immediate
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal :immediate, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_deferred
+          skip "DB2 adapter does not expose deferrable state for unique constraints" if current_adapter?(:IBM_DBAdapter)
+
+          @connection.add_unique_constraint :sections, [:position], deferrable: :deferred
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_1e07660b77", constraint.name
+          assert_equal :deferred, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_deferrable_invalid
+          error = assert_raises(ArgumentError) do
+            @connection.add_unique_constraint :sections, [:position], deferrable: true
+          end
+
+          assert_equal "deferrable must be `:immediate` or `:deferred`, got: `true`", error.message
+        end
+
+        def test_added_deferrable_initially_immediate_unique_constraint
+          skip "DB2 CLI driver reports function-sequence errors for deferred unique-constraint checks" if current_adapter?(:IBM_DBAdapter)
+
+          @connection.add_unique_constraint :sections, [:position], deferrable: :immediate, name: "unique_section_position"
+
+          section = Section.create!(position: 1)
+
+          assert_raises(ActiveRecord::StatementInvalid) do
+            Section.transaction(requires_new: true) do
+              Section.create!(position: 1)
+              section.update!(position: 2)
+            end
+          end
+
+          assert_nothing_raised do
+            Section.transaction(requires_new: true) do
+              Section.lease_connection.exec_query("SET CONSTRAINTS unique_section_position DEFERRED")
+              Section.create!(position: 1)
+              section.update!(position: 2)
+
+              # NOTE: Clear `SET CONSTRAINTS` statement at the end of transaction.
+              raise ActiveRecord::Rollback
+            end
+          end
+        end
+
+        def test_add_unique_constraint_with_name_and_using_index
+          skip "DB2 does not support ADD UNIQUE CONSTRAINT ... USING INDEX syntax" if current_adapter?(:IBM_DBAdapter)
+
+          @connection.add_index :sections, [:position], name: "unique_index", unique: true
+          @connection.add_unique_constraint :sections, name: "unique_constraint", deferrable: :immediate, using_index: "unique_index"
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "unique_constraint", constraint.name
+          assert_equal ["position"], constraint.column
+          assert_equal :immediate, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_only_using_index
+          skip "DB2 does not support ADD UNIQUE CONSTRAINT ... USING INDEX syntax" if current_adapter?(:IBM_DBAdapter)
+
+          @connection.add_index :sections, [:position], name: "unique_index", unique: true
+          @connection.add_unique_constraint :sections, using_index: "unique_index"
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal "uniq_rails_79b901ffb4", constraint.name
+          assert_equal ["position"], constraint.column
+          assert_equal false, constraint.deferrable
+        end
+
+        def test_add_unique_constraint_with_columns_and_using_index
+          @connection.add_index :sections, [:position], name: "unique_index", unique: true
+
+          assert_raises(ArgumentError) do
+            @connection.add_unique_constraint :sections, [:position], using_index: "unique_index"
+          end
+        end
+
+        def test_remove_unique_constraint
+          @connection.add_unique_constraint :sections, [:position], name: :unique_section_position
+          assert_equal 1, @connection.unique_constraints("sections").size
+          @connection.remove_unique_constraint :sections, name: :unique_section_position
+          assert_empty @connection.unique_constraints("sections")
+        end
+
+        def test_remove_unique_constraint_by_column
+          @connection.add_unique_constraint :sections, [:position]
+          assert_equal 1, @connection.unique_constraints("sections").size
+          @connection.remove_unique_constraint :sections, [:position]
+          assert_empty @connection.unique_constraints("sections")
+        end
+
+        def test_remove_non_existing_unique_constraint
+          assert_raises(ArgumentError, match: /Table 'sections' has no unique constraint/) do
+            @connection.remove_unique_constraint :sections, name: "nonexistent"
+          end
+        end
+
+        def test_renamed_unique_constraint
+          @connection.add_unique_constraint :sections, [:position]
+          @connection.rename_column :sections, :position, :new_position
+
+          unique_constraints = @connection.unique_constraints("sections")
+          assert_equal 1, unique_constraints.size
+
+          constraint = unique_constraints.first
+          assert_equal "sections", constraint.table_name
+          assert_equal ["new_position"], constraint.column
+        end
+      end
+    end
+  end
+end