activerecord-oracle_enhanced-adapter 1.2.0 → 1.2.1

data/History.txt

@@ -1,3 +1,14 @@
+== 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
 
 * Enhancements

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_adapter.rb

@@ -137,9 +137,9 @@ module ActiveRecord
         end
       end
 
-      # RSI: convert Time value to Date for :date columns
+      # RSI: convert Time or DateTime value to Date for :date columns
       def self.string_to_date(string)
-        return string.to_date if string.is_a?(Time)
+        return string.to_date if string.is_a?(Time) || string.is_a?(DateTime)
         super
       end
 
@@ -346,8 +346,11 @@ module ActiveRecord
       # unescaped table name should start with letter and
       # contain letters, digits, _, $ or #
       # can be prefixed with schema name
+      # CamelCase table names should be quoted
       def self.valid_table_name?(name)
-        name.to_s =~ /^([A-Z_0-9]+\.)?[A-Z][A-Z_0-9\$#]*$/i ? true : false
+        name = name.to_s
+        name =~ /^([A-Za-z_0-9]+\.)?[a-z][a-z_0-9\$#]*$/ ||
+        name =~ /^([A-Za-z_0-9]+\.)?[A-Z][A-Z_0-9\$#]*$/ ? true : false
       end
 
       # abstract_adapter calls quote_column_name from quote_table_name, so prevent that
@@ -515,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
@@ -556,36 +570,45 @@ module ActiveRecord
 
       # RSI: changed select from user_tables to all_tables - much faster in large data dictionaries
       def tables(name = nil) #:nodoc:
-        select_all("select lower(table_name) name from all_tables where owner = sys_context('userenv','session_user')").map {|t| t['name']}
+        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
@@ -723,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
 
@@ -822,12 +853,12 @@ module ActiveRecord
       end
 
       def structure_dump #:nodoc:
-        s = select_all("select sequence_name from user_sequences").inject("") do |structure, seq|
+        s = select_all("select sequence_name from user_sequences order by 1").inject("") do |structure, seq|
           structure << "create sequence #{seq.to_a.first.last};\n\n"
         end
 
         # RSI: changed select from user_tables to all_tables - much faster in large data dictionaries
-        select_all("select table_name from all_tables where owner = sys_context('userenv','session_user')").inject(s) do |structure, table|
+        select_all("select table_name from all_tables where owner = sys_context('userenv','session_user') order by 1").inject(s) do |structure, table|
           ddl = "create table #{table.to_a.first.last} (\n "
           cols = select_all(%Q{
             select column_name, data_type, data_length, char_used, char_length, data_precision, data_scale, data_default, nullable
@@ -855,12 +886,12 @@ module ActiveRecord
       end
 
       def structure_drop #:nodoc:
-        s = select_all("select sequence_name from user_sequences").inject("") do |drop, seq|
+        s = select_all("select sequence_name from user_sequences order by 1").inject("") do |drop, seq|
           drop << "drop sequence #{seq.to_a.first.last};\n\n"
         end
 
         # RSI: changed select from user_tables to all_tables - much faster in large data dictionaries
-        select_all("select table_name from all_tables where owner = sys_context('userenv','session_user')").inject(s) do |drop, table|
+        select_all("select table_name from all_tables where owner = sys_context('userenv','session_user') order by 1").inject(s) do |drop, table|
           drop << "drop table #{table.to_a.first.last} cascade constraints;\n\n"
         end
       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,11 +1,7 @@
 module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
     module OracleEnhancedVersion #:nodoc:
-      MAJOR = 1
-      MINOR = 2
-      TINY  = 0
-
-      STRING = [MAJOR, MINOR, TINY].join('.')
+      VERSION = '1.2.1'
     end
   end
 end

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -47,6 +47,17 @@ describe "OracleEnhancedAdapter schema dump" do
     @new_conn = ActiveRecord::Base.oracle_enhanced_connection(CONNECTION_PARAMS)
     @new_conn.class.should == ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
   end
+  
+  after(:all) do
+    # Workaround for undefining callback that was defined by JDBC adapter
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      ActiveRecord::Base.class_eval do
+        def after_save_with_oracle_lob
+          nil
+        end
+      end
+    end
+  end
 
   unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION =~ /^1\.9/
     it "should return the same tables list as original oracle adapter" do
@@ -66,11 +77,11 @@ describe "OracleEnhancedAdapter schema dump" do
     end
 
     it "should return the same structure dump as original oracle adapter" do
-      @new_conn.structure_dump.should == @old_conn.structure_dump
+      @new_conn.structure_dump.split(";\n\n").sort.should == @old_conn.structure_dump.split(";\n\n").sort
     end
 
     it "should return the same structure drop as original oracle adapter" do
-      @new_conn.structure_drop.should == @old_conn.structure_drop
+      @new_conn.structure_drop.split(";\n\n").sort.should == @old_conn.structure_drop.split(";\n\n").sort
     end
   end
 
@@ -530,14 +541,26 @@ describe "OracleEnhancedAdapter table quoting" do
     end
   end
 
+  def create_camel_case_table
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        create_table "CamelCase" do |t|
+          t.string      :name
+          t.integer     :foo
+        end
+      end
+    end
+  end
+
   after(:each) do
     ActiveRecord::Schema.define do
       suppress_messages do
-        drop_table "warehouse-things"
+        drop_table "warehouse-things" rescue nil
+        drop_table "CamelCase" rescue nil
       end
     end
-    Object.send(:remove_const, "WarehouseThing")
-    ActiveRecord::Base.table_name_prefix = nil
+    Object.send(:remove_const, "WarehouseThing") rescue nil
+    Object.send(:remove_const, "CamelCase") rescue nil
   end
 
   it "should allow creation of a table with non alphanumeric characters" do
@@ -548,6 +571,20 @@ describe "OracleEnhancedAdapter table quoting" do
 
     wh = WarehouseThing.create!(:name => "Foo", :foo => 2)
     wh.id.should_not be_nil
+
+    @conn.tables.should include("warehouse-things")
+  end
+
+  it "should allow creation of a table with CamelCase name" do
+    create_camel_case_table
+    class ::CamelCase < ActiveRecord::Base
+      set_table_name "CamelCase"
+    end
+
+    cc = CamelCase.create!(:name => "Foo", :foo => 2)
+    cc.id.should_not be_nil
+    
+    @conn.tables.should include("CamelCase")
   end
 
 end

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_data_types_spec.rb

@@ -74,6 +74,13 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
     column.type_cast(Time.now).class.should == Date
   end
 
+  it "should typecast DateTime value to Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+    columns = @conn.columns('test_employees')
+    column = columns.detect{|c| c.name == "hire_date"}
+    column.type_cast(DateTime.new(1900,1,1)).class.should == Date
+  end
+
   describe "/ DATE values from ActiveRecord model" do
     before(:each) do
       ActiveRecord::Base.connection.clear_types_for_columns
@@ -85,9 +92,9 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
       end
     end
     
-    def create_test_employee
-      @today = Date.new(2008,8,19)
-      @now = Time.local(2008,8,19,17,03,59)
+    def create_test_employee(params={})
+      @today = params[:today] || Date.new(2008,8,19)
+      @now = params[:now] || Time.local(2008,8,19,17,03,59)
       @employee = TestEmployee.create(
         :first_name => "First",
         :last_name => "Last",
@@ -114,6 +121,12 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
       @employee.hire_date.class.should == Date
     end
 
+    it "should return Date value from DATE column with old date value if column name contains 'date' and emulate_dates_by_column_name is true" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+      create_test_employee(:today => Date.new(1900,1,1))
+      @employee.hire_date.class.should == Date
+    end
+
     it "should return Time value from DATE column if column name does not contain 'date' and emulate_dates_by_column_name is true" do
       ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
       create_test_employee
@@ -129,6 +142,15 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
       @employee.hire_date.class.should == Date
     end
 
+    it "should return Date value from DATE column with old date value if emulate_dates_by_column_name is false but column is defined as date" do
+      class ::TestEmployee < ActiveRecord::Base
+        set_date_columns :hire_date
+      end
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
+      create_test_employee(:today => Date.new(1900,1,1))
+      @employee.hire_date.class.should == Date
+    end
+
     it "should return Time value from DATE column if emulate_dates_by_column_name is true but column is defined as datetime" do
       class ::TestEmployee < ActiveRecord::Base
         set_datetime_columns :hire_date

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

data/spec/spec_helper.rb

@@ -58,28 +58,35 @@ module LoggerSpecHelper
   end
 end
 
+DATABASE_NAME = ENV['DATABASE_NAME'] || 'orcl'
+DATABASE_HOST = ENV['DATABASE_HOST'] || 'localhost'
+DATABASE_PORT = ENV['DATABASE_PORT'] || 1521
+DATABASE_USER = ENV['DATABASE_USER'] || 'hr'
+DATABASE_PASSWORD = ENV['DATABASE_PASSWORD'] || 'hr'
+DATABASE_SYS_PASSWORD = ENV['DATABASE_SYS_PASSWORD'] || 'admin'
+
 CONNECTION_PARAMS = {
   :adapter => "oracle_enhanced",
-  :database => "xe",
-  :host => "ubuntu810",
-  :username => "hr",
-  :password => "hr"
+  :database => DATABASE_NAME,
+  :host => DATABASE_HOST,
+  :username => DATABASE_USER,
+  :password => DATABASE_PASSWORD
 }
 
 JDBC_CONNECTION_PARAMS = {
   :adapter => "jdbc",
   :driver => "oracle.jdbc.driver.OracleDriver",
-  :url => "jdbc:oracle:thin:@ubuntu810:1521:XE",
-  :username => "hr",
-  :password => "hr"
+  :url => "jdbc:oracle:thin:@#{DATABASE_HOST}:#{DATABASE_PORT}:#{DATABASE_NAME}",
+  :username => DATABASE_USER,
+  :password => DATABASE_PASSWORD
 }
 
 SYS_CONNECTION_PARAMS = {
   :adapter => "oracle_enhanced",
-  :database => "xe",
-  :host => "ubuntu810",
+  :database => DATABASE_NAME,
+  :host => DATABASE_HOST,
   :username => "sys",
-  :password => "manager",
+  :password => DATABASE_SYS_PASSWORD,
   :privilege => "SYSDBA"
 }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-oracle_enhanced-adapter
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors: 
 - Raimonds Simanovskis
@@ -9,9 +9,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-22 00:00:00 +02:00
+date: 2009-06-08 00:00:00 +03:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
   type: :development
@@ -20,11 +40,21 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.2
+        version: 1.8.0
     version: 
-description: Oracle enhaced adapter for Active Record
+description: |-
+  Oracle "enhanced" ActiveRecord adapter contains useful additional methods for working with new and legacy Oracle databases
+  from Rails which are extracted from current real projects' monkey patches of original Oracle adapter.
+  
+  See http://github.com/rsim/oracle-enhanced/wikis for more information.
+  
+  For questions and feature discussion please use http://groups.google.com/group/oracle-enhanced
+  
+  Blog posts about oracle-enahnced can be found at http://blog.rayapps.com/category/oracle-enhanced
+  
+  Bugs and enhancement requests can be reported at http://rsim.lighthouseapp.com/projects/11468-oracle-enhanced
 email: 
-- raymonds72@gmail.com
+- raimonds.simanovskis@gmail.com
 executables: []
 
 extensions: []
@@ -32,11 +62,11 @@ extensions: []
 extra_rdoc_files: 
 - History.txt
 - License.txt
-- README.txt
+- README.rdoc
 files: 
 - 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
@@ -61,11 +91,13 @@ files:
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
-homepage: http://oracle-enhanced.rubyforge.org
-post_install_message: ""
+homepage: http://rubyforge.org/projects/oracle-enhanced/
+licenses: []
+
+post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -83,9 +115,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: oracle-enhanced
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Oracle enhaced adapter for Active Record
 test_files: []