pmacs-activerecord-oracle_enhanced-adapter 1.4.2.rc1 → 1.5.5.1

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -23,7 +23,9 @@ module ActiveRecord
       def initialize(config)
         @raw_connection = OCI8EnhancedAutoRecover.new(config, OracleEnhancedOCIFactory)
         # default schema owner
-        @owner = config[:username].to_s.upcase
+        @owner = config[:schema]
+        @owner ||= config[:username]
+        @owner = @owner.to_s.upcase
       end
 
       def raw_oci_connection
@@ -113,11 +115,17 @@ module ActiveRecord
           @raw_cursor = raw_cursor
         end
 
-        def bind_param(position, value, col_type = nil)
-          if value.nil?
+        def bind_param(position, value, column = nil)
+          if column && column.object_type?
+            if @connection.raw_connection.respond_to? :get_tdo_by_typename
+              @raw_cursor.bind_param(position, value, :named_type, column.sql_type)
+            else
+              raise "Use ruby-oci8 2.1.6 or later to bind Oracle objects."
+            end
+          elsif value.nil?
             @raw_cursor.bind_param(position, nil, String)
           else
-            case col_type
+            case col_type = column && column.type
             when :text, :binary
               # ruby-oci8 cannot create CLOB/BLOB from ''
               lob_value = value == '' ? ' ' : value
@@ -202,15 +210,19 @@ module ActiveRecord
       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
+        if e.code == 4043
+          raise OracleEnhancedConnectionException, %Q{"DESC #{name}" failed; does it exist?}
+        else
+          # fall back to SELECT which can handle synonyms to database links
+          super
+        end
       end
 
       # Return OCIError error code
@@ -244,9 +256,7 @@ module ActiveRecord
           else
             value
           end
-        # ruby-oci8 1.0 returns OraDate
-        # ruby-oci8 2.0 returns Time or DateTime
-        when OraDate, Time, DateTime
+        when Time, DateTime
           if OracleEnhancedAdapter.emulate_dates && date_without_time?(value)
             value.to_date
           else
@@ -296,6 +306,7 @@ module ActiveRecord
         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]
@@ -323,6 +334,7 @@ module ActiveRecord
         conn.prefetch_rows = prefetch_rows
         conn.exec "alter session set cursor_sharing = #{cursor_sharing}" rescue nil
         conn.exec "alter session set time_zone = '#{time_zone}'" unless time_zone.blank?
+        conn.exec "alter session set current_schema = #{schema}" unless schema.blank?
 
         # Initialize NLS parameters
         OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS.each do |key, default_value|
@@ -343,66 +355,15 @@ 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?
+  def describe(name)
+    info = describe_table(name.to_s)
+    raise %Q{"DESC #{name}" failed} if info.nil?
+    if info.respond_to? :obj_link and info.obj_link
+      [info.obj_schema, info.obj_name, '@' + info.obj_link]
+    else
       [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
@@ -480,12 +441,5 @@ class OCI8EnhancedAutoRecover < DelegateClass(OCI8) #:nodoc:
     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

@@ -1,260 +1,194 @@
-# 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
-  if respond_to? :class_attribute
-    class_attribute :custom_create_method, :custom_update_method, :custom_delete_method
-  elsif respond_to? :class_inheritable_accessor
-    class_inheritable_accessor :custom_create_method, :custom_update_method, :custom_delete_method
-  end
-end
-
 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
-
-        if ActiveRecord::VERSION::MAJOR < 3
-          def create_method_name_before_custom_methods #:nodoc:
-            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 #:nodoc:
-            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
+  # 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
 
-          def destroy_method_name_before_custom_methods #:nodoc:
-            if public_method_defined?(:destroy_without_callbacks)
-              :destroy_without_callbacks
-            else
-              :destroy
-            end
-          end
-        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
 
-        private
+      # 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 include_with_custom_methods
-          unless included_modules.include? InstanceMethods
-            include InstanceMethods
-          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
 
-      module InstanceMethods #:nodoc:
-        def self.included(base)
-          # alias methods just for ActiveRecord 2.x
-          # for ActiveRecord 3.0 will just redefine create, update, delete methods which call super
-          if ActiveRecord::VERSION::MAJOR < 3
-            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
+    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
 
-        if ActiveRecord::VERSION::MAJOR >= 3
-          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_destroy_callbacks { destroy_using_custom_method }
+    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.each do |column|
+              if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
+                write_attribute(column.to_s, current_time)
               end
-            else
-              super
-            end
-          end
-        end
-
-        private
-
-        # Creates a record with custom create method
-        # and returns its id.
-        if ActiveRecord::VERSION::MAJOR < 3
-          def create_with_custom_method
-            # check if class has custom create method
-            self.class.custom_create_method ? create_using_custom_method : create_without_custom_method
-          end
-        else # ActiveRecord 3.x
-          def create
-            # check if class has custom create method
-            if self.class.custom_create_method
-              set_timestamps_before_custom_create_method
-              # run before/after callbacks defined in model
-              _run_create_callbacks { create_using_custom_method }
-            else
-              super
             end
           end
+          # run
+          create_using_custom_method
         end
+      else
+        super
+      end
+    end
 
-        def create_using_custom_method
-          self.class.connection.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
+    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.
-        if ActiveRecord::VERSION::MAJOR < 3
-          def update_with_custom_method(attribute_names = @attributes.keys)
-            # check if class has custom create method
-            self.class.custom_update_method ? update_using_custom_method(attribute_names) : update_without_custom_method(attribute_names)
-          end
-        else # ActiveRecord 3.x
-          def update(attribute_names = @attributes.keys)
-            # check if class has custom update method
-            if self.class.custom_update_method
-              set_timestamps_before_custom_update_method
-              # run before/after callbacks defined in model
-              _run_update_callbacks do
-                # 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.serialized_attributes.keys))
-                else
-                  update_using_custom_method(attribute_names)
-                end
-              end
-            else
-              super
+    # 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 attribute_changed?(column)
+              write_attribute(column, current_time)
             end
           end
-        end
-
-        def update_using_custom_method(attribute_names)
-          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
-            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).
-        if ActiveRecord::VERSION::MAJOR < 3
-          def destroy_with_custom_method
-            # check if class has custom delete method
-            self.class.custom_delete_method ? destroy_using_custom_method : destroy_without_custom_method
+          # update just dirty attributes
+          if partial_writes?
+            # Serialized attributes should always be written in case they've been
+            # changed in place.
+            update_using_custom_method(changed | (attributes.keys & self.class.serialized_attributes.keys))
+          else
+            update_using_custom_method(attribute_names)
           end
         end
+      else
+        super
+      end
+    end
 
-        def destroy_using_custom_method
-          unless new_record? || @destroyed
-            self.class.connection.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
-
-        if ActiveRecord::VERSION::MAJOR >= 3
-          def set_timestamps_before_custom_create_method
-            if record_timestamps
-              current_time = current_time_from_proper_timezone
-
-              write_attribute('created_at', current_time) if respond_to?(:created_at) && created_at.nil?
-              write_attribute('created_on', current_time) if respond_to?(:created_on) && created_on.nil?
-
-              write_attribute('updated_at', current_time) if respond_to?(:updated_at) && updated_at.nil?
-              write_attribute('updated_on', current_time) if respond_to?(:updated_on) && updated_on.nil?
-            end
-          end
-
-          def set_timestamps_before_custom_update_method
-            if record_timestamps && (!partial_updates? || changed?)
-              current_time = current_time_from_proper_timezone
+    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
 
-              write_attribute('updated_at', current_time) if respond_to?(:updated_at)
-              write_attribute('updated_on', current_time) if respond_to?(:updated_on)
-            end
-          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
-  end
-end
 
-ActiveRecord::Base.class_eval do
-  extend ActiveRecord::ConnectionAdapters::OracleEnhancedProcedures::ClassMethods
-end
+    def log_custom_method(*args)
+      self.class.connection.send(:log, *args) { yield }
+    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
+    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