Default to identity primary keys in Migration[8.2]+

Adopt identity primary keys as the default for `Migration[8.2]` and
later when the server supports them (Oracle Database 12.1+); preserve
sequence-backed primary keys for `Migration[8.1]` and earlier, for
schema loads, and for direct `connection.create_table` calls so
existing schemas and dumps replay unchanged.

* New `OracleEnhanced::CompatibilityBehavior` (`extend Base::Resolver`)
  routes the per-version behavior via Rails'
  `compatibility_behavior_for(migration_class)` hook:
  * `V8_2` forces `options[:identity] = true` when the option is
    omitted, no sequence options exist, the connection supports
    identity columns, and the caller is not a schema load — detected
    via `ActiveRecord::Schema::Definition`, which plain `Schema.define`
    and versioned `ActiveRecord::Schema[x.y].define` (the form schema
    dumps actually use; its anonymous class is not a subclass of
    `ActiveRecord::Schema`) both include — so dump -> load -> dump
    stays idempotent.
  * `primary_key_trigger: true` (an inherently sequence-backed
    mechanism) also opts out, like `sequence_name:` and
    `sequence_start_value:`, instead of raising about an
    `identity: true` the migration author never wrote.
  * `V8_1` forces `options[:identity] = false` to keep the pre-8.2
    sequence default on older migrations.
* `rename_table` and `drop_table` become identity-aware: they skip the
  paired `<table>_seq` rename/drop when the table's primary key is an
  Oracle identity column, so unrelated application-owned sequences with
  matching names are left untouched.
* The schema dumper emits `identity: true` for identity-backed primary
  keys. Sequence-backed primary keys carry no annotation: `identity:
  false` is the adapter's baseline default (schema loads, direct
  `connection.create_table`, and Migration[8.1] and earlier all keep the
  sequence default), so emitting it on every sequence-backed table would
  be redundant for reload and only add schema.rb churn.
* The "identity counterparts" spec block now actually runs (its guard
  read an instance variable never assigned in that file) and its
  NEXTVAL assertion matches sequence fetches (`.NEXTVAL`) rather than
  the has_primary_key_trigger? lookup SQL.
* Gemfile points activerecord at yahonda/rails
  per-adapter-migration-compatibility-v7 for the framework dispatch.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

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-v7"
   gem "ruby-plsql", github: "rsim/ruby-plsql", branch: "master"
 
   platforms :ruby do

lib/active_record/connection_adapters/oracle_enhanced/compatibility_behavior.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module CompatibilityBehavior # :nodoc: all
+        Base = ActiveRecord::Migration::CompatibilityBehavior
+        extend Base::Resolver
+
+        # Migration[8.2]+ migrations default to an Oracle identity primary
+        # key when the server supports it. Schema loads (plain and versioned
+        # `ActiveRecord::Schema[x.y].define`, both including
+        # +ActiveRecord::Schema::Definition+) and direct adapter calls keep
+        # the adapter's pre-existing sequence default so that schema dumps
+        # written by older releases reload unchanged. An explicit
+        # `identity:` value always wins.
+        class V8_2 < Base
+          def create_table(table_name, **options)
+            options[:identity] = true if default_to_identity?(options)
+            super
+          end
+
+          private
+            def default_to_identity?(options)
+              return false if migration.is_a?(ActiveRecord::Schema::Definition)
+              return false if options.key?(:identity)
+              return false if options[:sequence_name] || options[:sequence_start_value]
+              return false if options[:primary_key_trigger]
+              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
+
+        # Migration[8.1] and earlier keep the pre-8.2 sequence-backed primary
+        # key default so existing migrations replay unchanged.
+        class V8_1 < V8_2
+          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_statements.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "openssl"
+require "active_record/connection_adapters/oracle_enhanced/compatibility_behavior"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -10,6 +11,10 @@ module SchemaStatements
         #
         # see: abstract/schema_statements.rb
 
+        def compatibility_behavior_for(migration_class) # :nodoc:
+          OracleEnhanced::CompatibilityBehavior.for(migration_class)
+        end
+
         def tables # :nodoc:
           select_values(<<~SQL.squish, "SCHEMA")
             SELECT
@@ -263,8 +268,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 +289,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
@@ -1231,6 +1242,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

spec/active_record/connection_adapters/oracle_enhanced/identity_primary_key_spec.rb

@@ -336,7 +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).not_to include("identity: true")
+      expect(stream.string).not_to include("identity:")
     end
   end
 
@@ -352,4 +352,114 @@ 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 @conn.database_version >= "12"
+    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")
+        # Match sequence fetches (`"<name>_SEQ".NEXTVAL`) but not the
+        # has_primary_key_trigger? lookup, whose SQL text contains the
+        # literal 'NEXTVAL INTO :NEW'.
+        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