activerecord-oracle_enhanced-adapter 7.2.1-java

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

@@ -0,0 +1,457 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+begin
+  require "oci8"
+rescue LoadError => e
+  # OCI8 driver is unavailable or failed to load a required library.
+  raise LoadError, "ERROR: '#{e.message}'. "\
+    "ActiveRecord oracle_enhanced adapter could not load ruby-oci8 library. "\
+    "You may need install ruby-oci8 gem."
+end
+
+# check ruby-oci8 version
+required_oci8_version = [2, 2, 4]
+oci8_version_ints = OCI8::VERSION.scan(/\d+/).map { |s| s.to_i }
+if (oci8_version_ints <=> required_oci8_version) < 0
+  $stderr.puts <<~EOS
+    "ERROR: ruby-oci8 version #{OCI8::VERSION} is too old. Please install ruby-oci8 version #{required_oci8_version.join('.')} or later."
+  EOS
+
+  exit!
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    # OCI database interface for MRI
+    module OracleEnhanced
+      class OCIConnection < OracleEnhanced::Connection # :nodoc:
+        def initialize(config)
+          @raw_connection = OCI8EnhancedAutoRecover.new(config, OracleEnhancedOCIFactory)
+          # default schema owner
+          @owner = config[:schema]
+          @owner ||= config[:username]
+          @owner = @owner.to_s.upcase
+        end
+
+        def raw_oci_connection
+          if @raw_connection.is_a? OCI8
+            @raw_connection
+          # ActiveRecord Oracle enhanced adapter puts OCI8EnhancedAutoRecover wrapper around OCI8
+          # in this case we need to pass original OCI8 connection
+          else
+            @raw_connection.instance_variable_get(:@raw_connection)
+          end
+        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 OracleEnhanced::ConnectionException, e.message
+        end
+
+        def active?
+          @raw_connection.active?
+        end
+
+        def reset
+          @raw_connection.reset
+        end
+
+        def reset!
+          @raw_connection.reset!
+        rescue OCIException => e
+          raise OracleEnhanced::ConnectionException, e.message
+        end
+
+        def exec(sql, *bindvars, allow_retry: false, &block)
+          with_retry(allow_retry: allow_retry) { @raw_connection.exec(sql, *bindvars, &block) }
+        end
+
+        def with_retry(allow_retry: false, &block)
+          @raw_connection.with_retry(allow_retry: allow_retry, &block)
+        end
+
+        def prepare(sql)
+          Cursor.new(self, @raw_connection.parse(sql))
+        end
+
+        class Cursor
+          def initialize(connection, raw_cursor)
+            @raw_connection = connection
+            @raw_cursor = raw_cursor
+          end
+
+          def bind_params(*bind_vars)
+            index = 1
+            bind_vars.flatten.each do |var|
+              if Hash === var
+                var.each { |key, val| bind_param key, val }
+              else
+                bind_param index, var
+                index += 1
+              end
+            end
+          end
+
+          def bind_param(position, value)
+            case value
+            when Type::OracleEnhanced::Raw
+              @raw_cursor.bind_param(position, OracleEnhanced::Quoting.encode_raw(value))
+            when ActiveModel::Type::Decimal
+              @raw_cursor.bind_param(position, BigDecimal(value.to_s))
+            when Type::OracleEnhanced::CharacterString::Data
+              @raw_cursor.bind_param(position, value.to_character_str)
+            when NilClass
+              @raw_cursor.bind_param(position, nil, String)
+            else
+              @raw_cursor.bind_param(position, value)
+            end
+          end
+
+          def bind_returning_param(position, bind_type)
+            @raw_cursor.bind_param(position, nil, bind_type)
+          end
+
+          def exec
+            @raw_cursor.exec
+          end
+
+          def exec_update
+            @raw_cursor.exec
+          end
+
+          def get_col_names
+            @raw_cursor.get_col_names
+          end
+
+          def fetch(options = {})
+            if row = @raw_cursor.fetch
+              get_lob_value = options[:get_lob_value]
+              col_index = 0
+              row.map do |col|
+                col_value = @raw_connection.typecast_result_value(col, get_lob_value)
+                col_metadata = @raw_cursor.column_metadata.fetch(col_index)
+                if !col_metadata.nil?
+                  key = col_metadata.data_type
+                  case key.to_s.downcase
+                  when "char"
+                    col_value = col.to_s.rstrip
+                  end
+                end
+                col_index = col_index + 1
+                col_value
+              end
+            end
+          end
+
+          def get_returning_param(position, type)
+            @raw_cursor[position]
+          end
+
+          def close
+            @raw_cursor.close
+          end
+        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|
+              col_value = typecast_result_value(row[i], get_lob_value)
+              col_metadata = cursor.column_metadata.fetch(i)
+              if !col_metadata.nil?
+                key = col_metadata.data_type
+                case key.to_s.downcase
+                when "char"
+                  col_value = col_value.to_s.rstrip
+                end
+              end
+              hash[col] = col_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)
+          super
+        end
+
+        # Return OCIError error code
+        def error_code(exception)
+          case exception
+          when OCIError
+            exception.code
+          else
+            nil
+          end
+        end
+
+        def typecast_result_value(value, get_lob_value)
+          case value
+          when Integer
+            value
+          when String
+            value
+          when Float, BigDecimal
+            # return Integer 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 OCI8::LOB
+            if get_lob_value
+              data = value.read || ""     # if value.read returns nil, then we have an empty_clob() i.e. an empty string
+              # 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
+          when Time, DateTime
+            create_time_with_default_timezone(value)
+          else
+            value
+          end
+        end
+
+        def database_version
+          @database_version ||= (version = raw_connection.oracle_server_version) && [version.major, version.minor]
+        end
+
+      private
+        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(ActiveRecord.default_timezone, year, month, day, hour, min, sec, usec)
+          rescue
+            offset = ActiveRecord.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:
+        DEFAULT_TCP_KEEPALIVE_TIME = 600
+
+        def self.new_connection(config)
+          # to_s needed if username, password or database is specified as number in database.yml file
+          username = config[:username] && config[:username].to_s
+          password = config[:password] && config[:password].to_s
+          database = config[:database] && config[:database].to_s
+          schema = config[:schema] && config[:schema].to_s
+          host, port = config[:host], config[:port]
+          privilege = config[:privilege] && config[:privilege].to_sym
+          async = config[:allow_concurrency]
+          prefetch_rows = config[:prefetch_rows] || 100
+          cursor_sharing = config[:cursor_sharing] || "force"
+          # get session time_zone from configuration or from TZ environment variable
+          time_zone = config[:time_zone] || ENV["TZ"]
+
+          # using a connection string via DATABASE_URL
+          connection_string = if host == "connection-string"
+            database
+          # connection using host, port and database name
+          elsif host || port
+            host ||= "localhost"
+            host = "[#{host}]" if /^[^\[].*:/.match?(host)  # IPv6
+            port ||= 1521
+            database = "/#{database}" unless database.start_with?("/")
+            "//#{host}:#{port}#{database}"
+          # if no host is specified then assume that
+          # database parameter is TNS alias or TNS connection string
+          else
+            database
+          end
+
+          OCI8.properties[:tcp_keepalive] = config[:tcp_keepalive] == false ? false : true
+          begin
+            OCI8.properties[:tcp_keepalive_time] = config[:tcp_keepalive_time] || DEFAULT_TCP_KEEPALIVE_TIME
+          rescue NotImplementedError
+          end
+
+          conn = OCI8.new username, password, connection_string, privilege
+          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 if cursor_sharing
+          if ActiveRecord.default_timezone == :local
+            conn.exec "alter session set time_zone = '#{time_zone}'" unless time_zone.blank?
+          elsif ActiveRecord.default_timezone == :utc
+            conn.exec "alter session set time_zone = '+00:00'"
+          end
+          conn.exec "alter session set current_schema = #{schema}" unless schema.blank?
+
+          # Initialize NLS parameters
+          OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS.each do |key, default_value|
+            value = config[key] || ENV[key.to_s.upcase] || default_value
+            if value
+              conn.exec "alter session set #{key} = '#{value}'"
+            end
+          end
+
+          OracleEnhancedAdapter::FIXED_NLS_PARAMETERS.each do |key, value|
+            conn.exec "alter session set #{key} = '#{value}'"
+          end
+          conn
+        end
+      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
+    @raw_connection = @factory.new_connection @config
+    super @raw_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:
+    @raw_connection.exec("select 1 from dual") { |r| nil }
+    @active = true
+  rescue
+    @active = false
+    raise
+  end
+
+  def reset
+    # tentative
+    reset!
+  end
+
+  # Resets connection, by logging off and creating a new connection.
+  def reset! # :nodoc:
+    logoff rescue nil
+    begin
+      @raw_connection = @factory.new_connection @config
+      __setobj__ @raw_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.
+  def with_retry(allow_retry: false) # :nodoc:
+    should_retry = (allow_retry || self.class.auto_retry?) && autocommit?
+
+    begin
+      yield
+    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
+
+  def exec(sql, *bindvars, &block) # :nodoc:
+    with_retry { @raw_connection.exec(sql, *bindvars, &block) }
+  end
+end
+# :startdoc:

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module OCIQuoting
+        def type_cast(value)
+          case value
+          when ActiveModel::Type::Binary::Data
+            lob_value = value == "" ? " " : value
+            bind_type = OCI8::BLOB
+            ora_value = bind_type.new(_connection.raw_oci_connection, lob_value)
+            ora_value.size = 0 if value == ""
+            ora_value
+          when Type::OracleEnhanced::Text::Data
+            lob_value = value.to_s == "" ? " " : value.to_s
+            bind_type = OCI8::CLOB
+            ora_value = bind_type.new(_connection.raw_oci_connection, lob_value)
+            ora_value.size = 0 if value.to_s == ""
+            ora_value
+          when Type::OracleEnhanced::NationalCharacterText::Data
+            lob_value = value.to_s == "" ? " " : value.to_s
+            bind_type = OCI8::NCLOB
+            ora_value = bind_type.new(_connection.raw_oci_connection, lob_value)
+            ora_value.size = 0 if value.to_s == ""
+            ora_value
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        prepend OCIQuoting
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+module ActiveRecord # :nodoc:
+  # Custom create, update, delete methods functionality.
+  #
+  # Example:
+  #
+  #   class Employee < ActiveRecord::Base
+  #     include ActiveRecord::OracleEnhancedProcedures
+  #
+  #     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
+  #
+  #     set_update_method do
+  #       plsql.employees_pkg.update_employee(
+  #         :p_employee_id => id,
+  #         :p_first_name => first_name,
+  #         :p_last_name => last_name
+  #       )
+  #     end
+  #
+  #     set_delete_method do
+  #       plsql.employees_pkg.delete_employee(
+  #         :p_employee_id => id
+  #       )
+  #     end
+  #   end
+  #
+  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)
+        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)
+        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)
+        self.custom_delete_method = block
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        class_attribute :custom_create_method
+        class_attribute :custom_update_method
+        class_attribute :custom_delete_method
+      end
+    end
+
+    def destroy # :nodoc:
+      # check if class has custom delete method
+      if self.class.custom_delete_method
+        # wrap destroy in transaction
+        with_transaction_returning_status do
+          # run before/after callbacks defined in model
+          run_callbacks(:destroy) { destroy_using_custom_method }
+        end
+      else
+        super
+      end
+    end
+
+    private
+      # Creates a record with custom create method
+      # and returns its id.
+      def _create_record
+        # check if class has custom create method
+        if self.class.custom_create_method
+          # run before/after callbacks defined in model
+          run_callbacks(:create) do
+            # timestamp
+            if self.record_timestamps
+              current_time = current_time_from_proper_timezone
+
+              all_timestamp_attributes_in_model.each do |column|
+                if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
+                  write_attribute(column.to_s, current_time)
+                end
+              end
+            end
+            # run
+            create_using_custom_method
+          end
+        else
+          super
+        end
+      end
+
+      def create_using_custom_method
+        log_custom_method("custom create method", "#{self.class.name} Create") do
+          self.id = instance_eval(&self.class.custom_create_method)
+        end
+        @new_record = false
+        # Starting from ActiveRecord 3.0.3 @persisted is used instead of @new_record
+        @persisted = true
+        id
+      end
+
+      # Updates the associated record with custom update method
+      # Returns the number of affected rows.
+      def _update_record(attribute_names = @attributes.keys)
+        # check if class has custom update method
+        if self.class.custom_update_method
+          # run before/after callbacks defined in model
+          run_callbacks(:update) do
+            # timestamp
+            if should_record_timestamps?
+              current_time = current_time_from_proper_timezone
+
+              timestamp_attributes_for_update_in_model.each do |column|
+                column = column.to_s
+                next if will_save_change_to_attribute?(column)
+                write_attribute(column, current_time)
+              end
+            end
+            # update just dirty attributes
+            if partial_updates?
+              # Serialized attributes should always be written in case they've been
+              # changed in place.
+              update_using_custom_method(changed | (attributes.keys & self.class.columns.select { |column| column.is_a?(Type::Serialized) }))
+            else
+              update_using_custom_method(attributes.keys)
+            end
+          end
+        else
+          super
+        end
+      end
+
+      def update_using_custom_method(attribute_names)
+        return 0 if attribute_names.empty?
+        log_custom_method("custom update method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Update") do
+          instance_eval(&self.class.custom_update_method)
+        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_using_custom_method
+        unless new_record? || @destroyed
+          log_custom_method("custom delete method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Destroy") do
+            instance_eval(&self.class.custom_delete_method)
+          end
+        end
+
+        @destroyed = true
+        freeze
+      end
+
+      def log_custom_method(*args, &block)
+        self.class.connection.send(:log, *args, &block)
+      end
+
+      alias_method :update_record, :_update_record if private_method_defined?(:_update_record)
+      alias_method :create_record, :_create_record if private_method_defined?(:_create_record)
+  end
+end