activerecord-oracle_enhanced-adapter 1.8.2 → 5.2.0.beta1

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
@@ -72,7 +74,6 @@ module ActiveRecord
         #  add_context_index :posts, :title, :transactional => true
         #
         def add_context_index(table_name, column_name, options = {})
-          self.all_schema_indexes = nil
           column_names = Array(column_name)
           index_name = options[:name] || index_name(table_name, column: options[:index_column] || column_names,
             # CONEXT index name max length is 25
@@ -85,7 +86,7 @@ module ActiveRecord
             create_index_column_trigger(table_name, index_name, options[:index_column], options[:index_column_trigger_on])
           end
 
-          sql = "CREATE INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+          sql = "CREATE INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}".dup
           sql << " (#{quoted_column_name})"
           sql << " INDEXTYPE IS CTXSYS.CONTEXT"
           parameters = []
@@ -127,7 +128,6 @@ module ActiveRecord
 
         # Drop full text index with Oracle specific CONTEXT index type
         def remove_context_index(table_name, options = {})
-          self.all_schema_indexes = nil
           unless Hash === options # if column names passed as argument
             options = { column: Array(options) }
           end
@@ -149,11 +149,11 @@ module ActiveRecord
             select_queries = select_queries.map { |s| s.strip.gsub(/\s+/, " ") }
             keys, selected_columns = parse_select_queries(select_queries)
             quoted_column_names = (column_names + keys).map { |col| quote_column_name(col) }
-            execute compress_lines(<<-SQL)
+            execute <<-SQL
             CREATE OR REPLACE PROCEDURE #{quote_table_name(procedure_name)}
               (p_rowid IN	      ROWID,
               p_clob	IN OUT NOCOPY CLOB) IS
-              -- add_context_index_parameters #{(column_names + select_queries).inspect}#{!options.empty? ? ', ' << options.inspect[1..-2] : ''}
+              -- add_context_index_parameters #{(column_names + select_queries).inspect}#{!options.empty? ? ', '.dup << options.inspect[1..-2] : ''}
               #{
               selected_columns.map do |cols|
                 cols.map do |col|
@@ -170,7 +170,7 @@ module ActiveRecord
                 #{
                 (column_names.map do |col|
                   col = col.to_s
-                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n" <<
+                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n".dup <<
                   "IF LENGTH(r1.#{col}) > 0 THEN\n" <<
                   "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(r1.#{col}), r1.#{col});\n" <<
                   "END IF;\n" <<
@@ -188,7 +188,7 @@ module ActiveRecord
                   "END LOOP;\n" <<
                   (cols.map do |col|
                     col = col.to_s
-                    "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n" <<
+                    "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n".dup <<
                     "IF LENGTH(l_#{col}) > 0 THEN\n" <<
                     "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(l_#{col}), l_#{col});\n" <<
                     "END IF;\n" <<
@@ -225,7 +225,7 @@ module ActiveRecord
 
           def create_storage_preference(storage_name, tablespace)
             drop_ctx_preference(storage_name)
-            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{storage_name}', 'BASIC_STORAGE');\n"
+            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{storage_name}', 'BASIC_STORAGE');\n".dup
             ["I_TABLE_CLAUSE", "K_TABLE_CLAUSE", "R_TABLE_CLAUSE",
             "N_TABLE_CLAUSE", "I_INDEX_CLAUSE", "P_TABLE_CLAUSE"].each do |clause|
               default_clause = case clause
@@ -241,7 +241,7 @@ module ActiveRecord
 
           def create_lexer_preference(lexer_name, lexer_type, options)
             drop_ctx_preference(lexer_name)
-            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{lexer_name}', '#{lexer_type}');\n"
+            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{lexer_name}', '#{lexer_type}');\n".dup
             options.each do |key, value|
               plsql_value = case value
                             when String; "'#{value}'"
@@ -258,7 +258,7 @@ module ActiveRecord
 
           def create_wordlist_preference(wordlist_name, wordlist_type, options)
             drop_ctx_preference(wordlist_name)
-            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{wordlist_name}', '#{wordlist_type}');\n"
+            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{wordlist_name}', '#{wordlist_type}');\n".dup
             options.each do |key, value|
               plsql_value = case value
                             when String; "'#{value}'"
@@ -281,7 +281,7 @@ module ActiveRecord
             trigger_name = default_index_column_trigger_name(index_name)
             columns = Array(index_column_source)
             quoted_column_names = columns.map { |col| quote_column_name(col) }.join(", ")
-            execute compress_lines(<<-SQL)
+            execute <<-SQL
             CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
             BEFORE UPDATE OF #{quoted_column_names} ON #{quote_table_name(table_name)} FOR EACH ROW
             BEGIN
@@ -332,7 +332,7 @@ module ActiveRecord
             def contains(column, query, options = {})
               score_label = options[:label].to_i || 1
               where("CONTAINS(#{connection.quote_table_name(column)}, ?, #{score_label}) > 0", query).
-                order("SCORE(#{score_label}) DESC")
+                order(Arel.sql("SCORE(#{score_label}) DESC"))
             end
           end
       end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module DatabaseLimits
+        # maximum length of Oracle identifiers
+        IDENTIFIER_MAX_LENGTH = 30
+
+        def table_alias_length #:nodoc:
+          IDENTIFIER_MAX_LENGTH
+        end
+
+        # the maximum length of a table name
+        def table_name_length
+          IDENTIFIER_MAX_LENGTH
+        end
+
+        # the maximum length of a column name
+        def column_name_length
+          IDENTIFIER_MAX_LENGTH
+        end
+
+        # Returns the maximum allowed length for an index name. This
+        # limit is enforced by rails and Is less than or equal to
+        # <tt>index_name_length</tt>. The gap between
+        # <tt>index_name_length</tt> is to allow internal rails
+        # opreations to use prefixes in temporary opreations.
+        def allowed_index_name_length
+          index_name_length
+        end
+
+        # the maximum length of an index name
+        # supported by this database
+        def index_name_length
+          IDENTIFIER_MAX_LENGTH
+        end
+
+        # the maximum length of a sequence name
+        def sequence_name_length
+          IDENTIFIER_MAX_LENGTH
+        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 in_clause_length
+          1000
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
@@ -42,7 +44,7 @@ module ActiveRecord
               res = true
             else
               columns = cursor.get_col_names.map do |col_name|
-                @connection.oracle_downcase(col_name)
+                oracle_downcase(col_name)
               end
               rows = []
               fetch_options = { get_lob_value: (name != "Writable Large Object") }
@@ -57,10 +59,6 @@ module ActiveRecord
           end
         end
 
-        def supports_statement_cache?
-          true
-        end
-
         def supports_explain?
           true
         end
@@ -81,7 +79,7 @@ module ActiveRecord
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)
           unless id_value || pk == false || pk.nil? ||  pk.is_a?(Array)
             sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
-            (binds = binds.dup) << ActiveRecord::Relation::QueryAttribute.new("returning_id", nil, ActiveRecord::OracleEnhanced::Type::Integer.new)
+            (binds = binds.dup) << ActiveRecord::Relation::QueryAttribute.new("returning_id", nil, Type::OracleEnhanced::Integer.new)
           end
           super
         end
@@ -113,7 +111,7 @@ module ActiveRecord
               if sql =~ /:returning_id/
                 # it currently expects that returning_id comes last part of binds
                 returning_id_index = binds.size
-                cursor.bind_returning_param(returning_id_index, Integer) if ORACLE_ENHANCED_CONNECTION == :jdbc
+                cursor.bind_returning_param(returning_id_index, Integer)
               end
 
               cached = true
@@ -224,12 +222,42 @@ module ActiveRecord
           end
         end
 
+        # fallback to non bulk fixture insert
+        def insert_fixtures(fixtures, table_name)
+          fixtures.each do |fixture|
+            insert_fixture(fixture, table_name)
+          end
+        end
+
         # Oracle Database does not support this feature
         # Refer https://community.oracle.com/ideas/13845 and consider to vote
         # if you need this feature.
         def empty_insert_statement_value
           raise NotImplementedError
         end
+
+        # Writes LOB values from attributes for specified columns
+        def write_lobs(table_name, klass, attributes, columns) #:nodoc:
+          id = quote(attributes[klass.primary_key])
+          columns.each do |col|
+            value = attributes[col.name]
+            # changed sequence of next two lines - should check if value is nil before converting to yaml
+            next if value.blank?
+            if klass.attribute_types[col.name].is_a? Type::Serialized
+              value = klass.attribute_types[col.name].serialize(value)
+            end
+            uncached do
+              unless lob_record = select_one(<<-SQL.strip.gsub(/\s+/, " "), "Writable Large Object")
+                SELECT #{quote_column_name(col.name)} FROM #{quote_table_name(table_name)}
+                WHERE #{quote_column_name(klass.primary_key)} = #{id} FOR UPDATE
+              SQL
+                raise ActiveRecord::RecordNotFound, "statement #{sql} returned no rows"
+              end
+              lob = lob_record[col.name]
+              @connection.write_lob(lob, value.to_s, col.type == :binary)
+            end
+          end
+        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_record/base"
 
 module ActiveRecord

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module DbmsOutput
+        # DBMS_OUTPUT =============================================
+        #
+        # PL/SQL in Oracle uses dbms_output for logging print statements
+        # These methods stick that output into the Rails log so Ruby and PL/SQL
+        # code can can be debugged together in a single application
+
+        # Maximum DBMS_OUTPUT buffer size
+        DBMS_OUTPUT_BUFFER_SIZE = 10000  # can be 1-1000000
+
+        # Turn DBMS_Output logging on
+        def enable_dbms_output
+          set_dbms_output_plsql_connection
+          @enable_dbms_output = true
+          plsql(:dbms_output).sys.dbms_output.enable(DBMS_OUTPUT_BUFFER_SIZE)
+        end
+        # Turn DBMS_Output logging off
+        def disable_dbms_output
+          set_dbms_output_plsql_connection
+          @enable_dbms_output = false
+          plsql(:dbms_output).sys.dbms_output.disable
+        end
+        # Is DBMS_Output logging enabled?
+        def dbms_output_enabled?
+          @enable_dbms_output
+        end
+
+      private
+
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+          super
+        ensure
+          log_dbms_output if dbms_output_enabled?
+        end
+
+        def set_dbms_output_plsql_connection
+          raise OracleEnhanced::ConnectionException, "ruby-plsql gem is required for logging DBMS output" unless self.respond_to?(:plsql)
+          # do not reset plsql connection if it is the same (as resetting will clear PL/SQL metadata cache)
+          unless plsql(:dbms_output).connection && plsql(:dbms_output).connection.raw_connection == raw_connection
+            plsql(:dbms_output).connection = raw_connection
+          end
+        end
+
+        def log_dbms_output
+          while true do
+            result = plsql(:dbms_output).sys.dbms_output.get_line(line: "", status: 0)
+            break unless result[:status] == 0
+            @logger.debug "DBMS_OUTPUT: #{result[:line]}" if @logger
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require "java"
   require "jruby"
@@ -48,495 +50,463 @@ end
 module ActiveRecord
   module ConnectionAdapters
     # JDBC database interface for JRuby
-    class OracleEnhancedJDBCConnection < OracleEnhancedConnection #:nodoc:
-      attr_accessor :active
-      alias :active? :active
-
-      attr_accessor :auto_retry
-      alias :auto_retry? :auto_retry
-      @auto_retry = false
-
-      def initialize(config)
-        @active = true
-        @config = config
-        new_connection(@config)
-      end
+    module OracleEnhanced
+      class JDBCConnection < OracleEnhanced::Connection #:nodoc:
+        attr_accessor :active
+        alias :active? :active
 
-      # modified method to support JNDI connections
-      def new_connection(config)
-        username = nil
+        attr_accessor :auto_retry
+        alias :auto_retry? :auto_retry
+        @auto_retry = false
 
-        if config[:jndi]
-          jndi = config[:jndi].to_s
-          ctx = javax.naming.InitialContext.new
-          ds = nil
+        def initialize(config)
+          @active = true
+          @config = config
+          new_connection(@config)
+        end
 
-          # tomcat needs first lookup method, oc4j (and maybe other application servers) need second method
-          begin
-            env = ctx.lookup("java:/comp/env")
-            ds = env.lookup(jndi)
-          rescue
-            ds = ctx.lookup(jndi)
-          end
+        # modified method to support JNDI connections
+        def new_connection(config)
+          username = nil
+
+          if config[:jndi]
+            jndi = config[:jndi].to_s
+            ctx = javax.naming.InitialContext.new
+            ds = nil
+
+            # tomcat needs first lookup method, oc4j (and maybe other application servers) need second method
+            begin
+              env = ctx.lookup("java:/comp/env")
+              ds = env.lookup(jndi)
+            rescue
+              ds = ctx.lookup(jndi)
+            end
 
-          # check if datasource supports pooled connections, otherwise use default
-          if ds.respond_to?(:pooled_connection)
-            @raw_connection = ds.pooled_connection
-          else
-            @raw_connection = ds.connection
-          end
+            # check if datasource supports pooled connections, otherwise use default
+            if ds.respond_to?(:pooled_connection)
+              @raw_connection = ds.pooled_connection
+            else
+              @raw_connection = ds.connection
+            end
 
-          # get Oracle JDBC connection when using DBCP in Tomcat or jBoss
-          if @raw_connection.respond_to?(:getInnermostDelegate)
-            @pooled_connection = @raw_connection
-            @raw_connection = @raw_connection.innermost_delegate
-          elsif @raw_connection.respond_to?(:getUnderlyingConnection)
-            @pooled_connection = @raw_connection
-            @raw_connection = @raw_connection.underlying_connection
-          end
+            # get Oracle JDBC connection when using DBCP in Tomcat or jBoss
+            if @raw_connection.respond_to?(:getInnermostDelegate)
+              @pooled_connection = @raw_connection
+              @raw_connection = @raw_connection.innermost_delegate
+            elsif @raw_connection.respond_to?(:getUnderlyingConnection)
+              @pooled_connection = @raw_connection
+              @raw_connection = @raw_connection.underlying_connection
+            end
 
-          config[:driver] ||= @raw_connection.meta_data.connection.java_class.name
-          username = @raw_connection.meta_data.user_name
-        else
-          # to_s needed if username, password or database is specified as number in database.yml file
-          username = config[:username] && config[:username].to_s
-          password = config[:password] && config[:password].to_s
-          database = config[:database] && config[:database].to_s || "XE"
-          host, port = config[:host], config[:port]
-          privilege = config[:privilege] && config[:privilege].to_s
-
-          # connection using TNS alias, or connection-string from DATABASE_URL
-          using_tns_alias = !host && !config[:url] && ENV["TNS_ADMIN"]
-          if database && (using_tns_alias || host == "connection-string")
-            url = "jdbc:oracle:thin:@#{database}"
+            config[:driver] ||= @raw_connection.meta_data.connection.java_class.name
+            username = @raw_connection.meta_data.user_name
           else
-            unless database.match(/^(\:|\/)/)
-              # assume database is a SID if no colon or slash are supplied (backward-compatibility)
-              database = ":#{database}"
+            # to_s needed if username, password or database is specified as number in database.yml file
+            username = config[:username] && config[:username].to_s
+            password = config[:password] && config[:password].to_s
+            database = config[:database] && config[:database].to_s || "XE"
+            host, port = config[:host], config[:port]
+            privilege = config[:privilege] && config[:privilege].to_s
+
+            # connection using TNS alias, or connection-string from DATABASE_URL
+            using_tns_alias = !host && !config[:url] && ENV["TNS_ADMIN"]
+            if database && (using_tns_alias || host == "connection-string")
+              url = "jdbc:oracle:thin:@#{database}"
+            else
+              unless database.match(/^(\:|\/)/)
+                # assume database is a SID if no colon or slash are supplied (backward-compatibility)
+                database = ":#{database}"
+              end
+              url = config[:url] || "jdbc:oracle:thin:@#{host || 'localhost'}:#{port || 1521}#{database}"
             end
-            url = config[:url] || "jdbc:oracle:thin:@#{host || 'localhost'}:#{port || 1521}#{database}"
-          end
 
-          prefetch_rows = config[:prefetch_rows] || 100
-          # get session time_zone from configuration or from TZ environment variable
-          time_zone = config[:time_zone] || ENV["TZ"] || java.util.TimeZone.default.getID
+            prefetch_rows = config[:prefetch_rows] || 100
+            # get session time_zone from configuration or from TZ environment variable
+            time_zone = config[:time_zone] || ENV["TZ"] || java.util.TimeZone.default.getID
+
+            properties = java.util.Properties.new
+            properties.put("user", username)
+            properties.put("password", password)
+            properties.put("defaultRowPrefetch", "#{prefetch_rows}") if prefetch_rows
+            properties.put("internal_logon", privilege) if privilege
+
+            begin
+              @raw_connection = java.sql.DriverManager.getConnection(url, properties)
+            rescue
+              # bypass DriverManager to work in cases where ojdbc*.jar
+              # is added to the load path at runtime and not on the
+              # system classpath
+              @raw_connection = ORACLE_DRIVER.connect(url, properties)
+            end
 
-          properties = java.util.Properties.new
-          properties.put("user", username)
-          properties.put("password", password)
-          properties.put("defaultRowPrefetch", "#{prefetch_rows}") if prefetch_rows
-          properties.put("internal_logon", privilege) if privilege
+            # Set session time zone to current time zone
+            if ActiveRecord::Base.default_timezone == :local
+              @raw_connection.setSessionTimeZone(time_zone)
+            elsif ActiveRecord::Base.default_timezone == :utc
+              @raw_connection.setSessionTimeZone("UTC")
+            end
 
-          begin
-            @raw_connection = java.sql.DriverManager.getConnection(url, properties)
-          rescue
-            # bypass DriverManager to work in cases where ojdbc*.jar
-            # is added to the load path at runtime and not on the
-            # system classpath
-            @raw_connection = ORACLE_DRIVER.connect(url, properties)
+            # Set default number of rows to prefetch
+            # @raw_connection.setDefaultRowPrefetch(prefetch_rows) if prefetch_rows
           end
 
-          # Set session time zone to current time zone
-          if ActiveRecord::Base.default_timezone == :local
-            @raw_connection.setSessionTimeZone(time_zone)
-          elsif ActiveRecord::Base.default_timezone == :utc
-            @raw_connection.setSessionTimeZone("UTC")
-          end
+          cursor_sharing = config[:cursor_sharing]
+          exec "alter session set cursor_sharing = #{cursor_sharing}" if cursor_sharing
 
-          # Set default number of rows to prefetch
-          # @raw_connection.setDefaultRowPrefetch(prefetch_rows) if prefetch_rows
-        end
+          # Initialize NLS parameters
+          OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS.each do |key, default_value|
+            value = config[key] || ENV[key.to_s.upcase] || default_value
+            if value
+              exec "alter session set #{key} = '#{value}'"
+            end
+          end
 
-        cursor_sharing = config[:cursor_sharing] || "force"
-        exec "alter session set cursor_sharing = #{cursor_sharing}"
+          self.autocommit = true
 
-        # Initialize NLS parameters
-        OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS.each do |key, default_value|
-          value = config[key] || ENV[key.to_s.upcase] || default_value
-          if value
-            exec "alter session set #{key} = '#{value}'"
+          schema = config[:schema] && config[:schema].to_s
+          if schema.blank?
+            # default schema owner
+            @owner = username.upcase unless username.nil?
+          else
+            exec "alter session set current_schema = #{schema}"
+            @owner = schema
           end
-        end
 
-        self.autocommit = true
-
-        schema = config[:schema] && config[:schema].to_s
-        if schema.blank?
-          # default schema owner
-          @owner = username.upcase unless username.nil?
-        else
-          exec "alter session set current_schema = #{schema}"
-          @owner = schema
+          @raw_connection
         end
 
-        @raw_connection
-      end
-
-      def logoff
-        @active = false
-        if defined?(@pooled_connection)
-          @pooled_connection.close
-        else
-          @raw_connection.close
+        def logoff
+          @active = false
+          if defined?(@pooled_connection)
+            @pooled_connection.close
+          else
+            @raw_connection.close
+          end
+          true
+        rescue
+          false
         end
-        true
-      rescue
-        false
-      end
 
-      def commit
-        @raw_connection.commit
-      end
-
-      def rollback
-        @raw_connection.rollback
-      end
+        def commit
+          @raw_connection.commit
+        end
 
-      def autocommit?
-        @raw_connection.getAutoCommit
-      end
+        def rollback
+          @raw_connection.rollback
+        end
 
-      def autocommit=(value)
-        @raw_connection.setAutoCommit(value)
-      end
+        def autocommit?
+          @raw_connection.getAutoCommit
+        end
 
-      # Checks connection, returns true if active. Note that ping actively
-      # checks the connection, while #active? simply returns the last
-      # known state.
-      def ping
-        exec_no_retry("select 1 from dual")
-        @active = true
-      rescue NativeException => e
-        @active = false
-        if e.message =~ /^java\.sql\.SQL(Recoverable)?Exception/
-          raise OracleEnhancedConnectionException, e.message
-        else
-          raise
+        def autocommit=(value)
+          @raw_connection.setAutoCommit(value)
         end
-      end
 
-      # Resets connection, by logging off and creating a new connection.
-      def reset!
-        logoff rescue nil
-        begin
-          new_connection(@config)
+        # Checks connection, returns true if active. Note that ping actively
+        # checks the connection, while #active? simply returns the last
+        # known state.
+        def ping
+          exec_no_retry("select 1 from dual")
           @active = true
         rescue NativeException => e
           @active = false
           if e.message =~ /^java\.sql\.SQL(Recoverable)?Exception/
-            raise OracleEnhancedConnectionException, e.message
+            raise OracleEnhanced::ConnectionException, e.message
           else
             raise
           end
         end
-      end
 
-      # mark connection as dead if connection lost
-      def with_retry(&block)
-        should_retry = auto_retry? && autocommit?
-        begin
-          yield if block_given?
-        rescue NativeException => e
-          raise unless e.message =~ /^java\.sql\.SQL(Recoverable)?Exception: (Closed Connection|Io exception:|No more data to read from socket|IO Error:)/
-          @active = false
-          raise unless should_retry
-          should_retry = false
-          reset! rescue nil
-          retry
+        # Resets connection, by logging off and creating a new connection.
+        def reset!
+          logoff rescue nil
+          begin
+            new_connection(@config)
+            @active = true
+          rescue NativeException => e
+            @active = false
+            if e.message =~ /^java\.sql\.SQL(Recoverable)?Exception/
+              raise OracleEnhanced::ConnectionException, e.message
+            else
+              raise
+            end
+          end
         end
-      end
 
-      def exec(sql)
-        with_retry do
-          exec_no_retry(sql)
+        # mark connection as dead if connection lost
+        def with_retry(&block)
+          should_retry = auto_retry? && autocommit?
+          begin
+            yield if block_given?
+          rescue NativeException => e
+            raise unless e.message =~ /^java\.sql\.SQL(Recoverable)?Exception: (Closed Connection|Io exception:|No more data to read from socket|IO Error:)/
+            @active = false
+            raise unless should_retry
+            should_retry = false
+            reset! rescue nil
+            retry
+          end
         end
-      end
 
-      def exec_no_retry(sql)
-        case sql
-        when /\A\s*(UPDATE|INSERT|DELETE)/i
-          s = @raw_connection.prepareStatement(sql)
-          s.executeUpdate
-        # it is safer for CREATE and DROP statements not to use PreparedStatement
-        # as it does not allow creation of triggers with :NEW in their definition
-        when /\A\s*(CREATE|DROP)/i
-          s = @raw_connection.createStatement()
-          # this disables SQL92 syntax processing of {...} which can result in statement execution errors
-          # if sql contains {...} in strings or comments
-          s.setEscapeProcessing(false)
-          s.execute(sql)
-          true
-        else
-          s = @raw_connection.prepareStatement(sql)
-          s.execute
-          true
+        def exec(sql)
+          with_retry do
+            exec_no_retry(sql)
+          end
         end
-      ensure
-        s.close rescue nil
-      end
-
-      def returning_clause(quoted_pk)
-        " RETURNING #{quoted_pk} INTO ?"
-      end
 
-      # execute sql with RETURNING ... INTO :insert_id
-      # and return :insert_id value
-      def exec_with_returning(sql)
-        with_retry do
-          begin
-            # it will always be INSERT statement
-
-            # TODO: need to investigate why PreparedStatement is giving strange exception "Protocol violation"
-            # s = @raw_connection.prepareStatement(sql)
-            # s.registerReturnParameter(1, ::Java::oracle.jdbc.OracleTypes::NUMBER)
-            # count = s.executeUpdate
-            # if count > 0
-            #   rs = s.getReturnResultSet
-            #   if rs.next
-            #     # Assuming that primary key will not be larger as long max value
-            #     insert_id = rs.getLong(1)
-            #     rs.wasNull ? nil : insert_id
-            #   else
-            #     nil
-            #   end
-            # else
-            #   nil
-            # end
-
-            # Workaround with CallableStatement
-            s = @raw_connection.prepareCall("BEGIN #{sql}; END;")
-            s.registerOutParameter(1, java.sql.Types::BIGINT)
+        def exec_no_retry(sql)
+          case sql
+          when /\A\s*(UPDATE|INSERT|DELETE)/i
+            s = @raw_connection.prepareStatement(sql)
+            s.executeUpdate
+          # it is safer for CREATE and DROP statements not to use PreparedStatement
+          # as it does not allow creation of triggers with :NEW in their definition
+          when /\A\s*(CREATE|DROP)/i
+            s = @raw_connection.createStatement()
+            # this disables SQL92 syntax processing of {...} which can result in statement execution errors
+            # if sql contains {...} in strings or comments
+            s.setEscapeProcessing(false)
+            s.execute(sql)
+            true
+          else
+            s = @raw_connection.prepareStatement(sql)
             s.execute
-            insert_id = s.getLong(1)
-            s.wasNull ? nil : insert_id
-          ensure
-            # rs.close rescue nil
-            s.close rescue nil
+            true
           end
+        ensure
+          s.close rescue nil
         end
-      end
-
-      def prepare(sql)
-        Cursor.new(self, @raw_connection.prepareStatement(sql))
-      end
 
-      def database_version
-        @database_version ||= (md = raw_connection.getMetaData) && [md.getDatabaseMajorVersion, md.getDatabaseMinorVersion]
-      end
+        def prepare(sql)
+          Cursor.new(self, @raw_connection.prepareStatement(sql))
+        end
 
-      class Cursor
-        def initialize(connection, raw_statement)
-          @connection = connection
-          @raw_statement = raw_statement
+        def database_version
+          @database_version ||= (md = raw_connection.getMetaData) && [md.getDatabaseMajorVersion, md.getDatabaseMinorVersion]
         end
 
-        def bind_params(*bind_vars)
-          index = 1
-          bind_vars.flatten.each do |var|
-            if Hash === var
-              var.each { |key, val| bind_param key, val }
-            else
-              bind_param index, var
-              index += 1
+        class Cursor
+          def initialize(connection, raw_statement)
+            @connection = connection
+            @raw_statement = raw_statement
+          end
+
+          def bind_params(*bind_vars)
+            index = 1
+            bind_vars.flatten.each do |var|
+              if Hash === var
+                var.each { |key, val| bind_param key, val }
+              else
+                bind_param index, var
+                index += 1
+              end
             end
           end
-        end
 
-        def bind_param(position, value)
-          case value
-          when Integer
-            @raw_statement.setLong(position, value)
-          when Float
-            @raw_statement.setFloat(position, value)
-          when BigDecimal
-            @raw_statement.setBigDecimal(position, value)
-          when Java::OracleSql::BLOB
-            @raw_statement.setBlob(position, value)
-          when Java::OracleSql::CLOB
-            @raw_statement.setClob(position, value)
-          when ActiveRecord::OracleEnhanced::Type::Raw
-            @raw_statement.setString(position, ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting.encode_raw(value))
-          when String
-            @raw_statement.setString(position, value)
-          when Java::OracleSql::DATE
-            @raw_statement.setDATE(position, value)
-          when Date, DateTime
-            # TODO: Really needed or not
-            @raw_statement.setDATE(position, value)
-          when Java::JavaSql::Timestamp
-            @raw_statement.setTimestamp(position, value)
-          when Time
-            new_value = Java::java.sql.Timestamp.new(value.year - 1900, value.month - 1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
-            @raw_statement.setTimestamp(position, new_value)
-          when NilClass
-            # TODO: currently nil is always bound as NULL with VARCHAR type.
-            # When nils will actually be used by ActiveRecord as bound parameters
-            # then need to pass actual column type.
-            @raw_statement.setNull(position, java.sql.Types::VARCHAR)
-          else
-            raise ArgumentError, "Don't know how to bind variable with type #{value.class}"
+          def bind_param(position, value)
+            case value
+            when Integer
+              @raw_statement.setLong(position, value)
+            when Float
+              @raw_statement.setFloat(position, value)
+            when BigDecimal
+              @raw_statement.setBigDecimal(position, value)
+            when Java::OracleSql::BLOB
+              @raw_statement.setBlob(position, value)
+            when Java::OracleSql::CLOB
+              @raw_statement.setClob(position, value)
+            when Java::OracleSql::NCLOB
+              @raw_statement.setClob(position, value)
+            when Type::OracleEnhanced::Raw
+              @raw_statement.setString(position, OracleEnhanced::Quoting.encode_raw(value))
+            when String
+              @raw_statement.setString(position, value)
+            when Java::OracleSql::DATE
+              @raw_statement.setDATE(position, value)
+            when Java::JavaSql::Timestamp
+              @raw_statement.setTimestamp(position, value)
+            when Time
+              new_value = Java::java.sql.Timestamp.new(value.year - 1900, value.month - 1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
+              @raw_statement.setTimestamp(position, new_value)
+            when NilClass
+              # TODO: currently nil is always bound as NULL with VARCHAR type.
+              # When nils will actually be used by ActiveRecord as bound parameters
+              # then need to pass actual column type.
+              @raw_statement.setNull(position, java.sql.Types::VARCHAR)
+            else
+              raise ArgumentError, "Don't know how to bind variable with type #{value.class}"
+            end
           end
-        end
 
-        def bind_returning_param(position, bind_type)
-          @returning_positions ||= []
-          @returning_positions << position
-          if bind_type == Integer
-            @raw_statement.registerReturnParameter(position, java.sql.Types::BIGINT)
+          def bind_returning_param(position, bind_type)
+            @returning_positions ||= []
+            @returning_positions << position
+            if bind_type == Integer
+              @raw_statement.registerReturnParameter(position, java.sql.Types::BIGINT)
+            end
           end
-        end
 
-        def exec
-          @raw_result_set = @raw_statement.executeQuery
-          true
-        end
+          def exec
+            @raw_result_set = @raw_statement.executeQuery
+            true
+          end
 
-        def exec_update
-          @raw_statement.executeUpdate
-        end
+          def exec_update
+            @raw_statement.executeUpdate
+          end
 
-        def metadata
-          @metadata ||= @raw_result_set.getMetaData
-        end
+          def metadata
+            @metadata ||= @raw_result_set.getMetaData
+          end
 
-        def column_types
-          @column_types ||= (1..metadata.getColumnCount).map { |i| metadata.getColumnTypeName(i).to_sym }
-        end
+          def column_types
+            @column_types ||= (1..metadata.getColumnCount).map { |i| metadata.getColumnTypeName(i).to_sym }
+          end
 
-        def column_names
-          @column_names ||= (1..metadata.getColumnCount).map { |i| metadata.getColumnName(i) }
-        end
-        alias :get_col_names :column_names
-
-        def fetch(options = {})
-          if @raw_result_set.next
-            get_lob_value = options[:get_lob_value]
-            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)
+          def column_names
+            @column_names ||= (1..metadata.getColumnCount).map { |i| metadata.getColumnName(i) }
+          end
+          alias :get_col_names :column_names
+
+          def fetch(options = {})
+            if @raw_result_set.next
+              get_lob_value = options[:get_lob_value]
+              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)
+              end
+              row_values
+            else
+              @raw_result_set.close
+              nil
             end
-            row_values
-          else
-            @raw_result_set.close
-            nil
           end
-        end
 
-        def get_returning_param(position, type)
-          rs_position = @returning_positions.index(position) + 1
-          rs = @raw_statement.getReturnResultSet
-          if rs.next
-            # Assuming that primary key will not be larger as long max value
-            returning_id = rs.getLong(rs_position)
-            rs.wasNull ? nil : returning_id
-          else
-            nil
+          def get_returning_param(position, type)
+            rs_position = @returning_positions.index(position) + 1
+            rs = @raw_statement.getReturnResultSet
+            if rs.next
+              # Assuming that primary key will not be larger as long max value
+              returning_id = rs.getLong(rs_position)
+              rs.wasNull ? nil : returning_id
+            else
+              nil
+            end
           end
-        end
 
-        def close
-          @raw_statement.close
+          def close
+            @raw_statement.close
+          end
         end
-      end
 
-      def select(sql, name = nil, return_column_names = false)
-        with_retry do
-          select_no_retry(sql, name, return_column_names)
+        def select(sql, name = nil, return_column_names = false)
+          with_retry do
+            select_no_retry(sql, name, return_column_names)
+          end
         end
-      end
 
-      def select_no_retry(sql, name = nil, return_column_names = false)
-        stmt = @raw_connection.prepareStatement(sql)
-        rset = stmt.executeQuery
+        def select_no_retry(sql, name = nil, return_column_names = false)
+          stmt = @raw_connection.prepareStatement(sql)
+          rset = stmt.executeQuery
 
-        # Reuse the same hash for all rows
-        column_hash = {}
+          # Reuse the same hash for all rows
+          column_hash = {}
 
-        metadata = rset.getMetaData
-        column_count = metadata.getColumnCount
+          metadata = rset.getMetaData
+          column_count = metadata.getColumnCount
 
-        cols_types_index = (1..column_count).map do |i|
-          col_name = oracle_downcase(metadata.getColumnName(i))
-          next if col_name == "raw_rnum_"
-          column_hash[col_name] = nil
-          [col_name, metadata.getColumnTypeName(i).to_sym, i]
-        end
-        cols_types_index.delete(nil)
+          cols_types_index = (1..column_count).map do |i|
+            col_name = _oracle_downcase(metadata.getColumnName(i))
+            next if col_name == "raw_rnum_"
+            column_hash[col_name] = nil
+            [col_name, metadata.getColumnTypeName(i).to_sym, i]
+          end
+          cols_types_index.delete(nil)
 
-        rows = []
-        get_lob_value = !(name == "Writable Large Object")
+          rows = []
+          get_lob_value = !(name == "Writable Large Object")
 
-        while rset.next
-          hash = column_hash.dup
-          cols_types_index.each do |col, column_type, i|
-            hash[col] = get_ruby_value_from_result_set(rset, i, column_type, get_lob_value)
+          while rset.next
+            hash = column_hash.dup
+            cols_types_index.each do |col, column_type, i|
+              hash[col] = get_ruby_value_from_result_set(rset, i, column_type, get_lob_value)
+            end
+            rows << hash
           end
-          rows << hash
-        end
 
-        return_column_names ? [rows, cols_types_index.map(&:first)] : rows
-      ensure
-        rset.close rescue nil
-        stmt.close rescue nil
-      end
+          return_column_names ? [rows, cols_types_index.map(&:first)] : rows
+        ensure
+          rset.close rescue nil
+          stmt.close rescue nil
+        end
 
-      def write_lob(lob, value, is_binary = false)
-        if is_binary
-          lob.setBytes(1, value.to_java_bytes)
-        else
-          lob.setString(1, value)
+        def write_lob(lob, value, is_binary = false)
+          if is_binary
+            lob.setBytes(1, value.to_java_bytes)
+          else
+            lob.setString(1, value)
+          end
         end
-      end
 
-      # Return NativeException / java.sql.SQLException error code
-      def error_code(exception)
-        case exception
-        when NativeException
-          exception.cause.getErrorCode
-        else
-          nil
+        # To allow private method called from `JDBCConnection`
+        def describe(name)
+          super
         end
-      end
 
-      def get_ruby_value_from_result_set(rset, i, type_name, get_lob_value = true)
-        case type_name
-        when :NUMBER
-          d = rset.getNUMBER(i)
-          if d.nil?
-            nil
-          elsif d.isInt
-            Integer(d.stringValue)
+        # Return NativeException / java.sql.SQLException error code
+        def error_code(exception)
+          case exception
+          when NativeException
+            exception.cause.getErrorCode
+          when Java::JavaSql::SQLException
+            exception.getErrorCode
           else
-            BigDecimal.new(d.stringValue)
+            nil
           end
-        when :BINARY_FLOAT
-          rset.getFloat(i)
-        when :VARCHAR2, :CHAR, :LONG, :NVARCHAR2, :NCHAR
-          rset.getString(i)
-        when :DATE
-          if dt = rset.getDATE(i)
-            d = dt.dateValue
-            t = dt.timeValue
-            Time.send(Base.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+        end
+
+        def get_ruby_value_from_result_set(rset, i, type_name, get_lob_value = true)
+          case type_name
+          when :NUMBER
+            d = rset.getNUMBER(i)
+            if d.nil?
+              nil
+            elsif d.isInt
+              Integer(d.stringValue)
+            else
+              BigDecimal.new(d.stringValue)
+            end
+          when :BINARY_FLOAT
+            rset.getFloat(i)
+          when :VARCHAR2, :CHAR, :LONG, :NVARCHAR2, :NCHAR
+            rset.getString(i)
+          when :DATE
+            if dt = rset.getDATE(i)
+              d = dt.dateValue
+              t = dt.timeValue
+              Time.send(Base.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+            else
+              nil
+            end
+          when :TIMESTAMP, :TIMESTAMPTZ, :TIMESTAMPLTZ, :"TIMESTAMP WITH TIME ZONE", :"TIMESTAMP WITH LOCAL TIME ZONE"
+            ts = rset.getTimestamp(i)
+            ts && Time.send(Base.default_timezone, ts.year + 1900, ts.month + 1, ts.date, ts.hours, ts.minutes, ts.seconds,
+              ts.nanos / 1000)
+          when :CLOB
+            get_lob_value ? lob_to_ruby_value(rset.getClob(i)) : rset.getClob(i)
+          when :NCLOB
+            get_lob_value ? lob_to_ruby_value(rset.getClob(i)) : rset.getClob(i)
+          when :BLOB
+            get_lob_value ? lob_to_ruby_value(rset.getBlob(i)) : rset.getBlob(i)
+          when :RAW
+            raw_value = rset.getRAW(i)
+            raw_value && raw_value.getBytes.to_a.pack("C*")
           else
             nil
           end
-        when :TIMESTAMP, :TIMESTAMPTZ, :TIMESTAMPLTZ, :"TIMESTAMP WITH TIME ZONE", :"TIMESTAMP WITH LOCAL TIME ZONE"
-          ts = rset.getTimestamp(i)
-          ts && Time.send(Base.default_timezone, ts.year + 1900, ts.month + 1, ts.date, ts.hours, ts.minutes, ts.seconds,
-            ts.nanos / 1000)
-        when :CLOB
-          get_lob_value ? lob_to_ruby_value(rset.getClob(i)) : rset.getClob(i)
-        when :BLOB
-          get_lob_value ? lob_to_ruby_value(rset.getBlob(i)) : rset.getBlob(i)
-        when :RAW
-          raw_value = rset.getRAW(i)
-          raw_value && raw_value.getBytes.to_a.pack("C*")
-        else
-          nil
         end
-      end
 
       private
 
@@ -548,6 +518,12 @@ module ActiveRecord
             else
               val.getSubString(1, val.length)
             end
+          when ::Java::OracleSql::NCLOB
+            if val.isEmptyLob
+              nil
+            else
+              val.getSubString(1, val.length)
+            end
           when ::Java::OracleSql::BLOB
             if val.isEmptyLob
               nil
@@ -556,6 +532,7 @@ module ActiveRecord
             end
           end
         end
+      end
     end
   end
 end