activerecord-oracle_enhanced-adapter 1.4.3 → 1.5.0.beta1

data/lib/active_record/connection_adapters/oracle_enhanced_column_dumper.rb

@@ -0,0 +1,55 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedColumnDumper #:nodoc:
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          private
+          alias_method_chain :column_spec,            :oracle_enhanced
+          alias_method_chain :prepare_column_options, :oracle_enhanced
+          alias_method_chain :migration_keys,         :oracle_enhanced
+        end
+      end
+
+      def column_spec_with_oracle_enhanced(column, types)
+        # return original method if not using 'OracleEnhanced'
+        if (rails_env = defined?(Rails.env) ? Rails.env : (defined?(RAILS_ENV) ? RAILS_ENV : nil)) &&
+              ActiveRecord::Base.configurations[rails_env] &&
+              ActiveRecord::Base.configurations[rails_env]['adapter'] != 'oracle_enhanced'
+          return column_spec_with_oracle_enhanced(column, types)
+        end
+        
+        spec = prepare_column_options(column, types)
+        (spec.keys - [:name, :type]).each do |k|
+          key_s = (k == :virtual_type ? "type: " : "#{k.to_s}: ")
+          spec[k] = key_s + spec[k]
+        end
+        spec
+      end
+
+      def prepare_column_options_with_oracle_enhanced(column, types)
+        spec = {}
+        spec[:name]      = column.name.inspect
+        spec[:type]      = column.virtual? ? 'virtual' : column.type.to_s
+        spec[:virtual_type] = column.type.inspect if column.virtual? && column.sql_type != 'NUMBER'
+        spec[:limit]     = column.limit.inspect if column.limit != types[column.type][:limit] && column.type != :decimal
+        spec[:precision] = column.precision.inspect if !column.precision.nil?
+        spec[:scale]     = column.scale.inspect if !column.scale.nil?
+        spec[:null]      = 'false' if !column.null
+        spec[:as]        = column.virtual_column_data_default if column.virtual?
+        spec[:default]   = default_string(column.default) if column.has_default? && !column.virtual?
+        spec
+      end
+
+      def migration_keys_with_oracle_enhanced
+        # TODO `& column_specs.map(&:keys).flatten` should be exetuted here
+        [:name, :limit, :precision, :scale, :default, :null, :as, :virtual_type]
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::ColumnDumper.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedColumnDumper
+end

data/lib/active_record/connection_adapters/oracle_enhanced_context_index.rb

@@ -329,19 +329,10 @@ module ActiveRecord
 
       module ContextIndexClassMethods
         # Add context index condition.
-        case ::ActiveRecord::VERSION::MAJOR
-        when 3
-          def contains(column, query, options ={})
-            score_label = options[:label].to_i || 1
-            where("CONTAINS(#{connection.quote_column_name(column)}, ?, #{score_label}) > 0", query).
-              order("SCORE(#{score_label}) DESC")
-          end
-        when 2
-          def contains(column, query, options ={})
-            score_label = options[:label].to_i || 1
-            scoped(:conditions => ["CONTAINS(#{connection.quote_column_name(column)}, ?, #{score_label}) > 0", query],
-              :order => "SCORE(#{score_label}) DESC")
-          end
+        def contains(column, query, options ={})
+          score_label = options[:label].to_i || 1
+          where("CONTAINS(#{connection.quote_column_name(column)}, ?, #{score_label}) > 0", query).
+            order("SCORE(#{score_label}) DESC")
         end
       end
 

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -18,7 +18,7 @@ module ActiveRecord #:nodoc:
             # therefore need to convert empty string value to nil if old value is nil
             elsif column.type == :string && column.null && old.nil?
               value = nil if value == ''
-            elsif old == 0 && value.is_a?(String) && value.present? && value != '0'
+            elsif old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
               value = nil
             else
               value = column.type_cast(value)
@@ -27,6 +27,10 @@ module ActiveRecord #:nodoc:
 
           old != value
         end
+
+        def non_zero?(value)
+          value !~ /\A0+(\.0+)?\z/
+        end 
         
       end
 
@@ -37,10 +41,5 @@ end
 if ActiveRecord::Base.method_defined?(:changed?)
   ActiveRecord::Base.class_eval do
     include ActiveRecord::ConnectionAdapters::OracleEnhancedDirty::InstanceMethods
-    # Starting with rails 3.2.9 the method #field_changed?
-    # was renamed to #_field_changed?
-    if private_method_defined?(:field_changed?)
-      alias_method :field_changed?, :_field_changed?
-    end
   end
 end

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -2,26 +2,34 @@ begin
   require "java"
   require "jruby"
 
-  # ojdbc6.jar or ojdbc5.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
+  # ojdbc7.jar, ojdbc6.jar or ojdbc5.jar file should be in application ./lib directory or in load path or in ENV['PATH']
 
   java_version = java.lang.System.getProperty("java.version")
-  ojdbc_jar = if java_version =~ /^1.5/
-    "ojdbc5.jar"
+  ojdbc_jars = if java_version =~ /^1.5/
+    %w(ojdbc5.jar)
   elsif java_version =~ /^1.6/
-    "ojdbc6.jar"
+    %w(ojdbc6.jar)
   elsif java_version =~ /^1.7/
-    "ojdbc7.jar"
+    # Oracle 11g client ojdbc6.jar is also compatible with Java 1.7
+    # Oracle 12c client provides new ojdbc7.jar
+    %w(ojdbc7.jar ojdbc6.jar)
   else
     nil
   end
 
-  unless ojdbc_jar.nil? || ENV_JAVA['java.class.path'] =~ Regexp.new(ojdbc_jar)
+  if ojdbc_jars && ENV_JAVA['java.class.path'] !~ Regexp.new(ojdbc_jars.join('|'))
     # On Unix environment variable should be PATH, on Windows it is sometimes Path
     env_path = (ENV["PATH"] || ENV["Path"] || '').split(File::PATH_SEPARATOR)
     # Look for JDBC driver at first in lib subdirectory (application specific JDBC file version)
     # then in Ruby load path and finally in environment PATH
-    if ojdbc_jar_path = ['./lib'].concat($LOAD_PATH).concat(env_path).find{|d| File.exists?(File.join(d,ojdbc_jar))}
-      require File.join(ojdbc_jar_path,ojdbc_jar)
+    ['./lib'].concat($LOAD_PATH).concat(env_path).detect do |dir|
+      # check any compatible JDBC driver in the priority order
+      ojdbc_jars.any? do |ojdbc_jar|
+        if File.exists?(file_path = File.join(dir, ojdbc_jar))
+          require file_path
+          true
+        end
+      end
     end
   end
 
@@ -35,7 +43,7 @@ begin
 
 rescue LoadError, NameError
   # JDBC driver is unavailable.
-  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. Please install #{ojdbc_jar || "Oracle JDBC"} library."
+  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. Please install #{ojdbc_jars.join(' or ') || "Oracle JDBC"} library."
 end
 
 
@@ -88,7 +96,7 @@ module ActiveRecord
             @raw_connection = @raw_connection.innermost_delegate
           elsif @raw_connection.respond_to?(:getUnderlyingConnection)
             @pooled_connection = @raw_connection
-            @raw_connection = @raw_connection.underlying_connection            
+            @raw_connection = @raw_connection.underlying_connection
           end
 
           config[:driver] ||= @raw_connection.meta_data.connection.java_class.name
@@ -287,7 +295,7 @@ module ActiveRecord
             # else
             #   nil
             # end
-            
+
             # Workaround with CallableStatement
             s = @raw_connection.prepareCall("BEGIN #{sql}; END;")
             s.registerOutParameter(1, java.sql.Types::BIGINT)

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -1,260 +1,191 @@
-# 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
-
-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
+    def log_custom_method(*args)
+      self.class.connection.send(:log, *args) { yield }
+    end
+  end
 end