rsim-activerecord-oracle_enhanced-adapter 1.1.9.91 → 1.1.9.92

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -130,6 +130,8 @@ module ActiveRecord
       def self.value_to_boolean(value)
         if value == true || value == false
           value
+        elsif value.is_a?(String) && value.blank?
+          nil
         else
           %w(true t 1 y +).include?(value.to_s.downcase)
         end
@@ -326,8 +328,9 @@ module ActiveRecord
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by #columns.
       def select_rows(sql, name = nil)
-        result = select(sql, name)
-        result.map{ |v| v.values}
+        # last parameter indicates to return also column list
+        result, columns = select(sql, name, true)
+        result.map{ |v| columns.map{|c| v[c]} }
       end
 
       # QUOTING ==================================================
@@ -557,13 +560,16 @@ module ActiveRecord
       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, user_ind_columns c
-           WHERE i.table_name = '#{table_name.to_s.upcase}'
+            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 i.index_name NOT IN (SELECT uc.index_name FROM user_constraints uc WHERE uc.constraint_type = 'P')
-             AND i.owner = sys_context('userenv','session_user')
+             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
 
@@ -572,7 +578,7 @@ module ActiveRecord
 
         result.each do |row|
           if current_index != row['index_name']
-            indexes << IndexDefinition.new(table_name, row['index_name'], row['uniqueness'] == "UNIQUE", [])
+            indexes << IndexDefinition.new(table_name.downcase, row['index_name'], row['uniqueness'] == "UNIQUE", [])
             current_index = row['index_name']
           end
 
@@ -707,8 +713,8 @@ module ActiveRecord
       end
 
       def rename_table(name, new_name) #:nodoc:
-        execute "RENAME #{name} TO #{new_name}"
-        execute "RENAME #{name}_seq TO #{new_name}_seq" rescue nil
+        execute "RENAME #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
+        execute "RENAME #{quote_table_name("#{name}_seq")} TO #{quote_table_name("#{new_name}_seq")}" rescue nil
       end
 
       def drop_table(name, options = {}) #:nodoc:
@@ -721,22 +727,48 @@ module ActiveRecord
         execute "DROP INDEX #{index_name(table_name, options)}"
       end
 
+      def add_column(table_name, column_name, type, options = {})
+        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        options[:type] = type
+        add_column_options!(add_column_sql, options)
+        execute(add_column_sql)
+      end
+
       def change_column_default(table_name, column_name, default) #:nodoc:
-        execute "ALTER TABLE #{table_name} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
+        execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
+      end
+
+      def change_column_null(table_name, column_name, null, default = nil)
+        column = column_for(table_name, column_name)
+
+        unless null || default.nil?
+          execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+        end
+
+        change_column table_name, column_name, column.sql_type, :null => null
       end
 
       def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        change_column_sql = "ALTER TABLE #{table_name} MODIFY #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        column = column_for(table_name, column_name)
+
+        # remove :null option if its value is the same as current column definition
+        # otherwise Oracle will raise error
+        if options.has_key?(:null) && options[:null] == column.null
+          options[:null] = nil
+        end
+
+        change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        options[:type] = type
         add_column_options!(change_column_sql, options)
         execute(change_column_sql)
       end
 
       def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        execute "ALTER TABLE #{table_name} RENAME COLUMN #{quote_column_name(column_name)} to #{quote_column_name(new_column_name)}"
+        execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} to #{quote_column_name(new_column_name)}"
       end
 
       def remove_column(table_name, column_name) #:nodoc:
-        execute "ALTER TABLE #{table_name} DROP COLUMN #{quote_column_name(column_name)}"
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
       end
 
       # RSI: table and column comments
@@ -777,7 +809,7 @@ module ActiveRecord
         # RSI: changed select from all_constraints to user_constraints - much faster in large data dictionaries
         pks = select_values(<<-SQL, 'Primary Key')
           select cc.column_name
-            from user_constraints c, all_cons_columns cc
+            from user_constraints c, user_cons_columns cc
            where c.owner = '#{owner}'
              and c.table_name = '#{table_name}'
              and c.constraint_type = 'P'
@@ -834,11 +866,23 @@ module ActiveRecord
       end
 
       def add_column_options!(sql, options) #:nodoc:
+        type = options[:type] || ((column = options[:column]) && column.type)
+        type = type && type.to_sym
         # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
-        if options_include_default?(options) && (column = options[:column]) && column.type == :text
-          sql << " DEFAULT #{quote(options.delete(:default))}" 
+        if options_include_default?(options)
+          if type == :text
+            sql << " DEFAULT #{quote(options[:default])}"
+          else
+            # from abstract adapter
+            sql << " DEFAULT #{quote(options[:default], options[:column])}"
+          end
+        end
+        # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
+        if options[:null] == false
+          sql << " NOT NULL"
+        elsif options[:null] == true
+          sql << " NULL" unless type == :primary_key
         end
-        super
       end
 
       # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
@@ -879,9 +923,9 @@ module ActiveRecord
 
       private
 
-      def select(sql, name = nil)
+      def select(sql, name = nil, return_column_names = false)
         log(sql, name) do
-          @connection.select(sql, name)
+          @connection.select(sql, name, return_column_names)
         end
       end
 
@@ -889,6 +933,13 @@ module ActiveRecord
         @connection.oracle_downcase(column_name)
       end
 
+      def column_for(table_name, column_name)
+        unless column = columns(table_name).find { |c| c.name == column_name.to_s }
+          raise "No such column: #{table_name}.#{column_name}"
+        end
+        column
+      end
+
     end
   end
 end

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -8,12 +8,12 @@ module ActiveRecord #:nodoc:
         def field_changed?(attr, old, value)
           if column = column_for_attribute(attr)
             # RSI: added also :decimal type
-            if (column.type == :integer || column.type == :decimal) && column.null && (old.nil? || old == 0)
+            if (column.type == :integer || column.type == :decimal) && column.null && (old.nil? || old == 0) && value.blank?
               # For nullable integer columns, NULL gets stored in database for blank (i.e. '') values.
               # Hence we don't record it as a change if the value changes from nil to ''.
               # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
               # be typecast back to 0 (''.to_i => 0)
-              value = nil if value.blank?
+              value = nil
             # RSI: Oracle stores empty string '' or empty text (CLOB) as NULL
             # therefore need to convert empty string value to nil if old value is nil
             elsif (column.type == :string || column.type == :text) && column.null && old.nil?

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -157,19 +157,24 @@ module ActiveRecord
 
       def exec_no_retry(sql)
         cs = prepare_call(sql)
-        cs.execute
-        true
+        case sql
+        when /\A\s*UPDATE/i, /\A\s*INSERT/i, /\A\s*DELETE/i
+          cs.executeUpdate
+        else
+          cs.execute
+          true
+        end
       ensure
         cs.close rescue nil        
       end
 
-      def select(sql, name = nil)
+      def select(sql, name = nil, return_column_names = false)
         with_retry do
-          select_no_retry(sql, name)
+          select_no_retry(sql, name, return_column_names)
         end        
       end
 
-      def select_no_retry(sql, name = nil)
+      def select_no_retry(sql, name = nil, return_column_names = false)
         stmt = prepare_statement(sql)
         rset = stmt.executeQuery
         metadata = rset.getMetaData
@@ -222,7 +227,7 @@ module ActiveRecord
           rows << hash
         end
 
-        rows
+        return_column_names ? [rows, cols] : rows
       ensure
         rset.close rescue nil
         stmt.close rescue nil
@@ -237,8 +242,8 @@ module ActiveRecord
       end
 
       def describe(name)
-        real_name = OracleEnhancedAdapter.valid_table_name?(name) ? name.upcase : name
-        if name.include?('.')
+        real_name = OracleEnhancedAdapter.valid_table_name?(name) ? name.to_s.upcase : name.to_s
+        if real_name.include?('.')
           table_owner, table_name = real_name.split('.')
         else
           table_owner, table_name = @owner, real_name
@@ -262,7 +267,7 @@ module ActiveRecord
           SELECT table_owner, table_name, 'SYNONYM' name_type
           FROM all_synonyms
           WHERE owner = 'PUBLIC'
-            AND synonym_name = '#{name.upcase}'
+            AND synonym_name = '#{real_name}'
         SQL
         if result = select_one(sql)
           case result['name_type']
@@ -289,7 +294,7 @@ module ActiveRecord
 
       def get_ruby_value_from_result_set(rset, i, type_name)
         case type_name
-        when "CHAR", "VARCHAR2"
+        when "CHAR", "VARCHAR2", "LONG"
           rset.getString(i)
         when "CLOB"
           ora_value_to_ruby_value(rset.getClob(i))
@@ -300,13 +305,23 @@ module ActiveRecord
           if d.nil?
             nil
           elsif d.scale == 0
-            d.longValue
+            d.toBigInteger+0
+          else
+            # Is there better way how to convert Java BigDecimal to Ruby BigDecimal?
+            d.toString.to_d
+          end
+        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)
           else
-            d.doubleValue
+            nil
           end
-        when "DATE", /^TIMESTAMP/
+        when /^TIMESTAMP/
           ts = rset.getTimestamp(i)
-          ts && Time.at(ts.getTime/1000)
+          ts && Time.send(Base.default_timezone, ts.year + 1900, ts.month + 1, ts.date, ts.hours, ts.minutes, ts.seconds,
+            ts.nanos / 1000)
         else
           nil
         end
@@ -314,8 +329,6 @@ module ActiveRecord
       
       def ora_value_to_ruby_value(val)
         case val
-        when Float, BigDecimal
-          ora_number_to_ruby_number(val)
         when ::Java::OracleSql::CLOB
           if val.isEmptyLob
             nil
@@ -333,13 +346,33 @@ module ActiveRecord
         end
       end
 
-      def ora_number_to_ruby_number(num)
-        num.to_i == num.to_f ? num.to_i : num.to_f
-      end
-      
-
     end
     
   end
 end
 
+# add BigDecimal#to_d, Fixnum#to_d and Bignum#to_d methods if not already present
+require "bigdecimal"
+unless BigDecimal.instance_methods.include?("to_d")
+  BigDecimal.class_eval do
+    def to_d
+      self
+    end
+  end
+end
+
+unless Bignum.instance_methods.include?("to_d")
+  Bignum.class_eval do
+    def to_d
+      BigDecimal.new(self.to_s)
+    end
+  end
+end
+
+unless Fixnum.instance_methods.include?("to_d")
+  Fixnum.class_eval do
+    def to_d
+      BigDecimal.new(self.to_s)
+    end
+  end
+end

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -82,7 +82,7 @@ module ActiveRecord
         @raw_connection.exec(sql, *bindvars, &block)
       end
 
-      def select(sql, name = nil)
+      def select(sql, name = nil, return_column_names = false)
         cursor = @raw_connection.exec(sql)
         cols = cursor.get_col_names.map { |x| oracle_downcase(x) }
         rows = []
@@ -104,14 +104,12 @@ module ActiveRecord
                 if OracleEnhancedAdapter.emulate_dates && (d.hour == 0 && d.minute == 0 && d.second == 0)
                   d.to_date
                 else
-                  # see string_to_time; Time overflowing to DateTime, respecting the default timezone
-                  time_array = [d.year, d.month, d.day, d.hour, d.minute, d.second]
+                  # code from Time.time_with_datetime_fallback
                   begin
-                    Time.send(Base.default_timezone, *time_array)
+                    Time.send(Base.default_timezone, d.year, d.month, d.day, d.hour, d.minute, d.second)
                   rescue
-                    zone_offset = if Base.default_timezone == :local then DateTime.now.offset else 0 end
-                    # Append zero calendar reform start to account for dates skipped by calendar reform
-                    DateTime.new(*time_array[0..5] << zone_offset << 0) rescue nil
+                    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)
                   end
                 end
               # RSI: added emulate_integers_by_column_name functionality
@@ -129,7 +127,7 @@ module ActiveRecord
           rows << hash
         end
 
-        rows
+        return_column_names ? [rows, cols] : rows
       ensure
         cursor.close if cursor
       end

data/oracle-enhanced.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{activerecord-oracle_enhanced-adapter}
-  s.version = "1.1.9.91"
+  s.version = "1.1.9.92"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Raimonds Simanovskis"]

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -127,6 +127,11 @@ describe "OracleEnhancedAdapter database session store" do
       CREATE SEQUENCE sessions_seq  MINVALUE 1 MAXVALUE 999999999999999999999999999
         INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
     SQL
+    if ENV['RAILS_GEM_VERSION'] >= '2.3'
+      SESSION_CLASS = ActiveRecord::SessionStore::Session
+    else
+      SESSION_CLASS = CGI::Session::ActiveRecordStore::Session
+    end
   end
 
   after(:all) do
@@ -139,29 +144,29 @@ describe "OracleEnhancedAdapter database session store" do
   end
 
   it "should save session data" do
-    @session = CGI::Session::ActiveRecordStore::Session.new :session_id => "111111", :data  => "something" #, :updated_at => Time.now
+    @session = SESSION_CLASS.new :session_id => "111111", :data  => "something" #, :updated_at => Time.now
     @session.save!
-    @session = CGI::Session::ActiveRecordStore::Session.find_by_session_id("111111")
+    @session = SESSION_CLASS.find_by_session_id("111111")
     @session.data.should == "something"
   end
 
   it "should change session data when partial updates enabled" do
-    return pending("Not in this ActiveRecord version") unless CGI::Session::ActiveRecordStore::Session.respond_to?(:partial_updates=)
-    CGI::Session::ActiveRecordStore::Session.partial_updates = true
-    @session = CGI::Session::ActiveRecordStore::Session.new :session_id => "222222", :data  => "something" #, :updated_at => Time.now
+    return pending("Not in this ActiveRecord version") unless SESSION_CLASS.respond_to?(:partial_updates=)
+    SESSION_CLASS.partial_updates = true
+    @session = SESSION_CLASS.new :session_id => "222222", :data  => "something" #, :updated_at => Time.now
     @session.save!
-    @session = CGI::Session::ActiveRecordStore::Session.find_by_session_id("222222")
+    @session = SESSION_CLASS.find_by_session_id("222222")
     @session.data = "other thing"
     @session.save!
     # second save should call again blob writing callback
     @session.save!
-    @session = CGI::Session::ActiveRecordStore::Session.find_by_session_id("222222")
+    @session = SESSION_CLASS.find_by_session_id("222222")
     @session.data.should == "other thing"
   end
 
   it "should have one enhanced_write_lobs callback" do
-    return pending("Not in this ActiveRecord version") unless CGI::Session::ActiveRecordStore::Session.respond_to?(:after_save_callback_chain)
-    CGI::Session::ActiveRecordStore::Session.after_save_callback_chain.select{|cb| cb.method == :enhanced_write_lobs}.should have(1).record
+    return pending("Not in this ActiveRecord version") unless SESSION_CLASS.respond_to?(:after_save_callback_chain)
+    SESSION_CLASS.after_save_callback_chain.select{|cb| cb.method == :enhanced_write_lobs}.should have(1).record
   end
 
   it "should not set sessions table session_id column type as integer if emulate_integers_by_column_name is true" do

data/spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb

@@ -60,6 +60,10 @@ describe "OracleEnhancedConnection SQL execution" do
     @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
   end
 
+  it "should execute SQL select and return also columns" do
+    @conn.select("SELECT * FROM dual", nil, true).should == [ [{'dummy' => 'X'}], ['dummy'] ]
+  end
+
 end
 
 describe "OracleEnhancedConnection auto reconnection" do

data/spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb

@@ -284,9 +284,9 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
         department_id NUMBER(4,0),
         created_at    DATE,
         has_email     CHAR(1),
-        has_phone     VARCHAR2(1),
+        has_phone     VARCHAR2(1) DEFAULT 'Y',
         active_flag   VARCHAR2(2),
-        manager_yn    VARCHAR2(3),
+        manager_yn    VARCHAR2(3) DEFAULT 'N',
         test_boolean  VARCHAR2(3)
       )
     SQL
@@ -358,6 +358,13 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
     ActiveRecord::Base.connection.type_to_sql(
       :boolean, nil, nil, nil).should == "NUMBER(1)"
   end
+
+  it "should get default value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+    columns = @conn.columns('test3_employees')
+    columns.detect{|c| c.name == 'has_phone'}.default.should be_true
+    columns.detect{|c| c.name == 'manager_yn'}.default.should be_false
+  end
   
   describe "/ VARCHAR2 boolean values from ActiveRecord model" do
     before(:each) do
@@ -422,6 +429,12 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
       create_employee3(:test_boolean => false)
       @employee3.test_boolean.class.should == FalseClass
       @employee3.test_boolean_before_type_cast.should == "N"
+      create_employee3(:test_boolean => nil)
+      @employee3.test_boolean.class.should == NilClass
+      @employee3.test_boolean_before_type_cast.should == nil
+      create_employee3(:test_boolean => "")
+      @employee3.test_boolean.class.should == NilClass
+      @employee3.test_boolean_before_type_cast.should == nil
     end
   
   end
@@ -493,18 +506,35 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
       end
     end
 
-    it "should return Time value without fractional seconds from TIMESTAMP columns" do
-      # currently fractional seconds are not retrieved from database
-      @now = Time.local(2008,5,26,23,11,11,10)
-      @employee = TestEmployee.create(
-        :created_at => @now,
-        :created_at_tz => @now,
-        :created_at_ltz => @now
-      )
-      @employee.reload
-      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
-        @employee.send(c).class.should == Time
-        @employee.send(c).to_f.should == @now.to_f.to_i.to_f # remove fractional seconds
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      it "should return Time value with fractional seconds from TIMESTAMP columns" do
+        # currently fractional seconds are not retrieved from database
+        @now = Time.local(2008,5,26,23,11,11,10)
+        @employee = TestEmployee.create(
+          :created_at => @now,
+          :created_at_tz => @now,
+          :created_at_ltz => @now
+        )
+        @employee.reload
+        [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+          @employee.send(c).class.should == Time
+          @employee.send(c).to_f.should == @now.to_f
+        end
+      end
+    else
+      it "should return Time value without fractional seconds from TIMESTAMP columns" do
+        # currently fractional seconds are not retrieved from database
+        @now = Time.local(2008,5,26,23,11,11,10)
+        @employee = TestEmployee.create(
+          :created_at => @now,
+          :created_at_tz => @now,
+          :created_at_ltz => @now
+        )
+        @employee.reload
+        [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+          @employee.send(c).class.should == Time
+          @employee.send(c).to_f.should == @now.to_f.to_i.to_f # remove fractional seconds
+        end
       end
     end
 

data/spec/active_record/connection_adapters/oracle_enhanced_dirty_spec.rb

@@ -12,7 +12,7 @@ if ActiveRecord::Base.instance_methods.include?('changed?')
           id            NUMBER,
           first_name    VARCHAR2(20),
           last_name     VARCHAR2(25),
-          job_id        NUMBER(6,0),
+          job_id        NUMBER(6,0) NULL,
           salary        NUMBER(8,2),
           comments      CLOB,
           hire_date     DATE
@@ -77,6 +77,17 @@ if ActiveRecord::Base.instance_methods.include?('changed?')
       @employee.should_not be_changed
     end
 
+    it "should not mark integer as changed when reassigning it" do
+      @employee = TestEmployee.new
+      @employee.job_id = 0
+      @employee.save!.should be_true
+      
+      @employee.should_not be_changed
+
+      @employee.job_id = '0'
+      @employee.should_not be_changed
+    end
+
   end
 
 end

data/spec/active_record/connection_adapters/oracle_enhanced_emulate_oracle_adapter_spec.rb

@@ -6,6 +6,7 @@ describe "OracleEnhancedAdapter emulate OracleAdapter" do
 
   before(:all) do
     if defined?(ActiveRecord::ConnectionAdapters::OracleAdapter)
+      @old_oracle_adapter = ActiveRecord::ConnectionAdapters::OracleAdapter
       ActiveRecord::ConnectionAdapters.send(:remove_const, :OracleAdapter)
     end
   end
@@ -17,9 +18,10 @@ describe "OracleEnhancedAdapter emulate OracleAdapter" do
   end
 
   after(:all) do
-    if defined?(ActiveRecord::ConnectionAdapters::OracleAdapter)
+    if @old_oracle_adapter
       ActiveRecord::ConnectionAdapters.send(:remove_const, :OracleAdapter)
-    end    
+      ActiveRecord::ConnectionAdapters::OracleAdapter = @old_oracle_adapter
+    end
   end
 
 end

data/spec/spec_helper.rb

@@ -14,16 +14,27 @@ elsif ENV['RAILS_GEM_VERSION'] =~ /^2.1/
   gem 'actionpack', '=2.1.2'
   gem 'activesupport', '=2.1.2'
   gem 'composite_primary_keys', '=1.0.8'
-else
+elsif ENV['RAILS_GEM_VERSION'] =~ /^2.2/
   gem 'activerecord', '=2.2.2'
   gem 'actionpack', '=2.2.2'
   gem 'activesupport', '=2.2.2'
-  gem 'composite_primary_keys', '=2.2.0'
+  gem 'composite_primary_keys', '=2.2.2'
+else
+  ENV['RAILS_GEM_VERSION'] ||= '2.3.2'
+  gem 'activerecord', '=2.3.2'
+  gem 'actionpack', '=2.3.2'
+  gem 'activesupport', '=2.3.2'
+  gem 'composite_primary_keys', '=2.2.2'
 end
 
 require 'activerecord'
 require 'actionpack'
-require 'action_controller/session/active_record_store'
+if ENV['RAILS_GEM_VERSION'] >= '2.3'
+  require 'action_controller/session/abstract_store'
+  require 'active_record/session_store'
+else
+  require 'action_controller/session/active_record_store'
+end
 if !defined?(RUBY_ENGINE)
   gem "activerecord-oracle-adapter"
   require 'active_record/connection_adapters/oracle_adapter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rsim-activerecord-oracle_enhanced-adapter
 version: !ruby/object:Gem::Version 
-  version: 1.1.9.91
+  version: 1.1.9.92
 platform: ruby
 authors: 
 - Raimonds Simanovskis