neo-activerecord-jdbc-adapter 5.0.pre2

data/lib/arjdbc/mysql/explain_support.rb

@@ -0,0 +1,82 @@
+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
+        result = exec_query(sql, "EXPLAIN", binds)
+        elapsed = Time.now.to_f - start
+        ExplainPrettyPrinter.new.pp result, elapsed
+      end
+
+      # @private
+      class ExplainPrettyPrinter
+        # 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(sep = "\n") << sep
+        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/mysql/schema_creation.rb

@@ -0,0 +1,58 @@
+module ArJdbc
+  module MySQL
+    # @private copied from native adapter 4.0/4.1
+    class SchemaCreation < ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+
+      def visit_AddColumn(o)
+        add_column_position!(super, column_options(o))
+      end
+
+      private
+
+      def visit_DropForeignKey(name)
+        "DROP FOREIGN KEY #{name}"
+      end
+
+      def visit_TableDefinition(o)
+        name = o.name
+        create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(name)} "
+
+        statements = o.columns.map { |c| accept c }
+        statements.concat(o.indexes.map { |column_name, options| index_in_create(name, column_name, options) })
+
+        create_sql << "(#{statements.join(', ')}) " if statements.present?
+        create_sql << "#{o.options}"
+        create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+        create_sql
+      end if AR42
+
+      def visit_ChangeColumnDefinition(o)
+        column = o.column
+        options = o.options
+        sql_type = type_to_sql(o.type, options[:limit], options[:precision], options[:scale])
+        change_column_sql = "CHANGE #{quote_column_name(column.name)} #{quote_column_name(options[:name])} #{sql_type}"
+        add_column_options!(change_column_sql, options.merge(:column => column))
+        add_column_position!(change_column_sql, options)
+      end
+
+      def add_column_position!(sql, options)
+        if options[:first]
+          sql << " FIRST"
+        elsif options[:after]
+          sql << " AFTER #{quote_column_name(options[:after])}"
+        end
+        sql
+      end
+
+      def index_in_create(table_name, column_name, options)
+        index_name, index_type, index_columns, index_options, index_algorithm, index_using = @conn.add_index_options(table_name, column_name, options)
+        "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_options} #{index_algorithm}"
+      end
+    end
+  end
+
+  def schema_creation
+    SchemaCreation.new self
+  end
+
+end if ::ActiveRecord::ConnectionAdapters::AbstractAdapter.const_defined? :SchemaCreation

data/lib/arjdbc/oracle.rb

@@ -0,0 +1,4 @@
+require 'arjdbc'
+require 'arjdbc/oracle/adapter'
+require 'arjdbc/oracle/connection_methods'
+ArJdbc.warn_unsupported_adapter 'oracle', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/oracle/adapter.rb

@@ -0,0 +1,952 @@
+# NOTE: file contains code adapted from **oracle-enhanced** adapter, license follows
+=begin
+Copyright (c) 2008-2011 Graham Jenkins, Michael Schoen, Raimonds Simanovskis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end
+
+ArJdbc.load_java_part :Oracle
+
+module ArJdbc
+  module Oracle
+
+    require 'arjdbc/oracle/column'
+
+    # @private
+    def self.extended(adapter); initialize!; end
+
+    # @private
+    @@_initialized = nil
+
+    # @private
+    def self.initialize!
+      return if @@_initialized; @@_initialized = true
+
+      require 'arjdbc/util/serialized_attributes'
+      Util::SerializedAttributes.setup /LOB\(|LOB$/i, 'after_save_with_oracle_lob'
+
+      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
+    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
+    @@update_lob_values = true
+
+    # Updating records with LOB values (binary/text columns) in a separate
+    # statement can be disabled using :
+    #
+    #   ArJdbc::Oracle.update_lob_values = false
+    #
+    # @note This only applies when prepared statements are not used.
+    def self.update_lob_values?; @@update_lob_values; end
+    # @see #update_lob_values?
+    def self.update_lob_values=(update); @@update_lob_values = update; end
+
+    # @see #update_lob_values?
+    # @see ArJdbc::Util::SerializedAttributes#update_lob_columns
+    def update_lob_value?(value, column = nil)
+      Oracle.update_lob_values? && ! prepared_statements? && ! ( value.nil? || value == '' )
+    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
+    # @deprecated Use {#emulate_booleans?} instead.
+    def self.emulate_booleans; @@emulate_booleans; end
+    # @see #emulate_booleans?
+    def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
+
+    class TableDefinition < ::ActiveRecord::ConnectionAdapters::TableDefinition
+      def raw(*args)
+        options = args.extract_options!
+        column(args[0], 'raw', options)
+      end unless AR42
+
+      def raw(name, options={})
+        column(name, :raw, options)
+      end if AR42
+
+      def xml(*args)
+        options = args.extract_options!
+        column(args[0], 'xml', options)
+      end unless AR42
+
+      def raw(name, options={})
+        column(name, :xml, options)
+      end if AR42
+
+      def aliased_types(name, fallback)
+        # NOTE: disable aliasing :timestamp as :datetime :
+        fallback # 'timestamp' == name ? :datetime : fallback
+      end if AR42
+    end
+
+    def table_definition(*args)
+      new_table_definition(TableDefinition, *args)
+    end
+
+    def create_table_definition(name, temporary, options, as = nil)
+      TableDefinition.new native_database_types, name, temporary, options, as
+    end if AR42
+
+    ADAPTER_NAME = 'Oracle'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    def initialize_type_map(m)
+      super
+
+      m.register_type(%r(NUMBER)i) do |sql_type|
+        scale = extract_scale(sql_type)
+        precision = extract_precision(sql_type)
+        limit = extract_limit(sql_type)
+        if scale == 0
+          if Oracle.emulate_booleans? && limit == 1
+            ActiveRecord::Type::Boolean.new
+          else
+            ActiveRecord::Type::Integer.new(:precision => precision, :limit => limit)
+          end
+        else
+          ActiveRecord::Type::Decimal.new(:precision => precision, :scale => scale)
+        end
+      end
+
+      register_class_with_limit m, %r(date)i,      ActiveRecord::Type::DateTime
+      register_class_with_limit m, %r(raw)i,       RawType
+      register_class_with_limit m, %r(timestamp)i, TimestampType
+
+      m.register_type %r(xmltype)i, XmlType.new
+    end if AR42
+
+    def clear_cache!
+      super
+      reload_type_map
+    end if AR42
+
+    # @private
+    class RawType < ActiveRecord::Type::String
+      def type; :raw end
+    end if AR42
+
+    # @private
+    class TimestampType < ActiveRecord::Type::DateTime
+      def type; :timestamp end
+    end if AR42
+
+    # @private
+    class XmlType < ActiveRecord::Type::String
+      def type; :xml end
+
+      def type_cast_for_database(value)
+        return unless value
+        Data.new(super)
+      end
+
+      class Data
+        def initialize(value)
+          @value = value
+        end
+        def to_s; @value end
+      end
+    end if AR42
+
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "NUMBER(38) NOT NULL PRIMARY KEY",
+      :string => { :name => "VARCHAR2", :limit => 255 },
+      :text => { :name => "CLOB" },
+      :integer => { :name => "NUMBER", :limit => 38 },
+      :float => { :name => "NUMBER" },
+      :decimal => { :name => "DECIMAL" },
+      :datetime => { :name => "DATE" },
+      :timestamp => { :name => "TIMESTAMP" },
+      :time => { :name => "DATE" },
+      :date => { :name => "DATE" },
+      :binary => { :name => "BLOB" },
+      :boolean => { :name => "NUMBER", :limit => 1 },
+      :raw => { :name => "RAW", :limit => 2000 },
+      :xml => { :name => 'XMLTYPE' }
+    }
+
+    def native_database_types
+      super.merge(NATIVE_DATABASE_TYPES)
+    end
+
+    def modify_types(types)
+      super(types)
+      NATIVE_DATABASE_TYPES.each do |key, value|
+        types[key] = value.dup
+      end
+      types
+    end
+
+    # Prevent ORA-01795 for in clauses with more than 1000
+    def in_clause_length
+      1000
+    end
+    alias_method :ids_in_list_limit, :in_clause_length
+
+    IDENTIFIER_LENGTH = 30
+
+    # maximum length of Oracle identifiers is 30
+    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 sequence_name_length; IDENTIFIER_LENGTH end
+
+    # @private
+    # Will take all or first 26 characters of table name and append _seq suffix
+    def default_sequence_name(table_name, primary_key = nil)
+      len = IDENTIFIER_LENGTH - 4
+      table_name.to_s.gsub (/(^|\.)([\w$-]{1,#{len}})([\w$-]*)$/), '\1\2_seq'
+    end
+
+    # @private
+    def default_trigger_name(table_name)
+      "#{table_name.to_s[0, IDENTIFIER_LENGTH - 4]}_pkt"
+    end
+
+    # @override
+    def create_table(name, options = {})
+      super(name, options)
+      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
+
+    # @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
+
+    # @override
+    def drop_table(name, options = {})
+      outcome = super(name)
+      return outcome if name == 'schema_migrations'
+      seq_name = options.key?(:sequence_name) ? # pass nil/false - no sequence
+        options[:sequence_name] : default_sequence_name(name)
+      return outcome unless seq_name
+      execute_quietly "DROP SEQUENCE #{quote_table_name(seq_name)}"
+    end
+
+    # @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,
+        #   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 indexes(table, name = nil)
+      @connection.indexes(table, name, schema_owner)
+    end
+
+    # @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}"
+      elsif offset > 0
+        sql.replace "SELECT * FROM " <<
+          "(select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_)" <<
+          " WHERE raw_rnum_ > #{offset}"
+      end
+    end if ::ActiveRecord::VERSION::MAJOR < 3
+
+    def current_user
+      @current_user ||= execute("SELECT sys_context('userenv', 'session_user') su FROM dual").first['su']
+    end
+
+    def current_database
+      @current_database ||= execute("SELECT sys_context('userenv', 'db_name') db FROM dual").first['db']
+    end
+
+    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
+
+    # @override
+    def release_savepoint(name = nil)
+      # no RELEASE SAVEPOINT statement in Oracle (JDBC driver throws "Unsupported feature")
+    end
+
+    # @override
+    def add_index(table_name, column_name, options = {})
+      index_name, index_type, quoted_column_names, tablespace, index_options = add_index_options(table_name, column_name, options)
+      execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{index_options}"
+      if index_type == 'UNIQUE'
+        unless quoted_column_names =~ /\(.*\)/
+          execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
+        end
+      end
+    end if AR42
+
+    # @private
+    def add_index_options(table_name, column_name, options = {})
+      column_names = Array(column_name)
+      index_name   = index_name(table_name, column: column_names)
+
+      options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :tablespace, :options, :using)
+
+      index_type = options[:unique] ? "UNIQUE" : ""
+      index_name = options[:name].to_s if options.key?(:name)
+      tablespace = '' # tablespace_for(:index, options[:tablespace])
+      max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
+      index_options =  '' # index_options = options[:options]
+
+      if index_name.to_s.length > max_index_length
+        raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{max_index_length} characters"
+      end
+      if index_name_exists?(table_name, index_name, false)
+        raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
+      end
+
+      quoted_column_names = column_names.map { |e| quote_column_name(e, true) }.join(", ")
+      [ index_name, index_type, quoted_column_names, tablespace, index_options ]
+    end if AR42
+
+    # @override
+    def remove_index(table_name, options = {})
+      index_name = index_name(table_name, options)
+      unless index_name_exists?(table_name, index_name, true)
+        # sometimes options can be String or Array with column names
+        options = {} unless options.is_a?(Hash)
+        if options.has_key? :name
+          options_without_column = options.dup
+          options_without_column.delete :column
+          index_name_without_column = index_name(table_name, options_without_column)
+          return index_name_without_column if index_name_exists?(table_name, index_name_without_column, false)
+        end
+        raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+      end
+      execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(index_name)}" rescue nil
+      execute "DROP INDEX #{quote_column_name(index_name)}"
+    end if AR42
+
+    # @private
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{index_name(table_name, options)}"
+    end unless AR42
+
+    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
+
+    # @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))}"
+      end
+      super
+    end
+
+    # @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
+
+    # @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
+
+    if ActiveRecord::VERSION::MAJOR >= 4
+
+    # @override
+    def remove_column(table_name, column_name, type = nil, options = {})
+      do_remove_column(table_name, column_name)
+    end
+
+    else
+
+    # @override
+    def remove_column(table_name, *column_names)
+      for column_name in column_names.flatten
+        do_remove_column(table_name, column_name)
+      end
+    end
+    alias remove_columns remove_column
+
+    end
+
+    def do_remove_column(table_name, column_name)
+      execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
+    end
+    private :do_remove_column
+
+    # 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
+    # queries. However, with those columns included in the SELECT DISTINCT list, you
+    # won't actually get a distinct list of the column you want (presuming the column
+    # has duplicates with multiple values for the ordered-by columns. So we use the
+    # FIRST_VALUE function to get a single (first) value for each column, effectively
+    # making every row the same.
+    #
+    #   distinct("posts.id", "posts.created_at desc")
+    #
+    # @override
+    def distinct(columns, order_by)
+      "DISTINCT #{columns_for_distinct(columns, order_by)}"
+    end
+
+    # @override Since AR 4.0 (on 4.1 {#distinct} is gone and won't be called).
+    def columns_for_distinct(columns, orders)
+      return columns if orders.blank?
+      if orders.is_a?(Array) # AR 3.x vs 4.x
+        orders = orders.map { |column| column.is_a?(String) ? column : column.to_sql }
+      else
+        orders = extract_order_columns(orders)
+      end
+      # 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 = orders.map do |c, i|
+        "FIRST_VALUE(#{c.split.first}) OVER (PARTITION BY #{columns} ORDER BY #{c}) AS alias_#{i}__"
+      end
+      columns = [ columns ]; columns.flatten!
+      columns.push( *order_columns ).join(', ')
+    end
+
+    # ORDER BY clause for the passed order option.
+    #
+    # Uses column aliases as defined by {#distinct}.
+    def add_order_by_for_association_limiting!(sql, options)
+      return sql if options[:order].blank?
+
+      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.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 temporary_table?(table_name)
+      select_value("SELECT temporary FROM user_tables WHERE table_name = '#{table_name.upcase}'") == 'Y'
+    end
+
+    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)
+      @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
+
+    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
+        |name, value| @database_parameters[name] = value
+      end
+      @database_parameters
+    end
+
+    # QUOTING ==================================================
+
+    # @override
+    def quote_table_name(name)
+      name.to_s.split('.').map{ |n| n.split('@').map{ |m| quote_column_name(m) }.join('@') }.join('.')
+    end
+
+    # @private
+    LOWER_CASE_ONLY = /\A[a-z][a-z_0-9\$#]*\Z/
+
+    # @override
+    def quote_column_name(name, handle_expression = false)
+      # if only valid lowercase column characters in name
+      if ( name = name.to_s ) =~ LOWER_CASE_ONLY
+        # 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
+      else
+        if handle_expression
+          name =~ /^[a-z][a-z_0-9\$#\-]*$/i ? "\"#{name}\"" : name
+        else
+          # remove double quotes which cannot be used inside quoted identifier
+          "\"#{name.gsub('"', '')}\""
+        end
+      end
+    end
+
+    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)
+
+      column_type = column && column.type
+      if column_type == :text || column_type == :binary
+        return 'NULL' if value.nil? || value == ''
+        if update_lob_value?(value, column)
+          if /(.*?)\([0-9]+\)/ =~ ( sql_type = column.sql_type )
+            %Q{empty_#{ $1.downcase }()}
+          else
+            %Q{empty_#{ sql_type.respond_to?(:downcase) ? sql_type.downcase : 'blob' }()}
+          end
+        else
+          "'#{quote_string(value.to_s)}'"
+        end
+      elsif column_type == :xml
+        "XMLTYPE('#{quote_string(value)}')" # XMLTYPE ?
+      elsif column_type == :raw
+        quote_raw(value)
+      else
+        if column.respond_to?(:primary) && column.primary && column.klass != String
+          return value.to_i.to_s
+        end
+
+        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
+      end
+    end
+
+    # 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
+
+    # @override
+    def supports_migrations?; true end
+
+    # @override
+    def supports_primary_key?; true end
+
+    # @override
+    def supports_savepoints?; true end
+
+    # @override
+    def supports_explain?; true end
+
+    # @override
+    def supports_views?; true end
+
+    def truncate(table_name, name = nil)
+      execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+    end
+
+    def explain(arel, binds = [])
+      sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
+      return if sql =~ /FROM all_/
+      exec_update(sql, 'EXPLAIN', binds)
+      select_values("SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY)", 'EXPLAIN').join("\n")
+    end
+
+    def select(sql, name = nil, binds = [])
+      result = super # AR::Result (4.0) or Array (<= 3.2)
+      result.columns.delete('raw_rnum_') if result.respond_to?(:columns)
+      result.each { |row| row.delete('raw_rnum_') } # Hash rows even for AR::Result
+      result
+    end
+
+    @@do_not_prefetch_primary_key = {}
+
+    # 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?
+      do_not_prefetch_hash = @@do_not_prefetch_primary_key
+      do_not_prefetch = do_not_prefetch_hash[ table_name = table_name.to_s ]
+      if do_not_prefetch.nil?
+        owner, desc_table_name, db_link = describe(table_name)
+        do_not_prefetch_hash[table_name] = do_not_prefetch =
+          ! has_primary_key?(table_name, owner, desc_table_name, db_link) ||
+          has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
+      end
+      ! do_not_prefetch
+    end
+
+    # used to clear prefetch primary key flag for all tables
+    # @private
+    def clear_prefetch_primary_key; @@do_not_prefetch_primary_key = {} end
+
+    # @private
+    def has_primary_key?(table_name, owner = nil, desc_table_name = nil, db_link = nil)
+      ! pk_and_sequence_for(table_name, owner, desc_table_name, db_link).nil?
+    end
+
+    # @private check if table has primary key trigger with _pkt suffix
+    def has_primary_key_trigger?(table_name, owner = nil, desc_table_name = nil, db_link = nil)
+      (owner, desc_table_name, db_link) = describe(table_name) unless desc_table_name
+
+      trigger_name = default_trigger_name(table_name).upcase
+      pkt_sql = "SELECT trigger_name FROM all_triggers#{db_link} WHERE owner = '#{owner}'" <<
+          " AND trigger_name = '#{trigger_name}'" <<
+          " AND table_owner = '#{owner}'" <<
+          " AND table_name = '#{desc_table_name}'" <<
+          " AND status = 'ENABLED'"
+      select_value(pkt_sql, 'Primary Key Trigger') ? true : false
+    end
+
+    # use in set_sequence_name to avoid fetching primary key value from sequence
+    AUTOGENERATED_SEQUENCE_NAME = 'autogenerated'.freeze
+
+    # Returns the next sequence value from a sequence generator. Not generally
+    # called directly; used by ActiveRecord to get the next primary key value
+    # when inserting a new database record (see #prefetch_primary_key?).
+    def next_sequence_value(sequence_name)
+      # if sequence_name is set to :autogenerated then it means that primary key will be populated by trigger
+      return nil if sequence_name == AUTOGENERATED_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
+
+    def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil, db_link = nil)
+      (owner, desc_table_name, db_link) = describe(table_name) unless desc_table_name
+
+      seqs = "SELECT us.sequence_name" <<
+        " FROM all_sequences#{db_link} us" <<
+        " WHERE us.sequence_owner = '#{owner}'" <<
+          " AND us.sequence_name = '#{desc_table_name}_SEQ'"
+      seqs = select_values(seqs, 'Sequence')
+
+      # changed back from user_constraints to all_constraints for consistency
+      pks = "SELECT cc.column_name" <<
+        " FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc" <<
+        " WHERE c.owner = '#{owner}'" <<
+          " AND c.table_name = '#{desc_table_name}'" <<
+          " AND c.constraint_type = 'P'" <<
+          " AND cc.owner = c.owner" <<
+          " AND cc.constraint_name = c.constraint_name"
+      pks = select_values(pks, 'Primary Key')
+
+      # only support single column keys
+      pks.size == 1 ? [oracle_downcase(pks.first), oracle_downcase(seqs.first)] : nil
+    end
+    private :pk_and_sequence_for
+
+    # Returns just a table's primary key
+    def primary_key(table_name)
+      pk_and_sequence = pk_and_sequence_for(table_name)
+      pk_and_sequence && pk_and_sequence.first
+    end
+
+    # @override
+    def supports_foreign_keys?; true end
+
+    # @private
+    def disable_referential_integrity
+      sql_constraints = "SELECT constraint_name, owner, table_name FROM user_constraints WHERE constraint_type = 'R' AND status = 'ENABLED'"
+      old_constraints = select_all(sql_constraints)
+      begin
+        old_constraints.each do |constraint|
+          execute "ALTER TABLE #{constraint["table_name"]} DISABLE CONSTRAINT #{constraint["constraint_name"]}"
+        end
+        yield
+      ensure
+        old_constraints.reverse_each do |constraint|
+          execute "ALTER TABLE #{constraint["table_name"]} ENABLE CONSTRAINT #{constraint["constraint_name"]}"
+        end
+      end
+    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)} INTO ?"
+        exec_insert_returning(sql, name, nil, pk)
+      else
+        execute(sql, name)
+      end
+    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)} INTO ?"
+        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?
+        if sql.is_a?(String) && sql.index('RETURNING')
+          return exec_insert_returning(sql, name, binds, pk)
+        end
+      end
+      super(sql, name, binds) # assume no generated id for table
+    end
+
+    def exec_insert_returning(sql, name, binds, pk = nil)
+      sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+      if prepared_statements?
+        log(sql, name, binds) { @connection.execute_insert_returning(sql, binds) }
+      else
+        log(sql, name) { @connection.execute_insert_returning(sql, nil) }
+      end
+    end
+    # private :exec_insert_returning
+
+    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?
+        @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)
+      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]
+        @config[:schema].to_s
+      elsif @config[:username]
+        @config[:username].to_s
+      end
+    end
+
+    # default schema owner
+    def schema_owner(force = true)
+      unless defined? @schema_owner
+        username = config[:username] ? config[:username].to_s : nil
+        username = jdbc_connection.meta_data.user_name if force && username.nil?
+        @schema_owner = username.nil? ? nil : username.upcase
+      end
+      @schema_owner
+    end
+
+    # do not force reading schema_owner as we're read on our own ...
+    def describe(table_name, owner = schema_owner(false))
+      @connection.describe(table_name, owner)
+    end
+
+    def oracle_downcase(column_name)
+      return nil if column_name.nil?
+      column_name =~ /[a-z]/ ? column_name : column_name.downcase
+    end
+
+  end
+end
+
+require 'arjdbc/util/quoted_cache'
+
+module ActiveRecord::ConnectionAdapters
+
+  remove_const(:OracleAdapter) if const_defined?(:OracleAdapter)
+
+  class OracleAdapter < JdbcAdapter
+    include ::ArJdbc::Oracle
+    include ::ArJdbc::Util::QuotedCache
+
+    # By default, the OracleAdapter will consider all columns of type
+    # <tt>NUMBER(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;  ::ArJdbc::Oracle.emulate_booleans?; end # oracle-enhanced
+    def self.emulate_booleans=(emulate); ::ArJdbc::Oracle.emulate_booleans = emulate; end
+
+    def initialize(*args)
+      ::ArJdbc::Oracle.initialize!
+      super # configure_connection happens in super
+
+      @use_insert_returning = config.key?(:insert_returning) ?
+        self.class.type_cast_config_to_boolean(config[:insert_returning]) : nil
+    end
+
+  end
+
+  class OracleColumn < JdbcColumn
+    include ::ArJdbc::Oracle::Column
+
+    # def returning_id?; @returning_id ||= nil end
+    # def returning_id!; @returning_id = true end
+
+  end
+
+end