unclebilly-activerecord-oracle_enhanced-adapter 1.2.4

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -0,0 +1,396 @@
+require 'delegate'
+
+begin
+  require 'oci8' unless self.class.const_defined? :OCI8
+
+  # added mapping for TIMESTAMP / WITH TIME ZONE / LOCAL TIME ZONE types
+  # latest version of Ruby-OCI8 supports fractional seconds for timestamps
+  # therefore default binding to Time class should be used
+  # 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 #:nodoc:
+
+      def initialize(config)
+        @raw_connection = OCI8EnhancedAutoRecover.new(config, OracleEnhancedOCIFactory)
+        # default schema owner
+        @owner = config[:username].to_s.upcase
+      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 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)
+        cols = []
+        # Ignore raw_rnum_ which is used to simulate LIMIT and OFFSET
+        cursor.get_col_names.each do |col_name|
+          col_name = oracle_downcase(col_name)
+          cols << col_name unless col_name == 'raw_rnum_'
+        end
+        # Reuse the same hash for all rows
+        column_hash = {}
+        cols.each {|c| column_hash[c] = nil}
+        rows = []
+        get_lob_value = !(name == 'Writable Large Object')
+
+        while row = cursor.fetch
+          hash = column_hash.dup
+
+          cols.each_with_index do |col, i|
+            hash[col] = typecast_result_value(row[i], get_lob_value)
+          end
+
+          rows << hash
+        end
+
+        return_column_names ? [rows, cols] : rows
+      ensure
+        cursor.close if cursor
+      end
+
+      def write_lob(lob, value, is_binary = false)
+        lob.write value
+      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
+        # 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, BigDecimal
+          # return Fixnum or Bignum if value is integer (to avoid issues with _before_type_cast values for id attributes)
+          value == (v_to_i = value.to_i) ? v_to_i : value
+        when OraNumber
+          # change OraNumber value (returned in early versions of ruby-oci8 2.0.x) to BigDecimal
+          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, usec = case value
+        when Time
+          [value.year, value.month, value.day, value.hour, value.min, value.sec, value.usec]
+        when OraDate
+          [value.year, value.month, value.day, value.hour, value.minute, value.second, 0]
+        else
+          [value.year, value.month, value.day, value.hour, value.min, value.sec, 0]
+        end
+        # code from Time.time_with_datetime_fallback
+        begin
+          Time.send(Base.default_timezone, year, month, day, hour, min, sec, usec)
+        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
+    # 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] || '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'
+        # get session time_zone from configuration or from TZ environment variable
+        time_zone = config[:time_zone] || ENV['TZ']
+
+        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:FF6'} 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.exec "alter session set nls_length_semantics = '#{nls_length_semantics}'"
+        conn.exec "alter session set time_zone = '#{time_zone}'" unless time_zone.blank?
+        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.
+#:stopdoc:
+class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
+  attr_accessor :active #:nodoc:
+  alias :active? :active #:nodoc:
+
+  cattr_accessor :auto_retry
+  class << self
+    alias :auto_retry? :auto_retry #:nodoc:
+  end
+  @@auto_retry = false
+
+  def initialize(config, factory) #:nodoc:
+    @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 #:nodoc:
+    @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! #:nodoc:
+    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 ] #:nodoc:
+
+  # Adds auto-recovery functionality.
+  #
+  # See: http://www.jiubao.org/ruby-oci8/api.en.html#label-11
+  def exec(sql, *bindvars, &block) #:nodoc:
+    should_retry = self.class.auto_retry? && autocommit?
+
+    begin
+      @connection.exec(sql, *bindvars, &block)
+    rescue OCIException => e
+      raise unless e.is_a?(OCIError) && LOST_CONNECTION_ERROR_CODES.include?(e.code)
+      @active = false
+      raise unless should_retry
+      should_retry = false
+      reset! rescue nil
+      retry
+    end
+  end
+
+  # otherwise not working in Ruby 1.9.1
+  if RUBY_VERSION =~ /^1\.9/
+    def describe(name) #:nodoc:
+      @connection.describe(name)
+    end
+  end
+
+end
+#:startdoc:

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -0,0 +1,164 @@
+# define accessors before requiring ruby-plsql as these accessors are used in clob writing callback and should be
+# available also if ruby-plsql could not be loaded
+ActiveRecord::Base.class_eval do
+  class_inheritable_accessor :custom_create_method, :custom_update_method, :custom_delete_method
+end
+
+require 'ruby_plsql'
+require 'active_support'
+
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedProcedures #:nodoc:
+
+      module ClassMethods
+        # Specify custom create method which should be used instead of Rails generated INSERT statement.
+        # Provided block should return ID of new record.
+        # Example:
+        #   set_create_method do
+        #     plsql.employees_pkg.create_employee(
+        #       :p_first_name => first_name,
+        #       :p_last_name => last_name,
+        #       :p_employee_id => nil
+        #     )[:p_employee_id]
+        #   end
+        def set_create_method(&block)
+          include_with_custom_methods
+          self.custom_create_method = block
+        end
+
+        # Specify custom update method which should be used instead of Rails generated UPDATE statement.
+        # Example:
+        #   set_update_method do
+        #     plsql.employees_pkg.update_employee(
+        #       :p_employee_id => id,
+        #       :p_first_name => first_name,
+        #       :p_last_name => last_name
+        #     )
+        #   end
+        def set_update_method(&block)
+          include_with_custom_methods
+          self.custom_update_method = block
+        end
+
+        # Specify custom delete method which should be used instead of Rails generated DELETE statement.
+        # Example:
+        #   set_delete_method do
+        #     plsql.employees_pkg.delete_employee(
+        #       :p_employee_id => id
+        #     )
+        #   end
+        def set_delete_method(&block)
+          include_with_custom_methods
+          self.custom_delete_method = block
+        end
+        
+        def create_method_name_before_custom_methods
+          if private_method_defined?(:create_without_timestamps) && defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING.to_f >= 2.3
+            :create_without_timestamps
+          elsif private_method_defined?(:create_without_callbacks)
+            :create_without_callbacks
+          else
+            :create
+          end
+        end
+        
+        def update_method_name_before_custom_methods
+          if private_method_defined?(:update_without_dirty)
+            :update_without_dirty
+          elsif private_method_defined?(:update_without_timestamps) && defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING.to_f >= 2.3
+            :update_without_timestamps
+          elsif private_method_defined?(:update_without_callbacks)
+            :update_without_callbacks
+          else
+            :update
+          end
+        end
+        
+        def destroy_method_name_before_custom_methods
+          if public_method_defined?(:destroy_without_callbacks)
+            :destroy_without_callbacks
+          else
+            :destroy
+          end
+        end
+        
+        private
+        def include_with_custom_methods
+          unless included_modules.include? InstanceMethods
+            include InstanceMethods
+          end
+        end
+      end
+      
+      module InstanceMethods #:nodoc:
+        def self.included(base)
+          base.instance_eval do
+            alias_method :create_without_custom_method, create_method_name_before_custom_methods
+            alias_method create_method_name_before_custom_methods, :create_with_custom_method
+            alias_method :update_without_custom_method, update_method_name_before_custom_methods
+            alias_method update_method_name_before_custom_methods, :update_with_custom_method
+            alias_method :destroy_without_custom_method, destroy_method_name_before_custom_methods
+            alias_method destroy_method_name_before_custom_methods, :destroy_with_custom_method
+            private :create, :update
+            public :destroy
+          end
+        end
+        
+        private
+        
+        # Creates a record with custom create method
+        # and returns its id.
+        def create_with_custom_method
+          # check if class has custom create method
+          return create_without_custom_method unless self.class.custom_create_method
+          self.class.connection.log_custom_method("custom create method", "#{self.class.name} Create") do
+            self.id = self.class.custom_create_method.bind(self).call
+          end
+          @new_record = false
+          id
+        end
+
+        # Updates the associated record with custom update method
+        # Returns the number of affected rows.
+        def update_with_custom_method(attribute_names = @attributes.keys)
+          # check if class has custom create method
+          return update_without_custom_method unless self.class.custom_update_method
+          return 0 if attribute_names.empty?
+          self.class.connection.log_custom_method("custom update method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Update") do
+            self.class.custom_update_method.bind(self).call
+          end
+          1
+        end
+
+        # Deletes the record in the database with custom delete method
+        # and freezes this instance to reflect that no changes should
+        # be made (since they can't be persisted).
+        def destroy_with_custom_method
+          # check if class has custom create method
+          return destroy_without_custom_method unless self.class.custom_delete_method
+          unless new_record?
+            self.class.connection.log_custom_method("custom delete method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Destroy") do
+              self.class.custom_delete_method.bind(self).call
+            end
+          end
+
+          @destroyed = true
+          freeze
+        end
+
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend ActiveRecord::ConnectionAdapters::OracleEnhancedProcedures::ClassMethods
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  # public alias to log method which could be used from other objects
+  alias_method :log_custom_method, :log
+  public :log_custom_method
+end