Merge pull request #2793 from yahonda/enforced-foreign-key

Support enforced: option on foreign keys

Author: yahonda

lib/active_record/connection_adapters/oracle_enhanced/schema_creation.rb

@@ -85,10 +85,28 @@ def add_column_options!(sql, options)
             end
           end
 
+          # `enforced:` and `validate:` map to Oracle's 4-state constraint model.
+          # Both defaults are `true`; the options are independent.
+          #
+          # | enforced | validate | Oracle state      | DML on the child table        |
+          # |----------|----------|-------------------|-------------------------------|
+          # | true     | true     | ENABLE VALIDATE   | enforced, existing data valid |
+          # | true     | false    | ENABLE NOVALIDATE | enforced for new DML only     |
+          # | false    | true     | DISABLE VALIDATE  | blocked (ORA-25128)           |
+          # | false    | false    | DISABLE NOVALIDATE| not enforced (~ PG NOT ENFORCED) |
+          #
+          # Oracle's bare `DISABLE` clause defaults to `NOVALIDATE`, so when
+          # `enforced: false` and `validate: true` (the Rails default), `VALIDATE`
+          # is emitted explicitly to preserve the user's intent.
           def visit_ForeignKeyDefinition(o)
             super.dup.tap do |sql|
               sql << " DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
-              sql << " NOVALIDATE" unless o.validate?
+              sql << " DISABLE" unless o.enforced?
+              if !o.validate?
+                sql << " NOVALIDATE"
+              elsif !o.enforced?
+                sql << " VALIDATE"
+              end
             end
           end
 

lib/active_record/connection_adapters/oracle_enhanced/schema_statements.rb

@@ -754,6 +754,7 @@ def foreign_keys(table_name) # :nodoc:
                   ,c.deferrable
                   ,c.deferred
                   ,c.validated
+                  ,c.status
               FROM all_constraints c, all_cons_columns cc,
                    all_constraints r, all_cons_columns rc
              WHERE c.owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -777,6 +778,7 @@ def foreign_keys(table_name) # :nodoc:
             }
             options[:on_delete] = extract_foreign_key_action(row["delete_rule"])
             options[:deferrable] = extract_foreign_key_deferrable(row["deferrable"], row["deferred"])
+            options[:enforced] = false if row["status"] == "DISABLED"
             options[:validate] = false if row["validated"] == "NOT VALIDATED"
             ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(oracle_downcase(table_name), oracle_downcase(row["to_table"]), options)
           end
@@ -822,6 +824,20 @@ def validate_foreign_key(from_table, to_table = nil, **options) # :nodoc:
           validate_constraint(from_table, fk_name_to_validate)
         end
 
+        # Accepted options: +:enforced+ (the only mutable axis) plus the identifying
+        # keys +:column+, +:name+, +:to_table+ passed through to +foreign_key_for!+.
+        # ALTER ... MODIFY CONSTRAINT name DISABLE/ENABLE follows Oracle's defaults:
+        # bare DISABLE leaves the constraint at DISABLE NOVALIDATE, and bare ENABLE
+        # at ENABLE VALIDATE; introspection reflects those side effects on +:validate+.
+        def change_foreign_key(from_table, to_table = nil, **options) # :nodoc:
+          unless options.key?(:enforced)
+            raise ArgumentError, "change_foreign_key requires at least one option (e.g. enforced:)"
+          end
+          enforced = options[:enforced]
+          fk_name = foreign_key_for!(from_table, to_table: to_table, **options.except(:enforced)).name
+          execute "ALTER TABLE #{quote_table_name(from_table)} MODIFY CONSTRAINT #{quote_column_name(fk_name)} #{enforced ? 'ENABLE' : 'DISABLE'}"
+        end
+
         # Returns an array of unique constraints for the given table.
         # The unique constraints are represented as UniqueConstraintDefinition objects.
         def unique_constraints(table_name) # :nodoc:

lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -527,6 +527,10 @@ def supports_validate_constraints?
         true
       end
 
+      def supports_enforced_foreign_keys?
+        true
+      end
+
       def supports_expression_index?
         true
       end

spec/active_record/connection_adapters/oracle_enhanced/schema_dumper_spec.rb

@@ -388,6 +388,57 @@ def drop_test_posts_table
       expect(fk.options[:validate]).to be(false)
     end
 
+    it "dumps enforced: false for DISABLEd foreign keys" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, enforced: false
+      end
+      output = dump_table_schema "test_comments"
+      expect(output).to match(/add_foreign_key "test_comments", "test_posts".*enforced: false/)
+    end
+
+    it "round-trips enforced: false alone (DISABLE VALIDATE) through dump and load" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, enforced: false
+      end
+
+      dumped = dump_table_schema "test_comments"
+      expect(dumped).to match(/add_foreign_key "test_comments", "test_posts".*enforced: false/)
+      expect(dumped).not_to match(/validate: /)
+
+      schema_define do
+        remove_foreign_key :test_comments, :test_posts, if_exists: true
+      end
+
+      body = dumped[/ActiveRecord::Schema\[.+?\]\.define\(version: \d+\) do\n(.+)\nend\s*\z/m, 1]
+      schema_define { instance_eval(body) }
+
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk).not_to be_nil
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options.key?(:validate)).to be(false)
+    end
+
+    it "round-trips enforced: false, validate: false (DISABLE NOVALIDATE) through dump and load" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, enforced: false, validate: false
+      end
+
+      dumped = dump_table_schema "test_comments"
+      expect(dumped).to match(/add_foreign_key "test_comments", "test_posts".*validate: false.*enforced: false/)
+
+      schema_define do
+        remove_foreign_key :test_comments, :test_posts, if_exists: true
+      end
+
+      body = dumped[/ActiveRecord::Schema\[.+?\]\.define\(version: \d+\) do\n(.+)\nend\s*\z/m, 1]
+      schema_define { instance_eval(body) }
+
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk).not_to be_nil
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options[:validate]).to be(false)
+    end
+
     it "should not include foreign keys on ignored table regexes in schema dump" do
       schema_define do
         add_foreign_key :test_comments, :test_posts

spec/active_record/connection_adapters/oracle_enhanced/schema_statements_spec.rb

@@ -1950,6 +1950,120 @@ class ::TestComment < ActiveRecord::Base
       expect(fk).not_to be_nil
       expect(fk.options.key?(:validate)).to be(false)
     end
+
+    it "creates DISABLE VALIDATE when enforced: false is given (validate defaults to true)" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, enforced: false
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options.key?(:validate)).to be(false)
+      expect do
+        TestComment.create(body: "test", test_post_id: 1)
+      end.to raise_error(/ORA-25128/)
+    end
+
+    it "creates DISABLE NOVALIDATE when both enforced: false and validate: false are given (closest to PG NOT ENFORCED)" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, enforced: false, validate: false
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options[:validate]).to be(false)
+      expect do
+        TestComment.create(body: "test", test_post_id: 1)
+      end.not_to raise_error
+    end
+
+    it "leaves both :enforced and :validate absent when the foreign key is ENABLE VALIDATE" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options.key?(:enforced)).to be(false)
+      expect(fk.options.key?(:validate)).to be(false)
+    end
+
+    it "enables a DISABLEd foreign key via change_foreign_key" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, enforced: false, validate: false
+        change_foreign_key :test_comments, :test_posts, enforced: true
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options.key?(:enforced)).to be(false)
+      expect(fk.options.key?(:validate)).to be(false)
+      expect do
+        TestComment.create(body: "test", test_post_id: 1)
+      end.to raise_error(/ORA-02291/)
+    end
+
+    it "disables an ENFORCED foreign key via change_foreign_key" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts
+        change_foreign_key :test_comments, :test_posts, enforced: false
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options[:validate]).to be(false)
+      expect do
+        TestComment.create(body: "test", test_post_id: 1)
+      end.not_to raise_error
+    end
+
+    it "raises ArgumentError when change_foreign_key is called without :enforced" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts
+      end
+      expect do
+        ActiveRecord::Base.lease_connection.change_foreign_key :test_comments, :test_posts
+      end.to raise_error(ArgumentError, /change_foreign_key requires at least one option/)
+    end
+
+    it "toggles enforced via change_foreign_key identified by name:" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, name: "comments_posts_fk"
+        change_foreign_key :test_comments, name: "comments_posts_fk", enforced: false
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options[:enforced]).to be(false)
+    end
+
+    it "honors enforced: false on add_reference foreign_key option hash" do
+      schema_define do
+        drop_table :test_comments, if_exists: true
+        create_table :test_comments, force: true do |t|
+          t.string :body, limit: 4000
+        end
+        add_reference :test_comments, :test_post, foreign_key: { enforced: false, validate: false }
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options[:validate]).to be(false)
+    end
+
+    it "honors enforced: false on inline t.foreign_key inside create_table" do
+      schema_define do
+        drop_table :test_comments, if_exists: true
+        create_table :test_comments, force: true do |t|
+          t.string :body, limit: 4000
+          t.references :test_post
+          t.foreign_key :test_posts, enforced: false, validate: false
+        end
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options[:validate]).to be(false)
+    end
+
+    it "round-trips enforced: false combined with deferrable: :deferred" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts, enforced: false, validate: false, deferrable: :deferred
+      end
+      fk = ActiveRecord::Base.lease_connection.foreign_keys(:test_comments).first
+      expect(fk.options[:enforced]).to be(false)
+      expect(fk.options[:validate]).to be(false)
+      expect(fk.options[:deferrable]).to eq(:deferred)
+    end
   end
 
   describe "check constraints" do