Rails 7.x Compatibility

Gemfile

@@ -13,7 +13,10 @@ group :development do
   gem "rubocop-rails", require: false
   gem "rubocop-rspec", require: false
 
-  gem "activerecord",   github: "rails/rails", ref: "0e9267767f19065fa513038253179ad6b05c29ab"
+  #  gem "activerecord",   github: "rails/rails", ref: "3421e892afa532a254e54379ac2ce9bef138cf3f" # introduction of RETURNING code
+  #  gem "activerecord",   github: "rails/rails", ref: "c2c861f98ae25d0daa177898db48f12de1065cf6" # fix for RETURNING code on main (7.2.x)
+  #  gem "activerecord",   github: "rails/rails", ref: "221e609ee8cb1dfb686e43481f3e9496b549e974" # backport of RETURNING code to 7-1-stable
+  gem "activerecord",   github: "rails/rails", branch: "7-1-stable"
   gem "ruby-plsql", github: "rsim/ruby-plsql", branch: "master"
 
   platforms :ruby do

activerecord-oracle_enhanced-adapter.gemspec

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "rake"
-
 version = File.read(File.expand_path("../VERSION", __FILE__)).strip
 
 Gem::Specification.new do |s|
@@ -19,7 +17,7 @@ This adapter is superset of original ActiveRecord Oracle adapter.
   s.extra_rdoc_files = [
     "README.md"
   ]
-  s.files = FileList["History.md", "License.txt", "README.md", "VERSION", "lib/**/*"].exclude("lib/ojdbc*.jar")
+  s.files = Dir["History.md", "License.txt", "README.md", "VERSION", "lib/**/*"]
   s.homepage = "http://github.com/rsim/oracle-enhanced"
   s.require_paths = ["lib"]
   s.summary = "Oracle enhanced adapter for ActiveRecord"
@@ -28,7 +26,7 @@ This adapter is superset of original ActiveRecord Oracle adapter.
     "rubygems_mfa_required" => "true"
   }
 
-  s.add_runtime_dependency("activerecord", ["~> 7.1.0.alpha"])
+  s.add_runtime_dependency("activerecord", ["<= 8.0"])
   s.add_runtime_dependency("ruby-plsql", [">= 0.6.0"])
   if /java/.match?(RUBY_PLATFORM)
     s.platform = Gem::Platform.new("java")

lib/active_record/connection_adapters/oracle_enhanced/column.rb

@@ -13,6 +13,11 @@ def initialize(name, default, sql_type_metadata = nil, null = true, comment: nil
         def virtual?
           virtual
         end
+
+        def auto_incremented_by_db?
+          # TODO: Identify if a column is the primary key and is auto-incremented (e.g. by a sequence)
+          super
+        end
       end
     end
   end

lib/active_record/connection_adapters/oracle_enhanced/database_limits.rb

@@ -17,13 +17,13 @@ def table_alias_length # :nodoc:
         def table_name_length
           IDENTIFIER_MAX_LENGTH
         end
-        deprecate :table_name_length
+        deprecate :table_name_length, deprecator: ActiveSupport::Deprecation.new
 
         # the maximum length of a column name
         def column_name_length
           IDENTIFIER_MAX_LENGTH
         end
-        deprecate :column_name_length
+        deprecate :column_name_length, deprecator: ActiveSupport::Deprecation.new
 
         # the maximum length of an index name
         # supported by this database

lib/active_record/connection_adapters/oracle_enhanced/database_statements.rb

@@ -9,13 +9,13 @@ module DatabaseStatements
         # see: abstract/database_statements.rb
 
         # Executes a SQL statement
-        def execute(sql, name = nil, async: false)
+        def execute(sql, name = nil, async: false, allow_retry: false)
           sql = transform_query(sql)
 
-          log(sql, name, async: async) { @raw_connection.exec(sql) }
+          log(sql, name, async: async) { _connection.exec(sql, allow_retry: allow_retry) }
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false)
+        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false)
           sql = transform_query(sql)
 
           type_casted_binds = type_casted_binds(binds)
@@ -25,10 +25,10 @@ def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false)
             cached = false
             with_retry do
               if without_prepared_statement?(binds)
-                cursor = @raw_connection.prepare(sql)
+                cursor = _connection.prepare(sql)
               else
                 unless @statements.key? sql
-                  @statements[sql] = @raw_connection.prepare(sql)
+                  @statements[sql] = _connection.prepare(sql)
                 end
 
                 cursor = @statements[sql]
@@ -59,6 +59,7 @@ def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false)
             res
           end
         end
+        alias_method :internal_exec_query, :exec_query
 
         def supports_explain?
           true
@@ -77,22 +78,22 @@ def explain(arel, binds = [])
 
         # New method in ActiveRecord 3.1
         # Will add RETURNING clause in case of trigger generated primary keys
-        def sql_for_insert(sql, pk, binds)
+        def sql_for_insert(sql, pk, binds, _returning)
           unless pk == false || pk.nil? || pk.is_a?(Array) || pk.is_a?(String)
             sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
             (binds = binds.dup) << ActiveRecord::Relation::QueryAttribute.new("returning_id", nil, Type::OracleEnhanced::Integer.new)
           end
           super
         end
 
-        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
           pk = nil if id_value
-          super
+          Array(super || id_value)
         end
 
         # New method in ActiveRecord 3.1
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
-          sql, binds = sql_for_insert(sql, pk, binds)
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+          sql, binds = sql_for_insert(sql, pk, binds, returning)
           type_casted_binds = type_casted_binds(binds)
 
           log(sql, name, binds, type_casted_binds) do
@@ -101,10 +102,10 @@ def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
             returning_id_col = returning_id_index = nil
             with_retry do
               if without_prepared_statement?(binds)
-                cursor = @raw_connection.prepare(sql)
+                cursor = _connection.prepare(sql)
               else
                 unless @statements.key?(sql)
-                  @statements[sql] = @raw_connection.prepare(sql)
+                  @statements[sql] = _connection.prepare(sql)
                 end
 
                 cursor = @statements[sql]
@@ -141,12 +142,12 @@ def exec_update(sql, name = nil, binds = [])
             with_retry do
               cached = false
               if without_prepared_statement?(binds)
-                cursor = @raw_connection.prepare(sql)
+                cursor = _connection.prepare(sql)
               else
                 if @statements.key?(sql)
                   cursor = @statements[sql]
                 else
-                  cursor = @statements[sql] = @raw_connection.prepare(sql)
+                  cursor = @statements[sql] = _connection.prepare(sql)
                 end
 
                 cursor.bind_params(type_casted_binds)
@@ -163,8 +164,12 @@ def exec_update(sql, name = nil, binds = [])
 
         alias :exec_delete :exec_update
 
+        def returning_column_values(result)
+          result.rows.first
+        end
+
         def begin_db_transaction # :nodoc:
-          @raw_connection.autocommit = false
+          _connection.autocommit = false
         end
 
         def transaction_isolation_levels
@@ -183,15 +188,15 @@ def begin_isolated_db_transaction(isolation)
         end
 
         def commit_db_transaction # :nodoc:
-          @raw_connection.commit
+          _connection.commit
         ensure
-          @raw_connection.autocommit = true
+          _connection.autocommit = true
         end
 
         def exec_rollback_db_transaction # :nodoc:
-          @raw_connection.rollback
+          _connection.rollback
         ensure
-          @raw_connection.autocommit = true
+          _connection.autocommit = true
         end
 
         def create_savepoint(name = current_savepoint_name) # :nodoc:
@@ -265,14 +270,14 @@ def write_lobs(table_name, klass, attributes, columns) # :nodoc:
                 raise ActiveRecord::RecordNotFound, "statement #{sql} returned no rows"
               end
               lob = lob_record[col.name]
-              @raw_connection.write_lob(lob, value.to_s, col.type == :binary)
+              _connection.write_lob(lob, value.to_s, col.type == :binary)
             end
           end
         end
 
         private
           def with_retry
-            @raw_connection.with_retry do
+            _connection.with_retry do
               yield
             rescue
               @statements.clear

lib/active_record/connection_adapters/oracle_enhanced/oci_connection.rb

@@ -97,12 +97,12 @@ def reset!
           raise OracleEnhanced::ConnectionException, e.message
         end
 
-        def exec(sql, *bindvars, &block)
-          @raw_connection.exec(sql, *bindvars, &block)
+        def exec(sql, *bindvars, allow_retry: false, &block)
+          with_retry(allow_retry: allow_retry) { @raw_connection.exec(sql, *bindvars, &block) }
         end
 
-        def with_retry(&block)
-          @raw_connection.with_retry(&block)
+        def with_retry(allow_retry: false, &block)
+          @raw_connection.with_retry(allow_retry: allow_retry, &block)
         end
 
         def prepare(sql)
@@ -435,8 +435,8 @@ def reset! # :nodoc:
   LOST_CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114, 3135 ] # :nodoc:
 
   # Adds auto-recovery functionality.
-  def with_retry # :nodoc:
-    should_retry = self.class.auto_retry? && autocommit?
+  def with_retry(allow_retry: false) # :nodoc:
+    should_retry = (allow_retry || self.class.auto_retry?) && autocommit?
 
     begin
       yield

lib/active_record/connection_adapters/oracle_enhanced/oci_quoting.rb

@@ -9,19 +9,19 @@ def type_cast(value)
           when ActiveModel::Type::Binary::Data
             lob_value = value == "" ? " " : value
             bind_type = OCI8::BLOB
-            ora_value = bind_type.new(@raw_connection.raw_oci_connection, lob_value)
+            ora_value = bind_type.new(_connection.raw_oci_connection, lob_value)
             ora_value.size = 0 if value == ""
             ora_value
           when Type::OracleEnhanced::Text::Data
             lob_value = value.to_s == "" ? " " : value.to_s
             bind_type = OCI8::CLOB
-            ora_value = bind_type.new(@raw_connection.raw_oci_connection, lob_value)
+            ora_value = bind_type.new(_connection.raw_oci_connection, lob_value)
             ora_value.size = 0 if value.to_s == ""
             ora_value
           when Type::OracleEnhanced::NationalCharacterText::Data
             lob_value = value.to_s == "" ? " " : value.to_s
             bind_type = OCI8::NCLOB
-            ora_value = bind_type.new(@raw_connection.raw_oci_connection, lob_value)
+            ora_value = bind_type.new(_connection.raw_oci_connection, lob_value)
             ora_value.size = 0 if value.to_s == ""
             ora_value
           else

lib/active_record/connection_adapters/oracle_enhanced/schema_definitions.rb

@@ -81,6 +81,11 @@ def references(*args, **options)
           super(*args, type: :integer, **options)
         end
         alias :belongs_to :references
+
+        private
+          def valid_column_definition_options
+            super + [ :as, :sequence_name, :sequence_start_value, :type ]
+          end
       end
 
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable

lib/active_record/connection_adapters/oracle_enhanced/schema_statements.rb

@@ -53,7 +53,7 @@ def table_exists?(table_name)
         end
 
         def data_source_exists?(table_name)
-          (_owner, _table_name) = @raw_connection.describe(table_name)
+          (_owner, _table_name) = _connection.describe(table_name)
           true
         rescue
           false
@@ -87,7 +87,7 @@ def synonyms
         end
 
         def indexes(table_name) # :nodoc:
-          (_owner, table_name) = @raw_connection.describe(table_name)
+          (_owner, table_name) = _connection.describe(table_name)
           default_tablespace_name = default_tablespace
 
           result = select_all(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
@@ -276,7 +276,7 @@ def drop_table(table_name, **options) # :nodoc:
         end
 
         def insert_versions_sql(versions) # :nodoc:
-          sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
+          sm_table = quote_table_name(ActiveRecord::Base.connection.schema_migration.table_name)
 
           if supports_multi_insert?
             versions.inject(+"INSERT ALL\n") { |sql, version|
@@ -368,7 +368,7 @@ def index_name(table_name, options) # :nodoc:
         #
         # Will always query database and not index cache.
         def index_name_exists?(table_name, index_name)
-          (_owner, table_name) = @raw_connection.describe(table_name)
+          (_owner, table_name) = _connection.describe(table_name)
           result = select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("index_name", index_name.to_s.upcase)])
             SELECT 1 FROM all_indexes i
             WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -511,7 +511,7 @@ def change_column_comment(table_name, column_name, comment_or_changes)
 
         def table_comment(table_name) # :nodoc:
           # TODO
-          (_owner, table_name) = @raw_connection.describe(table_name)
+          (_owner, table_name) = _connection.describe(table_name)
           select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name)])
             SELECT comments FROM all_tab_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -527,7 +527,7 @@ def table_options(table_name) # :nodoc:
 
         def column_comment(table_name, column_name) # :nodoc:
           # TODO: it  does not exist in Abstract adapter
-          (_owner, table_name) = @raw_connection.describe(table_name)
+          (_owner, table_name) = _connection.describe(table_name)
           select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
             SELECT comments FROM all_col_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -555,7 +555,7 @@ def tablespace(table_name)
 
         # get table foreign keys for schema dump
         def foreign_keys(table_name) # :nodoc:
-          (_owner, desc_table_name) = @raw_connection.describe(table_name)
+          (_owner, desc_table_name) = _connection.describe(table_name)
 
           fk_info = select_all(<<~SQL.squish, "SCHEMA", [bind_string("desc_table_name", desc_table_name)])
             SELECT r.table_name to_table
@@ -639,7 +639,7 @@ def create_table_definition(name, **options)
             OracleEnhanced::TableDefinition.new(self, name, **options)
           end
 
-          def new_column_from_field(table_name, field)
+          def new_column_from_field(table_name, field, definitions)
             limit, scale = field["limit"], field["scale"]
             if limit || scale
               field["sql_type"] += "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")