activerecord-oracle_enhanced-adapter 1.2.4 → 1.3.0

data/lib/active_record/connection_adapters/oracle_enhanced_context_index.rb

@@ -0,0 +1,282 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhancedContextIndex
+
+      # Define full text index with Oracle specific CONTEXT index type
+      #
+      # Oracle CONTEXT index by default supports full text indexing of one column.
+      # This method allows full text index creation also on several columns
+      # as well as indexing related table columns by generating stored procedure
+      # that concatenates all columns for indexing as well as generating trigger
+      # that will update main index column to trigger reindexing of record.
+      #
+      # Use +contains+ ActiveRecord model instance method to add CONTAINS where condition
+      # and order by score of matched results.
+      #
+      # ===== Examples
+      #
+      # ====== Creating single column index
+      #  add_context_index :posts, :title
+      # search with
+      #  Post.contains(:title, 'word')
+      #
+      # ====== Creating index on several columns
+      #  add_context_index :posts, [:title, :body]
+      # search with (use first column as argument for contains method but it will search in all index columns)
+      #  Post.contains(:title, 'word')
+      #
+      # ====== Creating index on several columns with dummy index column and commit option
+      #  add_context_index :posts, [:title, :body], :index_column => :all_text, :sync => 'ON COMMIT'
+      # search with
+      #  Post.contains(:all_text, 'word')
+      #
+      # ====== Creating index with trigger option (will reindex when specified columns are updated)
+      #  add_context_index :posts, [:title, :body], :index_column => :all_text, :sync => 'ON COMMIT',
+      #                     :index_column_trigger_on => [:created_at, :updated_at]
+      # search with
+      #  Post.contains(:all_text, 'word')
+      #
+      # ====== Creating index on multiple tables
+      #  add_context_index :posts, [:title, :body], :index_column => :all_text, :sync => 'ON COMMIT',
+      #                     :index_column_trigger_on => [:created_at, :updated_at]
+      #  add_context_index :posts,
+      #   [:title, :body,
+      #   # specify aliases always with AS keyword
+      #   "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
+      #   ],
+      #   :name => 'post_and_comments_index',
+      #   :index_column => :all_text, :index_column_trigger_on => [:updated_at, :comments_count],
+      #   :sync => 'ON COMMIT'
+      # search in any table columns
+      #  Post.contains(:all_text, 'word')
+      # search in specified column
+      #  Post.contains(:all_text, "aaa within title")
+      #  Post.contains(:all_text, "bbb within comment_author")
+      #
+      def add_context_index(table_name, column_name, options = {})
+        self.all_schema_indexes = nil
+        column_names = Array(column_name)
+        index_name = options[:name] || index_name(table_name, :column => options[:index_column] || column_names,
+          # CONEXT index name max length is 25
+          :identifier_max_length => 25)
+
+        quoted_column_name = quote_column_name(options[:index_column] || column_names.first)
+        if options[:index_column_trigger_on]
+          raise ArgumentError, "Option :index_column should be specified together with :index_column_cource option" \
+            unless options[:index_column]
+          create_index_column_trigger(table_name, index_name, options[:index_column], options[:index_column_trigger_on])
+        end
+
+        sql = "CREATE INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+        sql << " (#{quoted_column_name})"
+        sql << " INDEXTYPE IS CTXSYS.CONTEXT"
+        parameters = []
+        if column_names.size > 1
+          procedure_name = default_datastore_procedure(index_name)
+          datastore_name = default_datastore_name(index_name)
+          create_datastore_procedure(table_name, procedure_name, column_names, options)
+          create_datastore_preference(datastore_name, procedure_name)
+          parameters << "DATASTORE #{datastore_name} SECTION GROUP CTXSYS.AUTO_SECTION_GROUP"
+        end
+        if options[:tablespace]
+          storage_name = default_storage_name(index_name)
+          create_storage_preference(storage_name, options[:tablespace])
+          parameters << "STORAGE #{storage_name}"
+        end
+        if options[:sync]
+          parameters << "SYNC(#{options[:sync]})"
+        end
+        unless parameters.empty?
+          sql << " PARAMETERS ('#{parameters.join(' ')}')"
+        end
+        execute sql
+      end
+
+      # Drop full text index with Oracle specific CONTEXT index type
+      def remove_context_index(table_name, options = {})
+        self.all_schema_indexes = nil
+        unless Hash === options # if column names passed as argument
+          options = {:column => Array(options)}
+        end
+        index_name = options[:name] || index_name(table_name,
+          :column => options[:index_column] || options[:column], :identifier_max_length => 25)
+        execute "DROP INDEX #{index_name}"
+        drop_ctx_preference(default_datastore_name(index_name))
+        drop_ctx_preference(default_storage_name(index_name))
+        procedure_name = default_datastore_procedure(index_name)
+        execute "DROP PROCEDURE #{quote_table_name(procedure_name)}" rescue nil
+        drop_index_column_trigger(index_name)
+      end
+
+      private
+
+      def create_datastore_procedure(table_name, procedure_name, column_names, options)
+        quoted_table_name = quote_table_name(table_name)
+        select_queries = column_names.select{|c| c.to_s =~ /^SELECT /i}
+        column_names = column_names - select_queries
+        keys, selected_columns = parse_select_queries(select_queries)
+        quoted_column_names = (column_names+keys).map{|col| quote_column_name(col)}
+        execute compress_lines(<<-SQL)
+          CREATE OR REPLACE PROCEDURE #{quote_table_name(procedure_name)}
+            (p_rowid IN	      ROWID,
+            p_clob	IN OUT NOCOPY CLOB) IS
+            -- add_context_index_parameters #{(column_names+select_queries).inspect}#{!options.empty? ? ', ' << options.inspect[1..-2] : ''}
+            #{
+            selected_columns.map do |cols|
+              cols.map do |col|
+                raise ArgumentError, "Alias #{col} too large, should be 28 or less characters long" unless col.length <= 28
+                "l_#{col} VARCHAR2(32767);\n"
+              end.join
+            end.join
+            } BEGIN
+            FOR r1 IN (
+              SELECT #{quoted_column_names.join(', ')}
+              FROM	 #{quoted_table_name}
+              WHERE  #{quoted_table_name}.ROWID = p_rowid
+            ) LOOP
+              #{
+              (column_names.map do |col|
+                col = col.to_s
+                "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+2}, '<#{col}>');\n" <<
+                "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(r1.#{col}), r1.#{col});\n" <<
+                "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+3}, '</#{col}>');\n"
+              end.join) <<
+              (selected_columns.zip(select_queries).map do |cols, query|
+                (cols.map do |col|
+                  "l_#{col} := '';\n"
+                end.join) <<
+                "FOR r2 IN (\n" <<
+                query.gsub(/:(\w+)/,"r1.\\1") << "\n) LOOP\n" <<
+                (cols.map do |col|
+                  "l_#{col} := l_#{col} || r2.#{col} || CHR(10);\n"
+                end.join) <<
+                "END LOOP;\n" <<
+                (cols.map do |col|
+                  col = col.to_s
+                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+2}, '<#{col}>');\n" <<
+                  "IF LENGTH(l_#{col}) > 0 THEN\n" <<
+                  "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(l_#{col}), l_#{col});\n" <<
+                  "END IF;\n" <<
+                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length+3}, '</#{col}>');\n"
+                end.join)
+              end.join)
+              }
+            END LOOP;
+          END;
+        SQL
+      end
+
+      def parse_select_queries(select_queries)
+        keys = []
+        selected_columns = []
+        select_queries.each do |query|
+          # get primary or foreign keys like :id or :something_id
+          keys << (query.scan(/:\w+/).map{|k| k[1..-1].downcase.to_sym})
+          select_part = query.scan(/^select\s.*\sfrom/i).first
+          selected_columns << select_part.scan(/\sas\s+(\w+)/i).map{|c| c.first}
+        end
+        [keys.flatten.uniq, selected_columns]
+      end
+
+      def create_datastore_preference(datastore_name, procedure_name)
+        drop_ctx_preference(datastore_name)
+        execute <<-SQL
+          BEGIN
+            CTX_DDL.CREATE_PREFERENCE('#{datastore_name}', 'USER_DATASTORE');
+            CTX_DDL.SET_ATTRIBUTE('#{datastore_name}', 'PROCEDURE', '#{procedure_name}');
+          END;
+        SQL
+      end
+
+      def create_storage_preference(storage_name, tablespace)
+        drop_ctx_preference(storage_name)
+        sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{storage_name}', 'BASIC_STORAGE');\n"
+        ['I_TABLE_CLAUSE', 'K_TABLE_CLAUSE', 'R_TABLE_CLAUSE',
+        'N_TABLE_CLAUSE', 'I_INDEX_CLAUSE', 'P_TABLE_CLAUSE'].each do |clause|
+          default_clause = case clause
+          when 'R_TABLE_CLAUSE'; 'LOB(DATA) STORE AS (CACHE) '
+          when 'I_INDEX_CLAUSE'; 'COMPRESS 2 '
+          else ''
+          end
+          sql << "CTX_DDL.SET_ATTRIBUTE('#{storage_name}', '#{clause}', '#{default_clause}TABLESPACE #{tablespace}');\n"
+        end
+        sql << "END;\n"
+        execute sql
+      end
+
+      def drop_ctx_preference(preference_name)
+        execute "BEGIN CTX_DDL.DROP_PREFERENCE('#{preference_name}'); END;" rescue nil
+      end
+
+      def create_index_column_trigger(table_name, index_name, index_column, index_column_source)
+        trigger_name = default_index_column_trigger_name(index_name)
+        columns = Array(index_column_source)
+        quoted_column_names = columns.map{|col| quote_column_name(col)}.join(', ')
+        execute compress_lines(<<-SQL)
+          CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
+          BEFORE UPDATE OF #{quoted_column_names} ON #{quote_table_name(table_name)} FOR EACH ROW
+          BEGIN
+            :new.#{quote_column_name(index_column)} := '1';
+          END;
+        SQL
+      end
+
+      def drop_index_column_trigger(index_name)
+        trigger_name = default_index_column_trigger_name(index_name)
+        execute "DROP TRIGGER #{quote_table_name(trigger_name)}" rescue nil
+      end
+
+      def default_datastore_procedure(index_name)
+        "#{index_name}_prc"
+      end
+
+      def default_datastore_name(index_name)
+        "#{index_name}_dst"
+      end
+
+      def default_storage_name(index_name)
+        "#{index_name}_sto"
+      end
+
+      def default_index_column_trigger_name(index_name)
+        "#{index_name}_trg"
+      end
+
+      module BaseClassMethods
+        # Declare that model table has context index defined.
+        # As a result <tt>contains</tt> class scope method is defined.
+        def has_context_index
+          extend ContextIndexClassMethods
+        end
+      end
+
+      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
+        end
+      end
+
+    end
+    
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedContextIndex
+end
+
+ActiveRecord::Base.class_eval do
+  extend ActiveRecord::ConnectionAdapters::OracleEnhancedContextIndex::BaseClassMethods
+end

data/lib/active_record/connection_adapters/oracle_enhanced_core_ext.rb

@@ -26,7 +26,6 @@ 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"
 
@@ -53,7 +52,9 @@ if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '1.9'
 
   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)
+    if defined?(Rails.logger) && Rails.logger
+      Rails.logger.warn warning_message
+    elsif defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER
       RAILS_DEFAULT_LOGGER.warn warning_message
     else
       STDERR.puts warning_message

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -32,7 +32,7 @@ module ActiveRecord #:nodoc:
   end
 end
 
-if ActiveRecord::Base.instance_methods.include?('changed?')
+if ActiveRecord::Base.method_defined?(:changed?)
   ActiveRecord::Base.class_eval do
     include ActiveRecord::ConnectionAdapters::OracleEnhancedDirty::InstanceMethods
   end

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -154,7 +154,7 @@ module ActiveRecord
         @active = true
       rescue NativeException => e
         @active = false
-        if e.message =~ /^java\.sql\.SQLException/
+        if e.message =~ /^java\.sql\.SQL(Recoverable)?Exception/
           raise OracleEnhancedConnectionException, e.message
         else
           raise
@@ -169,7 +169,7 @@ module ActiveRecord
           @active = true
         rescue NativeException => e
           @active = false
-          if e.message =~ /^java\.sql\.SQLException/
+          if e.message =~ /^java\.sql\.SQL(Recoverable)?Exception/
             raise OracleEnhancedConnectionException, e.message
           else
             raise
@@ -183,7 +183,7 @@ module ActiveRecord
         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)/
+          raise unless e.message =~ /^java\.sql\.SQL(Recoverable)?Exception: (Closed Connection|Io exception:|No more data to read from socket)/
           @active = false
           raise unless should_retry
           should_retry = false

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -138,7 +138,12 @@ module ActiveRecord
 
       # Return OCIError error code
       def error_code(exception)
-        exception.code
+        case exception
+        when OCIError
+          exception.code
+        else
+          nil
+        end
       end
 
       private

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -51,68 +51,106 @@ module ActiveRecord #:nodoc:
           include_with_custom_methods
           self.custom_delete_method = block
         end
-        
-        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
+
+        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
-        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
+
+          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
-        end
-        
-        def destroy_method_name_before_custom_methods #:nodoc:
-          if public_method_defined?(:destroy_without_callbacks)
-            :destroy_without_callbacks
-          else
-            :destroy
+
+          def destroy_method_name_before_custom_methods #:nodoc:
+            if public_method_defined?(:destroy_without_callbacks)
+              :destroy_without_callbacks
+            else
+              :destroy
+            end
           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
+          # 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
+        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 }
+              end
+            else
+              super
+            end
           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
+        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
+        end
+
+        def create_using_custom_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
+            self.id = instance_eval(&self.class.custom_create_method)
           end
           @new_record = false
           id
@@ -120,12 +158,37 @@ module ActiveRecord #:nodoc:
 
         # 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
+        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
+            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
-            self.class.custom_update_method.bind(self).call
+            instance_eval(&self.class.custom_update_method)
           end
           1
         end
@@ -133,12 +196,17 @@ module ActiveRecord #:nodoc:
         # 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?
+        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
+          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
-              self.class.custom_delete_method.bind(self).call
+              instance_eval(&self.class.custom_delete_method)
             end
           end
 
@@ -146,6 +214,29 @@ module ActiveRecord #:nodoc:
           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
+
+              write_attribute('updated_at', current_time) if respond_to?(:updated_at)
+              write_attribute('updated_on', current_time) if respond_to?(:updated_on)
+            end
+          end
+        end
+
       end
 
     end