activerecord-oracle_enhanced-adapter 1.3.2 → 1.4.0

data/lib/active_record/connection_adapters/oracle_enhanced_base_ext.rb

@@ -61,7 +61,11 @@ module ActiveRecord
 
     # After setting large objects to empty, select the OCI8::LOB
     # and write back the data.
-    after_save :enhanced_write_lobs
+    if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR >= 1
+      after_update :enhanced_write_lobs
+    else
+      after_save :enhanced_write_lobs
+    end
     def enhanced_write_lobs #:nodoc:
       if connection.is_a?(ConnectionAdapters::OracleEnhancedAdapter) &&
           !(self.class.custom_create_method || self.class.custom_update_method)
@@ -74,6 +78,23 @@ module ActiveRecord
     def self.table_comment
       connection.table_comment(self.table_name)
     end
+    
+    if ActiveRecord::VERSION::MAJOR < 3
+      def attributes_with_quotes_with_virtual_columns(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
+        virtual_columns = self.class.columns.select(& :virtual?).map(&:name)
+        attributes_with_quotes_without_virtual_columns(include_primary_key, include_readonly_attributes, attribute_names - virtual_columns)
+      end
+
+      alias_method_chain :attributes_with_quotes, :virtual_columns
+    else
+      def arel_attributes_values_with_virtual_columns(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
+        virtual_columns = self.class.columns.select(& :virtual?).map(&:name)
+        arel_attributes_values_without_virtual_columns(include_primary_key, include_readonly_attributes, attribute_names - virtual_columns)
+      end
+
+      alias_method_chain :arel_attributes_values, :virtual_columns
+    end
+
   end
 
 end

data/lib/active_record/connection_adapters/oracle_enhanced_column.rb

@@ -2,22 +2,29 @@ module ActiveRecord
   module ConnectionAdapters #:nodoc:
     class OracleEnhancedColumn < Column
 
-      attr_reader :table_name, :forced_column_type, :nchar #:nodoc:
+      attr_reader :table_name, :forced_column_type, :nchar, :virtual_column_data_default #:nodoc:
       
-      def initialize(name, default, sql_type = nil, null = true, table_name = nil, forced_column_type = nil) #:nodoc:
+      def initialize(name, default, sql_type = nil, null = true, table_name = nil, forced_column_type = nil, virtual=false) #:nodoc:
         @table_name = table_name
         @forced_column_type = forced_column_type
+        @virtual = virtual
         super(name, default, sql_type, null)
+        @virtual_column_data_default = default.inspect if virtual
         # Is column NCHAR or NVARCHAR2 (will need to use N'...' value quoting for these data types)?
         # Define only when needed as adapter "quote" method will check at first if instance variable is defined.
         @nchar = true if @type == :string && sql_type[0,1] == 'N'
       end
 
       def type_cast(value) #:nodoc:
+        return OracleEnhancedColumn::string_to_raw(value) if type == :raw
         return guess_date_or_time(value) if type == :datetime && OracleEnhancedAdapter.emulate_dates
         super
       end
 
+      def virtual?
+        @virtual
+      end
+
       # convert something to a boolean
       # added y as boolean value
       def self.value_to_boolean(value) #:nodoc:
@@ -42,6 +49,11 @@ module ActiveRecord
         super
       end
 
+      # convert RAW column values back to byte strings.
+      def self.string_to_raw(string) #:nodoc:
+        string
+      end
+
       # Get column comment from schema definition.
       # Will work only if using default ActiveRecord connection.
       def comment
@@ -63,6 +75,8 @@ module ActiveRecord
           else
             :decimal
           end
+        when /raw/i
+          :raw
         when /char/i
           if OracleEnhancedAdapter.emulate_booleans_from_strings &&
              OracleEnhancedAdapter.is_boolean_column?(name, field_type, table_name)
@@ -119,4 +133,4 @@ module ActiveRecord
 
   end
 
-end
+end

data/lib/active_record/connection_adapters/oracle_enhanced_context_index.rb

@@ -13,6 +13,16 @@ module ActiveRecord
       # Use +contains+ ActiveRecord model instance method to add CONTAINS where condition
       # and order by score of matched results.
       #
+      # Options:
+      #
+      # * <tt>:name</tt>
+      # * <tt>:index_column</tt>
+      # * <tt>:index_column_trigger_on</tt>
+      # * <tt>:tablespace</tt>
+      # * <tt>:sync</tt> - 'MANUAL', 'EVERY "interval-string"' or 'ON COMMIT' (defaults to 'MANUAL').
+      # * <tt>:lexer</tt> - Lexer options (e.g. <tt>:type => 'BASIC_LEXER', :base_letter => true</tt>).
+      # * <tt>:transactional</tt> - When +true+, the CONTAINS operator will process inserted and updated rows.
+      #
       # ===== Examples
       #
       # ====== Creating single column index
@@ -54,6 +64,9 @@ module ActiveRecord
       # ====== Creating index using lexer
       #  add_context_index :posts, :title, :lexer => { :type => 'BASIC_LEXER', :base_letter => true, ... }
       #
+      # ====== Creating transactional index (will reindex changed rows when querying)
+      #  add_context_index :posts, :title, :transactional => true
+      #
       def add_context_index(table_name, column_name, options = {})
         self.all_schema_indexes = nil
         column_names = Array(column_name)
@@ -63,7 +76,7 @@ module ActiveRecord
 
         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" \
+          raise ArgumentError, "Option :index_column should be specified together with :index_column_trigger_on option" \
             unless options[:index_column]
           create_index_column_trigger(table_name, index_name, options[:index_column], options[:index_column_trigger_on])
         end
@@ -93,6 +106,9 @@ module ActiveRecord
           create_lexer_preference(lexer_name, lexer_type, lexer_options)
           parameters << "LEXER #{lexer_name}"
         end
+        if options[:transactional]
+          parameters << "TRANSACTIONAL"
+        end
         unless parameters.empty?
           sql << " PARAMETERS ('#{parameters.join(' ')}')"
         end
@@ -119,8 +135,8 @@ module ActiveRecord
 
       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
+        select_queries, column_names = column_names.partition { |c| c.to_s =~ /^\s*SELECT\s+/i }
+        select_queries = select_queries.map { |s| s.strip.gsub(/\s+/, ' ') }
         keys, selected_columns = parse_select_queries(select_queries)
         quoted_column_names = (column_names+keys).map{|col| quote_column_name(col)}
         execute compress_lines(<<-SQL)

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -2,19 +2,28 @@ begin
   require "java"
   require "jruby"
 
-  # ojdbc14.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
-
-  ojdbc_jar = "ojdbc14.jar"
+  # ojdbc6.jar or ojdbc5.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
+
+  java_version = java.lang.System.getProperty("java.version")
+  ojdbc_jar = if java_version =~ /^1.5/
+    "ojdbc5.jar"
+  elsif java_version >= '1.6'
+    "ojdbc6.jar"
+  else
+    nil
+  end
 
-  unless ENV_JAVA['java.class.path'] =~ Regexp.new(ojdbc_jar)
+  unless ojdbc_jar.nil? || ENV_JAVA['java.class.path'] =~ Regexp.new(ojdbc_jar)
     # On Unix environment variable should be PATH, on Windows it is sometimes Path
-    env_path = ENV["PATH"] || ENV["Path"] || ''
-    if ojdbc_jar_path = env_path.split(/[:;]/).concat($LOAD_PATH).find{|d| File.exists?(File.join(d,ojdbc_jar))}
+    env_path = (ENV["PATH"] || ENV["Path"] || '').split(/[:;]/)
+    # 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)
     end
   end
 
-  java.sql.DriverManager.registerDriver Java::oracle.jdbc.driver.OracleDriver.new
+  java.sql.DriverManager.registerDriver Java::oracle.jdbc.OracleDriver.new
 
   # set tns_admin property from TNS_ADMIN environment variable
   if !java.lang.System.get_property("oracle.net.tns_admin") && ENV["TNS_ADMIN"]
@@ -23,7 +32,7 @@ begin
 
 rescue LoadError, NameError
   # JDBC driver is unavailable.
-  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. Please install ojdbc14.jar library."
+  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. Please install #{ojdbc_jar || "Oracle JDBC"} library."
 end
 
 
@@ -199,7 +208,7 @@ module ActiveRecord
         begin
           yield if block_given?
         rescue NativeException => e
-          raise unless e.message =~ /^java\.sql\.SQL(Recoverable)?Exception: (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|IO Error:)/
           @active = false
           raise unless should_retry
           should_retry = false
@@ -288,17 +297,26 @@ module ActiveRecord
           @raw_statement = raw_statement
         end
 
-        def bind_param(position, value)
-          java_value = ruby_to_java_value(value)
+        def bind_param(position, value, col_type = nil)
+          java_value = ruby_to_java_value(value, col_type)
           case value
           when Integer
-            @raw_statement.setInt(position, java_value)
+            @raw_statement.setLong(position, java_value)
           when Float
             @raw_statement.setFloat(position, java_value)
           when BigDecimal
             @raw_statement.setBigDecimal(position, java_value)
           when String
-            @raw_statement.setString(position, java_value)
+            case col_type
+            when :text
+              @raw_statement.setClob(position, java_value)
+            when :binary
+              @raw_statement.setBlob(position, java_value)
+            when :raw
+              @raw_statement.setString(position, OracleEnhancedAdapter.encode_raw(java_value))
+            else
+              @raw_statement.setString(position, java_value)
+            end
           when Date, DateTime
             @raw_statement.setDATE(position, java_value)
           when Time
@@ -313,12 +331,24 @@ module ActiveRecord
           end
         end
 
+        def bind_returning_param(position, bind_type)
+          @returning_positions ||= []
+          @returning_positions << position
+          if bind_type == Integer
+            @raw_statement.registerReturnParameter(position, java.sql.Types::BIGINT)
+          end
+        end
+
         def exec
           @raw_result_set = @raw_statement.executeQuery
           get_metadata
           true
         end
 
+        def exec_update
+          @raw_statement.executeUpdate
+        end
+
         def get_metadata
           metadata = @raw_result_set.getMetaData
           column_count = metadata.getColumnCount
@@ -345,16 +375,41 @@ module ActiveRecord
           end
         end
 
+        def get_returning_param(position, type)
+          rs_position = @returning_positions.index(position) + 1
+          rs = @raw_statement.getReturnResultSet
+          if rs.next
+            # Assuming that primary key will not be larger as long max value
+            returning_id = rs.getLong(rs_position)
+            rs.wasNull ? nil : returning_id
+          else
+            nil
+          end
+        end
+
         def close
           @raw_statement.close
         end
 
         private
 
-        def ruby_to_java_value(value)
+        def ruby_to_java_value(value, col_type = nil)
           case value
-          when Fixnum, String, Float
+          when Fixnum, Float
             value
+          when String
+            case col_type
+            when :text
+              clob = Java::OracleSql::CLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
+              clob.setString(1, value)
+              clob
+            when :binary
+              blob = Java::OracleSql::BLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
+              blob.setBytes(1, value.to_java_bytes)
+              blob
+            else
+              value
+            end
           when BigDecimal
             java.math.BigDecimal.new(value.to_s)
           when Date, DateTime
@@ -438,7 +493,7 @@ module ActiveRecord
           else
             BigDecimal.new(d.stringValue)
           end
-        when :VARCHAR2, :CHAR, :LONG
+        when :VARCHAR2, :CHAR, :LONG, :NVARCHAR2, :NCHAR
           rset.getString(i)
         when :DATE
           if dt = rset.getDATE(i)
@@ -452,7 +507,7 @@ module ActiveRecord
           else
             nil
           end
-        when :TIMESTAMP, :TIMESTAMPTZ, :TIMESTAMPLTZ
+        when :TIMESTAMP, :TIMESTAMPTZ, :TIMESTAMPLTZ, :"TIMESTAMP WITH TIME ZONE", :"TIMESTAMP WITH LOCAL TIME ZONE"
           ts = rset.getTimestamp(i)
           ts && Time.send(Base.default_timezone, ts.year + 1900, ts.month + 1, ts.date, ts.hours, ts.minutes, ts.seconds,
             ts.nanos / 1000)
@@ -460,6 +515,9 @@ module ActiveRecord
           get_lob_value ? lob_to_ruby_value(rset.getClob(i)) : rset.getClob(i)
         when :BLOB
           get_lob_value ? lob_to_ruby_value(rset.getBlob(i)) : rset.getBlob(i)
+        when :RAW
+          raw_value = rset.getRAW(i)
+          raw_value && raw_value.getBytes.to_a.pack('C*')
         else
           nil
         end

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -26,6 +26,16 @@ module ActiveRecord
         @owner = config[:username].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(:@connection)
+        end
+      end
+
       def auto_retry
         @raw_connection.auto_retry if @raw_connection
       end
@@ -103,14 +113,38 @@ module ActiveRecord
           @raw_cursor = raw_cursor
         end
 
-        def bind_param(position, value)
-          @raw_cursor.bind_param(position, value)
+        def bind_param(position, value, col_type = nil)
+          if value.nil?
+            @raw_cursor.bind_param(position, nil, String)
+          else
+            case col_type
+            when :text, :binary
+              # ruby-oci8 cannot create CLOB/BLOB from ''
+              lob_value = value == '' ? ' ' : value
+              bind_type = col_type == :text ? OCI8::CLOB : OCI8::BLOB
+              ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
+              ora_value.size = 0 if value == ''
+              @raw_cursor.bind_param(position, ora_value)
+            when :raw
+              @raw_cursor.bind_param(position, OracleEnhancedAdapter.encode_raw(value))
+            else
+              @raw_cursor.bind_param(position, value)
+            end
+          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
@@ -124,9 +158,14 @@ module ActiveRecord
           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)

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -1,10 +1,10 @@
 # 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_inheritable_accessor
-    class_inheritable_accessor :custom_create_method, :custom_update_method, :custom_delete_method
-  elsif respond_to? :class_attribute
+  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
 

data/lib/active_record/connection_adapters/oracle_enhanced_schema_definitions.rb

@@ -10,11 +10,36 @@ module ActiveRecord
       :tablespace, :columns) #:nodoc:
     end
 
+    module OracleEnhancedColumnDefinition
+       def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :to_sql, :virtual_columns
+          alias to_s :to_sql
+        end
+       end
+
+      def to_sql_with_virtual_columns
+        if type==:virtual
+          "#{base.quote_column_name(name)} AS (#{default})"
+        else
+          to_sql_without_virtual_columns
+        end
+      end
+
+      def lob?
+        ['CLOB', 'BLOB'].include?(sql_type)
+      end
+    end
+
     module OracleEnhancedSchemaDefinitions #:nodoc:
       def self.included(base)
         base::TableDefinition.class_eval do
           include OracleEnhancedTableDefinition
         end
+
+        base::ColumnDefinition.class_eval do
+          include OracleEnhancedColumnDefinition
+        end
         
         # Available starting from ActiveRecord 2.1
         base::Table.class_eval do
@@ -31,10 +56,21 @@ module ActiveRecord
         alias to_s :to_sql
       end
 
+      def raw(name, options={})
+        column(name, :raw, options)
+      end
+
       def self.included(base) #:nodoc:
         base.class_eval do
           alias_method_chain :references, :foreign_keys
           alias_method_chain :to_sql, :foreign_keys
+
+          def virtual(* args)
+            options = args.extract_options!
+            column_names = args
+            column_names.each { |name| column(name, :virtual, options) }
+          end
+
         end
       end
     
@@ -88,6 +124,10 @@ module ActiveRecord
         sql << ', ' << (foreign_keys * ', ') unless foreign_keys.blank?
         sql
       end
+
+      def lob_columns
+        columns.select(&:lob?)
+      end
     
       private
         def foreign_keys