activerecord-oracle_enhanced-adapter 7.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b353a0c4917c1696bc44c5c3e60565c2863fc6639e48ff71814064394497a5
-  data.tar.gz: bdf94614cb38f1ad7ab121f580164ccb48e974ac7f09bcce3bbdfaca7cc51ca8
+  metadata.gz: 2c54d072a9a65f5b91b230da739c0b2f117d397813b9f2dfb0ca56c13da00979
+  data.tar.gz: 0b4e805aff8d23258dda658e70a87494cb93d6da7b5e0024bd74a3807f54295e
 SHA512:
-  metadata.gz: b0586d8753686b7f81a2b8137397fe0ab9af4f0607775f866f06e0625d9dc9eae480093bbb73f9331798dcba124b5d0b86039d06e039827281cbb05ba2e9b0dc
-  data.tar.gz: 90c2613d22b1705db2f82d5dca382327c3b4c36edba9ac46879441614b143e136e054eed07aebb2f12b06aac95e7d89e17021ac62dfb22f8efaa67206577d341
+  metadata.gz: 72464c92eb71576aae495a2e93674d6823e1a2967f7f8bc45116d14dfbe8f29291c71b7f122e83c74698834be25e729bfddc0b64baf23de7e1b26044960faf26
+  data.tar.gz: 165de73dc654f318d7dc3042ae10f669047733255decd38f9abb2c3db3522bbb6f4c471db44a1ffe40ebaab05b400f9cd2eede381ea1018ea28217529a1c7610

data/History.md

@@ -1,3 +1,59 @@
+## 7.1.0 / 2024-09-25
+
+* Changes and bug fixes
+  No changes since 7.1.0.beta2
+
+## 7.1.0.beta2 / 2024-09-23
+* Changes and bug fixes
+  * Implement `build_explain_clause(options = [])` as no-op [#2394, #2398, #2402]
+
+## 7.1.0.beta1 / 2024-09-23
+
+* Changes and bug fixes
+  * Support Rails 7.1 [#2384]
+  * All attributes serialized before writing [#2203]
+  * Support LIKE case-insensitive matching [#2247]
+  * Support LOB equality [#2258]
+  * Rename the raw connection ivar to @raw_connection [#2265]
+  * Require 'activerecord', not 'rails' not to attempt to install digest [#2241]
+  * Add ruby-oci8 as dependency only for CRuby [#2240]
+  * Address uninitialized constant TestEmployee::AttributeSignature::Base64 [#2264]
+  * Enable Lint/EnsureReturn cop [#2259]
+  * Enable Performance/OpenStruct cop [#2263]
+  * Enable Style/MapToHash cop [#2266]
+  * Fix broken link [#2250]
+  * Use debug gem to replace byebug [#2275]
+  * Support linting YAML files [#2272]
+
+* Known issues
+  * `build_explain_clause(options = [])` has not been implemented yet [#2394]
+  * `supports_fetch_first_n_rows_and_offset?` always returns `false` [#2395]
+  * Oracle enhanced adapter has not been tested against JRuby
+  * bug_report_templates are not tested [#2318]
+
+## 7.0.3 / 2023-08-10
+
+* Changes and bug fixes
+  * Support Rails 7.0.7
+  * Make ActiveRecord's quoted name caches thread-safe on JRuby/TruffleRuby [#2347, #2346]
+  * Address `NameError: uninitialized constant TestEmployee::AttributeSignature::Base64` [#2347]
+  * Address `Style/RedundantRegexpEscape` offense [#2347]
+
+## 7.0.2 / 2022-01-21
+
+* Changes and bug fixes
+  * Fix `columns_for_distinct` when using Rails 6.1 [#2249 #2251 rails/rails#31966]
+
+## 7.0.1 / 2022-01-13
+
+* Changes and bug fixes
+  * Add ruby-oci8 as dependency only for CRuby [#2238 #2240 #2243]
+  * Add if_exists option to remove_index [#2219 #2233]
+  * all attributes serialized before writing [#2203 #2234]
+  * Require 'activerecord', not 'rails' not to attempt to install digest [#2241]
+* CI
+  * Bump Ruby versions at Travis CI [#2242]
+  * CI against Ruby 3.1 at GitHub Actions [#2235 #2244]
 ## 7.0.0 / 2021-12-16
 * Changes and bug fixes
   * Support Rails 7.0.0

data/README.md

@@ -18,7 +18,6 @@ When using Ruby on Rails version 7.0 then in Gemfile include
 ```ruby
 # Use oracle as the database for Active Record
 gem 'activerecord-oracle_enhanced-adapter', '~> 7.0.0'
-gem 'ruby-oci8' # only for CRuby users
 ```
 
 ### Rails 6.1

data/VERSION

@@ -1 +1 @@
-7.0.0
+7.1.0

data/lib/active_record/connection_adapters/oracle_enhanced/column.rb

@@ -13,6 +13,11 @@ module ActiveRecord
         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

data/lib/active_record/connection_adapters/oracle_enhanced/connection.rb

@@ -101,7 +101,7 @@ module ActiveRecord
               _oracle_downcase(col_name)
             end
             row = cursor.fetch
-            columns.each_with_index.map { |x, i| [x, row[i]] }.to_h if row
+            columns.each_with_index.to_h { |x, i| [x, row[i]] } if row
           ensure
             cursor.close
           end

data/lib/active_record/connection_adapters/oracle_enhanced/database_limits.rb

@@ -17,13 +17,13 @@ module ActiveRecord
         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

data/lib/active_record/connection_adapters/oracle_enhanced/database_statements.rb

@@ -9,13 +9,13 @@ module ActiveRecord
         # 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) { @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 @@ module ActiveRecord
             cached = false
             with_retry do
               if without_prepared_statement?(binds)
-                cursor = @connection.prepare(sql)
+                cursor = _connection.prepare(sql)
               else
                 unless @statements.key? sql
-                  @statements[sql] = @connection.prepare(sql)
+                  @statements[sql] = _connection.prepare(sql)
                 end
 
                 cursor = @statements[sql]
@@ -59,12 +59,13 @@ module ActiveRecord
             res
           end
         end
+        alias_method :internal_exec_query, :exec_query
 
         def supports_explain?
           true
         end
 
-        def explain(arel, binds = [])
+        def explain(arel, binds = [], options = [])
           sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
           return if /FROM all_/.match?(sql)
           if ORACLE_ENHANCED_CONNECTION == :jdbc
@@ -75,9 +76,14 @@ module ActiveRecord
           select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", "EXPLAIN").join("\n")
         end
 
+        def build_explain_clause(options = [])
+          # Oracle does not have anything similar to "EXPLAIN ANALYZE"
+          # https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/EXPLAIN-PLAN.html#GUID-FD540872-4ED3-4936-96A2-362539931BA0
+        end
+
         # 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)
@@ -85,14 +91,14 @@ module ActiveRecord
           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 +107,10 @@ module ActiveRecord
             returning_id_col = returning_id_index = nil
             with_retry do
               if without_prepared_statement?(binds)
-                cursor = @connection.prepare(sql)
+                cursor = _connection.prepare(sql)
               else
                 unless @statements.key?(sql)
-                  @statements[sql] = @connection.prepare(sql)
+                  @statements[sql] = _connection.prepare(sql)
                 end
 
                 cursor = @statements[sql]
@@ -141,12 +147,12 @@ module ActiveRecord
             with_retry do
               cached = false
               if without_prepared_statement?(binds)
-                cursor = @connection.prepare(sql)
+                cursor = _connection.prepare(sql)
               else
                 if @statements.key?(sql)
                   cursor = @statements[sql]
                 else
-                  cursor = @statements[sql] = @connection.prepare(sql)
+                  cursor = @statements[sql] = _connection.prepare(sql)
                 end
 
                 cursor.bind_params(type_casted_binds)
@@ -163,8 +169,12 @@ module ActiveRecord
 
         alias :exec_delete :exec_update
 
+        def returning_column_values(result)
+          result.rows.first
+        end
+
         def begin_db_transaction # :nodoc:
-          @connection.autocommit = false
+          _connection.autocommit = false
         end
 
         def transaction_isolation_levels
@@ -183,15 +193,15 @@ module ActiveRecord
         end
 
         def commit_db_transaction # :nodoc:
-          @connection.commit
+          _connection.commit
         ensure
-          @connection.autocommit = true
+          _connection.autocommit = true
         end
 
         def exec_rollback_db_transaction # :nodoc:
-          @connection.rollback
+          _connection.rollback
         ensure
-          @connection.autocommit = true
+          _connection.autocommit = true
         end
 
         def create_savepoint(name = current_savepoint_name) # :nodoc:
@@ -254,11 +264,9 @@ module ActiveRecord
             value = attributes[col.name]
             # changed sequence of next two lines - should check if value is nil before converting to yaml
             next unless value
-            if klass.attribute_types[col.name].is_a? Type::Serialized
-              value = klass.attribute_types[col.name].serialize(value)
-              # value can be nil after serialization because ActiveRecord serializes [] and {} as nil
-              next unless value
-            end
+            value = klass.attribute_types[col.name].serialize(value)
+            # value can be nil after serialization because ActiveRecord serializes [] and {} as nil
+            next unless value
             uncached do
               unless lob_record = select_one(sql = <<~SQL.squish, "Writable Large Object")
                 SELECT #{quote_column_name(col.name)} FROM #{quote_table_name(table_name)}
@@ -267,14 +275,14 @@ module ActiveRecord
                 raise ActiveRecord::RecordNotFound, "statement #{sql} returned no rows"
               end
               lob = lob_record[col.name]
-              @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
-            @connection.with_retry do
+            _connection.with_retry do
               yield
             rescue
               @statements.clear

data/lib/active_record/connection_adapters/oracle_enhanced/dbms_output.rb

@@ -31,8 +31,21 @@ module ActiveRecord
         end
 
       private
-        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil, async: false)
-          super
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil, async: false, &block)
+          @instrumenter.instrument(
+            "sql.active_record",
+            sql:               sql,
+            name:              name,
+            binds:             binds,
+            type_casted_binds: type_casted_binds,
+            statement_name:    statement_name,
+            async:             async,
+            connection:        self,
+            &block
+          )
+        rescue => e
+          # FIXME: raise ex.set_query(sql, binds)
+          raise translate_exception_class(e, sql, binds)
         ensure
           log_dbms_output if dbms_output_enabled?
         end

data/lib/active_record/connection_adapters/oracle_enhanced/jdbc_connection.rb

@@ -135,6 +135,13 @@ module ActiveRecord
             properties.put("defaultRowPrefetch", "#{prefetch_rows}") if prefetch_rows
             properties.put("internal_logon", privilege) if privilege
 
+            if config[:jdbc_connect_properties] # arbitrary additional properties for JDBC connection
+              raise "jdbc_connect_properties should contain an associative array / hash" unless config[:jdbc_connect_properties].is_a? Hash
+              config[:jdbc_connect_properties].each do |key, value|
+                properties.put(key, value)
+              end
+            end
+
             begin
               @raw_connection = java.sql.DriverManager.getConnection(url, properties)
             rescue
@@ -295,7 +302,7 @@ module ActiveRecord
 
         class Cursor
           def initialize(connection, raw_statement)
-            @connection = connection
+            @raw_connection = connection
             @raw_statement = raw_statement
           end
 
@@ -384,7 +391,7 @@ module ActiveRecord
               row_values = []
               column_types.each_with_index do |column_type, i|
                 row_values <<
-                  @connection.get_ruby_value_from_result_set(@raw_result_set, i + 1, column_type, get_lob_value)
+                  @raw_connection.get_ruby_value_from_result_set(@raw_result_set, i + 1, column_type, get_lob_value)
               end
               row_values
             else

data/lib/active_record/connection_adapters/oracle_enhanced/jdbc_quoting.rb

@@ -7,15 +7,15 @@ module ActiveRecord
         def type_cast(value)
           case value
           when ActiveModel::Type::Binary::Data
-            blob = Java::OracleSql::BLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
+            blob = Java::OracleSql::BLOB.createTemporary(@raw_connection.raw_connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
             blob.setBytes(1, value.to_s.to_java_bytes)
             blob
           when Type::OracleEnhanced::Text::Data
-            clob = Java::OracleSql::CLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
+            clob = Java::OracleSql::CLOB.createTemporary(@raw_connection.raw_connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
             clob.setString(1, value.to_s)
             clob
           when Type::OracleEnhanced::NationalCharacterText::Data
-            clob = Java::OracleSql::NCLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::NCLOB::DURATION_SESSION)
+            clob = Java::OracleSql::NCLOB.createTemporary(@raw_connection.raw_connection, false, Java::OracleSql::NCLOB::DURATION_SESSION)
             clob.setString(1, value.to_s)
             clob
           else

data/lib/active_record/connection_adapters/oracle_enhanced/oci_connection.rb

@@ -41,7 +41,7 @@ module ActiveRecord
           # ActiveRecord Oracle enhanced adapter puts OCI8EnhancedAutoRecover wrapper around OCI8
           # in this case we need to pass original OCI8 connection
           else
-            @raw_connection.instance_variable_get(:@connection)
+            @raw_connection.instance_variable_get(:@raw_connection)
           end
         end
 
@@ -87,18 +87,22 @@ module ActiveRecord
           @raw_connection.active?
         end
 
+        def reset
+          @raw_connection.reset
+        end
+
         def reset!
           @raw_connection.reset!
         rescue OCIException => e
           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)
@@ -107,7 +111,7 @@ module ActiveRecord
 
         class Cursor
           def initialize(connection, raw_cursor)
-            @connection = connection
+            @raw_connection = connection
             @raw_cursor = raw_cursor
           end
 
@@ -159,7 +163,7 @@ module ActiveRecord
               get_lob_value = options[:get_lob_value]
               col_index = 0
               row.map do |col|
-                col_value = @connection.typecast_result_value(col, get_lob_value)
+                col_value = @raw_connection.typecast_result_value(col, get_lob_value)
                 col_metadata = @raw_cursor.column_metadata.fetch(col_index)
                 if !col_metadata.nil?
                   key = col_metadata.data_type
@@ -390,27 +394,32 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) # :nodoc:
     @active = true
     @config = config
     @factory = factory
-    @connection = @factory.new_connection @config
-    super @connection
+    @raw_connection = @factory.new_connection @config
+    super @raw_connection
   end
 
   # Checks connection, returns true if active. Note that ping actively
   # checks the connection, while #active? simply returns the last
   # known state.
   def ping # :nodoc:
-    @connection.exec("select 1 from dual") { |r| nil }
+    @raw_connection.exec("select 1 from dual") { |r| nil }
     @active = true
   rescue
     @active = false
     raise
   end
 
+  def reset
+    # tentative
+    reset!
+  end
+
   # Resets connection, by logging off and creating a new connection.
   def reset! # :nodoc:
     logoff rescue nil
     begin
-      @connection = @factory.new_connection @config
-      __setobj__ @connection
+      @raw_connection = @factory.new_connection @config
+      __setobj__ @raw_connection
       @active = true
     rescue
       @active = false
@@ -426,8 +435,8 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) # :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
@@ -442,7 +451,7 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) # :nodoc:
   end
 
   def exec(sql, *bindvars, &block) # :nodoc:
-    with_retry { @connection.exec(sql, *bindvars, &block) }
+    with_retry { @raw_connection.exec(sql, *bindvars, &block) }
   end
 end
 # :startdoc:

data/lib/active_record/connection_adapters/oracle_enhanced/oci_quoting.rb

@@ -9,19 +9,19 @@ module ActiveRecord
           when ActiveModel::Type::Binary::Data
             lob_value = value == "" ? " " : value
             bind_type = OCI8::BLOB
-            ora_value = bind_type.new(@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(@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(@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

data/lib/active_record/connection_adapters/oracle_enhanced/quoting.rb

@@ -7,10 +7,12 @@ module ActiveRecord
         # QUOTING ==================================================
         #
         # see: abstract/quoting.rb
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
 
         def quote_column_name(name) # :nodoc:
           name = name.to_s
-          self.class.quoted_column_names[name] ||= if /\A[a-z][a-z_0-9$#]*\Z/.match?(name)
+          QUOTED_COLUMN_NAMES[name] ||= if /\A[a-z][a-z_0-9$#]*\Z/.match?(name)
             "\"#{name.upcase}\""
           else
             # remove double quotes which cannot be used inside quoted identifier
@@ -26,7 +28,7 @@ module ActiveRecord
           # if only valid lowercase column characters in name
           when /^[a-z][a-z_0-9$#]*$/
             "\"#{name.upcase}\""
-          when /^[a-z][a-z_0-9$#\-]*$/i
+          when /^[a-z][a-z_0-9$#-]*$/i
             "\"#{name}\""
           # if other characters present then assume that it is expression
           # which should not be quoted
@@ -67,7 +69,7 @@ module ActiveRecord
 
         def quote_table_name(name) # :nodoc:
           name, _link = name.to_s.split("@")
-          self.class.quoted_table_names[name] ||= [name.split(".").map { |n| quote_column_name(n) }].join(".")
+          QUOTED_TABLE_NAMES[name] ||= [name.split(".").map { |n| quote_column_name(n) }].join(".")
         end
 
         def quote_string(s) # :nodoc:
@@ -142,7 +144,7 @@ module ActiveRecord
           (
             (?:
               # "table_name"."column_name" | function(one or no argument)
-              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")) | \w+\((?:|\g<2>)\)
+              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
             )
             (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
           )
@@ -155,7 +157,7 @@ module ActiveRecord
           (
             (?:
               # "table_name"."column_name" | function(one or no argument)
-              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")) | \w+\((?:|\g<2>)\)
+              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
             )
             (?:\s+ASC|\s+DESC)?
             (?:\s+NULLS\s+(?:FIRST|LAST))?

data/lib/active_record/connection_adapters/oracle_enhanced/schema_creation.rb

@@ -20,7 +20,7 @@ module ActiveRecord
             statements = o.columns.map { |c| accept c }
             statements << accept(o.primary_keys) if o.primary_keys
 
-            if supports_foreign_keys?
+            if use_foreign_keys?
               statements.concat(o.foreign_keys.map { |fk| accept fk })
             end
 

data/lib/active_record/connection_adapters/oracle_enhanced/schema_definitions.rb

@@ -81,6 +81,11 @@ module ActiveRecord
           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

data/lib/active_record/connection_adapters/oracle_enhanced/schema_dumper.rb

@@ -181,7 +181,7 @@ module ActiveRecord # :nodoc:
           def extract_expression_for_virtual_column(column)
             column_name = column.name
             @connection.select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
-              select /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ data_default from all_tab_columns
+              select data_default from all_tab_columns
               where owner = SYS_CONTEXT('userenv', 'current_schema')
               and table_name = :table_name
               and column_name = :column_name