Auto-enable identity primary keys in Migration[8.2]+

Phase 2 of #2579: build on the explicit `identity:` option from Phase 1
and switch the default for migrations declared at
`ActiveRecord::Migration[8.2]` or later. Older migration versions,
`Schema.define`, and direct `connection.create_table` keep the existing
sequence + trigger behavior, so existing applications see no change
unless they explicitly adopt `Migration[8.2]`.

Wired through the new per-adapter extension point
`AbstractAdapter#migration_compatibility_module_for(migration_class)`
from yahonda/rails `per-adapter-migration-compatibility` (not yet on
rails master). The Gemfile temporarily points at that branch; once the
Rails commit lands on `rails/rails#main` the Gemfile reference can be
reverted.

Architecture: two compat modules layered via Rails' versioned dispatch.
`V8_2` forces `identity: true` for the current default; `V8_1` forces
`identity: false` to preserve legacy behavior on older migrations. The
adapter's underlying `create_table` honors `options[:identity]` exactly
as given and does no auto-injection, so callers outside the migration
compat chain (`Schema.define`, direct `connection.create_table`) keep
sequence-backed PKs by default. `db/schema.rb` roundtrips remain safe
because the schema dumper now emits `identity: true` / `identity: false`
explicitly for every primary-key table.

`V8_2` also treats explicit Oracle sequence options as opt-out: when
`sequence_name:` or `sequence_start_value:` is given, the requested
sequence is created and the PK stays sequence-backed.

`V8_2` pre-checks `connection.supports_identity_columns?` so
`Migration[8.2]+` on Oracle <12.1 silently falls back to the legacy
sequence path instead of triggering the Phase 1 ArgumentError. Per-table
opt-out remains via `identity: false`; per-migration opt-out via
`Migration[8.1]` or earlier.

`rename_table` and `drop_table` are now identity-aware: they no longer
rename or drop `<table>_seq` for tables whose primary key is an Oracle
identity column. Previously, an unrelated application-owned sequence
sharing that name would be silently mutated or removed when the table
was renamed/dropped.

Author: yahonda

Gemfile

@@ -8,7 +8,7 @@ group :development do
   gem "rspec"
   gem "rdoc"
   gem "rake"
-  gem "activerecord",   github: "rails/rails", branch: "main"
+  gem "activerecord",   github: "yahonda/rails", branch: "per-adapter-migration-compatibility"
   gem "ruby-plsql", github: "rsim/ruby-plsql", branch: "master"
 
   platforms :ruby do

lib/active_record/connection_adapters/oracle_enhanced/migration_compatibility.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module MigrationCompatibility # :nodoc: all
+        extend ActiveRecord::Migration::Compatibility::Versioned
+
+        module V8_2
+          def create_table(table_name, **options)
+            options[:identity] = true if oracle_enhanced_default_to_identity?(options)
+            super
+          end
+
+          private
+            def oracle_enhanced_default_to_identity?(options)
+              return false if options.key?(:identity)
+              return false if options[:sequence_name] || options[:sequence_start_value]
+              return false if options.fetch(:id, :primary_key) != :primary_key
+              return false if options[:primary_key].is_a?(Array)
+              connection.supports_identity_columns?
+            end
+        end
+
+        module V8_1
+          def create_table(table_name, **options)
+            options[:identity] = false unless options.key?(:identity)
+            super
+          end
+        end
+      end
+    end
+  end
+end

lib/active_record/connection_adapters/oracle_enhanced/schema_dumper.rb

@@ -187,6 +187,8 @@ def table(table, stream)
                   tbl.print ", primary_key_trigger: true"
                   default_name = @connection.default_trigger_name(table).upcase
                   tbl.print ", trigger_name: #{trigger_name.downcase.inspect}" unless trigger_name == default_name
+                elsif @connection.supports_identity_columns?
+                  tbl.print ", identity: false"
                 end
               when Array
                 tbl.print ", primary_key: #{pk.inspect}"

lib/active_record/connection_adapters/oracle_enhanced/schema_statements.rb

@@ -263,8 +263,11 @@ def rename_table(table_name, new_name, **options) # :nodoc:
           end
           schema_cache.clear_data_source_cache!(table_name.to_s)
           schema_cache.clear_data_source_cache!(new_name.to_s)
+          identity_pk = identity_pk?(table_name)
           execute "RENAME #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
-          execute "RENAME #{default_sequence_name(table_name, nil)} TO #{default_sequence_name(new_name, nil)}" rescue nil
+          unless identity_pk
+            execute "RENAME #{default_sequence_name(table_name, nil)} TO #{default_sequence_name(new_name, nil)}" rescue nil
+          end
           rename_pk_trigger(table_name, new_name)
           clear_table_caches(table_name)
           clear_table_caches(new_name)
@@ -281,10 +284,13 @@ def drop_table(*table_names, **options) # :nodoc:
 
           table_names.each do |table_name|
             schema_cache.clear_data_source_cache!(table_name.to_s)
-            seq_name = custom_sequence_name || default_sequence_name(table_name, nil)
+            # Identity-backed tables never carry a default `<table>_seq`, so
+            # skip the sequence drop entirely on those. `identity_pk?` must
+            # run before the table drop, while the table is still present.
+            seq_name = custom_sequence_name || (identity_pk?(table_name) ? nil : default_sequence_name(table_name, nil))
 
             drop_if_exists("TABLE", table_name, cascade_constraints: cascade, if_exists: if_exists)
-            drop_if_exists("SEQUENCE", seq_name, if_exists: true)
+            drop_if_exists("SEQUENCE", seq_name, if_exists: true) if seq_name
           ensure
             clear_table_caches(table_name)
           end
@@ -1215,6 +1221,18 @@ def missing_object_ora_code?(message, object_type)
             code && message.include?(code)
           end
 
+          # True when +table_name+ exists and its primary key column is an Oracle
+          # identity column. Returns false when the table is not present (e.g.
+          # +drop_table if_exists:+ for a missing table) or when the database does
+          # not support identity columns.
+          def identity_pk?(table_name)
+            return false unless supports_identity_columns?
+            owner, desc_table_name = resolve_data_source_name(table_name)
+            identity_primary_key?(owner, desc_table_name)
+          rescue OracleEnhanced::ConnectionException
+            false
+          end
+
           def index_column_names(column_names) # :nodoc:
             column_names.is_a?(Array) ? column_names : Array(column_names)
           end

lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -38,6 +38,7 @@
 require "active_record/connection_adapters/oracle_enhanced/deprecator"
 require "active_record/connection_adapters/oracle_enhanced/connection"
 require "active_record/connection_adapters/oracle_enhanced/database_statements"
+require "active_record/connection_adapters/oracle_enhanced/migration_compatibility"
 require "active_record/connection_adapters/oracle_enhanced/schema_creation"
 require "active_record/connection_adapters/oracle_enhanced/schema_definitions"
 require "active_record/connection_adapters/oracle_enhanced/schema_dumper"
@@ -619,6 +620,10 @@ def use_dbms_metadata_dump? # :nodoc:
         database_version >= "12.1"
       end
 
+      def migration_compatibility_module_for(migration_class) # :nodoc:
+        OracleEnhanced::MigrationCompatibility.module_for(migration_class)
+      end
+
       def supports_json?
         # Oracle Database 12.1 or higher version supports JSON.
         # However, Oracle enhanced adapter has limited support for JSON data type.

spec/active_record/connection_adapters/oracle_enhanced/identity_primary_key_spec.rb

@@ -336,6 +336,7 @@ def identity_column_exists?(table_name, column_name)
       ActiveRecord::SchemaDumper.ignore_tables = []
 
       expect(stream.string).to include('create_table "test_identity_pks"')
+      expect(stream.string).to include("identity: false")
       expect(stream.string).not_to include("identity: true")
     end
   end
@@ -352,4 +353,111 @@ def identity_column_exists?(table_name, column_name)
       }.to raise_error(NotImplementedError)
     end
   end
+
+  describe "identity counterparts to sequence-prerequisite behavior" do
+    before do
+      skip "requires Oracle 12.1+" unless @oracle12c_or_higher
+    end
+
+    it "renames a long-named identity table without touching a non-existent sequence" do
+      long_source = "a" * (@conn.max_identifier_length - 3)
+      schema_define do
+        create_table long_source.to_sym, force: true, identity: true do |t|
+          t.string :name
+        end
+      end
+
+      expected_old_seq = @conn.default_sequence_name(long_source, nil).upcase
+      expected_new_seq = @conn.default_sequence_name("renamed_identity_long", nil).upcase
+
+      expect {
+        @conn.rename_table(long_source, "renamed_identity_long")
+      }.not_to raise_error
+
+      sequences = @conn.select_values(
+        "SELECT sequence_name FROM user_sequences WHERE sequence_name IN ('#{expected_old_seq}', '#{expected_new_seq}')"
+      )
+      expect(sequences).to be_empty
+    ensure
+      schema_define do
+        drop_table :renamed_identity_long, if_exists: true
+        drop_table long_source.to_sym, if_exists: true
+      end
+    end
+
+    it "returns a nil sequence_name from pk_and_sequence_for for identity tables" do
+      schema_define do
+        create_table :test_identity_pks, identity: true do |t|
+          t.string :name
+        end
+      end
+
+      expect(@conn.pk_and_sequence_for(:test_identity_pks)).to eq(["id", nil])
+    end
+
+    it "does not query NEXTVAL when inserting into an identity table" do
+      schema_define do
+        create_table :test_identity_pks, identity: true do |t|
+          t.string :name
+        end
+      end
+      klass = Class.new(ActiveRecord::Base) { self.table_name = "test_identity_pks" }
+
+      set_logger
+      begin
+        klass.create!(name: "alpha")
+        klass.create!(name: "bravo")
+        expect(@logger.output(:debug)).not_to match(/NEXTVAL/i)
+      ensure
+        clear_logger
+      end
+    end
+
+    it "omits DROP SEQUENCE from full_drop output for identity-backed tables" do
+      schema_define do
+        create_table :test_identity_pks, identity: true do |t|
+          t.string :name
+        end
+      end
+
+      drop = @conn.full_drop
+
+      expect(drop).to match(/DROP TABLE "TEST_IDENTITY_PKS" CASCADE CONSTRAINTS/)
+      expect(drop).not_to match(/DROP SEQUENCE "TEST_IDENTITY_PKS_SEQ"/)
+    end
+
+    it "rename_table leaves an unrelated <table>_seq sequence alone for identity tables" do
+      schema_define do
+        create_table :test_identity_pks, identity: true do |t|
+          t.string :name
+        end
+      end
+      @conn.execute "CREATE SEQUENCE test_identity_pks_seq"
+
+      @conn.rename_table(:test_identity_pks, :test_identity_pks_renamed)
+
+      expect(sequence_exists?(:test_identity_pks_seq)).to be true
+      expect(sequence_exists?(:test_identity_pks_renamed_seq)).to be false
+    ensure
+      @conn.execute("DROP SEQUENCE test_identity_pks_seq") rescue nil
+      schema_define do
+        drop_table :test_identity_pks_renamed, if_exists: true
+      end
+    end
+
+    it "drop_table leaves an unrelated <table>_seq sequence alone for identity tables" do
+      schema_define do
+        create_table :test_identity_pks, identity: true do |t|
+          t.string :name
+        end
+      end
+      @conn.execute "CREATE SEQUENCE test_identity_pks_seq"
+
+      @conn.drop_table(:test_identity_pks)
+
+      expect(sequence_exists?(:test_identity_pks_seq)).to be true
+    ensure
+      @conn.execute("DROP SEQUENCE test_identity_pks_seq") rescue nil
+    end
+  end
 end