activerecord-oracle_enhanced-adapter 5.2.8 → 7.0.3

data/lib/active_record/type/oracle_enhanced/boolean.rb

@@ -5,7 +5,6 @@ module ActiveRecord
     module OracleEnhanced
       class Boolean < ActiveModel::Type::Boolean # :nodoc:
         private
-
           def cast_value(value)
             # Kind of adding 'n' and 'N' to  `FALSE_VALUES`
             if ["n", "N"].include?(value)

data/lib/active_record/type/oracle_enhanced/character_string.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_model/type/string"
+
+module ActiveRecord
+  module Type
+    module OracleEnhanced
+      class CharacterString < ActiveRecord::Type::OracleEnhanced::String # :nodoc:
+        def serialize(value)
+          return unless value
+          Data.new(super, self.limit)
+        end
+
+        class Data # :nodoc:
+          def initialize(value, limit)
+            @value = value
+            @limit = limit
+          end
+
+          def to_s
+            @value
+          end
+
+          def to_character_str
+            len = @value.to_s.length
+            if len < @limit
+              "%-#{@limit}s" % @value
+            else
+              @value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/oracle_enhanced/integer.rb

@@ -5,7 +5,6 @@ module ActiveRecord
     module OracleEnhanced
       class Integer < ActiveModel::Type::Integer # :nodoc:
         private
-
           def max_value
             ("9" * 38).to_i
           end

data/lib/arel/visitors/oracle.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Oracle < Arel::Visitors::ToSql
+      private
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          o = order_hacks(o)
+
+          # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
+          # then can use simple ROWNUM in WHERE clause
+          if o.limit && o.orders.empty? && o.cores.first.groups.empty? && !o.offset && !o.cores.first.set_quantifier.class.to_s.match?(/Distinct/)
+            o.cores.last.wheres.push Nodes::LessThanOrEqual.new(
+              Nodes::SqlLiteral.new("ROWNUM"), o.limit.expr
+            )
+            return super
+          end
+
+          if o.limit && o.offset
+            o        = o.dup
+            limit    = o.limit.expr
+            offset   = o.offset
+            o.offset = nil
+            collector << "
+                SELECT * FROM (
+                  SELECT raw_sql_.*, rownum raw_rnum_
+                  FROM ("
+
+            collector = super(o, collector)
+
+            if offset.expr.type.is_a? ActiveModel::Type::Value
+              collector << ") raw_sql_ WHERE rownum <= ("
+              collector = visit offset.expr, collector
+              collector << " + "
+              collector = visit limit, collector
+              collector << ") ) WHERE raw_rnum_ > "
+              collector = visit offset.expr, collector
+              return collector
+            else
+              collector << ") raw_sql_
+                  WHERE rownum <= #{offset.expr.value_before_type_cast + limit.value_before_type_cast}
+                )
+                WHERE "
+              return visit(offset, collector)
+            end
+          end
+
+          if o.limit
+            o       = o.dup
+            limit   = o.limit.expr
+            collector << "SELECT * FROM ("
+            collector = super(o, collector)
+            collector << ") WHERE ROWNUM <= "
+            return visit limit, collector
+          end
+
+          if o.offset
+            o        = o.dup
+            offset   = o.offset
+            o.offset = nil
+            collector << "SELECT * FROM (
+                  SELECT raw_sql_.*, rownum raw_rnum_
+                  FROM ("
+            collector = super(o, collector)
+            collector << ") raw_sql_
+                )
+                WHERE "
+            return visit offset, collector
+          end
+
+          super
+        end
+
+        def visit_Arel_Nodes_Limit(o, collector)
+          collector
+        end
+
+        def visit_Arel_Nodes_Offset(o, collector)
+          collector << "raw_rnum_ > "
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_Except(o, collector)
+          collector << "( "
+          collector = infix_value o, collector, " MINUS "
+          collector << " )"
+        end
+
+        ##
+        # To avoid ORA-01795: maximum number of expressions in a list is 1000
+        # tell ActiveRecord to limit us to 1000 ids at a time
+        def visit_Arel_Nodes_HomogeneousIn(o, collector)
+          in_clause_length = @connection.in_clause_length
+          values = o.casted_values.map { |v| @connection.quote(v) }
+          column_name = quote_table_name(o.table_name) + "." + quote_column_name(o.column_name)
+          operator =
+            if o.type == :in
+              " IN ("
+            else
+              " NOT IN ("
+            end
+
+          if !Array === values || values.length <= in_clause_length
+            collector << column_name
+            collector << operator
+
+            expr =
+              if values.empty?
+                @connection.quote(nil)
+              else
+                values.join(",")
+              end
+
+            collector << expr
+            collector << ")"
+          else
+            separator =
+              if o.type == :in
+                " OR "
+              else
+                " AND "
+              end
+            collector << "("
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << separator unless i == 0
+              collector << column_name
+              collector << operator
+              collector << valuez.join(",")
+              collector << ")"
+            end
+            collector << ")"
+          end
+
+          collector
+        end
+
+        def visit_Arel_Nodes_UpdateStatement(o, collector)
+          # Oracle does not allow ORDER BY/LIMIT in UPDATEs.
+          if o.orders.any? && o.limit.nil?
+            # However, there is no harm in silently eating the ORDER BY clause if no LIMIT has been provided,
+            # otherwise let the user deal with the error
+            o = o.dup
+            o.orders = []
+          end
+
+          super
+        end
+
+        ###
+        # Hacks for the order clauses specific to Oracle
+        def order_hacks(o)
+          return o if o.orders.empty?
+          return o unless o.cores.any? do |core|
+            core.projections.any? do |projection|
+              /FIRST_VALUE/ === projection
+            end
+          end
+          # Previous version with join and split broke ORDER BY clause
+          # if it contained functions with several arguments (separated by ',').
+          #
+          # orders   = o.orders.map { |x| visit x }.join(', ').split(',')
+          orders   = o.orders.map do |x|
+            string = visit(x, Arel::Collectors::SQLString.new).value
+            if string.include?(",")
+              split_order_string(string)
+            else
+              string
+            end
+          end.flatten
+          o.orders = []
+          orders.each_with_index do |order, i|
+            o.orders <<
+              Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i.match?(order)}")
+          end
+          o
+        end
+
+        # Split string by commas but count opening and closing brackets
+        # and ignore commas inside brackets.
+        def split_order_string(string)
+          array = []
+          i = 0
+          string.split(",").each do |part|
+            if array[i]
+              array[i] << "," << part
+            else
+              # to ensure that array[i] will be String and not Arel::Nodes::SqlLiteral
+              array[i] = part.to_s
+            end
+            i += 1 if array[i].count("(") == array[i].count(")")
+          end
+          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
+
+        def is_distinct_from(o, collector)
+          collector << "DECODE("
+          collector = visit [o.left, o.right, 0, 1], collector
+          collector << ")"
+        end
+
+        # Oracle will occur an error `ORA-00907: missing right parenthesis`
+        # when using `ORDER BY` in `UPDATE` or `DELETE`'s subquery.
+        #
+        # This method has been overridden based on the following code.
+        # https://github.com/rails/rails/blob/v6.1.0.rc1/activerecord/lib/arel/visitors/to_sql.rb#L815-L825
+        def build_subselect(key, o)
+          stmt             = super
+          stmt.orders      = [] # `orders` will never be set to prevent `ORA-00907`.
+          stmt
+        end
+    end
+  end
+end

data/lib/arel/visitors/oracle12.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Oracle12 < Arel::Visitors::ToSql
+      private
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          # Oracle does not allow LIMIT clause with select for update
+          if o.limit && o.lock
+            raise ArgumentError, <<~MSG
+              Combination of limit and lock is not supported. Because generated SQL statements
+              `SELECT FOR UPDATE and FETCH FIRST n ROWS` generates ORA-02014.
+            MSG
+          end
+          super
+        end
+
+        def visit_Arel_Nodes_SelectOptions(o, collector)
+          collector = maybe_visit o.offset, collector
+          collector = maybe_visit o.limit, collector
+          maybe_visit o.lock, collector
+        end
+
+        def visit_Arel_Nodes_Limit(o, collector)
+          collector << "FETCH FIRST "
+          collector = visit o.expr, collector
+          collector << " ROWS ONLY"
+        end
+
+        def visit_Arel_Nodes_Offset(o, collector)
+          collector << "OFFSET "
+          visit o.expr, collector
+          collector << " ROWS"
+        end
+
+        def visit_Arel_Nodes_Except(o, collector)
+          collector << "( "
+          collector = infix_value o, collector, " MINUS "
+          collector << " )"
+        end
+
+        ##
+        # To avoid ORA-01795: maximum number of expressions in a list is 1000
+        # tell ActiveRecord to limit us to 1000 ids at a time
+        def visit_Arel_Nodes_HomogeneousIn(o, collector)
+          in_clause_length = @connection.in_clause_length
+          values = o.casted_values.map { |v| @connection.quote(v) }
+          column_name = quote_table_name(o.table_name) + "." + quote_column_name(o.column_name)
+          operator =
+            if o.type == :in
+              " IN ("
+            else
+              " NOT IN ("
+            end
+
+          if !Array === values || values.length <= in_clause_length
+            collector << column_name
+            collector << operator
+
+            expr =
+              if values.empty?
+                @connection.quote(nil)
+              else
+                values.join(",")
+              end
+
+            collector << expr
+            collector << ")"
+          else
+            separator =
+              if o.type == :in
+                " OR "
+              else
+                " AND "
+              end
+            collector << "("
+            values.each_slice(in_clause_length).each_with_index do |valuez, i|
+              collector << separator unless i == 0
+              collector << column_name
+              collector << operator
+              collector << valuez.join(",")
+              collector << ")"
+            end
+            collector << ")"
+          end
+
+          collector
+        end
+
+        def visit_Arel_Nodes_UpdateStatement(o, collector)
+          # Oracle does not allow ORDER BY/LIMIT in UPDATEs.
+          if o.orders.any? && o.limit.nil?
+            # However, there is no harm in silently eating the ORDER BY clause if no LIMIT has been provided,
+            # otherwise let the user deal with the error
+            o = o.dup
+            o.orders = []
+          end
+
+          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
+
+        def is_distinct_from(o, collector)
+          collector << "DECODE("
+          collector = visit [o.left, o.right, 0, 1], collector
+          collector << ")"
+        end
+
+        # Oracle will occur an error `ORA-00907: missing right parenthesis`
+        # when using `ORDER BY` in `UPDATE` or `DELETE`'s subquery.
+        #
+        # This method has been overridden based on the following code.
+        # https://github.com/rails/rails/blob/v6.1.0.rc1/activerecord/lib/arel/visitors/to_sql.rb#L815-L825
+        def build_subselect(key, o)
+          stmt             = super
+          stmt.orders      = [] # `orders` will never be set to prevent `ORA-00907`.
+          stmt
+        end
+    end
+  end
+end

data/spec/active_record/connection_adapters/emulation/oracle_adapter_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 describe "OracleEnhancedAdapter emulate OracleAdapter" do
-
   before(:all) do
     @old_oracle_adapter = nil
     if defined?(ActiveRecord::ConnectionAdapters::OracleAdapter)
@@ -22,5 +21,4 @@ describe "OracleEnhancedAdapter emulate OracleAdapter" do
       ActiveRecord::ConnectionAdapters::OracleAdapter = @old_oracle_adapter
     end
   end
-
 end

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 describe "OracleEnhancedAdapter establish connection" do
-
   it "should connect to database" do
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
     expect(ActiveRecord::Base.connection).not_to be_nil
@@ -41,10 +40,32 @@ describe "OracleEnhancedAdapter establish connection" do
     ActiveRecord::Base.establish_connection(SYSTEM_CONNECTION_PARAMS.merge(cursor_sharing: :exact))
     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
+    expect(ActiveRecord::Base.connection.class).to eq(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter)
+  end
 end
 
 describe "OracleEnhancedConnection" do
-
   describe "create connection" do
     before(:all) do
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_PARAMS)
@@ -75,49 +96,64 @@ describe "OracleEnhancedConnection" do
     it "should be in autocommit mode after connection" do
       expect(@conn).to be_autocommit
     end
-
   end
 
   describe "create connection with schema option" do
-
     it "should create new connection" do
       ActiveRecord::Base.establish_connection(CONNECTION_WITH_SCHEMA_PARAMS)
       expect(ActiveRecord::Base.connection).to be_active
     end
 
-    it "should swith to specified schema" do
+    it "should switch to specified schema" do
       ActiveRecord::Base.establish_connection(CONNECTION_WITH_SCHEMA_PARAMS)
       expect(ActiveRecord::Base.connection.current_schema).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase)
+      expect(ActiveRecord::Base.connection.current_user).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:username].upcase)
     end
 
-    it "should swith to specified schema after reset" do
+    it "should switch to specified schema after reset" do
       ActiveRecord::Base.connection.reset!
       expect(ActiveRecord::Base.connection.current_schema).to eq(CONNECTION_WITH_SCHEMA_PARAMS[:schema].upcase)
     end
-
   end
 
   describe "create connection with NLS parameters" do
+    after do
+      ENV["NLS_TERRITORY"] = nil
+    end
+
+    it "should use NLS_TERRITORY environment variable" do
+      ENV["NLS_TERRITORY"] = "JAPAN"
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_PARAMS)
+      expect(@conn.select("select SYS_CONTEXT('userenv', 'NLS_TERRITORY') as value from dual")).to eq([{ "value" => "JAPAN" }])
+    end
+
+    it "should use configuration value and ignore NLS_TERRITORY environment variable" do
+      ENV["NLS_TERRITORY"] = "AMERICA"
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_PARAMS.merge(nls_territory: "INDONESIA"))
+      expect(@conn.select("select SYS_CONTEXT('userenv', 'NLS_TERRITORY') as value from dual")).to eq([{ "value" => "INDONESIA" }])
+    end
+  end
+
+  describe "Fixed NLS parameters" do
     after do
       ENV["NLS_DATE_FORMAT"] = nil
     end
 
-    it "should use NLS_DATE_FORMAT environment variable" do
+    it "should ignore NLS_DATE_FORMAT environment variable" do
       ENV["NLS_DATE_FORMAT"] = "YYYY-MM-DD"
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_PARAMS)
-      expect(@conn.select("select SYS_CONTEXT('userenv', 'NLS_DATE_FORMAT') as value from dual")).to eq([{ "value" => "YYYY-MM-DD" }])
+      expect(@conn.select("select SYS_CONTEXT('userenv', 'NLS_DATE_FORMAT') as value from dual")).to eq([{ "value" => "YYYY-MM-DD HH24:MI:SS" }])
     end
 
-    it "should use configuration value and ignore NLS_DATE_FORMAT environment variable" do
-      ENV["NLS_DATE_FORMAT"] = "YYYY-MM-DD"
+    it "should ignore NLS_DATE_FORMAT configuration value" do
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_PARAMS.merge(nls_date_format: "YYYY-MM-DD HH24:MI"))
-      expect(@conn.select("select SYS_CONTEXT('userenv', 'NLS_DATE_FORMAT') as value from dual")).to eq([{ "value" => "YYYY-MM-DD HH24:MI" }])
+      expect(@conn.select("select SYS_CONTEXT('userenv', 'NLS_DATE_FORMAT') as value from dual")).to eq([{ "value" => "YYYY-MM-DD HH24:MI:SS" }])
     end
 
     it "should use default value when NLS_DATE_FORMAT environment variable is not set" do
       ENV["NLS_DATE_FORMAT"] = nil
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(CONNECTION_PARAMS)
-      default = ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS[:nls_date_format]
+      default = ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::FIXED_NLS_PARAMETERS[:nls_date_format]
       expect(@conn.select("select SYS_CONTEXT('userenv', 'NLS_DATE_FORMAT') as value from dual")).to eq([{ "value" => default }])
     end
   end
@@ -167,7 +203,7 @@ describe "OracleEnhancedConnection" do
   describe "with slash-prefixed database name (service name)" do
     before(:all) do
       params = CONNECTION_PARAMS.dup
-      params[:database] = "/#{params[:database]}" unless params[:database].match(/^\//)
+      params[:database] = "/#{params[:database]}" unless params[:database].start_with?("/")
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(params)
     end
 
@@ -196,13 +232,12 @@ 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
       expect(post).to eq(Post.find_by!(created_at: created_at))
     end
-
   end
 
   describe 'with host="connection-string"' do
@@ -225,7 +260,6 @@ describe "OracleEnhancedConnection" do
   if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
 
     describe "create JDBC connection" do
-
       it "should create new connection using :url" do
         params = CONNECTION_PARAMS.dup
         params[:url] = "jdbc:oracle:thin:@#{DATABASE_HOST && "//#{DATABASE_HOST}#{DATABASE_PORT && ":#{DATABASE_PORT}"}/"}#{DATABASE_NAME}"
@@ -253,7 +287,6 @@ describe "OracleEnhancedConnection" do
       end
 
       it "should create a new connection using JNDI" do
-
         begin
           import "oracle.jdbc.driver.OracleDriver"
           import "org.apache.commons.pool.impl.GenericObjectPool"
@@ -274,7 +307,7 @@ describe "OracleEnhancedConnection" do
             @data_source.access_to_underlying_connection_allowed = true
           end
           def lookup(path)
-            if (path == "java:/comp/env")
+            if path == "java:/comp/env"
               self
             else
               @data_source
@@ -289,7 +322,6 @@ describe "OracleEnhancedConnection" do
         @conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(params)
         expect(@conn).to be_active
       end
-
     end
 
     it "should fall back to directly instantiating OracleDriver" do
@@ -320,7 +352,6 @@ describe "OracleEnhancedConnection" do
     it "should execute SQL select and return also columns" do
       expect(@conn.select("SELECT * FROM dual", nil, true)).to eq([ [{ "dummy" => "X" }], ["dummy"] ])
     end
-
   end
 
   describe "SQL with bind parameters" do
@@ -364,7 +395,7 @@ describe "OracleEnhancedConnection" do
     it "should execute prepared statement with decimal bind parameter " do
       cursor = @conn.prepare("INSERT INTO test_employees VALUES(:1)")
       type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "NUMBER", type: :decimal, limit: 10, precision: nil, scale: 2)
-      column = ActiveRecord::ConnectionAdapters::OracleEnhanced::Column.new("age", nil, type_metadata, false, "test_employees", nil)
+      column = ActiveRecord::ConnectionAdapters::OracleEnhanced::Column.new("age", nil, type_metadata, false, comment: nil)
       expect(column.type).to eq(:decimal)
       # Here 1.5 expects that this value has been type casted already
       # it should use bind_params in the long term.
@@ -379,10 +410,22 @@ describe "OracleEnhancedConnection" do
   end
 
   describe "auto reconnection" do
+    include SchemaSpecHelper
+
     before(:all) do
       ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
       @conn = ActiveRecord::Base.connection.instance_variable_get("@connection")
       @sys_conn = ActiveRecord::ConnectionAdapters::OracleEnhanced::Connection.create(SYS_CONNECTION_PARAMS)
+      schema_define do
+        create_table :posts, force: true
+      end
+      class ::Post < ActiveRecord::Base
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, "Post")
+      ActiveRecord::Base.clear_cache!
     end
 
     before(:each) do
@@ -433,6 +476,19 @@ describe "OracleEnhancedConnection" do
       end
     end
 
+    it "should reconnect and execute query if connection is lost and auto retry is enabled" do
+      Post.create!
+      ActiveRecord::Base.connection.auto_retry = true
+      kill_current_session
+      expect(Post.take).not_to be_nil
+    end
+
+    it "should not reconnect and execute query if connection is lost and auto retry is disabled" do
+      Post.create!
+      ActiveRecord::Base.connection.auto_retry = false
+      kill_current_session
+      expect { Post.take }.to raise_error(ActiveRecord::StatementInvalid)
+    end
   end
 
   describe "describe table" do
@@ -483,15 +539,11 @@ describe "OracleEnhancedConnection" do
 
     if defined?(OCI8)
       context "OCI8 adapter" do
-
         it "should not fallback to SELECT-based logic when querying non-existent table information" do
           expect(@conn).not_to receive(:select_one)
           @conn.describe("non_existent") rescue ActiveRecord::ConnectionAdapters::OracleEnhanced::ConnectionException
         end
-
       end
     end
-
   end
-
 end