rsim-activerecord-oracle_enhanced-adapter 1.1.9.90 → 1.1.9.91

data/Manifest.txt

@@ -4,13 +4,17 @@ README.txt
 lib/active_record/connection_adapters/emulation/oracle_adapter.rb
 lib/active_record/connection_adapters/oracle_enhanced.rake
 lib/active_record/connection_adapters/oracle_enhanced_adapter.rb
+lib/active_record/connection_adapters/oracle_enhanced_connection.rb
 lib/active_record/connection_adapters/oracle_enhanced_cpk.rb
 lib/active_record/connection_adapters/oracle_enhanced_dirty.rb
+lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb
+lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb
 lib/active_record/connection_adapters/oracle_enhanced_procedures.rb
 lib/active_record/connection_adapters/oracle_enhanced_reserved_words.rb
 lib/active_record/connection_adapters/oracle_enhanced_tasks.rb
 lib/active_record/connection_adapters/oracle_enhanced_version.rb
 spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb
+spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb
 spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb
 spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb
 spec/active_record/connection_adapters/oracle_enhanced_dirty_spec.rb

data/lib/active_record/connection_adapters/oracle_enhanced_connection.rb

@@ -0,0 +1,71 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # interface independent methods
+    class OracleEnhancedConnection
+
+      def self.create(config)
+        case ORACLE_ENHANCED_CONNECTION
+        when :oci
+          OracleEnhancedOCIConnection.new(config)
+        when :jdbc
+          OracleEnhancedJDBCConnection.new(config)
+        else
+          nil
+        end
+      end
+
+      attr_reader :raw_connection
+
+      # Oracle column names by default are case-insensitive, but treated as upcase;
+      # for neatness, we'll downcase within Rails. EXCEPT that folks CAN quote
+      # their column names when creating Oracle tables, which makes then case-sensitive.
+      # I don't know anybody who does this, but we'll handle the theoretical case of a
+      # 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)
+        column_name =~ /[a-z]/ ? column_name : column_name.downcase
+      end
+
+      private
+      
+      # Returns a record hash with the column names as keys and column values
+      # as values.
+      def select_one(sql)
+        result = select(sql)
+        result.first if result
+      end
+
+      # Returns a single value from a record
+      def select_value(sql)
+        if result = select_one(sql)
+          result.values.first
+        end
+      end
+
+      # Returns an array of the values of the first column in a select:
+      #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
+      def select_values(sql)
+        result = select(sql)
+        result.map { |r| r.values.first }
+      end
+      
+
+    end
+    
+    class OracleEnhancedConnectionException < StandardError
+    end
+
+  end
+end
+
+# if MRI or YARV
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+  ORACLE_ENHANCED_CONNECTION = :oci
+  require 'active_record/connection_adapters/oracle_enhanced_oci_connection'
+# if JRuby
+elsif RUBY_ENGINE == 'jruby'
+  ORACLE_ENHANCED_CONNECTION = :jdbc
+  require 'active_record/connection_adapters/oracle_enhanced_jdbc_connection'
+else
+  raise "Unsupported Ruby engine #{RUBY_ENGINE}"
+end

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -0,0 +1,345 @@
+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)
+
+  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)
+  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
+
+rescue LoadError, NameError
+  # JDBC driver is unavailable.
+  error_message = "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. "+
+                  "Please install ojdbc14.jar library."
+  if defined?(RAILS_DEFAULT_LOGGER)
+    RAILS_DEFAULT_LOGGER.error error_message
+  else
+    STDERR.puts error_message
+  end
+  raise LoadError
+end
+
+
+module ActiveRecord
+  module ConnectionAdapters
+
+    # JDBC database interface for JRuby
+    class OracleEnhancedJDBCConnection < OracleEnhancedConnection
+
+      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
+
+      def new_connection(config)
+        username, password, database = config[:username].to_s, config[:password].to_s, config[:database].to_s
+        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'}"
+
+        prefetch_rows = config[:prefetch_rows] || 100
+        cursor_sharing = config[:cursor_sharing] || 'similar'
+
+        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
+
+        @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
+        self.autocommit = true
+        
+        # Set session time zone to current time zone
+        @raw_connection.setSessionTimeZone(java.util.TimeZone.default.getID)
+        
+        # default schema owner
+        @owner = username.upcase
+        
+        @raw_connection
+      end
+
+      
+      def logoff
+        @active = false
+        @raw_connection.close
+        true
+      rescue
+        false
+      end
+      
+      def commit
+        @raw_connection.commit
+      end
+
+      def rollback
+        @raw_connection.rollback
+      end
+
+      def autocommit?
+        @raw_connection.getAutoCommit
+      end
+
+      def autocommit=(value)
+        @raw_connection.setAutoCommit(value)
+      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\.SQLException/
+          raise OracleEnhancedConnectionException, e.message
+        else
+          raise
+        end
+      end
+      
+      # 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\.SQLException/
+            raise OracleEnhancedConnectionException, 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\.SQLException: (Closed Connection|Io exception:|No more data to read from socket)/
+          @active = false
+          raise unless should_retry
+          should_retry = false
+          reset! rescue nil
+          retry
+        end
+      end
+
+      def exec(sql)
+        with_retry do
+          exec_no_retry(sql)
+        end
+      end
+
+      def exec_no_retry(sql)
+        cs = prepare_call(sql)
+        cs.execute
+        true
+      ensure
+        cs.close rescue nil        
+      end
+
+      def select(sql, name = nil)
+        with_retry do
+          select_no_retry(sql, name)
+        end        
+      end
+
+      def select_no_retry(sql, name = nil)
+        stmt = prepare_statement(sql)
+        rset = stmt.executeQuery
+        metadata = rset.getMetaData
+        column_count = metadata.getColumnCount
+        cols = (1..column_count).map do |i|
+          oracle_downcase(metadata.getColumnName(i))
+        end
+        col_types = (1..column_count).map do |i|
+          metadata.getColumnTypeName(i)
+        end
+
+        rows = []
+
+        while rset.next
+          hash = Hash.new
+
+          cols.each_with_index do |col, i0|
+            i = i0 + 1
+            hash[col] = 
+              case column_type = col_types[i0]
+              when /CLOB/
+                name == 'Writable Large Object' ? rset.getClob(i) : get_ruby_value_from_result_set(rset, i, column_type)
+              when /BLOB/
+                name == 'Writable Large Object' ? rset.getBlob(i) : get_ruby_value_from_result_set(rset, i, column_type)
+              when 'DATE'
+                t = get_ruby_value_from_result_set(rset, i, column_type)
+                # RSI: added emulate_dates_by_column_name functionality
+                # if emulate_dates_by_column_name && self.class.is_date_column?(col)
+                #   d.to_date
+                # elsif
+                if t && OracleEnhancedAdapter.emulate_dates && (t.hour == 0 && t.min == 0 && t.sec == 0)
+                  t.to_date
+                else
+                  # JRuby Time supports time before year 1900 therefore now need to fall back to DateTime
+                  t
+                end
+              # RSI: added emulate_integers_by_column_name functionality
+              when "NUMBER"
+                n = get_ruby_value_from_result_set(rset, i, column_type)
+                if n && n.is_a?(Float) && OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(col)
+                  n.to_i
+                else
+                  n
+                end
+              else
+                get_ruby_value_from_result_set(rset, i, column_type)
+              end unless col == 'raw_rnum_'
+          end
+
+          rows << hash
+        end
+
+        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)
+        end
+      end
+
+      def describe(name)
+        real_name = OracleEnhancedAdapter.valid_table_name?(name) ? name.upcase : name
+        if 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 = '#{name.upcase}'
+        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
+      end
+      
+
+      private
+
+      def prepare_statement(sql)
+        @raw_connection.prepareStatement(sql)
+      end
+
+      def prepare_call(sql, *bindvars)
+        @raw_connection.prepareCall(sql)
+      end
+
+      def get_ruby_value_from_result_set(rset, i, type_name)
+        case type_name
+        when "CHAR", "VARCHAR2"
+          rset.getString(i)
+        when "CLOB"
+          ora_value_to_ruby_value(rset.getClob(i))
+        when "BLOB"
+          ora_value_to_ruby_value(rset.getBlob(i))
+        when "NUMBER"
+          d = rset.getBigDecimal(i)
+          if d.nil?
+            nil
+          elsif d.scale == 0
+            d.longValue
+          else
+            d.doubleValue
+          end
+        when "DATE", /^TIMESTAMP/
+          ts = rset.getTimestamp(i)
+          ts && Time.at(ts.getTime/1000)
+        else
+          nil
+        end
+      end
+      
+      def ora_value_to_ruby_value(val)
+        case val
+        when Float, BigDecimal
+          ora_number_to_ruby_number(val)
+        when ::Java::OracleSql::CLOB
+          if val.isEmptyLob
+            nil
+          else
+            val.getSubString(1, val.length)
+          end
+        when ::Java::OracleSql::BLOB
+          if val.isEmptyLob
+            nil
+          else
+            String.from_java_bytes(val.getBytes(1, val.length))
+          end
+        else
+          val
+        end
+      end
+
+      def ora_number_to_ruby_number(num)
+        num.to_i == num.to_f ? num.to_i : num.to_f
+      end
+      
+
+    end
+    
+  end
+end
+

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -0,0 +1,322 @@
+require 'delegate'
+
+begin
+  require 'oci8' unless self.class.const_defined? :OCI8
+
+  # RSI: 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
+  OCI8::BindType::Mapping[OCI8::SQLT_TIMESTAMP_LTZ] = OCI8::BindType::OraDate
+rescue LoadError
+  # OCI8 driver is unavailable.
+  error_message = "ERROR: ActiveRecord oracle_enhanced adapter could not load ruby-oci8 library. "+
+                  "Please install ruby-oci8 library or gem."
+  if defined?(RAILS_DEFAULT_LOGGER)
+    RAILS_DEFAULT_LOGGER.error error_message
+  else
+    STDERR.puts error_message
+  end
+  raise LoadError
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+
+    # OCI database interface for MRI
+    class OracleEnhancedOCIConnection < OracleEnhancedConnection
+
+      def initialize(config)
+        @raw_connection = OCI8EnhancedAutoRecover.new(config, OracleEnhancedOCIFactory)
+      end
+
+      def auto_retry
+        @raw_connection.auto_retry if @raw_connection
+      end
+
+      def auto_retry=(value)
+        @raw_connection.auto_retry = value if @raw_connection
+      end
+
+      def logoff
+        @raw_connection.logoff
+        @raw_connection.active = false
+      end
+
+      def commit
+        @raw_connection.commit
+      end
+
+      def rollback
+        @raw_connection.rollback
+      end
+
+      def autocommit?
+        @raw_connection.autocommit?
+      end
+
+      def autocommit=(value)
+        @raw_connection.autocommit = value
+      end
+
+      # Checks connection, returns true if active. Note that ping actively
+      # checks the connection, while #active? simply returns the last
+      # known state.
+      def ping
+        @raw_connection.ping
+      rescue OCIException => e
+        raise OracleEnhancedConnectionException, e.message
+      end
+
+      def active?
+        @raw_connection.active?
+      end
+
+      def reset!
+        @raw_connection.reset!
+      rescue OCIException => e
+        raise OracleEnhancedConnectionException, e.message
+      end
+
+      def exec(sql, *bindvars, &block)
+        @raw_connection.exec(sql, *bindvars, &block)
+      end
+
+      def select(sql, name = nil)
+        cursor = @raw_connection.exec(sql)
+        cols = cursor.get_col_names.map { |x| oracle_downcase(x) }
+        rows = []
+
+        while row = cursor.fetch
+          hash = Hash.new
+
+          cols.each_with_index do |col, i|
+            hash[col] =
+              case row[i]
+              when OCI8::LOB
+                name == 'Writable Large Object' ? row[i]: row[i].read
+              when OraDate
+                d = row[i]
+                # RSI: added emulate_dates_by_column_name functionality
+                # if emulate_dates_by_column_name && self.class.is_date_column?(col)
+                #   d.to_date
+                # elsif
+                if OracleEnhancedAdapter.emulate_dates && (d.hour == 0 && d.minute == 0 && d.second == 0)
+                  d.to_date
+                else
+                  # see string_to_time; Time overflowing to DateTime, respecting the default timezone
+                  time_array = [d.year, d.month, d.day, d.hour, d.minute, d.second]
+                  begin
+                    Time.send(Base.default_timezone, *time_array)
+                  rescue
+                    zone_offset = if Base.default_timezone == :local then DateTime.now.offset else 0 end
+                    # Append zero calendar reform start to account for dates skipped by calendar reform
+                    DateTime.new(*time_array[0..5] << zone_offset << 0) rescue nil
+                  end
+                end
+              # RSI: added emulate_integers_by_column_name functionality
+              when Float
+                n = row[i]
+                if OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(col)
+                  n.to_i
+                else
+                  n
+                end
+              else row[i]
+              end unless col == 'raw_rnum_'
+          end
+
+          rows << hash
+        end
+
+        rows
+      ensure
+        cursor.close if cursor
+      end
+
+      def write_lob(lob, value, is_binary = false)
+        lob.write value
+      end
+      
+      def describe(name)
+        quoted_name = OracleEnhancedAdapter.valid_table_name?(name) ? name : "\"#{name}\""
+        @raw_connection.describe(quoted_name)
+      rescue OCIException => e
+        raise OracleEnhancedConnectionException, e.message
+      end
+      
+    end
+    
+    # The OracleEnhancedOCIFactory factors out the code necessary to connect and
+    # configure an Oracle/OCI connection.
+    class OracleEnhancedOCIFactory #:nodoc:
+      def self.new_connection(config)
+        username, password, database = config[:username].to_s, config[:password].to_s, config[:database].to_s
+        privilege = config[:privilege] && config[:privilege].to_sym
+        async = config[:allow_concurrency]
+        prefetch_rows = config[:prefetch_rows] || 100
+        cursor_sharing = config[:cursor_sharing] || 'similar'
+
+        conn = OCI8.new username, password, database, privilege
+        conn.exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
+        conn.exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS'} rescue nil
+        conn.autocommit = true
+        conn.non_blocking = true if async
+        conn.prefetch_rows = prefetch_rows
+        conn.exec "alter session set cursor_sharing = #{cursor_sharing}" rescue nil
+        conn
+      end
+    end
+    
+    
+  end
+end
+
+
+
+class OCI8 #:nodoc:
+
+  class Cursor #:nodoc:
+    if method_defined? :define_a_column
+      # This OCI8 patch is required with the ruby-oci8 1.0.x or lower.
+      # Set OCI8::BindType::Mapping[] to change the column type
+      # when using ruby-oci8 2.0.
+
+      alias :enhanced_define_a_column_pre_ar :define_a_column
+      def define_a_column(i)
+        case do_ocicall(@ctx) { @parms[i - 1].attrGet(OCI_ATTR_DATA_TYPE) }
+        when 8;   @stmt.defineByPos(i, String, 65535) # Read LONG values
+        when 187; @stmt.defineByPos(i, OraDate) # Read TIMESTAMP values
+        when 108
+          if @parms[i - 1].attrGet(OCI_ATTR_TYPE_NAME) == 'XMLTYPE'
+            @stmt.defineByPos(i, String, 65535)
+          else
+            raise 'unsupported datatype'
+          end
+        else enhanced_define_a_column_pre_ar i
+        end
+      end
+    end
+  end
+
+  if OCI8.public_method_defined?(:describe_table)
+    # ruby-oci8 2.0 or upper
+
+    def describe(name)
+      info = describe_table(name.to_s)
+      raise %Q{"DESC #{name}" failed} if info.nil?
+      [info.obj_schema, info.obj_name]
+    end
+  else
+    # ruby-oci8 1.0.x or lower
+
+    # missing constant from oci8 < 0.1.14
+    OCI_PTYPE_UNK = 0 unless defined?(OCI_PTYPE_UNK)
+
+    # Uses the describeAny OCI call to find the target owner and table_name
+    # indicated by +name+, parsing through synonynms as necessary. Returns
+    # an array of [owner, table_name].
+    def describe(name)
+      @desc ||= @@env.alloc(OCIDescribe)
+      @desc.attrSet(OCI_ATTR_DESC_PUBLIC, -1) if VERSION >= '0.1.14'
+      do_ocicall(@ctx) { @desc.describeAny(@svc, name.to_s, OCI_PTYPE_UNK) } rescue raise %Q{"DESC #{name}" failed; does it exist?}
+      info = @desc.attrGet(OCI_ATTR_PARAM)
+
+      case info.attrGet(OCI_ATTR_PTYPE)
+      when OCI_PTYPE_TABLE, OCI_PTYPE_VIEW
+        owner      = info.attrGet(OCI_ATTR_OBJ_SCHEMA)
+        table_name = info.attrGet(OCI_ATTR_OBJ_NAME)
+        [owner, table_name]
+      when OCI_PTYPE_SYN
+        schema = info.attrGet(OCI_ATTR_SCHEMA_NAME)
+        name   = info.attrGet(OCI_ATTR_NAME)
+        describe(schema + '.' + name)
+      else raise %Q{"DESC #{name}" failed; not a table or view.}
+      end
+    end
+  end
+
+end
+
+# The OCI8AutoRecover class enhances the OCI8 driver with auto-recover and
+# reset functionality. If a call to #exec fails, and autocommit is turned on
+# (ie., we're not in the middle of a longer transaction), it will
+# automatically reconnect and try again. If autocommit is turned off,
+# 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.
+class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
+  attr_accessor :active
+  alias :active? :active
+
+  cattr_accessor :auto_retry
+  class << self
+    alias :auto_retry? :auto_retry
+  end
+  @@auto_retry = false
+
+  def initialize(config, factory)
+    @active = true
+    @config = config
+    @factory = factory
+    @connection  = @factory.new_connection @config
+    super @connection
+  end
+
+  # Checks connection, returns true if active. Note that ping actively
+  # checks the connection, while #active? simply returns the last
+  # known state.
+  def ping
+    @connection.exec("select 1 from dual") { |r| nil }
+    @active = true
+  rescue
+    @active = false
+    raise
+  end
+
+  # Resets connection, by logging off and creating a new connection.
+  def reset!
+    logoff rescue nil
+    begin
+      @connection = @factory.new_connection @config
+      __setobj__ @connection
+      @active = true
+    rescue
+      @active = false
+      raise
+    end
+  end
+
+  # ORA-00028: your session has been killed
+  # ORA-01012: not logged on
+  # 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 ]
+
+  # Adds auto-recovery functionality.
+  #
+  # See: http://www.jiubao.org/ruby-oci8/api.en.html#label-11
+  def exec(sql, *bindvars, &block)
+    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)
+      @active = false
+      raise unless should_retry
+      should_retry = false
+      reset! rescue nil
+      retry
+    end
+  end
+
+  # RSI: otherwise not working in Ruby 1.9.1
+  if RUBY_VERSION =~ /^1\.9/
+    def describe(name)
+      @connection.describe(name)
+    end
+  end
+
+end

data/oracle-enhanced.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{activerecord-oracle_enhanced-adapter}
-  s.version = "1.1.9.90"
+  s.version = "1.1.9.91"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Raimonds Simanovskis"]
@@ -14,14 +14,18 @@ Gem::Specification.new do |s|
     "lib/active_record/connection_adapters/emulation/oracle_adapter.rb",
     "lib/active_record/connection_adapters/oracle_enhanced.rake",
     "lib/active_record/connection_adapters/oracle_enhanced_adapter.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_connection.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_cpk.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_dirty.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_procedures.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_reserved_words.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_tasks.rb",
     "lib/active_record/connection_adapters/oracle_enhanced_version.rb",
     "oracle-enhanced.gemspec",
     "spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb",
+    "spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb",
     "spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb",
     "spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb",
     "spec/active_record/connection_adapters/oracle_enhanced_dirty_spec.rb",

data/spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe "OracleEnhancedConnection create connection" do
+
+  before(:all) do
+    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+  end
+  
+  before(:each) do
+    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS) unless @conn.active?
+  end
+
+  after(:all) do
+    @conn.logoff if @conn.active?
+  end
+
+  it "should create new connection" do
+    @conn.should be_active
+  end
+
+  it "should ping active connection" do
+    @conn.ping.should be_true
+  end
+
+  it "should not ping inactive connection" do
+    @conn.logoff
+    lambda { @conn.ping }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+  end
+
+  it "should reset active connection" do
+    @conn.reset!
+    @conn.should be_active
+  end
+
+  it "should be in autocommit mode after connection" do
+    @conn.should be_autocommit
+  end
+
+end
+
+describe "OracleEnhancedConnection SQL execution" do
+
+  before(:all) do
+    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+  end
+  
+  before(:each) do
+    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS) unless @conn.active?
+  end
+
+  after(:all) do
+    @conn.logoff if @conn.active?
+  end
+
+  it "should execute SQL statement" do
+    @conn.exec("SELECT * FROM dual").should_not be_nil
+  end
+
+  it "should execute SQL select" do
+    @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+  end
+
+end
+
+describe "OracleEnhancedConnection auto reconnection" do
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection.instance_variable_get("@connection")
+    @sys_conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(SYS_CONNECTION_PARAMS)
+  end
+  
+  before(:each) do
+    ActiveRecord::Base.connection.reconnect! unless @conn.active?
+  end
+
+  after(:all) do
+    ActiveRecord::Base.connection.disconnect! if @conn.active?
+  end
+
+  def kill_current_session
+    audsid = @conn.select("SELECT userenv('sessionid') audsid FROM dual").first['audsid']
+    sid_serial = @sys_conn.select("SELECT s.sid||','||s.serial# sid_serial
+        FROM   v$session s
+        WHERE  audsid = '#{audsid}'").first['sid_serial']
+    @sys_conn.exec "ALTER SYSTEM KILL SESSION '#{sid_serial}' IMMEDIATE"
+  end
+
+  it "should reconnect and execute SQL statement if connection is lost and auto retry is enabled" do
+    # @conn.auto_retry = true
+    ActiveRecord::Base.connection.auto_retry = true
+    kill_current_session
+    @conn.exec("SELECT * FROM dual").should_not be_nil
+  end
+
+  it "should not reconnect and execute SQL statement if connection is lost and auto retry is disabled" do
+    # @conn.auto_retry = false
+    ActiveRecord::Base.connection.auto_retry = false
+    kill_current_session
+    lambda { @conn.exec("SELECT * FROM dual") }.should raise_error
+  end
+
+  it "should reconnect and execute SQL select if connection is lost and auto retry is enabled" do
+    # @conn.auto_retry = true
+    ActiveRecord::Base.connection.auto_retry = true
+    kill_current_session
+    @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+  end
+
+  it "should not reconnect and execute SQL select if connection is lost and auto retry is disabled" do
+    # @conn.auto_retry = false
+    ActiveRecord::Base.connection.auto_retry = false
+    kill_current_session
+    lambda { @conn.select("SELECT * FROM dual") }.should raise_error
+  end
+
+end
+
+describe "OracleEnhancedConnection describe table" do
+
+  before(:all) do
+    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+    @owner = CONNECTION_PARAMS[:username].upcase
+  end
+  
+  after(:all) do
+    @conn.logoff if @conn.active?
+  end
+
+  it "should describe existing table" do
+    @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+    @conn.describe("test_employees").should == [@owner, "TEST_EMPLOYEES"]
+    @conn.exec "DROP TABLE test_employees" rescue nil
+  end
+
+  it "should not describe non-existing table" do
+    lambda { @conn.describe("test_xxx") }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+  end
+
+  it "should describe table in other schema" do
+    @conn.describe("sys.dual").should == ["SYS", "DUAL"]
+  end
+
+  it "should describe existing view" do
+    @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+    @conn.exec "CREATE VIEW test_employees_v AS SELECT * FROM test_employees" rescue nil
+    @conn.describe("test_employees_v").should == [@owner, "TEST_EMPLOYEES_V"]
+    @conn.exec "DROP VIEW test_employees_v" rescue nil
+    @conn.exec "DROP TABLE test_employees" rescue nil
+  end
+
+  it "should describe view in other schema" do
+    @conn.describe("sys.v_$version").should == ["SYS", "V_$VERSION"]
+  end
+
+  it "should describe existing private synonym" do
+    @conn.exec "CREATE SYNONYM test_dual FOR sys.dual" rescue nil
+    @conn.describe("test_dual").should == ["SYS", "DUAL"]
+    @conn.exec "DROP SYNONYM test_dual" rescue nil
+  end
+
+  it "should describe existing public synonym" do
+    @conn.describe("all_tables").should == ["SYS", "ALL_TABLES"]
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rsim-activerecord-oracle_enhanced-adapter
 version: !ruby/object:Gem::Version 
-  version: 1.1.9.90
+  version: 1.1.9.91
 platform: ruby
 authors: 
 - Raimonds Simanovskis
@@ -42,14 +42,18 @@ files:
 - lib/active_record/connection_adapters/emulation/oracle_adapter.rb
 - lib/active_record/connection_adapters/oracle_enhanced.rake
 - lib/active_record/connection_adapters/oracle_enhanced_adapter.rb
+- lib/active_record/connection_adapters/oracle_enhanced_connection.rb
 - lib/active_record/connection_adapters/oracle_enhanced_cpk.rb
 - lib/active_record/connection_adapters/oracle_enhanced_dirty.rb
+- lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb
+- lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb
 - lib/active_record/connection_adapters/oracle_enhanced_procedures.rb
 - lib/active_record/connection_adapters/oracle_enhanced_reserved_words.rb
 - lib/active_record/connection_adapters/oracle_enhanced_tasks.rb
 - lib/active_record/connection_adapters/oracle_enhanced_version.rb
 - oracle-enhanced.gemspec
 - spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb
+- spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb
 - spec/active_record/connection_adapters/oracle_enhanced_dirty_spec.rb