activerecord-oracle_enhanced-adapter 1.1.9 → 1.2.0

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_core_ext.rb

@@ -0,0 +1,64 @@
+require "bigdecimal"
+unless BigDecimal.instance_methods.include?("to_d")
+  BigDecimal.class_eval do
+    def to_d
+      self
+    end
+  end
+end
+
+unless Bignum.instance_methods.include?("to_d")
+  Bignum.class_eval do
+    def to_d
+      BigDecimal.new(self.to_s)
+    end
+  end
+end
+
+unless Fixnum.instance_methods.include?("to_d")
+  Fixnum.class_eval do
+    def to_d
+      BigDecimal.new(self.to_s)
+    end
+  end
+end
+
+# Add Unicode aware String#upcase and String#downcase methods when mb_chars method is called
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '1.9'
+  begin
+    gem "unicode_utils", ">=1.0.0"
+    require "unicode_utils/upcase"
+    require "unicode_utils/downcase"
+
+    module ActiveRecord
+      module ConnectionAdapters
+        module OracleEnhancedUnicodeString
+          def upcase
+            UnicodeUtils.upcase(self)
+          end
+
+          def downcase
+            UnicodeUtils.downcase(self)
+          end
+        end
+      end
+    end
+
+    class String
+      def mb_chars
+        self.extend(ActiveRecord::ConnectionAdapters::OracleEnhancedUnicodeString)
+        self
+      end
+    end
+
+  rescue LoadError
+    warning_message = "WARNING: Please install unicode_utils gem to support Unicode aware upcase and downcase for String#mb_chars"
+    if defined?(RAILS_DEFAULT_LOGGER)
+      RAILS_DEFAULT_LOGGER.warn warning_message
+    else
+      STDERR.puts warning_message
+    end
+  end
+
+  
+end

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -8,12 +8,12 @@ module ActiveRecord #:nodoc:
         def field_changed?(attr, old, value)
           if column = column_for_attribute(attr)
             # RSI: added also :decimal type
-            if (column.type == :integer || column.type == :decimal) && column.null && (old.nil? || old == 0)
+            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 if value.blank?
+              value = nil
             # RSI: 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?

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -0,0 +1,352 @@
+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)
+        case sql
+        when /\A\s*UPDATE/i, /\A\s*INSERT/i, /\A\s*DELETE/i
+          cs.executeUpdate
+        else
+          cs.execute
+          true
+        end
+      ensure
+        cs.close rescue nil        
+      end
+
+      def select(sql, name = nil, return_column_names = false)
+        with_retry do
+          select_no_retry(sql, name, return_column_names)
+        end        
+      end
+
+      def select_no_retry(sql, name = nil, return_column_names = false)
+        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
+
+        return_column_names ? [rows, cols] : 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.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
+      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", "LONG"
+          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.toBigInteger+0
+          else
+            # Is there better way how to convert Java BigDecimal to Ruby BigDecimal?
+            d.toString.to_d
+          end
+        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/
+          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)
+        else
+          nil
+        end
+      end
+      
+      def ora_value_to_ruby_value(val)
+        case 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
+
+    end
+    
+  end
+end