rsim-activerecord-oracle_enhanced-adapter 1.2.0.2 → 1.2.1

data/History.txt

@@ -1,7 +1,13 @@
-== master development branch
+== 1.2.1 2009-06-07
 
+* Enhancements
+  * caching of table indexes query which makes schema dump much faster
 * Bug fixes:
   * return Date (and not DateTime) values for :date column value before year 1970
+  * fixed after_create/update/destroy callbacks with plsql custom methods
+  * fixed creation of large integers in JRuby
+  * Made test tasks respect RAILS_ENV
+  * fixed support for composite primary keys for tables with LOBs
 
 == 1.2.0 2009-03-22
 

data/Manifest.txt

@@ -1,6 +1,6 @@
 History.txt
 License.txt
-README.txt
+README.rdoc
 lib/active_record/connection_adapters/emulation/oracle_adapter.rb
 lib/active_record/connection_adapters/oracle_enhanced.rake
 lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

data/{README.txt → README.rdoc}

@@ -29,6 +29,17 @@ Bugs and enhancement requests can be reported at http://rsim.lighthouseapp.com/p
 
 * sudo gem install activerecord-oracle_enhanced-adapter
 
+== CONTRIBUTORS:
+
+* Raimonds Simanovskis
+* Jorge Dias
+* James Wylder
+* Rob Christie
+* Nate Wieger
+* Edgars Beigarts
+* Lachlan Laycock
+* toddwf
+
 == LICENSE:
 
 (The MIT License)

data/lib/active_record/connection_adapters/oracle_enhanced.rake

@@ -24,17 +24,19 @@ namespace :db do
   end
 
   namespace :test do
-    redefine_task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
+    redefine_task :clone_structure => [ :rails_env, "db:structure:dump", "db:test:purge" ] do
+      env = RAILS_ENV ||= 'test'
       abcs = ActiveRecord::Base.configurations
-      ActiveRecord::Base.establish_connection(:test)
+      ActiveRecord::Base.establish_connection(env.to_sym)
       IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |ddl|
         ActiveRecord::Base.connection.execute(ddl.chop)
       end
     end
 
-    redefine_task :purge => :environment do
+    redefine_task :purge => [:rails_env, :environment] do
+      env = RAILS_ENV ||= 'test'
       abcs = ActiveRecord::Base.configurations
-      ActiveRecord::Base.establish_connection(:test)
+      ActiveRecord::Base.establish_connection(env.to_sym)
       ActiveRecord::Base.connection.structure_drop.split("\n\n").each do |ddl|
         ActiveRecord::Base.connection.execute(ddl.chop)
       end

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -518,15 +518,26 @@ module ActiveRecord
 
       # Writes LOB values from attributes, as indicated by the LOB columns of klass.
       def write_lobs(table_name, klass, attributes)
-        id = quote(attributes[klass.primary_key])
+        # is class with composite primary key>
+        is_with_cpk = klass.respond_to?(:composite?) && klass.composite?
+        if is_with_cpk
+          id = klass.primary_key.map {|pk| attributes[pk.to_s] }
+        else
+          id = quote(attributes[klass.primary_key])
+        end
         klass.columns.select { |col| col.sql_type =~ /LOB$/i }.each do |col|
           value = attributes[col.name]
           # RSI: changed sequence of next two lines - should check if value is nil before converting to yaml
           next if value.nil?  || (value == '')
           value = value.to_yaml if col.text? && klass.serialized_attributes[col.name]
           uncached do
-            lob = select_one("SELECT #{col.name} FROM #{table_name} WHERE #{klass.primary_key} = #{id} FOR UPDATE",
+            if is_with_cpk
+              lob = select_one("SELECT #{col.name} FROM #{table_name} WHERE #{klass.composite_where_clause(id)} FOR UPDATE",
+                                'Writable Large Object')[col.name]
+            else
+              lob = select_one("SELECT #{col.name} FROM #{table_name} WHERE #{klass.primary_key} = #{id} FOR UPDATE",
                                'Writable Large Object')[col.name]
+            end
             @connection.write_lob(lob, value, col.type == :binary)
           end
         end
@@ -562,33 +573,42 @@ module ActiveRecord
         select_all("select decode(table_name,upper(table_name),lower(table_name),table_name) name from all_tables where owner = sys_context('userenv','session_user')").map {|t| t['name']}
       end
 
-      def indexes(table_name, name = nil) #:nodoc:
-        (owner, table_name) = @connection.describe(table_name)
-        result = select_all(<<-SQL, name)
-          SELECT lower(i.index_name) as index_name, i.uniqueness, lower(c.column_name) as column_name
-            FROM all_indexes i, all_ind_columns c
-           WHERE i.table_name = '#{table_name}'
-             AND i.owner = '#{owner}'
-             AND i.table_owner = '#{owner}'
-             AND c.index_name = i.index_name
-             AND c.index_owner = i.owner
-             AND NOT EXISTS (SELECT uc.index_name FROM all_constraints uc WHERE uc.index_name = i.index_name AND uc.owner = i.owner AND uc.constraint_type = 'P')
-            ORDER BY i.index_name, c.column_position
-        SQL
-
-        current_index = nil
-        indexes = []
+      cattr_accessor :all_schema_indexes
 
-        result.each do |row|
-          if current_index != row['index_name']
-            indexes << IndexDefinition.new(table_name.downcase, row['index_name'], row['uniqueness'] == "UNIQUE", [])
-            current_index = row['index_name']
+      # This method selects all indexes at once, and caches them in a class variable.
+      # Subsequent index calls get them from the variable, without going to the DB.
+      def indexes(table_name, name = nil)
+        (owner, table_name) = @connection.describe(table_name)
+        unless all_schema_indexes
+          result = select_all(<<-SQL)
+            SELECT lower(i.table_name) as table_name, lower(i.index_name) as index_name, i.uniqueness, lower(c.column_name) as column_name
+              FROM all_indexes i, all_ind_columns c
+             WHERE i.owner = '#{owner}'
+               AND i.table_owner = '#{owner}'
+               AND c.index_name = i.index_name
+               AND c.index_owner = i.owner
+               AND NOT EXISTS (SELECT uc.index_name FROM all_constraints uc WHERE uc.index_name = i.index_name AND uc.owner = i.owner AND uc.constraint_type = 'P')
+              ORDER BY i.index_name, c.column_position
+          SQL
+      
+          current_index = nil
+          self.all_schema_indexes = []
+      
+          result.each do |row|
+            # have to keep track of indexes because above query returns dups
+            # there is probably a better query we could figure out
+            if current_index != row['index_name']
+              self.all_schema_indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(row['table_name'], row['index_name'], row['uniqueness'] == "UNIQUE", [])
+              current_index = row['index_name']
+            end
+      
+            self.all_schema_indexes.last.columns << row['column_name']
           end
-
-          indexes.last.columns << row['column_name']
         end
-
-        indexes
+      
+        # Return the indexes just for the requested table, since AR is structured that way
+        table_name = table_name.downcase
+        all_schema_indexes.select{|i| i.table == table_name}
       end
       
       # RSI: set ignored columns for table
@@ -726,7 +746,15 @@ module ActiveRecord
         execute "DROP SEQUENCE #{seq_name}" rescue nil
       end
 
+      # clear cached indexes when adding new index
+      def add_index(table_name, column_name, options = {})
+        self.all_schema_indexes = nil
+        super
+      end
+
+      # clear cached indexes when removing index
       def remove_index(table_name, options = {}) #:nodoc:
+        self.all_schema_indexes = nil
         execute "DROP INDEX #{index_name(table_name, options)}"
       end
 

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -72,6 +72,9 @@ module ActiveRecord
         # Set session time zone to current time zone
         @raw_connection.setSessionTimeZone(java.util.TimeZone.default.getID)
         
+        # Set default number of rows to prefetch
+        # @raw_connection.setDefaultRowPrefetch(prefetch_rows) if prefetch_rows
+        
         # default schema owner
         @owner = username.upcase
         
@@ -156,7 +159,7 @@ module ActiveRecord
       end
 
       def exec_no_retry(sql)
-        cs = prepare_call(sql)
+        cs = @raw_connection.prepareCall(sql)
         case sql
         when /\A\s*UPDATE/i, /\A\s*INSERT/i, /\A\s*DELETE/i
           cs.executeUpdate
@@ -175,59 +178,35 @@ module ActiveRecord
       end
 
       def select_no_retry(sql, name = nil, return_column_names = false)
-        stmt = prepare_statement(sql)
+        stmt = @raw_connection.prepareStatement(sql)
         rset = stmt.executeQuery
+
+        # Reuse the same hash for all rows
+        column_hash = {}
+
         metadata = rset.getMetaData
         column_count = metadata.getColumnCount
-        cols = (1..column_count).map do |i|
-          oracle_downcase(metadata.getColumnName(i))
-        end
-        col_types = (1..column_count).map do |i|
-          metadata.getColumnTypeName(i)
+        
+        cols_types_index = (1..column_count).map do |i|
+          col_name = oracle_downcase(metadata.getColumnName(i))
+          next if col_name == 'raw_rnum_'
+          column_hash[col_name] = nil
+          [col_name, metadata.getColumnTypeName(i).to_sym, i]
         end
+        cols_types_index.delete(nil)
 
         rows = []
-
+        get_lob_value = !(name == 'Writable Large Object')
+        
         while rset.next
-          hash = Hash.new
-
-          cols.each_with_index do |col, i0|
-            i = i0 + 1
-            hash[col] = 
-              case column_type = col_types[i0]
-              when /CLOB/
-                name == 'Writable Large Object' ? rset.getClob(i) : get_ruby_value_from_result_set(rset, i, column_type)
-              when /BLOB/
-                name == 'Writable Large Object' ? rset.getBlob(i) : get_ruby_value_from_result_set(rset, i, column_type)
-              when 'DATE'
-                t = get_ruby_value_from_result_set(rset, i, column_type)
-                # RSI: added emulate_dates_by_column_name functionality
-                # if emulate_dates_by_column_name && self.class.is_date_column?(col)
-                #   d.to_date
-                # elsif
-                if t && OracleEnhancedAdapter.emulate_dates && (t.hour == 0 && t.min == 0 && t.sec == 0)
-                  t.to_date
-                else
-                  # JRuby Time supports time before year 1900 therefore now need to fall back to DateTime
-                  t
-                end
-              # RSI: added emulate_integers_by_column_name functionality
-              when "NUMBER"
-                n = get_ruby_value_from_result_set(rset, i, column_type)
-                if n && n.is_a?(Float) && OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(col)
-                  n.to_i
-                else
-                  n
-                end
-              else
-                get_ruby_value_from_result_set(rset, i, column_type)
-              end unless col == 'raw_rnum_'
+          hash = column_hash.dup
+          cols_types_index.each do |col, column_type, i|
+            hash[col] = get_ruby_value_from_result_set(rset, i, column_type, get_lob_value)
           end
-
           rows << hash
         end
 
-        return_column_names ? [rows, cols] : rows
+        return_column_names ? [rows, cols_types_index.map(&:first)] : rows
       ensure
         rset.close rescue nil
         stmt.close rescue nil
@@ -284,50 +263,62 @@ module ActiveRecord
 
       private
 
-      def prepare_statement(sql)
-        @raw_connection.prepareStatement(sql)
-      end
+      # def prepare_statement(sql)
+      #   @raw_connection.prepareStatement(sql)
+      # end
 
-      def prepare_call(sql, *bindvars)
-        @raw_connection.prepareCall(sql)
-      end
+      # def prepare_call(sql, *bindvars)
+      #   @raw_connection.prepareCall(sql)
+      # end
 
-      def get_ruby_value_from_result_set(rset, i, type_name)
+      def get_ruby_value_from_result_set(rset, i, type_name, get_lob_value = true)
         case type_name
-        when "CHAR", "VARCHAR2", "LONG"
-          rset.getString(i)
-        when "CLOB"
-          ora_value_to_ruby_value(rset.getClob(i))
-        when "BLOB"
-          ora_value_to_ruby_value(rset.getBlob(i))
-        when "NUMBER"
-          d = rset.getBigDecimal(i)
+        when :NUMBER
+          # d = rset.getBigDecimal(i)
+          # if d.nil?
+          #   nil
+          # elsif d.scale == 0
+          #   d.toBigInteger+0
+          # else
+          #   # Is there better way how to convert Java BigDecimal to Ruby BigDecimal?
+          #   d.toString.to_d
+          # end
+          d = rset.getNUMBER(i)
           if d.nil?
             nil
-          elsif d.scale == 0
-            d.toBigInteger+0
+          elsif d.isInt
+            Integer(d.stringValue)
           else
-            # Is there better way how to convert Java BigDecimal to Ruby BigDecimal?
-            d.toString.to_d
+            BigDecimal.new(d.stringValue)
           end
-        when "DATE"
+        when :VARCHAR2, :CHAR, :LONG
+          rset.getString(i)
+        when :DATE
           if dt = rset.getDATE(i)
             d = dt.dateValue
             t = dt.timeValue
-            Time.send(Base.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+            if OracleEnhancedAdapter.emulate_dates && t.hours == 0 && t.minutes == 0 && t.seconds == 0
+              Date.new(d.year + 1900, d.month + 1, d.date)
+            else
+              Time.send(Base.default_timezone, d.year + 1900, d.month + 1, d.date, t.hours, t.minutes, t.seconds)
+            end
           else
             nil
           end
-        when /^TIMESTAMP/
+        when :TIMESTAMP, :TIMESTAMPTZ, :TIMESTAMPLTZ
           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)
+        when :CLOB
+          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)
         else
           nil
         end
       end
       
-      def ora_value_to_ruby_value(val)
+      def lob_to_ruby_value(val)
         case val
         when ::Java::OracleSql::CLOB
           if val.isEmptyLob
@@ -341,8 +332,6 @@ module ActiveRecord
           else
             String.from_java_bytes(val.getBytes(1, val.length))
           end
-        else
-          val
         end
       end
 

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -84,70 +84,75 @@ module ActiveRecord
 
       def select(sql, name = nil, return_column_names = false)
         cursor = @raw_connection.exec(sql)
-        cols = cursor.get_col_names.map { |x| oracle_downcase(x) }
+        cols = []
+        # Ignore raw_rnum_ which is used to simulate LIMIT and OFFSET
+        cursor.get_col_names.each do |col_name|
+          col_name = oracle_downcase(col_name)
+          cols << col_name unless col_name == 'raw_rnum_'
+        end
+        # Reuse the same hash for all rows
+        column_hash = {}
+        cols.each {|c| column_hash[c] = nil}
         rows = []
+        get_lob_value = !(name == 'Writable Large Object')
 
         while row = cursor.fetch
-          hash = Hash.new
+          hash = column_hash.dup
 
           cols.each_with_index do |col, i|
             hash[col] =
-              case row[i]
+              case v = row[i]
+              # RSI: added emulate_integers_by_column_name functionality
+              when Float
+                # if OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(col)
+                #   v.to_i
+                # else
+                #   v
+                # end
+                v == (v_to_i = v.to_i) ? v_to_i : v
+              # ruby-oci8 2.0 returns OraNumber - convert it to Integer or BigDecimal
+              when OraNumber
+                v == (v_to_i = v.to_i) ? v_to_i : BigDecimal.new(v.to_s)
+              when String
+                v
               when OCI8::LOB
-                if name == 'Writable Large Object'
-                  row[i]
-                else
-                  data =  row[i].read
+                if get_lob_value
+                  data = v.read
                   # In Ruby 1.9.1 always change encoding to ASCII-8BIT for binaries
-                  data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding) && row[i].is_a?(OCI8::BLOB)
+                  data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding) && v.is_a?(OCI8::BLOB)
                   data
+                else
+                  v
                 end
               # ruby-oci8 1.0 returns OraDate
               when OraDate
-                d = row[i]
                 # RSI: added emulate_dates_by_column_name functionality
-                # if emulate_dates_by_column_name && self.class.is_date_column?(col)
-                #   d.to_date
-                # elsif
-                if OracleEnhancedAdapter.emulate_dates && (d.hour == 0 && d.minute == 0 && d.second == 0)
-                  d.to_date
+                if OracleEnhancedAdapter.emulate_dates && (v.hour == 0 && v.minute == 0 && v.second == 0)
+                  v.to_date
                 else
                   # code from Time.time_with_datetime_fallback
                   begin
-                    Time.send(Base.default_timezone, d.year, d.month, d.day, d.hour, d.minute, d.second)
+                    Time.send(Base.default_timezone, v.year, v.month, v.day, v.hour, v.minute, v.second)
                   rescue
                     offset = Base.default_timezone.to_sym == :local ? ::DateTime.local_offset : 0
-                    ::DateTime.civil(d.year, d.month, d.day, d.hour, d.minute, d.second, offset)
+                    ::DateTime.civil(v.year, v.month, v.day, v.hour, v.minute, v.second, offset)
                   end
                 end
               # ruby-oci8 2.0 returns Time or DateTime
               when Time, DateTime
-                d = row[i]
-                if OracleEnhancedAdapter.emulate_dates && (d.hour == 0 && d.min == 0 && d.sec == 0)
-                  d.to_date
+                if OracleEnhancedAdapter.emulate_dates && (v.hour == 0 && v.min == 0 && v.sec == 0)
+                  v.to_date
                 else
                   # recreate Time or DateTime using Base.default_timezone
                   begin
-                    Time.send(Base.default_timezone, d.year, d.month, d.day, d.hour, d.min, d.sec)
+                    Time.send(Base.default_timezone, v.year, v.month, v.day, v.hour, v.min, v.sec)
                   rescue
                     offset = Base.default_timezone.to_sym == :local ? ::DateTime.local_offset : 0
-                    ::DateTime.civil(d.year, d.month, d.day, d.hour, d.min, d.sec, offset)
+                    ::DateTime.civil(v.year, v.month, v.day, v.hour, v.min, v.sec, offset)
                   end
                 end
-              # RSI: added emulate_integers_by_column_name functionality
-              when Float
-                n = row[i]
-                if OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(col)
-                  n.to_i
-                else
-                  n
-                end
-              # ruby-oci8 2.0 returns OraNumber - convert it to Integer or BigDecimal
-              when OraNumber
-                n = row[i]
-                n == (n_to_i = n.to_i) ? n_to_i : BigDecimal.new(n.to_s)
-              else row[i]
-              end unless col == 'raw_rnum_'
+              else v
+              end
           end
 
           rows << hash

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -38,17 +38,30 @@ module ActiveRecord #:nodoc:
       module InstanceMethods
         def self.included(base)
           base.instance_eval do
-            alias_method_chain :create, :custom_method
+            if private_instance_methods.include?('create_without_callbacks') || private_instance_methods.include?(:create_without_callbacks)
+              alias_method :create_without_custom_method, :create_without_callbacks
+              alias_method :create_without_callbacks, :create_with_custom_method
+            else
+              alias_method_chain :create, :custom_method
+            end
             # insert after dirty checking in Rails 2.1
             # in Ruby 1.9 methods names are returned as symbols
             if private_instance_methods.include?('update_without_dirty') || private_instance_methods.include?(:update_without_dirty)
               alias_method :update_without_custom_method, :update_without_dirty
               alias_method :update_without_dirty, :update_with_custom_method
+            elsif private_instance_methods.include?('update_without_callbacks') || private_instance_methods.include?(:update_without_callbacks)
+              alias_method :update_without_custom_method, :update_without_callbacks
+              alias_method :update_without_callbacks, :update_with_custom_method
             else
               alias_method_chain :update, :custom_method
             end
             private :create, :update
-            alias_method_chain :destroy, :custom_method
+            if public_instance_methods.include?('destroy_without_callbacks') || public_instance_methods.include?(:destroy_without_callbacks)
+              alias_method :destroy_without_custom_method, :destroy_without_callbacks
+              alias_method :destroy_without_callbacks, :destroy_with_custom_method
+            else
+              alias_method_chain :destroy, :custom_method
+            end
             public :destroy
           end
         end

data/lib/active_record/connection_adapters/oracle_enhanced_version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
     module OracleEnhancedVersion #:nodoc:
-      VERSION = '1.2.0'
+      VERSION = '1.2.1'
     end
   end
 end

data/oracle-enhanced.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{activerecord-oracle_enhanced-adapter}
-  s.version = "1.2.0.2"
+  s.version = "1.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Raimonds Simanovskis"]
-  s.date = %q{2009-04-07}
+  s.date = %q{2009-06-07}
   s.description = %q{Oracle enhanced adapter for ActiveRecord}
   s.email = ["raimonds.simanovskis@gmail.com"]
-  s.extra_rdoc_files = ["History.txt", "License.txt", "Manifest.txt", "README.txt"]
-  s.files = ["History.txt", "License.txt", "Manifest.txt", "README.txt",
+  s.extra_rdoc_files = ["History.txt", "License.txt", "Manifest.txt", "README.rdoc"]
+  s.files = ["History.txt", "License.txt", "Manifest.txt", "README.rdoc",
     "lib/active_record/connection_adapters/emulation/oracle_adapter.rb",
     "lib/active_record/connection_adapters/oracle_enhanced.rake",
     "lib/active_record/connection_adapters/oracle_enhanced_adapter.rb",

data/spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb

@@ -3,35 +3,101 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 describe "OracleEnhancedAdapter composite_primary_keys support" do
 
   before(:all) do
-    if defined?(ActiveRecord::ConnectionAdapters::OracleAdapter)
-      @old_oracle_adapter = ActiveRecord::ConnectionAdapters::OracleAdapter
-      ActiveRecord::ConnectionAdapters.send(:remove_const, :OracleAdapter)
+    if defined?(::ActiveRecord::ConnectionAdapters::OracleAdapter)
+      @old_oracle_adapter = ::ActiveRecord::ConnectionAdapters::OracleAdapter
+      ::ActiveRecord::ConnectionAdapters.send(:remove_const, :OracleAdapter)
     end
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    require 'composite_primary_keys'
-    class ::JobHistory < ActiveRecord::Base
-      set_table_name "job_history"
-      set_primary_keys :employee_id, :start_date
+    if $cpk_oracle_adapter
+      ::ActiveRecord::ConnectionAdapters::OracleAdapter = $cpk_oracle_adapter
+      $cpk_oracle_adapter = nil
     end
+    require 'composite_primary_keys'
   end
 
   after(:all) do
-    Object.send(:remove_const, 'CompositePrimaryKeys') if defined?(CompositePrimaryKeys)
-    Object.send(:remove_const, 'JobHistory') if defined?(JobHistory)
+    # Object.send(:remove_const, 'CompositePrimaryKeys') if defined?(CompositePrimaryKeys)
+    if defined?(::ActiveRecord::ConnectionAdapters::OracleAdapter)
+      $cpk_oracle_adapter = ::ActiveRecord::ConnectionAdapters::OracleAdapter
+      ::ActiveRecord::ConnectionAdapters.send(:remove_const, :OracleAdapter)
+    end
     if @old_oracle_adapter
-      ActiveRecord::ConnectionAdapters.send(:remove_const, :OracleAdapter)
-      ActiveRecord::ConnectionAdapters::OracleAdapter = @old_oracle_adapter
+      ::ActiveRecord::ConnectionAdapters::OracleAdapter = @old_oracle_adapter
+      @old_oracle_adapter = nil
     end
   end
 
-  it "should tell ActiveRecord that count distinct is not supported" do
-    ActiveRecord::Base.connection.supports_count_distinct?.should be_false
-  end
+  describe "do not use count distinct" do
+    before(:all) do
+      class ::JobHistory < ActiveRecord::Base
+        set_table_name "job_history"
+        set_primary_keys :employee_id, :start_date
+      end
+    end
+    
+    after(:all) do
+      Object.send(:remove_const, 'JobHistory') if defined?(JobHistory)      
+    end
+    
+    it "should tell ActiveRecord that count distinct is not supported" do
+      ActiveRecord::Base.connection.supports_count_distinct?.should be_false
+    end
   
-  it "should execute correct SQL COUNT DISTINCT statement on table with composite primary keys" do
-    lambda { JobHistory.count(:distinct => true) }.should_not raise_error
+    it "should execute correct SQL COUNT DISTINCT statement on table with composite primary keys" do
+      lambda { JobHistory.count(:distinct => true) }.should_not raise_error
+    end
   end
 
+  describe "table with LOB" do
+    before(:all) do
+      ActiveRecord::Schema.define do
+        suppress_messages do
+          create_table  :cpk_write_lobs_test, :primary_key => [:type_category, :date_value], :force => true do |t|
+            t.string  :type_category, :limit => 15, :null => false  
+            t.date    :date_value, :null => false
+            t.text    :results, :null => false
+            t.timestamps
+          end
+          create_table :non_cpk_write_lobs_test, :force => true do |t|
+            t.date    :date_value, :null => false
+            t.text    :results, :null => false
+            t.timestamps
+          end
+        end
+      end
+      class ::CpkWriteLobsTest < ActiveRecord::Base
+        set_table_name 'cpk_write_lobs_test'
+        set_primary_keys :type_category, :date_value
+      end
+      class ::NonCpkWriteLobsTest < ActiveRecord::Base
+        set_table_name 'non_cpk_write_lobs_test'
+      end
+    end
+    
+    after(:all) do
+      ActiveRecord::Schema.define do
+        suppress_messages do
+          drop_table :cpk_write_lobs_test
+          drop_table :non_cpk_write_lobs_test
+        end
+      end
+      Object.send(:remove_const, "CpkWriteLobsTest")
+      Object.send(:remove_const, "NonCpkWriteLobsTest")
+    end
+
+    it "should create new record in table with CPK and LOB" do
+      lambda {
+        CpkWriteLobsTest.create(:type_category => 'AAA', :date_value => Date.today, :results => 'DATA '*10)
+      }.should_not raise_error
+    end
+    
+    it "should create new record in table without CPK and with LOB" do
+      lambda {
+        NonCpkWriteLobsTest.create(:date_value => Date.today, :results => 'DATA '*10)
+      }.should_not raise_error
+    end
+  end
+  
   # Other testing was done based on composite_primary_keys tests
 
 end

data/spec/active_record/connection_adapters/oracle_enhanced_procedures_spec.rb

@@ -159,6 +159,26 @@ describe "OracleEnhancedAdapter custom methods for create, update and destroy" d
     @employee.update_time.should_not be_nil
   end
 
+  it "should rollback record when exception is raised in after_create callback" do
+    @employee = TestEmployee.new(
+      :first_name => "First",
+      :last_name => "Last",
+      :hire_date => @today
+    )
+    TestEmployee.class_eval { def after_create() raise "Make the transaction rollback" end }
+    begin
+      employees_count = TestEmployee.count
+      @employee.save
+      fail "Did not raise exception"
+    rescue => e
+      e.message.should == "Make the transaction rollback"
+      @employee.id.should == nil
+      TestEmployee.count.should == employees_count
+    ensure
+      TestEmployee.class_eval { remove_method :after_create }
+    end
+  end
+
   it "should update record" do
     @employee = TestEmployee.create(
       :first_name => "First",
@@ -173,6 +193,29 @@ describe "OracleEnhancedAdapter custom methods for create, update and destroy" d
     @employee.description.should == "Second Last"
   end
 
+  it "should rollback record when exception is raised in after_update callback" do
+    TestEmployee.class_eval { def after_update() raise "Make the transaction rollback" end }
+    begin
+      @employee = TestEmployee.create(
+        :first_name => "First",
+        :last_name => "Last",
+        :hire_date => @today,
+        :description => "description"
+      )
+      empl_id = @employee.id
+      @employee.reload
+      @employee.first_name = "Second"
+      @employee.save!
+      fail "Did not raise exception"
+    rescue => e
+      e.message.should == "Make the transaction rollback"
+      @employee.reload
+      @employee.first_name.should == "First"
+    ensure
+      TestEmployee.class_eval { remove_method :after_update }
+    end
+  end
+
   it "should not update record if nothing is changed and partial updates are enabled" do
     return pending("Not in this ActiveRecord version") unless TestEmployee.respond_to?(:partial_updates=)
     TestEmployee.partial_updates = true
@@ -214,6 +257,27 @@ describe "OracleEnhancedAdapter custom methods for create, update and destroy" d
     TestEmployee.find_by_employee_id(empl_id).should be_nil
   end
 
+  it "should rollback record when exception is raised in after_desotry callback" do
+    TestEmployee.class_eval { def after_destroy() raise "Make the transaction rollback" end }
+    @employee = TestEmployee.create(
+      :first_name => "First",
+      :last_name => "Last",
+      :hire_date => @today
+    )
+    @employee.reload
+    empl_id = @employee.id
+    begin
+      @employee.destroy
+      fail "Did not raise exception"
+    rescue => e
+      e.message.should == "Make the transaction rollback"
+      @employee.id.should == empl_id
+      TestEmployee.find_by_employee_id(empl_id).should_not be_nil
+    ensure
+      TestEmployee.class_eval { remove_method :after_destroy }
+    end
+  end
+
   it "should log create record" do
     log_to @buffer
     # reestablish plsql.connection as log_to might reset existing connection

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rsim-activerecord-oracle_enhanced-adapter
 version: !ruby/object:Gem::Version 
-  version: 1.2.0.2
+  version: 1.2.1
 platform: ruby
 authors: 
 - Raimonds Simanovskis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-07 00:00:00 -07:00
+date: 2009-06-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -33,12 +33,12 @@ extra_rdoc_files:
 - History.txt
 - License.txt
 - Manifest.txt
-- README.txt
+- README.rdoc
 files: 
 - History.txt
 - License.txt
 - Manifest.txt
-- README.txt
+- README.rdoc
 - lib/active_record/connection_adapters/emulation/oracle_adapter.rb
 - lib/active_record/connection_adapters/oracle_enhanced.rake
 - lib/active_record/connection_adapters/oracle_enhanced_adapter.rb