activerecord-oracle_enhanced-adapter 6.1.4 → 7.0.1

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -63,9 +63,9 @@ require "active_record/type/oracle_enhanced/timestampltz"
 require "active_record/type/oracle_enhanced/character_string"
 
 module ActiveRecord
-  module ConnectionHandling #:nodoc:
+  module ConnectionHandling # :nodoc:
     # Establishes a connection to the database that's used by all Active Record objects.
-    def oracle_enhanced_connection(config) #:nodoc:
+    def oracle_enhanced_connection(config) # :nodoc:
       if config[:emulate_oracle_adapter] == true
         # allows the enhanced adapter to look like the OracleAdapter. Useful to pick up
         # conditionals in the rails activerecord test suite
@@ -79,7 +79,7 @@ module ActiveRecord
     end
   end
 
-  module ConnectionAdapters #:nodoc:
+  module ConnectionAdapters # :nodoc:
     # Oracle enhanced adapter will work with both
     # CRuby ruby-oci8 gem (which provides interface to Oracle OCI client)
     # or with JRuby and Oracle JDBC driver.
@@ -120,6 +120,7 @@ module ActiveRecord
     # * <tt>:schema</tt> - database schema which holds schema objects.
     # * <tt>:tcp_keepalive</tt> - TCP keepalive is enabled for OCI client, defaults to true
     # * <tt>:tcp_keepalive_time</tt> - TCP keepalive time for OCI client, defaults to 600
+    # * <tt>:jdbc_statement_cache_size</tt> - number of cached SQL cursors to keep open, disabled per default (for unpooled JDBC only)
     #
     # Optionals NLS parameters:
     #
@@ -248,7 +249,7 @@ module ActiveRecord
 
       ADAPTER_NAME = "OracleEnhanced"
 
-      def adapter_name #:nodoc:
+      def adapter_name # :nodoc:
         ADAPTER_NAME
       end
 
@@ -272,11 +273,11 @@ module ActiveRecord
         StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
       end
 
-      def supports_savepoints? #:nodoc:
+      def supports_savepoints? # :nodoc:
         true
       end
 
-      def supports_transaction_isolation? #:nodoc:
+      def supports_transaction_isolation? # :nodoc:
         true
       end
 
@@ -359,7 +360,7 @@ module ActiveRecord
         end
       end
 
-      #:stopdoc:
+      # :stopdoc:
       DEFAULT_NLS_PARAMETERS = {
         nls_calendar: nil,
         nls_comp: nil,
@@ -378,13 +379,13 @@ module ActiveRecord
         nls_time_tz_format: nil
       }
 
-      #:stopdoc:
+      # :stopdoc:
       FIXED_NLS_PARAMETERS = {
         nls_date_format: "YYYY-MM-DD HH24:MI:SS",
         nls_timestamp_format: "YYYY-MM-DD HH24:MI:SS:FF6"
       }
 
-      #:stopdoc:
+      # :stopdoc:
       NATIVE_DATABASE_TYPES = {
         primary_key: "NUMBER(38) NOT NULL PRIMARY KEY",
         string: { name: "VARCHAR2", limit: 255 },
@@ -408,9 +409,9 @@ module ActiveRecord
       NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS = NATIVE_DATABASE_TYPES.dup.merge(
         boolean: { name: "VARCHAR2", limit: 1 }
       )
-      #:startdoc:
+      # :startdoc:
 
-      def native_database_types #:nodoc:
+      def native_database_types # :nodoc:
         emulate_booleans_from_strings ? NATIVE_DATABASE_TYPES_BOOLEAN_STRINGS : NATIVE_DATABASE_TYPES
       end
 
@@ -420,10 +421,10 @@ module ActiveRecord
       # If SQL statement fails due to lost connection then reconnect
       # and retry SQL statement if autocommit mode is enabled.
       # By default this functionality is disabled.
-      attr_reader :auto_retry #:nodoc:
+      attr_reader :auto_retry # :nodoc:
       @auto_retry = false
 
-      def auto_retry=(value) #:nodoc:
+      def auto_retry=(value) # :nodoc:
         @auto_retry = value
         @connection.auto_retry = value if @connection
       end
@@ -434,7 +435,7 @@ module ActiveRecord
       end
 
       # Returns true if the connection is active.
-      def active? #:nodoc:
+      def active? # :nodoc:
         # Pings the connection to check if it's still good. Note that an
         # #active? method is also available, but that simply returns the
         # last known state, which isn't good enough if the connection has
@@ -445,7 +446,7 @@ module ActiveRecord
       end
 
       # Reconnects to the database.
-      def reconnect! #:nodoc:
+      def reconnect! # :nodoc:
         super
         @connection.reset!
       rescue OracleEnhanced::ConnectionException => e
@@ -458,7 +459,7 @@ module ActiveRecord
       end
 
       # Disconnects from the database.
-      def disconnect! #:nodoc:
+      def disconnect! # :nodoc:
         super
         @connection.logoff rescue nil
       end
@@ -491,12 +492,12 @@ module ActiveRecord
         do_not_prefetch = @do_not_prefetch_primary_key[table_name]
         if do_not_prefetch.nil?
           owner, desc_table_name = @connection.describe(table_name)
-          @do_not_prefetch_primary_key [table_name] = do_not_prefetch = !has_primary_key?(table_name, owner, desc_table_name)
+          @do_not_prefetch_primary_key[table_name] = do_not_prefetch = !has_primary_key?(table_name, owner, desc_table_name)
         end
         !do_not_prefetch
       end
 
-      def reset_pk_sequence!(table_name, primary_key = nil, sequence_name = nil) #:nodoc:
+      def reset_pk_sequence!(table_name, primary_key = nil, sequence_name = nil) # :nodoc:
         return nil unless data_source_exists?(table_name)
         unless primary_key && sequence_name
           # *Note*: Only primary key is implemented - sequence will be nil.
@@ -561,7 +562,7 @@ module ActiveRecord
       def column_definitions(table_name)
         (owner, desc_table_name) = @connection.describe(table_name)
 
-        select_all(<<~SQL.squish, "SCHEMA")
+        select_all(<<~SQL.squish, "SCHEMA", [bind_string("owner", owner), bind_string("table_name", desc_table_name)])
           SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ cols.column_name AS name, cols.data_type AS sql_type,
                  cols.data_default, cols.nullable, cols.virtual_column, cols.hidden_column,
                  cols.data_type_owner AS sql_type_owner,
@@ -574,8 +575,8 @@ module ActiveRecord
                  DECODE(data_type, 'NUMBER', data_scale, NULL) AS scale,
                  comments.comments as column_comment
             FROM all_tab_cols cols, all_col_comments comments
-           WHERE cols.owner      = '#{owner}'
-             AND cols.table_name = #{quote(desc_table_name)}
+           WHERE cols.owner      = :owner
+             AND cols.table_name = :table_name
              AND cols.hidden_column = 'NO'
              AND cols.owner = comments.owner
              AND cols.table_name = comments.table_name
@@ -590,22 +591,22 @@ module ActiveRecord
 
       # Find a table's primary key and sequence.
       # *Note*: Only primary key is implemented - sequence will be nil.
-      def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil) #:nodoc:
+      def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil) # :nodoc:
         (owner, desc_table_name) = @connection.describe(table_name)
 
-        seqs = select_values(<<~SQL.squish, "SCHEMA")
+        seqs = select_values_forcing_binds(<<~SQL.squish, "SCHEMA", [bind_string("owner", owner), bind_string("sequence_name", default_sequence_name(desc_table_name))])
           select /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ us.sequence_name
           from all_sequences us
-          where us.sequence_owner = '#{owner}'
-          and us.sequence_name = upper(#{quote(default_sequence_name(desc_table_name))})
+          where us.sequence_owner = :owner
+          and us.sequence_name = upper(:sequence_name)
         SQL
 
         # changed back from user_constraints to all_constraints for consistency
-        pks = select_values(<<~SQL.squish, "SCHEMA")
+        pks = select_values_forcing_binds(<<~SQL.squish, "SCHEMA", [bind_string("owner", owner), bind_string("table_name", desc_table_name)])
           SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ cc.column_name
             FROM all_constraints c, all_cons_columns cc
-           WHERE c.owner = '#{owner}'
-             AND c.table_name = #{quote(desc_table_name)}
+           WHERE c.owner = :owner
+             AND c.table_name = :table_name
              AND c.constraint_type = 'P'
              AND cc.owner = c.owner
              AND cc.constraint_name = c.constraint_name
@@ -628,14 +629,14 @@ module ActiveRecord
         pk_and_sequence && pk_and_sequence.first
       end
 
-      def has_primary_key?(table_name, owner = nil, desc_table_name = nil) #:nodoc:
+      def has_primary_key?(table_name, owner = nil, desc_table_name = nil) # :nodoc:
         !pk_and_sequence_for(table_name, owner, desc_table_name).nil?
       end
 
       def primary_keys(table_name) # :nodoc:
         (_owner, desc_table_name) = @connection.describe(table_name)
 
-        pks = select_values(<<~SQL.squish, "SCHEMA", [bind_string("table_name", desc_table_name)])
+        pks = select_values_forcing_binds(<<~SQL.squish, "SCHEMA", [bind_string("table_name", desc_table_name)])
           SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */ cc.column_name
             FROM all_constraints c, all_cons_columns cc
            WHERE c.owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -648,7 +649,7 @@ module ActiveRecord
         pks.map { |pk| oracle_downcase(pk) }
       end
 
-      def columns_for_distinct(columns, orders) #:nodoc:
+      def columns_for_distinct(columns, orders) # :nodoc:
         # construct a valid columns name for DISTINCT clause,
         # ie. one that includes the ORDER BY columns, using FIRST_VALUE such that
         # the inclusion of these columns doesn't invalidate the DISTINCT
@@ -664,8 +665,8 @@ module ActiveRecord
         [super, *order_columns].join(", ")
       end
 
-      def temporary_table?(table_name) #:nodoc:
-        select_value(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase)]) == "Y"
+      def temporary_table?(table_name) # :nodoc:
+        select_value_forcing_binds(<<~SQL.squish, "SCHEMA", [bind_string("table_name", table_name.upcase)]) == "Y"
           SELECT /*+ OPTIMIZER_FEATURES_ENABLE('11.2.0.2') */
           temporary FROM all_tables WHERE table_name = :table_name and owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
@@ -689,82 +690,106 @@ module ActiveRecord
         end
       end
 
-      private
-        def initialize_type_map(m = type_map)
-          super
-          # oracle
-          register_class_with_precision m, %r(WITH TIME ZONE)i,       Type::OracleEnhanced::TimestampTz
-          register_class_with_precision m, %r(WITH LOCAL TIME ZONE)i, Type::OracleEnhanced::TimestampLtz
-          register_class_with_limit m, %r(raw)i,            Type::OracleEnhanced::Raw
-          register_class_with_limit m, %r{^(char)}i,        Type::OracleEnhanced::CharacterString
-          register_class_with_limit m, %r{^(nchar)}i,       Type::OracleEnhanced::String
-          register_class_with_limit m, %r(varchar)i,        Type::OracleEnhanced::String
-          register_class_with_limit m, %r(clob)i,           Type::OracleEnhanced::Text
-          register_class_with_limit m, %r(nclob)i,           Type::OracleEnhanced::NationalCharacterText
-
-          m.register_type "NCHAR", Type::OracleEnhanced::NationalCharacterString.new
-          m.alias_type %r(NVARCHAR2)i,    "NCHAR"
-
-          m.register_type(%r(NUMBER)i) do |sql_type|
-            scale = extract_scale(sql_type)
-            precision = extract_precision(sql_type)
-            limit = extract_limit(sql_type)
-            if scale == 0
-              Type::OracleEnhanced::Integer.new(precision: precision, limit: limit)
-            else
-              Type::Decimal.new(precision: precision, scale: scale)
+      class << self
+        private
+          def initialize_type_map(m)
+            super
+            # oracle
+            register_class_with_precision m, %r(WITH TIME ZONE)i,       Type::OracleEnhanced::TimestampTz
+            register_class_with_precision m, %r(WITH LOCAL TIME ZONE)i, Type::OracleEnhanced::TimestampLtz
+            register_class_with_limit m, %r(raw)i,            Type::OracleEnhanced::Raw
+            register_class_with_limit m, %r{^(char)}i,        Type::OracleEnhanced::CharacterString
+            register_class_with_limit m, %r{^(nchar)}i,       Type::OracleEnhanced::String
+            register_class_with_limit m, %r(varchar)i,        Type::OracleEnhanced::String
+            register_class_with_limit m, %r(clob)i,           Type::OracleEnhanced::Text
+            register_class_with_limit m, %r(nclob)i,           Type::OracleEnhanced::NationalCharacterText
+
+            m.register_type "NCHAR", Type::OracleEnhanced::NationalCharacterString.new
+            m.alias_type %r(NVARCHAR2)i,    "NCHAR"
+
+            m.register_type(%r(NUMBER)i) do |sql_type|
+              scale = extract_scale(sql_type)
+              precision = extract_precision(sql_type)
+              limit = extract_limit(sql_type)
+              if scale == 0
+                Type::OracleEnhanced::Integer.new(precision: precision, limit: limit)
+              else
+                Type::Decimal.new(precision: precision, scale: scale)
+              end
             end
-          end
 
-          if OracleEnhancedAdapter.emulate_booleans
-            m.register_type %r(^NUMBER\(1\))i, Type::Boolean.new
+            if OracleEnhancedAdapter.emulate_booleans
+              m.register_type %r(^NUMBER\(1\))i, Type::Boolean.new
+            end
           end
-        end
+      end
 
-        def extract_value_from_default(default)
-          case default
-          when String
-            default.gsub("''", "'")
-          else
-            default
-          end
-        end
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
 
-        def extract_limit(sql_type) #:nodoc:
-          case sql_type
-          when /^bigint/i
-            19
-          when /\((.*)\)/
-            $1.to_i
-          end
+      def type_map
+        TYPE_MAP
+      end
+
+      def extract_value_from_default(default)
+        case default
+        when String
+          default.gsub("''", "'")
+        else
+          default
         end
+      end
 
-        def translate_exception(exception, message:, sql:, binds:) #:nodoc:
-          case @connection.error_code(exception)
-          when 1
-            RecordNotUnique.new(message, sql: sql, binds: binds)
-          when 60
-            Deadlocked.new(message)
-          when 900, 904, 942, 955, 1418, 2289, 2449, 17008
-            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
-          when 1400
-            ActiveRecord::NotNullViolation.new(message, sql: sql, binds: binds)
-          when 2291, 2292
-            InvalidForeignKey.new(message, sql: sql, binds: binds)
-          when 12899
-            ValueTooLong.new(message, sql: sql, binds: binds)
-          else
-            super
-          end
+      def extract_limit(sql_type) # :nodoc:
+        case sql_type
+        when /^bigint/i
+          19
+        when /\((.*)\)/
+          $1.to_i
         end
+      end
 
-        # create bind object for type String
-        def bind_string(name, value)
-          ActiveRecord::Relation::QueryAttribute.new(name, value, Type::OracleEnhanced::String.new)
+      def translate_exception(exception, message:, sql:, binds:) # :nodoc:
+        case @connection.error_code(exception)
+        when 1
+          RecordNotUnique.new(message, sql: sql, binds: binds)
+        when 60
+          Deadlocked.new(message)
+        when 900, 904, 942, 955, 1418, 2289, 2449, 17008
+          ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+        when 1400
+          ActiveRecord::NotNullViolation.new(message, sql: sql, binds: binds)
+        when 2291, 2292
+          InvalidForeignKey.new(message, sql: sql, binds: binds)
+        when 12899
+          ValueTooLong.new(message, sql: sql, binds: binds)
+        else
+          super
         end
+      end
+
+      # create bind object for type String
+      def bind_string(name, value)
+        ActiveRecord::Relation::QueryAttribute.new(name, value, Type::OracleEnhanced::String.new)
+      end
+
+      # call select_values using binds even if surrounding SQL preparation/execution is done + # with conn.unprepared_statement (like AR.to_sql)
+      def select_values_forcing_binds(arel, name, binds)
+        # remove possible force of unprepared SQL during dictionary access
+        unprepared_statement_forced = prepared_statements_disabled_cache.include?(object_id)
+        prepared_statements_disabled_cache.delete(object_id) if unprepared_statement_forced
+
+        select_values(arel, name, binds)
+      ensure
+        # Restore unprepared_statement setting for surrounding SQL
+        prepared_statements_disabled_cache.add(object_id) if unprepared_statement_forced
+      end
+
+      def select_value_forcing_binds(arel, name, binds)
+        single_value_from_rows(select_values_forcing_binds(arel, name, binds))
+      end
 
-        ActiveRecord::Type.register(:boolean, Type::OracleEnhanced::Boolean, adapter: :oracleenhanced)
-        ActiveRecord::Type.register(:json, Type::OracleEnhanced::Json, adapter: :oracleenhanced)
+      ActiveRecord::Type.register(:boolean, Type::OracleEnhanced::Boolean, adapter: :oracle_enhanced)
+      ActiveRecord::Type.register(:json, Type::OracleEnhanced::Json, adapter: :oracle_enhanced)
     end
   end
 end

data/lib/arel/visitors/oracle.rb

@@ -28,7 +28,7 @@ module Arel # :nodoc: all
 
             collector = super(o, collector)
 
-            if offset.expr.is_a? Nodes::BindParam
+            if offset.expr.type.is_a? ActiveModel::Type::Value
               collector << ") raw_sql_ WHERE rownum <= ("
               collector = visit offset.expr, collector
               collector << " + "
@@ -38,7 +38,7 @@ module Arel # :nodoc: all
               return collector
             else
               collector << ") raw_sql_
-                  WHERE rownum <= #{offset.expr.to_i + limit}
+                  WHERE rownum <= #{offset.expr.value_before_type_cast + limit.value_before_type_cast}
                 )
                 WHERE "
               return visit(offset, collector)
@@ -192,6 +192,10 @@ module Arel # :nodoc: all
           array
         end
 
+        def visit_ActiveModel_Attribute(o, collector)
+          collector.add_bind(o) { |i| ":a#{i}" }
+        end
+
         def visit_Arel_Nodes_BindParam(o, collector)
           collector.add_bind(o.value) { |i| ":a#{i}" }
         end

data/lib/arel/visitors/oracle12.rb

@@ -99,6 +99,10 @@ module Arel # :nodoc: all
           super
         end
 
+        def visit_ActiveModel_Attribute(o, collector)
+          collector.add_bind(o) { |i| ":a#{i}" }
+        end
+
         def visit_Arel_Nodes_BindParam(o, collector)
           collector.add_bind(o.value) { |i| ":a#{i}" }
         end

data/spec/active_record/connection_adapters/oracle_enhanced/connection_spec.rb

@@ -41,6 +41,23 @@ describe "OracleEnhancedAdapter establish connection" do
     expect(ActiveRecord::Base.connection.select_value("select value from v$parameter where name = 'cursor_sharing'")).to eq("EXACT")
   end
 
+  it "should not use JDBC statement caching" do
+    if ORACLE_ENHANCED_CONNECTION == :jdbc
+      ActiveRecord::Base.establish_connection(SYSTEM_CONNECTION_PARAMS)
+      expect(ActiveRecord::Base.connection.raw_connection.getImplicitCachingEnabled).to eq(false)
+      expect(ActiveRecord::Base.connection.raw_connection.getStatementCacheSize).to eq(-1)
+    end
+  end
+
+  it "should use JDBC statement caching" do
+    if ORACLE_ENHANCED_CONNECTION == :jdbc
+      ActiveRecord::Base.establish_connection(SYSTEM_CONNECTION_PARAMS.merge(jdbc_statement_cache_size: 100))
+      expect(ActiveRecord::Base.connection.raw_connection.getImplicitCachingEnabled).to eq(true)
+      expect(ActiveRecord::Base.connection.raw_connection.getStatementCacheSize).to eq(100)
+      # else: don't raise error if OCI connection has parameter "jdbc_statement_cache_size", still ignore it
+    end
+  end
+
   it "should connect to database using service_name" do
     ActiveRecord::Base.establish_connection(SERVICE_NAME_CONNECTION_PARAMS)
     expect(ActiveRecord::Base.connection).not_to be_nil
@@ -215,7 +232,7 @@ describe "OracleEnhancedConnection" do
     end
 
     it "should respect default_timezone = :utc than time_zone setting" do
-      # it expects that ActiveRecord::Base.default_timezone = :utc
+      # it expects that ActiveRecord.default_timezone = :utc
       ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_WITH_TIMEZONE_PARAMS)
       post = Post.create!
       created_at = post.created_at

data/spec/active_record/connection_adapters/oracle_enhanced/context_index_spec.rb

@@ -326,7 +326,7 @@ describe "OracleEnhancedAdapter context index" do
       it "should dump definition of single column index" do
         @conn.add_context_index :posts, :title
         output = dump_table_schema "posts"
-        expect(output).to match(/add_context_index "posts", \["title"\], name: \"index_posts_on_title\"$/)
+        expect(output).to match(/add_context_index "posts", \["title"\], name: "index_posts_on_title"$/)
         @conn.remove_context_index :posts, :title
       end
 
@@ -375,7 +375,7 @@ describe "OracleEnhancedAdapter context index" do
         sub_query = "SELECT comments.author AS comment_author, comments.body AS comment_body\nFROM comments\nWHERE comments.post_id = :id"
         @conn.add_context_index :posts, [:title, :body, sub_query], options
         output = dump_table_schema "posts"
-        expect(output).to match(/add_context_index "posts", \[:title, :body, "#{sub_query.gsub(/\n/, ' ')}"\], #{options.inspect[1..-2]}$/)
+        expect(output).to match(/add_context_index "posts", \[:title, :body, "#{sub_query.tr("\n", ' ')}"\], #{options.inspect[1..-2]}$/)
         @conn.remove_context_index :posts, name: "post_and_comments_index"
       end
     end

data/spec/active_record/connection_adapters/oracle_enhanced/procedures_spec.rb

@@ -210,8 +210,8 @@ describe "OracleEnhancedAdapter custom methods for create, update and destroy" d
     expect(@employee.first_name).to eq("First")
   end
 
-  it "should not update record if nothing is changed and partial writes are enabled" do
-    TestEmployee.partial_writes = true
+  it "should not update record if nothing is changed and partial updates are enabled" do
+    TestEmployee.partial_updates = true
     @employee = TestEmployee.create(
       first_name: "First",
       last_name: "Last",
@@ -223,8 +223,8 @@ describe "OracleEnhancedAdapter custom methods for create, update and destroy" d
     expect(@employee.version).to eq(1)
   end
 
-  it "should update record if nothing is changed and partial writes are disabled" do
-    TestEmployee.partial_writes = false
+  it "should update record if nothing is changed and partial updates are disabled" do
+    TestEmployee.partial_updates = false
     @employee = TestEmployee.create(
       first_name: "First",
       last_name: "Last",
@@ -316,7 +316,7 @@ describe "OracleEnhancedAdapter custom methods for create, update and destroy" d
   end
 
   it "should log update record" do
-    (TestEmployee.partial_writes = false) rescue nil
+    (TestEmployee.partial_updates = false) rescue nil
     @employee = TestEmployee.create(
       first_name: "First",
       last_name: "Last",

data/spec/active_record/connection_adapters/oracle_enhanced/schema_dumper_spec.rb

@@ -71,7 +71,7 @@ describe "OracleEnhancedAdapter schema dump" do
 
     it "should be able to dump default values using special characters" do
       output = dump_table_schema "test_defaults"
-      expect(output).to match(/t.string \"special_c\", default: "\\n"/)
+      expect(output).to match(/t.string "special_c", default: "\\n"/)
     end
   end
 
@@ -104,7 +104,7 @@ describe "OracleEnhancedAdapter schema dump" do
 
     it "should be able to dump ntext columns" do
       output = dump_table_schema "test_ntexts"
-      expect(output).to match(/t.ntext \"ntext_column\"/)
+      expect(output).to match(/t.ntext "ntext_column"/)
     end
   end
 
@@ -370,7 +370,7 @@ describe "OracleEnhancedAdapter schema dump" do
       expect(output).to match(/t\.virtual "full_name",(\s*)type: :string,(\s*)limit: 512,(\s*)as: "\\"FIRST_NAME\\"\|\|', '\|\|\\"LAST_NAME\\""/)
       expect(output).to match(/t\.virtual "short_name",(\s*)type: :string,(\s*)limit: 300,(\s*)as:(.*)/)
       expect(output).to match(/t\.virtual "full_name_length",(\s*)type: :integer,(\s*)precision: 38,(\s*)as:(.*)/)
-      expect(output).to match(/t\.virtual "name_ratio",(\s*)as:(.*)\"$/) # no :type
+      expect(output).to match(/t\.virtual "name_ratio",(\s*)as:(.*)"$/) # no :type
       expect(output).to match(/t\.virtual "abbrev_name",(\s*)type: :string,(\s*)limit: 100,(\s*)as:(.*)/)
       expect(output).to match(/t\.virtual "field_with_leading_space",(\s*)type: :string,(\s*)limit: 300,(\s*)as: "' '\|\|\\"FIRST_NAME\\"\|\|' '"/)
     end

data/spec/active_record/connection_adapters/oracle_enhanced/schema_statements_spec.rb

@@ -333,7 +333,7 @@ describe "OracleEnhancedAdapter schema definition" do
           ("index_test_employees_on_first_name_and_middle_name_and_last_name"))
       else
         expect(@conn.index_name("test_employees", column: ["first_name", "middle_name", "last_name"])).to eq(
-          "i" + Digest::SHA1.hexdigest("index_test_employees_on_first_name_and_middle_name_and_last_name")[0, 29]
+          "i" + OpenSSL::Digest::SHA1.hexdigest("index_test_employees_on_first_name_and_middle_name_and_last_name")[0, 29]
         )
       end
     end
@@ -455,7 +455,7 @@ end
     end
 
     it "should add foreign key" do
-      fk_name = "fk_rails_#{Digest::SHA256.hexdigest("test_comments_test_post_id_fk").first(10)}"
+      fk_name = "fk_rails_#{OpenSSL::Digest::SHA256.hexdigest("test_comments_test_post_id_fk").first(10)}"
 
       schema_define do
         add_foreign_key :test_comments, :test_posts
@@ -475,7 +475,7 @@ end
     end
 
     it "should add foreign key with column" do
-      fk_name = "fk_rails_#{Digest::SHA256.hexdigest("test_comments_post_id_fk").first(10)}"
+      fk_name = "fk_rails_#{OpenSSL::Digest::SHA256.hexdigest("test_comments_post_id_fk").first(10)}"
 
       schema_define do
         add_foreign_key :test_comments, :test_posts, column: "post_id"
@@ -1122,13 +1122,13 @@ end
 
     before(:each) do
       @conn.instance_variable_set :@would_execute_sql, @would_execute_sql = +""
-      class <<@conn
+      class << @conn
         def execute(sql, name = nil); @would_execute_sql << sql << ";\n"; end
       end
     end
 
     after(:each) do
-      class <<@conn
+      class << @conn
         remove_method :execute
       end
       @conn.instance_eval { remove_instance_variable :@would_execute_sql }