activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/lib/arjdbc/mysql/connection_methods.rb

@@ -1,22 +1,22 @@
-# Don't need to load native mysql adapter
-$LOADED_FEATURES << "active_record/connection_adapters/mysql_adapter.rb"
-$LOADED_FEATURES << "active_record/connection_adapters/mysql2_adapter.rb"
-
 class ActiveRecord::Base
   class << self
     def mysql_connection(config)
-      require 'active_record/connection_adapters/jdbcmysql_adapter'
+      begin
+        require 'jdbc/mysql'
+        ::Jdbc::MySQL.load_driver(:require) if defined?(::Jdbc::MySQL.load_driver)
+      rescue LoadError # assuming driver.jar is on the class-path
+      end
 
       config[:port] ||= 3306
+      config[:url] ||= "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      config[:driver] ||= defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
+      config[:adapter_class] = ActiveRecord::ConnectionAdapters::MysqlAdapter
+      config[:adapter_spec] = ::ArJdbc::MySQL
       options = (config[:options] ||= {})
       options['zeroDateTimeBehavior'] ||= 'convertToNull'
       options['jdbcCompliantTruncation'] ||= 'false'
       options['useUnicode'] ||= 'true'
       options['characterEncoding'] = config[:encoding] || 'utf8'
-      config[:url] ||= "jdbc:mysql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
-      config[:driver] ||= defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
-      config[:adapter_class] = ActiveRecord::ConnectionAdapters::MysqlAdapter
-      config[:adapter_spec] = ::ArJdbc::MySQL
       connection = jdbc_connection(config)
       ::ArJdbc::MySQL.kill_cancel_timer(connection.raw_connection)
       connection

data/lib/arjdbc/mysql/explain_support.rb

@@ -0,0 +1,85 @@
+module ::ArJdbc
+  module MySQL
+    module ExplainSupport
+      def supports_explain?
+        true
+      end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN #{to_sql(arel, binds)}"
+        start = Time.now.to_f
+        raw_result = execute(sql, "EXPLAIN", binds)
+        elapsed = Time.now.to_f - start
+        # TODO we should refactor to exce_query once it returns Result ASAP :
+        keys = raw_result[0] ? raw_result[0].keys : {}
+        rows = raw_result.map { |hash| hash.values }
+        ExplainPrettyPrinter.new.pp ActiveRecord::Result.new(keys, rows), elapsed
+      end
+
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+        # MySQL shell:
+        #
+        # +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        # | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+        # +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        # | 1 | SIMPLE | users | const | PRIMARY | PRIMARY | 4 | const | 1 | |
+        # | 1 | SIMPLE | posts | ALL | NULL | NULL | NULL | NULL | 1 | Using where |
+        # +----+-------------+-------+-------+---------------+---------+---------+-------+------+-------------+
+        # 2 rows in set (0.00 sec)
+        #
+        # This is an exercise in Ruby hyperrealism :).
+        def pp(result, elapsed)
+          widths = compute_column_widths(result)
+          separator = build_separator(widths)
+
+          pp = []
+
+          pp << separator
+          pp << build_cells(result.columns, widths)
+          pp << separator
+
+          result.rows.each do |row|
+            pp << build_cells(row, widths)
+          end
+
+          pp << separator
+          pp << build_footer(result.rows.length, elapsed)
+
+          pp.join("\n") + "\n"
+        end
+
+        private
+
+        def compute_column_widths(result)
+          [].tap do |widths|
+            result.columns.each_with_index do |column, i|
+              cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? 'NULL' : r[i].to_s}
+              widths << cells_in_column.map(&:length).max
+            end
+          end
+        end
+
+        def build_separator(widths)
+          padding = 1
+          '+' + widths.map {|w| '-' * (w + (padding*2))}.join('+') + '+'
+        end
+
+        def build_cells(items, widths)
+          cells = []
+          items.each_with_index do |item, i|
+            item = 'NULL' if item.nil?
+            justifier = item.is_a?(Numeric) ? 'rjust' : 'ljust'
+            cells << item.to_s.send(justifier, widths[i])
+          end
+          '| ' + cells.join(' | ') + ' |'
+        end
+
+        def build_footer(nrows, elapsed)
+          rows_label = nrows == 1 ? 'row' : 'rows'
+          "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/oracle.rb

@@ -1,3 +1,3 @@
 require 'arjdbc/jdbc'
-require 'arjdbc/oracle/connection_methods'
 require 'arjdbc/oracle/adapter'
+require 'arjdbc/oracle/connection_methods'

data/lib/arjdbc/oracle/adapter.rb

@@ -1,57 +1,58 @@
-module ActiveRecord::ConnectionAdapters
-  OracleAdapter = Class.new(AbstractAdapter) unless const_defined?(:OracleAdapter)
-end
+require 'arjdbc/jdbc/serialized_attributes_helper'
 
-module ::ArJdbc
+module ArJdbc
   module Oracle
+    
+    @@_lob_callback_added = nil
+    
     def self.extended(mod)
-      unless defined?(@lob_callback_added)
+      unless @@_lob_callback_added
         ActiveRecord::Base.class_eval do
           def after_save_with_oracle_lob
-            self.class.columns.select { |c| c.sql_type =~ /LOB\(|LOB$/i }.each do |c|
-              value = self[c.name]
-              if respond_to?(:unserializable_attribute?)
-                value = value.to_yaml if unserializable_attribute?(c.name, c)
-              else
-                value = value.to_yaml if value.is_a?(Hash)
-              end
-              next if value.nil?  || (value == '')
-
-              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+            self.class.columns.select { |c| c.sql_type =~ /LOB\(|LOB$/i }.each do |column|
+              value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
+              next if value.nil? || (value == '')
+
+              connection.write_large_object(
+                column.type == :binary, column.name, 
+                self.class.table_name, self.class.primary_key, 
+                quote_value(id), value
+              )
             end
           end
         end
 
         ActiveRecord::Base.after_save :after_save_with_oracle_lob
-        @lob_callback_added = true
+        
+        @@_lob_callback_added = true
       end
 
-      unless ActiveRecord::ConnectionAdapters::AbstractAdapter.instance_methods(false).detect {|m| m.to_s == "prefetch_primary_key?"}
+      unless ActiveRecord::ConnectionAdapters::AbstractAdapter.
+          instance_methods(false).detect { |m| m.to_s == "prefetch_primary_key?" }
         require 'arjdbc/jdbc/quoted_primary_key'
         ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
       end
-
+      
       (class << mod; self; end).class_eval do
         alias_chained_method :insert, :query_dirty, :ora_insert
         alias_chained_method :columns, :query_cache, :ora_columns
-        
-        # Prevent ORA-01795 for in clauses with more than 1000 
-        def in_clause_length
-          1000
-        end
       end
     end
-    
 
     def self.column_selector
-      [/oracle/i, lambda {|cfg,col| col.extend(::ArJdbc::Oracle::Column)}]
+      [ /oracle/i, lambda { |cfg, column| column.extend(::ArJdbc::Oracle::Column) } ]
     end
 
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::OracleJdbcConnection
     end
 
+    def jdbc_column_class
+      ::ActiveRecord::ConnectionAdapters::OracleColumn
+    end
+
     module Column
+      
       def primary=(val)
         super
         if val && @sql_type =~ /^NUMBER$/i
@@ -59,42 +60,52 @@ module ::ArJdbc
         end
       end
 
+      def extract_limit(sql_type)
+        case sql_type
+        when /^(clob|date)/i; nil
+        else super
+        end
+      end
+      
       def type_cast(value)
         return nil if value.nil?
         case type
-        when :datetime then ArJdbc::Oracle::Column.string_to_time(value, self.class)
+        when :datetime  then ArJdbc::Oracle::Column.string_to_time(value)
+        when :timestamp then ArJdbc::Oracle::Column.string_to_time(value)
         else
           super
         end
       end
 
-      def extract_limit(sql_type)
-        case sql_type
-        when /^(clob|date)/i; nil
-        else super
-        end
-      end
-
       def type_cast_code(var_name)
         case type
-        when :datetime  then "ArJdbc::Oracle::Column.string_to_time(#{var_name}, self.class)"
+        when :datetime  then "ArJdbc::Oracle::Column.string_to_time(#{var_name})"
+        when :timestamp then "ArJdbc::Oracle::Column.string_to_time(#{var_name})"
         else
           super
         end
       end
 
-      def self.string_to_time(string, klass)
-        time = klass.string_to_time(string)
-        guess_date_or_time(time)
+      def self.string_to_time(string)
+        return string unless string.is_a?(String)
+        return nil if string.empty?
+        return Time.now if string.index('CURRENT') == 0 # TODO seems very wrong
+        
+        ::ActiveRecord::ConnectionAdapters::JdbcColumn.string_to_time(string)
+      end
+
+      def self.string_to_dummy_time(string)
+        ::ActiveRecord::ConnectionAdapters::JdbcColumn.string_to_dummy_time(string)
       end
 
       def self.guess_date_or_time(value)
-        return value if Date === value
-        (value && value.hour == 0 && value.min == 0 && value.sec == 0) ?
-        Date.new(value.year, value.month, value.day) : value
+        return value if value.is_a? Date
+        ( value && value.hour == 0 && value.min == 0 && value.sec == 0 ) ? 
+          Date.new(value.year, value.month, value.day) : value
       end
 
       private
+      
       def simplified_type(field_type)
         case field_type
         when /^number\(1\)$/i                  then :boolean
@@ -102,29 +113,32 @@ module ::ArJdbc
         when /float|double/i                   then :float
         when /int/i                            then :integer
         when /num|dec|real/i                   then extract_scale(field_type) == 0 ? :integer : :decimal
-        when /date|time/i                      then :datetime
-        when /clob/i                           then :text
-        when /blob/i                           then :binary
+        # Oracle TIMESTAMP stores the date and time to up to 9 digits of sub-second precision
+        when /TIMESTAMP/i                      then :timestamp
+        # Oracle DATE stores the date and time to the second
+        when /DATE|TIME/i                      then :datetime
+        when /CLOB/i                           then :text
+        when /BLOB/i                           then :binary
+        else
+          super
         end
       end
 
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         return nil unless value
+        value = value.strip # Not sure why we need this for Oracle?
+        upcase = value.upcase
 
-        # Not sure why we need this for Oracle?
-        value = value.strip
-
-        return nil if value == "null"
-
-        # sysdate default should be treated like a null value
-        return nil if value.downcase == "sysdate"
-
+        return nil if upcase == "NULL"
+        # SYSDATE default should be treated like a NULL value
+        return nil if upcase == "SYSDATE"
         # jdbc returns column default strings with actual single quotes around the value.
         return $1 if value =~ /^'(.*)'$/
 
         value
       end
+      
     end
 
     def adapter_name
@@ -139,9 +153,17 @@ module ::ArJdbc
       columns(table_name).detect {|c| c.primary } if table_name
     end
 
-    def table_alias_length
-      30
+    # Prevent ORA-01795 for in clauses with more than 1000
+    def in_clause_length # :nodoc:
+      1000
     end
+    alias_method :ids_in_list_limit, :in_clause_length
+    
+    # maximum length of Oracle identifiers is 30
+    def table_alias_length; 30; end # :nodoc:
+    def table_name_length;  30; end # :nodoc:
+    def index_name_length;  30; end # :nodoc:
+    def column_name_length; 30; end # :nodoc:
 
     def default_sequence_name(table, column = nil) #:nodoc:
       "#{table}_seq"
@@ -173,10 +195,34 @@ module ::ArJdbc
     def drop_database(name)
       recreate_database(name)
     end
-
+    
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+      case type.to_sym
+      when :binary
+        # { BLOB | BINARY LARGE OBJECT } [ ( length [{K |M |G }] ) ]
+        # although Oracle does not like limit (length) with BLOB (or CLOB) :
+        # 
+        # CREATE TABLE binaries (data BLOB, short_data BLOB(1024));
+        # ORA-00907: missing right parenthesis             *
+        #
+        # TODO do we need to worry about NORMAL vs. non IN-TABLE BLOBs ?!
+        # http://dba.stackexchange.com/questions/8770/improve-blob-writing-performance-in-oracle-11g
+        # - if the LOB is smaller than 3900 bytes it can be stored inside the 
+        #   table row; by default this is enabled, 
+        #   unless you specify DISABLE STORAGE IN ROW
+        # - normal LOB - stored in a separate segment, outside of table, 
+        #   you may even put it in another tablespace;
+        super(type, nil, nil, nil)
+      when :text
+        super(type, nil, nil, nil)
+      else
+        super
+      end
+    end
+    
     def next_sequence_value(sequence_name)
       # avoid #select or #select_one so that the sequence values aren't cached
-      execute("select #{sequence_name}.nextval id from dual").first['id'].to_i
+      execute("SELECT #{quote_table_name(sequence_name)}.nextval id FROM dual").first['id'].to_i
     end
 
     def sql_literal?(value)
@@ -184,7 +230,7 @@ module ::ArJdbc
     end
 
     def ora_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) #:nodoc:
-      if (id_value && !sql_literal?(id_value)) || pk.nil?
+      if (id_value && ! sql_literal?(id_value)) || pk.nil?
         # Pre-assigned id or table without a primary key
         # Presence of #to_sql means an Arel literal bind variable
         # that should use #execute_id_insert below
@@ -196,7 +242,7 @@ module ::ArJdbc
         sequence_name ||= default_sequence_name(table)
         id_value = next_sequence_value(sequence_name)
         log(sql, name) do
-          @connection.execute_id_insert(sql,id_value)
+          @connection.execute_id_insert(sql, id_value)
         end
       end
       id_value
@@ -206,23 +252,15 @@ module ::ArJdbc
       @connection.indexes(table, name, @connection.connection.meta_data.user_name)
     end
 
-    def _execute(sql, name = nil)
-      case sql.strip
-        when /\A\(?\s*(select|show)/i then
-          @connection.execute_query(sql)
-        else
-          @connection.execute_update(sql)
-        end
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = "NUMBER(38) NOT NULL PRIMARY KEY"
-      tp[:integer] = { :name => "NUMBER", :limit => 38 }
-      tp[:datetime] = { :name => "DATE" }
-      tp[:timestamp] = { :name => "DATE" }
-      tp[:time] = { :name => "DATE" }
-      tp[:date] = { :name => "DATE" }
-      tp
+    def modify_types(types)
+      super(types)
+      types[:primary_key] = "NUMBER(38) NOT NULL PRIMARY KEY"
+      types[:integer] = { :name => "NUMBER", :limit => 38 }
+      types[:datetime] = { :name => "DATE" }
+      types[:timestamp] = { :name => "TIMESTAMP" }
+      types[:time] = { :name => "DATE" }
+      types[:date] = { :name => "DATE" }
+      types
     end
 
     def add_limit_offset!(sql, options) #:nodoc:
@@ -235,16 +273,41 @@ module ::ArJdbc
       end
     end
 
-    def current_database #:nodoc:
-      select_one("select sys_context('userenv','db_name') db from dual")["db"]
+    def current_user # :nodoc:
+      @current_user ||= execute("SELECT sys_context('userenv', 'session_user') su FROM dual").first['su']
+    end
+    
+    def current_database # :nodoc:
+      @current_database ||= execute("SELECT sys_context('userenv', 'db_name') db FROM dual").first['db']
+    end
+
+    def current_schema # :nodoc:
+      execute("SELECT sys_context('userenv', 'current_schema') schema FROM dual").first['schema']
     end
 
+    def current_schema=(schema_owner)
+      execute("ALTER SESSION SET current_schema=#{schema_owner}")
+    end
+    
+    def create_savepoint # :nodoc:
+      execute("SAVEPOINT #{current_savepoint_name}")
+    end
+
+    def rollback_to_savepoint # :nodoc:
+      execute("ROLLBACK TO #{current_savepoint_name}")
+    end
+
+    def release_savepoint # :nodoc:
+      # no RELEASE SAVEPOINT statement in Oracle
+    end
+    
     def remove_index(table_name, options = {}) #:nodoc:
       execute "DROP INDEX #{index_name(table_name, options)}"
     end
 
     def change_column_default(table_name, column_name, default) #:nodoc:
-      execute "ALTER TABLE #{table_name} MODIFY #{column_name} DEFAULT #{quote(default)}"
+      execute "ALTER TABLE #{quote_table_name(table_name)} " + 
+        "MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
     end
 
     def add_column_options!(sql, options) #:nodoc:
@@ -256,17 +319,21 @@ module ::ArJdbc
     end
 
     def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      change_column_sql = "ALTER TABLE #{table_name} MODIFY #{column_name} #{type_to_sql(type, options[:limit])}"
+      change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} " <<
+        "MODIFY #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit])}"
       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 #{column_name} to #{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 #{column_name}"
+    
+    def remove_column(table_name, *column_names) #:nodoc:
+      for column_name in column_names.flatten
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
+      end
     end
 
     def structure_dump #:nodoc:
@@ -277,19 +344,16 @@ module ::ArJdbc
       select_all("select table_name from user_tables").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, data_precision, data_scale, data_default, nullable
-              from user_tab_columns
-              where table_name = '#{table.to_a.first.last}'
-              order by column_id
-            }).map do |row|
-          row = row.inject({}) do |h,args|
-            h[args[0].downcase] = args[1]
-            h
-          end
+          select column_name, data_type, data_length, data_precision, data_scale, data_default, nullable
+          from user_tab_columns
+          where table_name = '#{table.to_a.first.last}'
+          order by column_id
+        }).map do |row|
+          row = row.inject({}) { |h, args| h[ args[0].downcase ] = args[1]; h }
           col = "#{row['column_name'].downcase} #{row['data_type'].downcase}"
-          if row['data_type'] =='NUMBER' and !row['data_precision'].nil?
+          if row['data_type'] == 'NUMBER' and ! row['data_precision'].nil?
             col << "(#{row['data_precision'].to_i}"
-            col << ",#{row['data_scale'].to_i}" if !row['data_scale'].nil?
+            col << ",#{row['data_scale'].to_i}" if ! row['data_scale'].nil?
             col << ')'
           elsif row['data_type'].include?('CHAR')
             col << "(#{row['data_length'].to_i})"
@@ -329,8 +393,7 @@ module ::ArJdbc
 
       # construct a valid DISTINCT clause, ie. one that includes the ORDER BY columns, using
       # FIRST_VALUE such that the inclusion of these columns doesn't invalidate the DISTINCT
-      order_columns = order_by.split(',').map { |s| s.strip }.reject(&:blank?)
-      order_columns = order_columns.zip((0...order_columns.size).to_a).map do |c, i|
+      order_columns = extract_order_columns(order_by).map do |c, i|
         "FIRST_VALUE(#{c.split.first}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__"
       end
       sql = "DISTINCT #{columns}, "
@@ -339,32 +402,41 @@ module ::ArJdbc
 
     # ORDER BY clause for the passed order option.
     #
-    # Uses column aliases as defined by #distinct.
+    # Uses column aliases as defined by {#distinct}.
     def add_order_by_for_association_limiting!(sql, options)
       return sql if options[:order].blank?
 
-      order = options[:order].split(',').collect { |s| s.strip }.reject(&:blank?)
-      order.map! {|s| $1 if s =~ / (.*)/}
-      order = order.zip((0...order.size).to_a).map { |s,i| "alias_#{i}__ #{s}" }.join(', ')
+      order_columns = extract_order_columns(options[:order]) do |columns|
+        columns.map! { |s| $1 if s =~ / (.*)/ }; columns
+      end
+      order = order_columns.map { |s, i| "alias_#{i}__ #{s}" } # @see {#distinct}
 
-      sql << "ORDER BY #{order}"
+      sql << "ORDER BY #{order.join(', ')}"
     end
-
+    
+    def extract_order_columns(order_by)
+      columns = order_by.split(',')
+      columns.map!(&:strip); columns.reject!(&:blank?)
+      columns = yield(columns) if block_given?
+      columns.zip( (0...columns.size).to_a )
+    end
+    private :extract_order_columns
+    
     def tables
       @connection.tables(nil, oracle_schema)
     end
 
-    def ora_columns(table_name, name=nil)
-      @connection.columns_internal(table_name, name, oracle_schema)
+    # NOTE: better to use current_schema instead of the configured one ?!
+    
+    def ora_columns(table_name, name = nil)
+      @connection.columns_internal(table_name.to_s, name, oracle_schema)
     end
 
     # QUOTING ==================================================
-    #
-    # see: abstract/quoting.rb
 
     # See ACTIVERECORD_JDBC-33 for details -- better to not quote
     # table names, esp. if they have schemas.
-    def quote_table_name(name) #:nodoc:
+    def quote_table_name(name) # :nodoc:
       name.to_s
     end
 
@@ -377,12 +449,8 @@ module ::ArJdbc
     def quote_column_name(name) #:nodoc:
       name.to_s =~ /^[a-z0-9_$#]+$/ ? name.to_s : "\"#{name}\""
     end
-
-    def quote_string(string) #:nodoc:
-      string.gsub(/'/, "''")
-    end
-
-    def quote(value, column = nil) #:nodoc:
+    
+    def quote(value, column = nil) # :nodoc:
       # Arel 2 passes SqlLiterals through
       return value if sql_literal?(value)
 
@@ -405,19 +473,55 @@ module ::ArJdbc
         quoted
       end
     end
+    
+    def supports_migrations? # :nodoc:
+      true
+    end
 
-    def quoted_true #:nodoc:
-      '1'
+    def supports_primary_key? # :nodoc:
+      true
     end
 
-    def quoted_false #:nodoc:
-      '0'
+    def supports_savepoints? # :nodoc:
+      true
+    end
+    
+    def supports_explain? # :nodoc:
+      true
     end
 
+    def explain(arel, binds = [])
+      sql = "EXPLAIN PLAN FOR #{to_sql(arel)}"
+      return if sql =~ /FROM all_/
+      exec_query(sql, 'EXPLAIN', binds)
+      select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", 'EXPLAIN').join("\n")
+    end
+
+    def select(sql, name = nil, binds = [])
+      records = execute(sql, name, binds)
+      for column in records
+        column.delete('raw_rnum_')
+      end
+      records
+    end
+    
     private
-    # In Oracle, schemas are usually created under your username:
+    
+    def _execute(sql, name = nil)
+      if self.class.select?(sql)
+        @connection.execute_query(sql)
+      else
+        @connection.execute_update(sql)
+      end
+    end
+
+    # In Oracle, schemas are usually created under your username :
     # http://www.oracle.com/technology/obe/2day_dba/schema/schema.htm
-    # But allow separate configuration as "schema:" anyway (GH #53)
+    # 
+    # A schema is the set of objects (tables, views, indexes, etc) that belongs
+    # to an user, often used as another way to refer to an Oracle user account.
+    # 
+    # But allow separate configuration as "schema:" anyway (see #53)
     def oracle_schema
       if @config[:schema]
         @config[:schema].to_s
@@ -426,13 +530,16 @@ module ::ArJdbc
       end
     end
 
-    def select(sql, name = nil, binds = [])
-      records = execute(sql, name, binds)
-      records.each do |col|
-          col.delete('raw_rnum_')
-      end
-      records
-    end
   end
 end
 
+module ActiveRecord::ConnectionAdapters
+  OracleAdapter = Class.new(AbstractAdapter) unless const_defined?(:OracleAdapter)
+
+  class OracleColumn < JdbcColumn
+    include ArJdbc::Oracle::Column
+
+    def call_discovered_column_callbacks(*)
+    end
+  end
+end