activerecord-oracle_enhanced-adapter 1.2.1 → 1.2.2

data/lib/active_record/connection_adapters/oracle_enhanced_connection.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
     # interface independent methods
-    class OracleEnhancedConnection
+    class OracleEnhancedConnection #:nodoc:
 
       def self.create(config)
         case ORACLE_ENHANCED_CONNECTION
@@ -23,9 +23,60 @@ module ActiveRecord
       # camelCase column name. I imagine other dbs handle this different, since there's a
       # unit test that's currently failing test_oci.
       def oracle_downcase(column_name)
+        return nil if column_name.nil?
         column_name =~ /[a-z]/ ? column_name : column_name.downcase
       end
 
+      # Used always by JDBC connection as well by OCI connection when describing tables over database link
+      def describe(name)
+        name = name.to_s
+        if name.include?('@')
+          name, db_link = name.split('@')
+          default_owner = select_value("SELECT username FROM all_db_links WHERE db_link = '#{db_link.upcase}'")
+          db_link = "@#{db_link}"
+        else
+          db_link = nil
+          default_owner = @owner
+        end
+        real_name = OracleEnhancedAdapter.valid_table_name?(name) ? name.upcase : name
+        if real_name.include?('.')
+          table_owner, table_name = real_name.split('.')
+        else
+          table_owner, table_name = default_owner, real_name
+        end
+        sql = <<-SQL
+          SELECT owner, table_name, 'TABLE' name_type
+          FROM all_tables#{db_link}
+          WHERE owner = '#{table_owner}'
+            AND table_name = '#{table_name}'
+          UNION ALL
+          SELECT owner, view_name table_name, 'VIEW' name_type
+          FROM all_views#{db_link}
+          WHERE owner = '#{table_owner}'
+            AND view_name = '#{table_name}'
+          UNION ALL
+          SELECT table_owner, DECODE(db_link, NULL, table_name, table_name||'@'||db_link), 'SYNONYM' name_type
+          FROM all_synonyms#{db_link}
+          WHERE owner = '#{table_owner}'
+            AND synonym_name = '#{table_name}'
+          UNION ALL
+          SELECT table_owner, DECODE(db_link, NULL, table_name, table_name||'@'||db_link), 'SYNONYM' name_type
+          FROM all_synonyms#{db_link}
+          WHERE owner = 'PUBLIC'
+            AND synonym_name = '#{real_name}'
+        SQL
+        if result = select_one(sql)
+          case result['name_type']
+          when 'SYNONYM'
+            describe("#{result['owner'] && "#{result['owner']}."}#{result['table_name']}#{db_link}")
+          else
+            db_link ? [result['owner'], result['table_name'], db_link] : [result['owner'], result['table_name']]
+          end
+        else
+          raise OracleEnhancedConnectionException, %Q{"DESC #{name}" failed; does it exist?}
+        end
+      end
+
       private
       
       # Returns a record hash with the column names as keys and column values
@@ -48,11 +99,10 @@ module ActiveRecord
         result = select(sql)
         result.map { |r| r.values.first }
       end
-      
 
     end
     
-    class OracleEnhancedConnectionException < StandardError
+    class OracleEnhancedConnectionException < StandardError #:nodoc:
     end
 
   end

data/lib/active_record/connection_adapters/oracle_enhanced_core_ext.rb

@@ -1,7 +1,7 @@
 require "bigdecimal"
 unless BigDecimal.instance_methods.include?("to_d")
   BigDecimal.class_eval do
-    def to_d
+    def to_d #:nodoc:
       self
     end
   end
@@ -9,7 +9,7 @@ end
 
 unless Bignum.instance_methods.include?("to_d")
   Bignum.class_eval do
-    def to_d
+    def to_d #:nodoc:
       BigDecimal.new(self.to_s)
     end
   end
@@ -17,7 +17,7 @@ end
 
 unless Fixnum.instance_methods.include?("to_d")
   Fixnum.class_eval do
-    def to_d
+    def to_d #:nodoc:
       BigDecimal.new(self.to_s)
     end
   end
@@ -30,22 +30,22 @@ if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '1.9'
     require "unicode_utils/upcase"
     require "unicode_utils/downcase"
 
-    module ActiveRecord
-      module ConnectionAdapters
-        module OracleEnhancedUnicodeString
-          def upcase
+    module ActiveRecord #:nodoc:
+      module ConnectionAdapters #:nodoc:
+        module OracleEnhancedUnicodeString #:nodoc:
+          def upcase #:nodoc:
             UnicodeUtils.upcase(self)
           end
 
-          def downcase
+          def downcase #:nodoc:
             UnicodeUtils.downcase(self)
           end
         end
       end
     end
 
-    class String
-      def mb_chars
+    class String #:nodoc:
+      def mb_chars #:nodoc:
         self.extend(ActiveRecord::ConnectionAdapters::OracleEnhancedUnicodeString)
         self
       end

data/lib/active_record/connection_adapters/oracle_enhanced_cpk.rb

@@ -2,13 +2,13 @@ module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
     module OracleEnhancedCpk #:nodoc:
 
-      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
-      # RSI: return that not supported if composite_primary_keys gem is required
+      # This mightn't be in Core, but count(distinct x,y) doesn't work for me.
+      # Return that not supported if composite_primary_keys gem is required.
       def supports_count_distinct? #:nodoc:
         @supports_count_distinct ||= ! defined?(CompositePrimaryKeys)
       end
       
-      def concat(*columns)
+      def concat(*columns) #:nodoc:
         "(#{columns.join('||')})"
       end
       

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -2,19 +2,19 @@ module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
     module OracleEnhancedDirty #:nodoc:
 
-      module InstanceMethods
+      module InstanceMethods #:nodoc:
         private
         
         def field_changed?(attr, old, value)
           if column = column_for_attribute(attr)
-            # RSI: added also :decimal type
+            # Added also :decimal type
             if (column.type == :integer || column.type == :decimal) && column.null && (old.nil? || old == 0) && value.blank?
               # For nullable integer columns, NULL gets stored in database for blank (i.e. '') values.
               # Hence we don't record it as a change if the value changes from nil to ''.
               # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
               # be typecast back to 0 (''.to_i => 0)
               value = nil
-            # RSI: Oracle stores empty string '' or empty text (CLOB) as NULL
+            # Oracle stores empty string '' or empty text (CLOB) as NULL
             # therefore need to convert empty string value to nil if old value is nil
             elsif (column.type == :string || column.type == :text) && column.null && old.nil?
               value = nil if value == ''

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -1,20 +1,28 @@
 begin
   require "java"
   require "jruby"
-  # Adds JRuby classloader to current thread classloader - as a result ojdbc14.jar should not be in $JRUBY_HOME/lib
-  java.lang.Thread.currentThread.setContextClassLoader(JRuby.runtime.jruby_class_loader)
+
+  # ojdbc14.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
 
   ojdbc_jar = "ojdbc14.jar"
-  if ojdbc_jar_path = ENV["PATH"].split(/[:;]/).find{|d| File.exists?(File.join(d,ojdbc_jar))}
-    require File.join(ojdbc_jar_path,ojdbc_jar)
+
+  unless ENV_JAVA['java.class.path'] =~ Regexp.new(ojdbc_jar)
+    # Adds JRuby classloader to current thread classloader - as a result ojdbc14.jar should not be in $JRUBY_HOME/lib
+    # not necessary anymore for JRuby 1.3
+    # java.lang.Thread.currentThread.setContextClassLoader(JRuby.runtime.jruby_class_loader)
+
+    if ojdbc_jar_path = ENV["PATH"].split(/[:;]/).concat($LOAD_PATH).find{|d| File.exists?(File.join(d,ojdbc_jar))}
+      require File.join(ojdbc_jar_path,ojdbc_jar)
+    end
   end
-  # import java.sql.Statement
-  # import java.sql.Connection
-  # import java.sql.SQLException
-  # import java.sql.Types
-  # import java.sql.DriverManager
+
   java.sql.DriverManager.registerDriver Java::oracle.jdbc.driver.OracleDriver.new
 
+  # set tns_admin property from TNS_ADMIN environment variable
+  if !java.lang.System.get_property("oracle.net.tns_admin") && ENV["TNS_ADMIN"]
+    java.lang.System.set_property("oracle.net.tns_admin", ENV["TNS_ADMIN"])
+  end
+
 rescue LoadError, NameError
   # JDBC driver is unavailable.
   error_message = "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. "+
@@ -32,7 +40,7 @@ module ActiveRecord
   module ConnectionAdapters
 
     # JDBC database interface for JRuby
-    class OracleEnhancedJDBCConnection < OracleEnhancedConnection
+    class OracleEnhancedJDBCConnection < OracleEnhancedConnection #:nodoc:
 
       attr_accessor :active
       alias :active? :active
@@ -52,10 +60,17 @@ module ActiveRecord
         privilege = config[:privilege] && config[:privilege].to_s
         host, port = config[:host], config[:port]
 
-        url = config[:url] || "jdbc:oracle:thin:@#{host || 'localhost'}:#{port || 1521}:#{database || 'XE'}"
+        # connection using TNS alias
+        if database && !host && !config[:url] && ENV['TNS_ADMIN']
+          url = "jdbc:oracle:thin:@#{database || 'XE'}"
+        else
+          url = config[:url] || "jdbc:oracle:thin:@#{host || 'localhost'}:#{port || 1521}:#{database || 'XE'}"
+        end
 
         prefetch_rows = config[:prefetch_rows] || 100
-        cursor_sharing = config[:cursor_sharing] || 'similar'
+        cursor_sharing = config[:cursor_sharing] || 'force'
+        # by default VARCHAR2 column size will be interpreted as max number of characters (and not bytes)
+        nls_length_semantics = config[:nls_length_semantics] || 'CHAR'
 
         properties = java.util.Properties.new
         properties.put("user", username)
@@ -65,8 +80,9 @@ module ActiveRecord
 
         @raw_connection = java.sql.DriverManager.getConnection(url, properties)
         exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
-        exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS'} # rescue nil
-        exec "alter session set cursor_sharing = #{cursor_sharing}" # rescue nil
+        exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS'}
+        exec "alter session set cursor_sharing = #{cursor_sharing}"
+        exec "alter session set nls_length_semantics = '#{nls_length_semantics}'"
         self.autocommit = true
         
         # Set session time zone to current time zone
@@ -159,16 +175,64 @@ module ActiveRecord
       end
 
       def exec_no_retry(sql)
-        cs = @raw_connection.prepareCall(sql)
         case sql
-        when /\A\s*UPDATE/i, /\A\s*INSERT/i, /\A\s*DELETE/i
-          cs.executeUpdate
+        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()
+          s.execute(sql)
+          true
         else
-          cs.execute
+          s = @raw_connection.prepareStatement(sql)
+          s.execute
           true
         end
       ensure
-        cs.close rescue nil        
+        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)
+            s.execute
+            insert_id = s.getLong(1)
+            s.wasNull ? nil : insert_id
+          ensure
+            # rs.close rescue nil
+            s.close rescue nil
+          end
+        end
       end
 
       def select(sql, name = nil, return_column_names = false)
@@ -220,46 +284,10 @@ module ActiveRecord
         end
       end
 
-      def describe(name)
-        real_name = OracleEnhancedAdapter.valid_table_name?(name) ? name.to_s.upcase : name.to_s
-        if real_name.include?('.')
-          table_owner, table_name = real_name.split('.')
-        else
-          table_owner, table_name = @owner, real_name
-        end
-        sql = <<-SQL
-          SELECT owner, table_name, 'TABLE' name_type
-          FROM all_tables
-          WHERE owner = '#{table_owner}'
-            AND table_name = '#{table_name}'
-          UNION ALL
-          SELECT owner, view_name table_name, 'VIEW' name_type
-          FROM all_views
-          WHERE owner = '#{table_owner}'
-            AND view_name = '#{table_name}'
-          UNION ALL
-          SELECT table_owner, table_name, 'SYNONYM' name_type
-          FROM all_synonyms
-          WHERE owner = '#{table_owner}'
-            AND synonym_name = '#{table_name}'
-          UNION ALL
-          SELECT table_owner, table_name, 'SYNONYM' name_type
-          FROM all_synonyms
-          WHERE owner = 'PUBLIC'
-            AND synonym_name = '#{real_name}'
-        SQL
-        if result = select_one(sql)
-          case result['name_type']
-          when 'SYNONYM'
-            describe("#{result['owner']}.#{result['table_name']}")
-          else
-            [result['owner'], result['table_name']]
-          end
-        else
-          raise OracleEnhancedConnectionException, %Q{"DESC #{name}" failed; does it exist?}
-        end
+      # Return NativeException / java.sql.SQLException error code
+      def error_code(exception)
+        exception.cause.getErrorCode
       end
-      
 
       private
 

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -3,7 +3,7 @@ require 'delegate'
 begin
   require 'oci8' unless self.class.const_defined? :OCI8
 
-  # RSI: added mapping for TIMESTAMP / WITH TIME ZONE / LOCAL TIME ZONE types
+  # added mapping for TIMESTAMP / WITH TIME ZONE / LOCAL TIME ZONE types
   # currently Ruby-OCI8 does not support fractional seconds for timestamps
   OCI8::BindType::Mapping[OCI8::SQLT_TIMESTAMP] = OCI8::BindType::OraDate
   OCI8::BindType::Mapping[OCI8::SQLT_TIMESTAMP_TZ] = OCI8::BindType::OraDate
@@ -24,10 +24,12 @@ module ActiveRecord
   module ConnectionAdapters
 
     # OCI database interface for MRI
-    class OracleEnhancedOCIConnection < OracleEnhancedConnection
+    class OracleEnhancedOCIConnection < OracleEnhancedConnection #:nodoc:
 
       def initialize(config)
         @raw_connection = OCI8EnhancedAutoRecover.new(config, OracleEnhancedOCIFactory)
+        # default schema owner
+        @owner = config[:username].to_s.upcase
       end
 
       def auto_retry
@@ -81,6 +83,21 @@ module ActiveRecord
       def exec(sql, *bindvars, &block)
         @raw_connection.exec(sql, *bindvars, &block)
       end
+      
+      def returning_clause(quoted_pk)
+        " RETURNING #{quoted_pk} INTO :insert_id"
+      end
+
+      # execute sql with RETURNING ... INTO :insert_id
+      # and return :insert_id value
+      def exec_with_returning(sql)
+        cursor = @raw_connection.parse(sql)
+        cursor.bind_param(':insert_id', nil, Integer)
+        cursor.exec
+        cursor[':insert_id']
+      ensure
+        cursor.close rescue nil
+      end
 
       def select(sql, name = nil, return_column_names = false)
         cursor = @raw_connection.exec(sql)
@@ -100,59 +117,7 @@ module ActiveRecord
           hash = column_hash.dup
 
           cols.each_with_index do |col, i|
-            hash[col] =
-              case v = row[i]
-              # RSI: added emulate_integers_by_column_name functionality
-              when Float
-                # if OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(col)
-                #   v.to_i
-                # else
-                #   v
-                # end
-                v == (v_to_i = v.to_i) ? v_to_i : v
-              # ruby-oci8 2.0 returns OraNumber - convert it to Integer or BigDecimal
-              when OraNumber
-                v == (v_to_i = v.to_i) ? v_to_i : BigDecimal.new(v.to_s)
-              when String
-                v
-              when OCI8::LOB
-                if get_lob_value
-                  data = v.read
-                  # In Ruby 1.9.1 always change encoding to ASCII-8BIT for binaries
-                  data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding) && v.is_a?(OCI8::BLOB)
-                  data
-                else
-                  v
-                end
-              # ruby-oci8 1.0 returns OraDate
-              when OraDate
-                # RSI: added emulate_dates_by_column_name functionality
-                if OracleEnhancedAdapter.emulate_dates && (v.hour == 0 && v.minute == 0 && v.second == 0)
-                  v.to_date
-                else
-                  # code from Time.time_with_datetime_fallback
-                  begin
-                    Time.send(Base.default_timezone, v.year, v.month, v.day, v.hour, v.minute, v.second)
-                  rescue
-                    offset = Base.default_timezone.to_sym == :local ? ::DateTime.local_offset : 0
-                    ::DateTime.civil(v.year, v.month, v.day, v.hour, v.minute, v.second, offset)
-                  end
-                end
-              # ruby-oci8 2.0 returns Time or DateTime
-              when Time, DateTime
-                if OracleEnhancedAdapter.emulate_dates && (v.hour == 0 && v.min == 0 && v.sec == 0)
-                  v.to_date
-                else
-                  # recreate Time or DateTime using Base.default_timezone
-                  begin
-                    Time.send(Base.default_timezone, v.year, v.month, v.day, v.hour, v.min, v.sec)
-                  rescue
-                    offset = Base.default_timezone.to_sym == :local ? ::DateTime.local_offset : 0
-                    ::DateTime.civil(v.year, v.month, v.day, v.hour, v.min, v.sec, offset)
-                  end
-                end
-              else v
-              end
+            hash[col] = typecast_result_value(row[i], get_lob_value)
           end
 
           rows << hash
@@ -168,12 +133,79 @@ module ActiveRecord
       end
       
       def describe(name)
+        # fall back to SELECT based describe if using database link
+        return super if name.to_s.include?('@')
         quoted_name = OracleEnhancedAdapter.valid_table_name?(name) ? name : "\"#{name}\""
         @raw_connection.describe(quoted_name)
       rescue OCIException => e
-        raise OracleEnhancedConnectionException, e.message
+        # fall back to SELECT which can handle synonyms to database links
+        super
+      end
+
+      # Return OCIError error code
+      def error_code(exception)
+        exception.code
+      end
+
+      private
+
+      def typecast_result_value(value, get_lob_value)
+        case value
+        when Fixnum, Bignum
+          value
+        when String
+          value
+        when Float
+          value == (v_to_i = value.to_i) ? v_to_i : value
+        # ruby-oci8 2.0 returns OraNumber if Oracle type is NUMBER
+        when OraNumber
+          value == (v_to_i = value.to_i) ? v_to_i : BigDecimal.new(value.to_s)
+        when OCI8::LOB
+          if get_lob_value
+            data = value.read
+            # In Ruby 1.9.1 always change encoding to ASCII-8BIT for binaries
+            data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding) && value.is_a?(OCI8::BLOB)
+            data
+          else
+            value
+          end
+        # ruby-oci8 1.0 returns OraDate
+        # ruby-oci8 2.0 returns Time or DateTime
+        when OraDate, Time, DateTime
+          if OracleEnhancedAdapter.emulate_dates && date_without_time?(value)
+            value.to_date
+          else
+            create_time_with_default_timezone(value)
+          end
+        else
+          value
+        end
       end
       
+      def date_without_time?(value)
+        case value
+        when OraDate
+          value.hour == 0 && value.minute == 0 && value.second == 0
+        else
+          value.hour == 0 && value.min == 0 && value.sec == 0
+        end
+      end
+      
+      def create_time_with_default_timezone(value)
+        year, month, day, hour, min, sec = case value
+        when OraDate
+          [value.year, value.month, value.day, value.hour, value.minute, value.second]
+        else
+          [value.year, value.month, value.day, value.hour, value.min, value.sec]
+        end
+        # code from Time.time_with_datetime_fallback
+        begin
+          Time.send(Base.default_timezone, year, month, day, hour, min, sec)
+        rescue
+          offset = Base.default_timezone.to_sym == :local ? ::DateTime.local_offset : 0
+          ::DateTime.civil(year, month, day, hour, min, sec, offset)
+        end
+      end
     end
     
     # The OracleEnhancedOCIFactory factors out the code necessary to connect and
@@ -184,7 +216,9 @@ module ActiveRecord
         privilege = config[:privilege] && config[:privilege].to_sym
         async = config[:allow_concurrency]
         prefetch_rows = config[:prefetch_rows] || 100
-        cursor_sharing = config[:cursor_sharing] || 'similar'
+        cursor_sharing = config[:cursor_sharing] || 'force'
+        # by default VARCHAR2 column size will be interpreted as max number of characters (and not bytes)
+        nls_length_semantics = config[:nls_length_semantics] || 'CHAR'
 
         conn = OCI8.new username, password, database, privilege
         conn.exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
@@ -193,6 +227,7 @@ module ActiveRecord
         conn.non_blocking = true if async
         conn.prefetch_rows = prefetch_rows
         conn.exec "alter session set cursor_sharing = #{cursor_sharing}" rescue nil
+        conn.exec "alter session set nls_length_semantics = '#{nls_length_semantics}'"
         conn
       end
     end
@@ -274,17 +309,18 @@ end
 # this would be dangerous (as the earlier part of the implied transaction
 # may have failed silently if the connection died) -- so instead the
 # connection is marked as dead, to be reconnected on it's next use.
+#:stopdoc:
 class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
-  attr_accessor :active
-  alias :active? :active
+  attr_accessor :active #:nodoc:
+  alias :active? :active #:nodoc:
 
   cattr_accessor :auto_retry
   class << self
-    alias :auto_retry? :auto_retry
+    alias :auto_retry? :auto_retry #:nodoc:
   end
   @@auto_retry = false
 
-  def initialize(config, factory)
+  def initialize(config, factory) #:nodoc:
     @active = true
     @config = config
     @factory = factory
@@ -295,7 +331,7 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
   # Checks connection, returns true if active. Note that ping actively
   # checks the connection, while #active? simply returns the last
   # known state.
-  def ping
+  def ping #:nodoc:
     @connection.exec("select 1 from dual") { |r| nil }
     @active = true
   rescue
@@ -304,7 +340,7 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
   end
 
   # Resets connection, by logging off and creating a new connection.
-  def reset!
+  def reset! #:nodoc:
     logoff rescue nil
     begin
       @connection = @factory.new_connection @config
@@ -321,18 +357,18 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
   # ORA-03113: end-of-file on communication channel
   # ORA-03114: not connected to ORACLE
   # ORA-03135: connection lost contact
-  LOST_CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114, 3135 ]
+  LOST_CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114, 3135 ] #:nodoc:
 
   # Adds auto-recovery functionality.
   #
   # See: http://www.jiubao.org/ruby-oci8/api.en.html#label-11
-  def exec(sql, *bindvars, &block)
+  def exec(sql, *bindvars, &block) #:nodoc:
     should_retry = self.class.auto_retry? && autocommit?
 
     begin
       @connection.exec(sql, *bindvars, &block)
     rescue OCIException => e
-      raise unless LOST_CONNECTION_ERROR_CODES.include?(e.code)
+      raise unless e.is_a?(OCIError) && LOST_CONNECTION_ERROR_CODES.include?(e.code)
       @active = false
       raise unless should_retry
       should_retry = false
@@ -341,11 +377,12 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
     end
   end
 
-  # RSI: otherwise not working in Ruby 1.9.1
+  # otherwise not working in Ruby 1.9.1
   if RUBY_VERSION =~ /^1\.9/
-    def describe(name)
+    def describe(name) #:nodoc:
       @connection.describe(name)
     end
   end
 
 end
+#:startdoc: