Honor foreign_keys: false database.yml option

Rails 7.1 (rails/rails#45301) introduced an adapter option that lets
applications opt out of foreign-key constraints via database.yml:

    production:
      adapter: oracle_enhanced
      ...
      foreign_keys: false

The Rails helper use_foreign_keys? (= supports_foreign_keys? &&
@config.fetch(:foreign_keys, true)) is then used to gate
add_foreign_key, remove_foreign_key, foreign_key_for, and
SchemaCreation FK emission.

oracle-enhanced's SchemaCreation#visit_TableDefinition already routes
through use_foreign_keys?, and remove_foreign_key/foreign_key_for are
inherited unchanged so Rails core's gates apply. Two oracle-enhanced
overrides needed adjustment:

* OracleEnhanced::SchemaDumper#tables overrides Rails' base method and
  emitted add_foreign_key lines unconditionally. Apply the gate inline
  next to divergent_unique_constraints(tbl, stream) so the original
  per-table interleave (FK_a -> UC_a -> FK_b -> UC_b) is preserved.
  This matches PR #45301's original dumper-gate intent; rails/rails#48731
  (Feb 2024) inadvertently reverted that gate to supports_foreign_keys?
  upstream, so adopting use_foreign_keys? here lets Oracle users
  actually benefit from foreign_keys: false.

* OracleEnhanced::SchemaStatements#add_foreign_key ran
  assert_valid_deferrable before delegating to super, so an invalid
  deferrable: value still raised when FKs were globally disabled.
  return unless use_foreign_keys? at the top of the override matches
  Rails core's contract (silent no-op) and mirrors the first line of
  Rails' own add_foreign_key in abstract/schema_statements.rb.

Specs stub @conn.use_foreign_keys? rather than re-establishing the
connection with foreign_keys: false. Pool replacement leaks a stale
@conn into other describe blocks under randomized order, which
otherwise surfaced as a tablespace-dump failure in
schema_dumper_spec.rb:571. The integration-style proof that
foreign_keys: false flows through to use_foreign_keys? is Rails core's
responsibility (foreign_keys_enabled? = @config.fetch(:foreign_keys,
true)) and is covered upstream. The new specs here cover the four
oracle-enhanced surfaces that must honor the flag: dumper output,
add_foreign_key no-op, deferrable validation skip, and SchemaCreation
inline FK suppression with an Oracle-invalid deferrable value.

structure.sql is intentionally left untouched. Rails core's per-adapter
Tasks::*DatabaseTasks#structure_dump (pg_dump / mysqldump / sqlite3)
does not gate on foreign_keys_enabled? / use_foreign_keys? because
structure dumps reflect live DB state, not adapter config. Oracle's
structure_dump (lib/.../oracle_enhanced/structure_dump.rb) is left
likewise: migrations run with foreign_keys: false create no FKs so
the structure dump has nothing to emit; if FKs already exist in the
DB they surface in structure.sql exactly as pg_dump would.

Targets master only (Rails 8.2.alpha).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: yahonda

lib/active_record/connection_adapters/oracle_enhanced/schema_dumper.rb

@@ -27,7 +27,7 @@ def tables(stream)
             # add foreign keys if table has them
             sorted_tables.each do |tbl|
               next if ignored? tbl
-              foreign_keys(tbl, stream)
+              foreign_keys(tbl, stream) if @connection.use_foreign_keys?
               divergent_unique_constraints(tbl, stream)
             end
 

lib/active_record/connection_adapters/oracle_enhanced/schema_statements.rb

@@ -735,6 +735,7 @@ def tablespace(table_name)
         end
 
         def add_foreign_key(from_table, to_table, **options)
+          return unless use_foreign_keys?
           assert_valid_deferrable(options[:deferrable])
 
           super

spec/active_record/connection_adapters/oracle_enhanced/schema_dumper_spec.rb

@@ -440,6 +440,84 @@ def drop_test_posts_table
     end
   end
 
+  describe "with use_foreign_keys? returning false (foreign_keys: false in database.yml)" do
+    before(:each) do
+      schema_define do
+        drop_table :test_comments, if_exists: true
+        drop_table :test_posts, if_exists: true
+        create_table :test_posts, force: true do |t|
+          t.string :title
+        end
+        create_table :test_comments, force: true do |t|
+          t.string :body, limit: 4000
+          t.references :test_post
+        end
+      end
+    end
+
+    after(:each) do
+      schema_define do
+        remove_foreign_key :test_comments, :test_posts, if_exists: true
+        drop_table :test_comments, if_exists: true
+        drop_table :test_posts, if_exists: true
+      end
+    end
+
+    it "schema dump omits add_foreign_key statements" do
+      schema_define do
+        add_foreign_key :test_comments, :test_posts
+      end
+      allow(@conn).to receive(:use_foreign_keys?).and_return(false)
+      expect(standard_dump).not_to match(/add_foreign_key/)
+    end
+
+    it "add_foreign_key is a silent no-op" do
+      allow(@conn).to receive(:use_foreign_keys?).and_return(false)
+      expect {
+        schema_define do
+          add_foreign_key :test_comments, :test_posts
+        end
+      }.not_to raise_error
+      expect(@conn.foreign_keys("test_comments")).to be_empty
+    end
+
+    it "add_foreign_key skips deferrable validation" do
+      allow(@conn).to receive(:use_foreign_keys?).and_return(false)
+      expect {
+        schema_define do
+          add_foreign_key :test_comments, :test_posts, deferrable: :always
+        end
+      }.not_to raise_error
+      expect(@conn.foreign_keys("test_comments")).to be_empty
+    end
+
+    it "create_table with inline t.references foreign_key: true does not create the FK" do
+      allow(@conn).to receive(:use_foreign_keys?).and_return(false)
+      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, foreign_key: true
+        end
+      end
+      expect(@conn.foreign_keys("test_comments")).to be_empty
+    end
+
+    it "create_table inline t.references with an Oracle-invalid deferrable does not raise" do
+      allow(@conn).to receive(:use_foreign_keys?).and_return(false)
+      expect {
+        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, foreign_key: { deferrable: :always }
+          end
+        end
+      }.not_to raise_error
+      expect(@conn.foreign_keys("test_comments")).to be_empty
+    end
+  end
+
   describe "synonyms" do
     after(:each) do
       schema_define do