activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/lib/arjdbc/mysql/column.rb

@@ -0,0 +1,123 @@
+module ArJdbc
+  module MySQL
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /mysql/i, lambda { |config, column| column.extend(Column) } ]
+    end
+
+    # Column behavior based on (abstract) MySQL adapter in Rails.
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module Column
+
+      def extract_default(default)
+        if sql_type =~ /blob/i || type == :text
+          if default.blank?
+            return null ? nil : ''
+          else
+            raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
+          end
+        elsif missing_default_forged_as_empty_string?(default)
+          nil
+        else
+          super
+        end
+      end
+
+      def has_default?
+        return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
+        super
+      end
+
+      def simplified_type(field_type)
+        if adapter.respond_to?(:emulate_booleans) && adapter.emulate_booleans
+          return :boolean if field_type.downcase.index('tinyint(1)')
+        end
+
+        case field_type
+        when /enum/i, /set/i then :string
+        when /year/i then :integer
+        # :tinyint : {:name=>"tinyint", :limit=>3}
+        # :"tinyint unsigned" : {:name=>"tinyint unsigned", :limit=>3}
+        # :bigint : {:name=>"bigint", :limit=>19}
+        # :"bigint unsigned" : {:name=>"bigint unsigned", :limit=>20}
+        # :integer : {:name=>"integer", :limit=>10}
+        # :"integer unsigned" : {:name=>"integer unsigned", :limit=>10}
+        # :int : {:name=>"int", :limit=>10}
+        # :"int unsigned" : {:name=>"int unsigned", :limit=>10}
+        # :mediumint : {:name=>"mediumint", :limit=>7}
+        # :"mediumint unsigned" : {:name=>"mediumint unsigned", :limit=>8}
+        # :smallint : {:name=>"smallint", :limit=>5}
+        # :"smallint unsigned" : {:name=>"smallint unsigned", :limit=>5}
+        when /int/i then :integer
+        when /double/i then :float # double precision (alias)
+        when 'bool' then :boolean
+        when 'char' then :string
+        # :mediumtext => {:name=>"mediumtext", :limit=>16777215}
+        # :longtext => {:name=>"longtext", :limit=>2147483647}
+        # :text => {:name=>"text"}
+        # :tinytext => {:name=>"tinytext", :limit=>255}
+        when /text/i then :text
+        when 'long varchar' then :text
+        # :"long varbinary" => {:name=>"long varbinary", :limit=>16777215}
+        # :varbinary => {:name=>"varbinary", :limit=>255}
+        when /binary/i then :binary
+        # :mediumblob => {:name=>"mediumblob", :limit=>16777215}
+        # :longblob => {:name=>"longblob", :limit=>2147483647}
+        # :blob => {:name=>"blob", :limit=>65535}
+        # :tinyblob => {:name=>"tinyblob", :limit=>255}
+        when /blob/i then :binary
+        when /^bit/i then :binary
+        else
+          super
+        end
+      end
+
+      def extract_limit(sql_type)
+        case sql_type
+        when /blob|text/i
+          case sql_type
+          when /tiny/i
+            255
+          when /medium/i
+            16777215
+          when /long/i
+            2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
+          else
+            super # we could return 65535 here, but we leave it undecorated by default
+          end
+        when /^bigint/i;    8
+        when /^int/i;       4
+        when /^mediumint/i; 3
+        when /^smallint/i;  2
+        when /^tinyint/i;   1
+        when /^enum\((.+)\)/i # 255
+          $1.split(',').map{ |enum| enum.strip.length - 2 }.max
+        when /^(bool|date|float|int|time)/i
+          nil
+        else
+          super
+        end
+      end
+
+      # MySQL misreports NOT NULL column default when none is given.
+      # We can't detect this for columns which may have a legitimate ''
+      # default (string) but we can for others (integer, datetime, boolean,
+      # and the rest).
+      #
+      # Test whether the column has default '', is not null, and is not
+      # a type allowing default ''.
+      def missing_default_forged_as_empty_string?(default)
+        type != :string && !null && default == ''
+      end
+
+      def adapter; end
+      private :adapter
+
+    end
+
+    # @private backwards-compatibility
+    ColumnExtensions = Column
+
+  end
+end

data/lib/arjdbc/mysql/connection_methods.rb

@@ -11,17 +11,14 @@ ArJdbc::ConnectionMethods.module_eval do
     config[:driver] ||= defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
     config[:adapter_spec] ||= ::ArJdbc::MySQL
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::MysqlAdapter unless config.key?(:adapter_class)
-    # config[:connection_alive_sql] ||= 'SELECT 1'
-    
+
     options = (config[:options] ||= {})
     options['zeroDateTimeBehavior'] ||= 'convertToNull'
     options['jdbcCompliantTruncation'] ||= 'false'
     options['useUnicode'] ||= 'true'
     options['characterEncoding'] = config[:encoding] || 'utf8'
-    
-    connection = jdbc_connection(config)
-    ::ArJdbc::MySQL.kill_cancel_timer(connection.raw_connection)
-    connection
+
+    jdbc_connection(config)
   end
   alias_method :jdbcmysql_connection, :mysql_connection
   alias_method :mysql2_connection, :mysql_connection

data/lib/arjdbc/oracle/adapter.rb

@@ -1,15 +1,20 @@
 ArJdbc.load_java_part :Oracle
 
+require 'arjdbc/oracle/column'
+
 module ArJdbc
   module Oracle
-    
+
+    # @private
     def self.extended(adapter); initialize!; end
-    
+
+    # @private
     @@_initialized = nil
-    
+
+    # @private
     def self.initialize!
       return if @@_initialized; @@_initialized = true
-      
+
       require 'arjdbc/jdbc/serialized_attributes_helper'
       ActiveRecord::Base.class_eval do
         def after_save_with_oracle_lob
@@ -17,11 +22,7 @@ module ArJdbc
             value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
             next if value.nil? || (value == '')
 
-            self.class.connection.write_large_object(
-              column.type == :binary, column.name,
-              self.class.table_name, self.class.primary_key, 
-              self.class.connection.quote(id), value
-            )
+            self.class.connection.update_lob_value(self, column, value)
           end
         end
       end
@@ -33,160 +34,60 @@ module ArJdbc
         ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
       end
     end
-    
-    def self.column_selector
-      [ /oracle/i, lambda { |cfg, column| column.extend(::ArJdbc::Oracle::Column) } ]
-    end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::OracleJdbcConnection
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
     def jdbc_column_class
       ::ActiveRecord::ConnectionAdapters::OracleColumn
     end
 
+    # @private
     @@emulate_booleans = true
-    
+
     # Boolean emulation can be disabled using :
-    # 
+    #
     #   ArJdbc::Oracle.emulate_booleans = false
-    # 
+    #
     # @see ActiveRecord::ConnectionAdapters::OracleAdapter#emulate_booleans
     def self.emulate_booleans; @@emulate_booleans; end
     def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
-    
-    module Column
-      
-      def primary=(value)
-        super
-        @type = :integer if value && @sql_type =~ /^NUMBER$/i
-      end
-      
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-        when :datetime  then Column.string_to_time(value)
-        when :timestamp then Column.string_to_time(value)
-        when :boolean   then Column.value_to_boolean(value)
-        else
-          super
-        end
-      end
-
-      def type_cast_code(var_name)
-        case type
-        when :datetime  then "ArJdbc::Oracle::Column.string_to_time(#{var_name})"
-        when :timestamp then "ArJdbc::Oracle::Column.string_to_time(#{var_name})"
-        when :boolean   then "ArJdbc::Oracle::Column.value_to_boolean(#{var_name})"
-        else
-          super
-        end
-      end
-
-      # convert a value to a boolean 
-      def self.value_to_boolean(value)
-        # NOTE: Oracle JDBC meta-data gets us DECIMAL for NUMBER(1) values
-        # thus we're likely to get a column back as BigDecimal (e.g. 1.0)
-        if value.is_a?(String)
-          value.blank? ? nil : value == '1'
-        elsif value.is_a?(Numeric)
-          value.to_i == 1 # <BigDecimal:7b5bfe,'0.1E1',1(4)>
-        else
-          !! value
-        end
-      end
-      
-      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 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 extract_limit(sql_type)
-        case sql_type
-        when /^(clob|date)/i then nil
-        when /^xml/i then @sql_type = 'XMLTYPE'; nil
-        else super
-        end
-      end
-      
-      def simplified_type(field_type)
-        case field_type
-        when /char/i            then :string
-        when /float|double/i    then :float
-        when /int/i             then :integer
-        when /^number\(1\)$/i   then Oracle.emulate_booleans ? :boolean : :integer
-        when /^num|dec|real/i   then extract_scale(field_type) == 0 ? :integer : :decimal
-        # 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
-        when /XML/i             then :xml
-        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
 
-        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
-    
-    class TableDefinition < ::ActiveRecord::ConnectionAdapters::TableDefinition # :nodoc:
+    class TableDefinition < ::ActiveRecord::ConnectionAdapters::TableDefinition
       def raw(*args)
         options = args.extract_options!
         column(args[0], 'raw', options)
       end
-      
+
       def xml(*args)
         options = args.extract_options!
         column(args[0], 'xml', options)
       end
     end
-    
+
     def table_definition(*args)
       new_table_definition(TableDefinition, *args)
     end
 
-    def self.arel2_visitors(config)
-      { 'oracle' => Arel::Visitors::Oracle }
+    def self.arel_visitor_type(config = nil)
+      ::Arel::Visitors::Oracle
     end
 
-    ADAPTER_NAME = 'Oracle'
-    
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#bind_substitution
+    # @private
+    class BindSubstitution < ::Arel::Visitors::Oracle
+      include ::Arel::Visitors::BindVisitor
+    end if defined? ::Arel::Visitors::BindVisitor
+
+    ADAPTER_NAME = 'Oracle'.freeze
+
     def adapter_name
       ADAPTER_NAME
     end
-    
+
     NATIVE_DATABASE_TYPES = {
       :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
       :string => { :name => "VARCHAR2", :limit => 255 },
@@ -207,7 +108,7 @@ module ArJdbc
     def native_database_types
       super.merge(NATIVE_DATABASE_TYPES)
     end
-    
+
     def modify_types(types)
       super(types)
       NATIVE_DATABASE_TYPES.each do |key, value|
@@ -215,63 +116,72 @@ module ArJdbc
       end
       types
     end
-    
-    def prefetch_primary_key?(table_name = nil)
-      columns(table_name).detect {|c| c.primary } if table_name
-    end
 
     # Prevent ORA-01795 for in clauses with more than 1000
-    def in_clause_length # :nodoc:
+    def in_clause_length
       1000
     end
     alias_method :ids_in_list_limit, :in_clause_length
-    
-    IDENTIFIER_LENGTH = 30 # :nodoc:
-    
+
+    IDENTIFIER_LENGTH = 30
+
     # maximum length of Oracle identifiers is 30
-    def table_alias_length; IDENTIFIER_LENGTH; end # :nodoc:
-    def table_name_length;  IDENTIFIER_LENGTH; end # :nodoc:
-    def index_name_length;  IDENTIFIER_LENGTH; end # :nodoc:
-    def column_name_length; IDENTIFIER_LENGTH; end # :nodoc:
+    def table_alias_length; IDENTIFIER_LENGTH; end
+    def table_name_length;  IDENTIFIER_LENGTH; end
+    def index_name_length;  IDENTIFIER_LENGTH; end
+    def column_name_length; IDENTIFIER_LENGTH; end
 
-    def default_sequence_name(table_name, column = nil) # :nodoc:
+    def default_sequence_name(table_name, column = nil)
+      # TODO: remove schema prefix if present (before truncating)
       "#{table_name.to_s[0, IDENTIFIER_LENGTH - 4]}_seq"
     end
 
-    def create_table(name, options = {}) #:nodoc:
+    # @override
+    def create_table(name, options = {})
       super(name, options)
-      seq_name = options[:sequence_name] || default_sequence_name(name)
-      start_value = options[:sequence_start_value] || 10000
-      raise ActiveRecord::StatementInvalid.new("name #{seq_name} too long") if seq_name.length > table_alias_length
-      execute "CREATE SEQUENCE #{seq_name} START WITH #{start_value}" unless options[:id] == false
+      unless options[:id] == false
+        seq_name = options[:sequence_name] || default_sequence_name(name)
+        start_value = options[:sequence_start_value] || 10000
+        raise ActiveRecord::StatementInvalid.new("name #{seq_name} too long") if seq_name.length > table_alias_length
+        execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{start_value}"
+      end
     end
 
-    def rename_table(name, new_name) #:nodoc:
-      execute "RENAME #{name} TO #{new_name}"
-      execute "RENAME #{name}_seq TO #{new_name}_seq" rescue nil
+    # @override
+    def rename_table(name, new_name)
+      if new_name.to_s.length > table_name_length
+        raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{table_name_length} characters"
+      end
+      if "#{new_name}_seq".to_s.length > sequence_name_length
+        raise ArgumentError, "New sequence name '#{new_name}_seq' is too long; the limit is #{sequence_name_length} characters"
+      end
+      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:
-      super(name) rescue nil
+    # @override
+    def drop_table(name, options = {})
+      super(name)
       seq_name = options[:sequence_name] || default_sequence_name(name)
-      execute "DROP SEQUENCE #{seq_name}" rescue nil
+      execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
     end
-    
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+
+    # @override
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       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, 
+        # - 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, 
+        # - 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
@@ -280,88 +190,63 @@ module ArJdbc
         super
       end
     end
-    
-    def next_sequence_value(sequence_name)
-      # avoid #select or #select_one so that the sequence values aren't cached
-      execute("SELECT #{quote_table_name(sequence_name)}.nextval id FROM dual").first['id'].to_i
-    end
 
     def sql_literal?(value)
       defined?(::Arel::SqlLiteral) && ::Arel::SqlLiteral === value
     end
+    private :sql_literal?
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) # :nodoc:
-      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
-        value = exec_insert(to_sql(sql, binds), name, binds)
-        id_value || last_inserted_id(value) # super
-      else
-        # Assume the sql contains a bind-variable for the id
-        # Extract the table from the insert sql. Yuck.
-        sequence_name ||= begin
-          table = extract_table_ref_from_insert_sql(sql)
-          default_sequence_name(table)
-        end
-        id_value = next_sequence_value(sequence_name)
-        log(sql, name) { @connection.execute_id_insert(sql, id_value) }
-        id_value
-      end
-    end
-    
     def indexes(table, name = nil)
       @connection.indexes(table, name, @connection.connection.meta_data.user_name)
     end
 
-    def add_limit_offset!(sql, options) #:nodoc:
+    # @note Only used with (non-AREL) ActiveRecord **2.3**.
+    # @see Arel::Visitors::Oracle
+    def add_limit_offset!(sql, options)
       offset = options[:offset] || 0
-
       if limit = options[:limit]
-        sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset+limit}) where raw_rnum_ > #{offset}"
+        sql.replace "SELECT * FROM " <<
+          "(select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset + limit})" <<
+          " WHERE raw_rnum_ > #{offset}"
       elsif offset > 0
-        sql.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_) where raw_rnum_ > #{offset}"
+        sql.replace "SELECT * FROM " <<
+          "(select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_)" <<
+          " WHERE raw_rnum_ > #{offset}"
       end
-    end
+    end if ::ActiveRecord::VERSION::MAJOR < 3
 
-    def current_user # :nodoc:
+    def current_user
       @current_user ||= execute("SELECT sys_context('userenv', 'session_user') su FROM dual").first['su']
     end
-    
-    def current_database # :nodoc:
+
+    def current_database
       @current_database ||= execute("SELECT sys_context('userenv', 'db_name') db FROM dual").first['db']
     end
 
-    def current_schema # :nodoc:
+    def current_schema
       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}")
+    # @override
+    def release_savepoint(name = nil)
+      # no RELEASE SAVEPOINT statement in Oracle (JDBC driver throws "Unsupported feature")
     end
 
-    def release_savepoint # :nodoc:
-      # no RELEASE SAVEPOINT statement in Oracle
-    end
-    
-    def remove_index(table_name, options = {}) #:nodoc:
+    def remove_index(table_name, options = {})
       execute "DROP INDEX #{index_name(table_name, options)}"
     end
 
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      execute "ALTER TABLE #{quote_table_name(table_name)} " + 
+    def change_column_default(table_name, column_name, 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:
+    # @override
+    def add_column_options!(sql, options)
       # 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))}"
@@ -369,24 +254,27 @@ module ArJdbc
       super
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    # @override
+    def change_column(table_name, column_name, type, options = {})
       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:
+    # @override
+    def rename_column(table_name, 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_names) #:nodoc:
+
+    # @override
+    def remove_column(table_name, *column_names)
       for column_name in column_names.flatten
         execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
       end
     end
-    
+
     # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
     #
     # Oracle requires the ORDER BY columns to be in the SELECT list for DISTINCT
@@ -422,7 +310,7 @@ module ArJdbc
 
       sql << "ORDER BY #{order.join(', ')}"
     end
-    
+
     def extract_order_columns(order_by)
       columns = order_by.split(',')
       columns.map!(&:strip); columns.reject!(&:blank?)
@@ -430,24 +318,24 @@ module ArJdbc
       columns.zip( (0...columns.size).to_a )
     end
     private :extract_order_columns
-    
-    def temporary_table?(table_name) # :nodoc:
+
+    def temporary_table?(table_name)
       select_value("SELECT temporary FROM user_tables WHERE table_name = '#{table_name.upcase}'") == 'Y'
     end
-    
-    def tables # :nodoc:
+
+    def tables
       @connection.tables(nil, oracle_schema)
     end
-    
+
     # NOTE: better to use current_schema instead of the configured one ?!
-    def columns(table_name, name = nil) # :nodoc:
+    def columns(table_name, name = nil)
       @connection.columns_internal(table_name.to_s, nil, oracle_schema)
     end
-    
+
     def tablespace(table_name)
       select_value "SELECT tablespace_name FROM user_tables WHERE table_name='#{table_name.to_s.upcase}'"
     end
-    
+
     def charset
       database_parameters['NLS_CHARACTERSET']
     end
@@ -455,25 +343,27 @@ module ArJdbc
     def collation
       database_parameters['NLS_COMP']
     end
-    
+
     def database_parameters
       return @database_parameters unless ( @database_parameters ||= {} ).empty?
-      @connection.execute_query_raw("SELECT * FROM NLS_DATABASE_PARAMETERS") do 
+      @connection.execute_query_raw("SELECT * FROM NLS_DATABASE_PARAMETERS") do
         |name, value| @database_parameters[name] = value
       end
       @database_parameters
     end
-    
+
     # QUOTING ==================================================
-    
-    def quote_table_name(name) # :nodoc:
+
+    # @override
+    def quote_table_name(name)
       name.to_s.split('.').map{ |n| n.split('@').map{ |m| quote_column_name(m) }.join('@') }.join('.')
     end
-    
-    def quote_column_name(name) #:nodoc:
+
+    # @override
+    def quote_column_name(name)
       # if only valid lowercase column characters in name
       if ( name = name.to_s ) =~ /\A[a-z][a-z_0-9\$#]*\Z/
-        # putting double-quotes around an identifier causes Oracle to treat the 
+        # putting double-quotes around an identifier causes Oracle to treat the
         # identifier as case sensitive (otherwise assumes case-insensitivity) !
         # all upper case is an exception, where double-quotes are meaningless
         "\"#{name.upcase}\"" # name.upcase
@@ -482,10 +372,16 @@ module ArJdbc
         "\"#{name.gsub('"', '')}\""
       end
     end
-    
-    def quote(value, column = nil) # :nodoc:
+
+    def unquote_table_name(name)
+      name = name[1...-1] if name[0, 1] == '"'
+      name.upcase == name ? name.downcase : name
+    end
+
+    # @override
+    def quote(value, column = nil)
       return value if sql_literal?(value) # Arel 2 passes SqlLiterals through
-      
+
       column_type = column && column.type
       if column_type == :text || column_type == :binary
         if /(.*?)\([0-9]+\)/ =~ column.sql_type
@@ -501,34 +397,67 @@ module ArJdbc
         if column.respond_to?(:primary) && column.primary && column.klass != String
           return value.to_i.to_s
         end
-        quoted = super
-        if value.acts_like?(:date)
-          quoted = %Q{DATE'#{quoted_date(value)}'}
-        elsif value.acts_like?(:time)
-          quoted = %Q{TIMESTAMP'#{quoted_date(value)}'}
+
+        if column_type == :datetime || column_type == :time
+          if value.acts_like?(:time)
+            %Q{TO_DATE('#{get_time(value).strftime("%Y-%m-%d %H:%M:%S")}','YYYY-MM-DD HH24:MI:SS')}
+          else
+            value.blank? ? 'NULL' : %Q{DATE'#{value}'} # assume correctly formated DATE (string)
+          end
+        elsif ( like_date = value.acts_like?(:date) ) || column_type == :date
+          if value.acts_like?(:time) # value.respond_to?(:strftime)
+            %Q{DATE'#{get_time(value).strftime("%Y-%m-%d")}'}
+          elsif like_date
+            %Q{DATE'#{quoted_date(value)}'} # DATE 'YYYY-MM-DD'
+          else
+            value.blank? ? 'NULL' : %Q{DATE'#{value}'} # assume correctly formated DATE (string)
+          end
+        elsif ( like_time = value.acts_like?(:time) ) || column_type == :timestamp
+          if like_time
+            %Q{TIMESTAMP'#{quoted_date(value, true)}'} # TIMESTAMP 'YYYY-MM-DD HH24:MI:SS.FF'
+          else
+            value.blank? ? 'NULL' : %Q{TIMESTAMP'#{value}'} # assume correctly formated TIMESTAMP (string)
+          end
+        else
+          super
         end
-        quoted
       end
     end
-    
-    def quote_raw(value) # :nodoc:
+
+    # Quote date/time values for use in SQL input.
+    # Includes milliseconds if the value is a Time responding to usec.
+    # @override
+    def quoted_date(value, time = nil)
+      if time || ( time.nil? && value.acts_like?(:time) )
+        usec = value.respond_to?(:usec) && (value.usec / 10000.0).round # .428000 -> .43
+        return "#{get_time(value).to_s(:db)}.#{sprintf("%02d", usec)}" if usec
+        # value.strftime("%Y-%m-%d %H:%M:%S")
+      end
+      value.to_s(:db)
+    end
+
+    def quote_raw(value)
       value = value.unpack('C*') if value.is_a?(String)
       "'#{value.map { |x| "%02X" % x }.join}'"
     end
-    
-    def supports_migrations? # :nodoc:
+
+    # @override
+    def supports_migrations?
       true
     end
 
-    def supports_primary_key? # :nodoc:
+    # @override
+    def supports_primary_key?
       true
     end
 
-    def supports_savepoints? # :nodoc:
+    # @override
+    def supports_savepoints?
       true
     end
-    
-    def supports_explain? # :nodoc:
+
+    # @override
+    def supports_explain?
       true
     end
 
@@ -545,35 +474,116 @@ module ArJdbc
       result.each { |row| row.delete('raw_rnum_') } # Hash rows even for AR::Result
       result
     end
-    
-    # @override as <code>#execute_insert</code> not working for Oracle e.g.
-    # getLong not implemented for class oracle.jdbc.driver.T4CRowidAccessor: 
-    # INSERT INTO binaries (data, id, name, short_data) VALUES (?, ?, ?, ?)
-    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil) # :nodoc:
-      execute(sql, name, binds)
+
+    # Returns true for Oracle adapter (since Oracle requires primary key
+    # values to be pre-fetched before insert).
+    # @see #next_sequence_value
+    # @override
+    def prefetch_primary_key?(table_name = nil)
+      return true if table_name.nil?
+      table_name = table_name.to_s
+      columns(table_name).detect { |column| column.primary }
+    end
+
+    # @override
+    def next_sequence_value(sequence_name)
+      sequence_name = quote_table_name(sequence_name)
+      sql = "SELECT #{sequence_name}.NEXTVAL id FROM dual"
+      log(sql, 'SQL') { @connection.next_sequence_value(sequence_name) }
+    end
+
+    # @override (for AR <= 3.0)
+    def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+      # if PK is already pre-fetched from sequence or if there is no PK :
+      if id_value || pk.nil?
+        execute(sql, name)
+        return id_value
+      end
+
+      if pk && use_insert_returning? # true by default on AR <= 3.0
+        sql = "#{sql} RETURNING #{quote_column_name(pk)}"
+      end
+      execute(sql, name)
+    end
+    protected :insert_sql
+
+    # @override
+    def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+      unless id_value || pk.nil?
+        if pk && use_insert_returning?
+          sql = "#{sql} RETURNING #{quote_column_name(pk)}"
+        end
+      end
+      [ sql, binds ]
+    end
+
+    # @override
+    def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+      # NOTE: ActiveRecord::Relation calls our {#next_sequence_value}
+      # (from its `insert`) and passes the returned id_value here ...
+      sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
+      if id_value
+        exec_update(sql, name, binds)
+        return id_value
+      else
+        value = exec_insert(sql, name, binds, pk, sequence_name)
+        id_value || last_inserted_id(value)
+      end
+    end
+
+    # @override
+    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+      if pk && use_insert_returning?
+        exec_query(sql, name, binds) # due RETURNING clause
+      else
+        super(sql, name, binds) # assume no generated id for table
+      end
+    end
+
+    def next_id_value(sql, sequence_name = nil)
+      # Assume the SQL contains a bind-variable for the ID
+      sequence_name ||= begin
+        # Extract the table from the insert SQL. Yuck.
+        table = extract_table_ref_from_insert_sql(sql)
+        default_sequence_name(table)
+      end
+      next_sequence_value(sequence_name)
     end
-    
+    private :next_id_value
+
+    def use_insert_returning?
+      if ( @use_insert_returning ||= nil ).nil?
+        @use_insert_returning = false
+      end
+      @use_insert_returning
+    end
+
     private
-    
+
     def _execute(sql, name = nil)
       if self.class.select?(sql)
         @connection.execute_query_raw(sql)
+      elsif self.class.insert?(sql)
+        @connection.execute_insert(sql)
       else
         @connection.execute_update(sql)
       end
     end
-    
-    def extract_table_ref_from_insert_sql(sql) # :nodoc:
-      table = sql.split(" ", 4)[2].gsub('"', '')
-      ( idx = table.index('(') ) ? table[0...idx] : table # INTO table(col1, col2) ...
+
+    def extract_table_ref_from_insert_sql(sql)
+      table = sql.split(" ", 4)[2]
+      if idx = table.index('(')
+        table = table[0...idx] # INTO table(col1, col2) ...
+      end
+      unquote_table_name(table)
     end
-    
+
     # In Oracle, schemas are usually created under your username :
     # http://www.oracle.com/technology/obe/2day_dba/schema/schema.htm
-    # 
+    #
     # 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]
@@ -586,52 +596,36 @@ module ArJdbc
   end
 end
 
+require 'arjdbc/util/quoted_cache'
+
 module ActiveRecord::ConnectionAdapters
-  
+
   remove_const(:OracleAdapter) if const_defined?(:OracleAdapter)
 
   class OracleAdapter < JdbcAdapter
     include ::ArJdbc::Oracle
-    
-    # By default, the MysqlAdapter will consider all columns of type 
+    include ::ArJdbc::Util::QuotedCache
+
+    # By default, the MysqlAdapter will consider all columns of type
     # <tt>tinyint(1)</tt> as boolean. If you wish to disable this :
     #
     #   ActiveRecord::ConnectionAdapters::OracleAdapter.emulate_booleans = false
     #
     def self.emulate_booleans; ::ArJdbc::Oracle.emulate_booleans; end
     def self.emulate_booleans=(emulate); ::ArJdbc::Oracle.emulate_booleans = emulate; end
-    
+
     def initialize(*args)
       ::ArJdbc::Oracle.initialize!
       super # configure_connection happens in super
-    end
-    
-    # some QUOTING caching :
-
-    @@quoted_table_names = {}
 
-    def quote_table_name(name)
-      unless quoted = @@quoted_table_names[name]
-        quoted = super
-        @@quoted_table_names[name] = quoted.freeze
-      end
-      quoted
+      @use_insert_returning = config.key?(:insert_returning) ?
+        self.class.type_cast_config_to_boolean(config[:insert_returning]) : nil
     end
 
-    @@quoted_column_names = {}
-
-    def quote_column_name(name)
-      unless quoted = @@quoted_column_names[name]
-        quoted = super
-        @@quoted_column_names[name] = quoted.freeze
-      end
-      quoted
-    end
-    
   end
 
   class OracleColumn < JdbcColumn
     include ::ArJdbc::Oracle::Column
   end
-  
+
 end