activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/lib/arjdbc/jdbc/column.rb

@@ -5,43 +5,48 @@ module ActiveRecord
 
       def initialize(config, name, default, *args)
         call_discovered_column_callbacks(config)
-        super(name,default_value(default),*args)
+        super(name, default_value(default), *args)
         init_column(name, default, *args)
       end
 
-      def init_column(*args)
-      end
+      def init_column(*args); end
+
+      def default_value(value); value; end
+
+      protected
 
-      def default_value(val)
-        val
+      def call_discovered_column_callbacks(config)
+        dialect = (config[:dialect] || config[:driver]).to_s
+        for matcher, block in self.class.column_types
+          block.call(config, self) if matcher === dialect
+        end
       end
 
+      public
+
       def self.column_types
-        # GH #25: reset the column types if the # of constants changed
-        # since last call
-        if ::ArJdbc.constants.size != driver_constants.size
-          @driver_constants = nil
-          @column_types = nil
+        # reset the column types if the # of constants changed since last call
+        @column_types ||= begin 
+          types = driver_constants.select { |c| c.respond_to? :column_selector }
+          types.map! { |c| c.column_selector }
+          types.inject({}) { |h, val| h[ val[0] ] = val[1]; h }
         end
-        @column_types ||= driver_constants.select {|c|
-          c.respond_to? :column_selector }.map {|c|
-          c.column_selector }.inject({}) {|h,val|
-          h[val[0]] = val[1]; h }
       end
 
       def self.driver_constants
-        @driver_constants ||= ::ArJdbc.constants.map {|c| ::ArJdbc.const_get c }
+        reset_constants
+        @driver_constants ||= ::ArJdbc.constants.map { |c| ::ArJdbc.const_get c }
       end
 
-      protected
-      def call_discovered_column_callbacks(config)
-        dialect = config[:dialect] || config[:driver]
-        for reg, func in JdbcColumn.column_types
-          if reg === dialect.to_s
-            func.call(config,self)
-          end
-        end
+      def self.reset_constants!
+        @driver_constants = nil; @column_types = nil
+      end
+      
+      def self.reset_constants
+        return false if ! defined?(@driver_constants) || ! @driver_constants
+        reset_constants! if ::ArJdbc.constants.size != @driver_constants.size
       end
+      
     end
   end
 end

data/lib/arjdbc/jdbc/connection.rb

@@ -41,7 +41,8 @@ module ActiveRecord
           url = configure_url
           username = config[:username].to_s
           password = config[:password].to_s
-          jdbc_driver = ( config[:driver_instance] ||= JdbcDriver.new(config[:driver].to_s) )
+          jdbc_driver = ( config[:driver_instance] ||= 
+              JdbcDriver.new(config[:driver].to_s, config[:properties]) )
 
           @connection_factory = JdbcConnectionFactory.impl do
             jdbc_driver.connection(url, username, password)
@@ -84,11 +85,14 @@ module ActiveRecord
         @stmts = {}
       rescue ::ActiveRecord::ActiveRecordError
         raise
-      rescue Exception => e
-        raise ::ActiveRecord::JDBCError.new("The driver encountered an unknown error: #{e}").tap { |err|
-          err.errno = 0
-          err.sql_exception = e
-        }
+      rescue Java::JavaSql::SQLException => e
+        e = e.cause if defined?(NativeException) && e.is_a?(NativeException) # JRuby-1.6.8
+        error = e.getMessage || e.getSQLState
+        error = error ? "#{e.java_class.name}: #{error}" : e.java_class.name
+        error = ::ActiveRecord::JDBCError.new("The driver encountered an unknown error: #{error}")
+        error.errno = e.getErrorCode
+        error.sql_exception = e
+        raise error
       end
 
       def adapter=(adapter)

data/lib/arjdbc/jdbc/driver.rb

@@ -1,9 +1,17 @@
 module ActiveRecord
   module ConnectionAdapters
     class JdbcDriver
-      def initialize(name)
+      attr_reader :name, :properties
+      
+      def initialize(name, properties = {})
         @name = name
         @driver = driver_class.new
+        if properties.is_a?(Java::JavaUtil::Properties)
+          @properties = properties # allow programmatically set properties
+        else
+          @properties = Java::JavaUtil::Properties.new
+          properties.each { |key, val| @properties[key] = val.to_s } if properties
+        end
       end
 
       def driver_class
@@ -25,10 +33,10 @@ module ActiveRecord
 
       def connection(url, user, pass)
         # bypass DriverManager to get around problem with dynamically loaded jdbc drivers
-        props = java.util.Properties.new
-        props.setProperty("user", user)
-        props.setProperty("password", pass)
-        @driver.connect(url, props)
+        properties = self.properties.clone
+        properties.setProperty("user", user) if user
+        properties.setProperty("password", pass) if pass
+        @driver.connect(url, properties)
       end
     end
   end

data/lib/arjdbc/jdbc/serialized_attributes_helper.rb

@@ -0,0 +1,21 @@
+module ArJdbc
+  module SerializedAttributesHelper
+
+    def self.dump_column_value(record, column)
+      value = record[ name = column.name.to_s ]
+      if record.class.respond_to?(:serialized_attributes)
+        if coder = record.class.serialized_attributes[name]
+          value = coder.respond_to?(:dump) ? coder.dump(value) : value.to_yaml
+        end
+      else
+        if record.respond_to?(:unserializable_attribute?)
+          value = value.to_yaml if record.unserializable_attribute?(name, column)
+        else
+          value = value.to_yaml if value.is_a?(Hash)
+        end
+      end
+      value
+    end
+    
+  end
+end

data/lib/arjdbc/mssql.rb

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

data/lib/arjdbc/mssql/adapter.rb

@@ -2,34 +2,34 @@ require 'strscan'
 require 'arjdbc/mssql/tsql_helper'
 require 'arjdbc/mssql/limit_helpers'
 require 'arjdbc/mssql/lock_helpers'
+require 'arjdbc/jdbc/serialized_attributes_helper'
 
-module ::ArJdbc
+module ArJdbc
   module MsSQL
     include TSqlMethods
     include LimitHelpers
 
+    @@_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_mssql_lob
-            self.class.columns.select { |c| c.sql_type =~ /image/i }.each do |c|
-              value = self[c.name]
-              if coder = self.class.serialized_attributes[c.name]
-                if coder.respond_to?(:dump)
-                  value = coder.dump(value)
-                else
-                  value = value.to_yaml
-                end
-              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 =~ /image/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_mssql_lob
-        @lob_callback_added = true
+        @@_lob_callback_added = true
       end
       mod.add_version_specific_add_limit_offset
     end
@@ -217,9 +217,9 @@ module ::ArJdbc
         else
           super
         end
-      when TrueClass             then '1'
-      when FalseClass            then '0'
-      else                       super
+      when TrueClass  then '1'
+      when FalseClass then '0'
+      else            super
       end
     end
 
@@ -319,12 +319,14 @@ module ::ArJdbc
         execute "ALTER TABLE #{table_name} ADD CONSTRAINT DF_#{table_name}_#{column_name} DEFAULT #{quote(default)} FOR #{quote_column_name(column_name)}"
       end
     end
-
-    def remove_column(table_name, column_name)
+    
+    def remove_column(table_name, *column_names) #:nodoc:
       clear_cached_table(table_name)
-      remove_check_constraints(table_name, column_name)
-      remove_default_constraint(table_name, column_name)
-      execute "ALTER TABLE #{table_name} DROP COLUMN [#{column_name}]"
+      for column_name in column_names.flatten
+        remove_check_constraints(table_name, column_name)
+        remove_default_constraint(table_name, column_name)
+        execute "ALTER TABLE #{table_name} DROP COLUMN [#{column_name}]"
+      end
     end
 
     def remove_default_constraint(table_name, column_name)
@@ -369,36 +371,6 @@ module ::ArJdbc
       @table_columns[table_name]
     end
 
-    def _execute(sql, name = nil)
-      # Match the start of the sql to determine appropriate behaviour.  Be aware of
-      # multi-line sql which might begin with 'create stored_proc' and contain 'insert into ...' lines.
-      # Possible improvements include ignoring comment blocks prior to the first statement.
-      if sql.lstrip =~ /\Ainsert/i
-        if query_requires_identity_insert?(sql)
-          table_name = get_table_name(sql)
-          with_identity_insert_enabled(table_name) do
-            id = @connection.execute_insert(sql)
-          end
-        else
-          @connection.execute_insert(sql)
-        end
-      elsif sql.lstrip =~ /\A(create|exec)/i
-        @connection.execute_update(sql)
-      elsif sql.lstrip =~ /\A\(?\s*(select|show)/i
-        repair_special_columns(sql)
-        @connection.execute_query(sql)
-      else
-        @connection.execute_update(sql)
-      end
-    end
-
-    def select(sql, name = nil, binds = [])
-      sql = substitute_binds(sql, binds)
-      log(sql, name) do
-        @connection.execute_query(sql)
-      end
-    end
-
     # Turns IDENTITY_INSERT ON for table during execution of the block
     # N.B. This sets the state of IDENTITY_INSERT to OFF after the
     # block has been executed without regard to its previous state
@@ -478,6 +450,32 @@ module ::ArJdbc
     def reset_column_information
       @table_columns = nil
     end
+    
+    private
+    
+    def _execute(sql, name = nil)
+      # Match the start of the SQL to determine appropriate behavior.
+      # Be aware of multi-line SQL which might begin with 'create stored_proc' 
+      # and contain 'insert into ...' lines.
+      # TODO test and refactor using `self.class.insert?(sql)` etc
+      # NOTE: ignoring comment blocks prior to the first statement ?!
+      if sql.lstrip =~ /\Ainsert/i # self.class.insert?(sql)
+        if query_requires_identity_insert?(sql)
+          table_name = get_table_name(sql)
+          with_identity_insert_enabled(table_name) do
+            @connection.execute_insert(sql)
+          end
+        else
+          @connection.execute_insert(sql)
+        end
+      elsif sql.lstrip =~ /\A\(?\s*(select|show)/i # self.class.select?(sql)
+        repair_special_columns(sql)
+        @connection.execute_query(sql)
+      else # sql.lstrip =~ /\A(create|exec)/i
+        @connection.execute_update(sql)
+      end
+    end
+    
   end
 end
 

data/lib/arjdbc/mssql/connection_methods.rb

@@ -1,7 +1,14 @@
 class ActiveRecord::Base
   class << self
     def mssql_connection(config)
-      require 'active_record/connection_adapters/jdbcmssql_adapter'
+      begin
+        require 'jdbc/jtds'
+        # NOTE: the adapter has only support for working with the
+        # open-source jTDS driver (won't work with MS's driver) !
+        ::Jdbc::JTDS.load_driver(:require) if defined?(::Jdbc::JTDS.load_driver)
+      rescue LoadError => e # assuming driver.jar is on the class-path
+        raise e unless e.message.to_s.index('no such file to load')
+      end
 
       config[:host] ||= "localhost"
       config[:port] ||= 1433

data/lib/arjdbc/mysql.rb

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

data/lib/arjdbc/mysql/adapter.rb

@@ -1,11 +1,9 @@
 require 'bigdecimal'
 require 'active_record/connection_adapters/abstract/schema_definitions'
+require 'arjdbc/mysql/explain_support'
 
-module ::ArJdbc
+module ArJdbc
   module MySQL
-    def self.column_selector
-      [/mysql/i, lambda {|cfg,col| col.extend(::ArJdbc::MySQL::ColumnExtensions)}]
-    end
 
     def self.extended(adapter)
       adapter.configure_connection
@@ -15,11 +13,16 @@ module ::ArJdbc
       execute("SET SQL_AUTO_IS_NULL=0")
     end
 
+    def self.column_selector
+      [ /mysql/i, lambda { |_,column| column.extend(::ArJdbc::MySQL::Column) } ]
+    end
+
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
     end
 
-    module ColumnExtensions
+    module Column
+      
       def extract_default(default)
         if sql_type =~ /blob/i || type == :text
           if default.blank?
@@ -60,14 +63,15 @@ module ::ArJdbc
           when /long/i
             2147483647 # mysql only allows 2^31-1, not 2^32-1, somewhat inconsistently with the tiny/medium/normal cases
           else
-            nil # we could return 65535 here, but we leave it undecorated by default
+            super # we could return 65535 here, but we leave it undecorated by default
           end
-        when /^enum/i;     255
         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
@@ -85,23 +89,51 @@ module ::ArJdbc
       def missing_default_forged_as_empty_string?(default)
         type != :string && !null && default == ''
       end
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = "int(11) DEFAULT NULL auto_increment PRIMARY KEY"
-      tp[:integer] = { :name => 'int', :limit => 4 }
-      tp[:decimal] = { :name => "decimal" }
-      tp[:timestamp] = { :name => "datetime" }
-      tp[:datetime][:limit] = nil
-      tp
-    end
-
+      
+    end
+
+    ColumnExtensions = Column # :nodoc: backwards-compatibility
+    
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
+      :string => { :name => "varchar", :limit => 255 },
+      :text => { :name => "text" },
+      :integer => { :name => "int", :limit => 4 },
+      :float => { :name => "float" },
+      :decimal => { :name => "decimal" },
+      :datetime => { :name => "datetime" },
+      :timestamp => { :name => "datetime" },
+      :time => { :name => "time" },
+      :date => { :name => "date" },
+      :binary => { :name => "blob" },
+      :boolean => { :name => "tinyint", :limit => 1 }
+    }
+
+    def native_database_types
+      NATIVE_DATABASE_TYPES
+    end
+    
+    def modify_types(types)
+      types[:primary_key] = "int(11) DEFAULT NULL auto_increment PRIMARY KEY"
+      types[:integer] = { :name => 'int', :limit => 4 }
+      types[:decimal] = { :name => "decimal" }
+      types[:timestamp] = { :name => "datetime" }
+      types[:datetime][:limit] = nil
+      types
+    end
+
+    ADAPTER_NAME = 'MySQL'.freeze
+    
     def adapter_name #:nodoc:
-      'MySQL'
+      ADAPTER_NAME
     end
 
     def self.arel2_visitors(config)
-      {}.tap {|v| %w(mysql mysql2 jdbcmysql).each {|a| v[a] = ::Arel::Visitors::MySQL } }
+      {
+        'mysql' => ::Arel::Visitors::MySQL,
+        'mysql2' => ::Arel::Visitors::MySQL,
+        'jdbcmysql' => ::Arel::Visitors::MySQL
+      }
     end
 
     def case_sensitive_equality_operator
@@ -120,32 +152,57 @@ module ::ArJdbc
 
     def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
-
-      if column && column.type == :primary_key
-        value.to_s
-      elsif column && String === value && column.type == :binary && column.class.respond_to?(:string_to_binary)
-        s = column.class.string_to_binary(value).unpack("H*")[0]
-        "x'#{s}'"
-      elsif BigDecimal === value
-        "'#{value.to_s("F")}'"
+      return value.to_s if column && column.type == :primary_key
+      
+      if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+        "x'#{column.class.string_to_binary(value).unpack("H*")[0]}'"
+      elsif value.kind_of?(BigDecimal)
+        value.to_s("F")
       else
         super
       end
     end
-
-    def quote_column_name(name)
+    
+    def quote_column_name(name) # :nodoc:
       "`#{name.to_s.gsub('`', '``')}`"
     end
+    
+    def quote_table_name(name) # :nodoc:
+      quote_column_name(name).gsub('.', '`.`')
+    end
+    
+    # Returns true, since this connection adapter supports migrations.
+    def supports_migrations?
+      true
+    end
 
-    def quoted_true
-      "1"
+    def supports_primary_key? # :nodoc:
+      true
     end
 
-    def quoted_false
-      "0"
+    def supports_bulk_alter? # :nodoc:
+      true
     end
 
-    def supports_savepoints? #:nodoc:
+    # Technically MySQL allows to create indexes with the sort order syntax
+    # but at the moment (5.5) it doesn't yet implement them
+    def supports_index_sort_order? # :nodoc:
+      true
+    end
+
+    # MySQL 4 technically support transaction isolation, but it is affected by a bug
+    # where the transaction level gets persisted for the whole session:
+    #
+    # http://bugs.mysql.com/bug.php?id=39170
+    def supports_transaction_isolation? # :nodoc:
+      version[0] && version[0] >= 5
+    end
+    
+    def supports_views? # :nodoc:
+      version[0] && version[0] >= 5
+    end
+    
+    def supports_savepoints? # :nodoc:
       true
     end
 
@@ -161,18 +218,31 @@ module ::ArJdbc
       execute("RELEASE SAVEPOINT #{current_savepoint_name}")
     end
 
-    def disable_referential_integrity(&block) #:nodoc:
-      old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+    def disable_referential_integrity # :nodoc:
+      fk_checks = select_value("SELECT @@FOREIGN_KEY_CHECKS")
       begin
         update("SET FOREIGN_KEY_CHECKS = 0")
         yield
       ensure
-        update("SET FOREIGN_KEY_CHECKS = #{old}")
+        update("SET FOREIGN_KEY_CHECKS = #{fk_checks}")
       end
     end
 
+    # DATABASE STATEMENTS ======================================
+    
+    def exec_insert(sql, name, binds)
+      execute sql, name, binds
+    end
+    alias :exec_update :exec_insert
+    alias :exec_delete :exec_insert
+    
+    # Make it public just like native MySQL adapter does.
+    def update_sql(sql, name = nil) # :nodoc:
+      super
+    end
+    
     # SCHEMA STATEMENTS ========================================
-
+    
     def structure_dump #:nodoc:
       if supports_views?
         sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
@@ -270,6 +340,11 @@ module ::ArJdbc
       execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
     end
 
+    def remove_index!(table_name, index_name) #:nodoc:
+      # missing table_name quoting in AR-2.3
+      execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+    end
+    
     def add_column(table_name, column_name, type, options = {})
       add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
       add_column_options!(add_column_sql, options)
@@ -373,15 +448,33 @@ module ::ArJdbc
     end
 
     def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-      return super unless type.to_s == 'integer'
-
-      case limit
-      when 1; 'tinyint'
-      when 2; 'smallint'
-      when 3; 'mediumint'
-      when nil, 4, 11; 'int(11)'  # compatibility with MySQL default
-      when 5..8; 'bigint'
-      else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+      case type.to_s
+      when 'binary'
+        case limit
+        when 0..0xfff; "varbinary(#{limit})"
+        when nil; "blob"
+        when 0x1000..0xffffffff; "blob(#{limit})"
+        else raise(ActiveRecordError, "No binary type has character length #{limit}")
+        end
+      when 'integer'
+        case limit
+        when 1; 'tinyint'
+        when 2; 'smallint'
+        when 3; 'mediumint'
+        when nil, 4, 11; 'int(11)' # compatibility with MySQL default
+        when 5..8; 'bigint'
+        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+        end
+      when 'text'
+        case limit
+        when 0..0xff; 'tinytext'
+        when nil, 0x100..0xffff; 'text'
+        when 0x10000..0xffffff; 'mediumtext'
+        when 0x1000000..0xffffffff; 'longtext'
+        else raise(ActiveRecordError, "No text type has character length #{limit}")
+        end
+      else
+        super
       end
     end
 
@@ -421,6 +514,7 @@ module ::ArJdbc
     end
 
     private
+    
     def column_for(table_name, column_name)
       unless column = columns(table_name).find { |c| c.name == column_name.to_s }
         raise "No such column: #{table_name}.#{column_name}"
@@ -431,10 +525,22 @@ module ::ArJdbc
     def show_create_table(table)
       select_one("SHOW CREATE TABLE #{quote_table_name(table)}")
     end
-
-    def supports_views?
-      false
+    
+    def version
+      return @version ||= begin
+        version = []
+        java_connection = jdbc_connection(true)
+        if java_connection.is_a?(Java::ComMysqlJdbc::ConnectionImpl)
+          version << jdbc_connection.serverMajorVersion
+          version << jdbc_connection.serverMinorVersion
+          version << jdbc_connection.serverSubMinorVersion
+        else
+          warn "INFO: failed to resolve MySQL server version using: #{java_connection}"
+        end
+        version
+      end
     end
+    
   end
 end
 
@@ -445,7 +551,7 @@ module ActiveRecord
     remove_const(:MysqlAdapter) if const_defined?(:MysqlAdapter)
 
     class MysqlColumn < JdbcColumn
-      include ArJdbc::MySQL::ColumnExtensions
+      include ::ArJdbc::MySQL::Column
 
       def initialize(name, *args)
         if Hash === name
@@ -460,128 +566,58 @@ module ActiveRecord
     end
 
     class MysqlAdapter < JdbcAdapter
-      include ArJdbc::MySQL
+      include ::ArJdbc::MySQL
+      include ::ArJdbc::MySQL::ExplainSupport
 
       def initialize(*args)
         super
         configure_connection
       end
 
-      ## EXPLAIN support lifted from the mysql2 gem with slight modifications
-      ## to work in the JDBC adapter gem.
-      def supports_explain?
-        true
-      end
-
-      def explain(arel, binds = [])
-        sql     = "EXPLAIN #{to_sql(arel, binds.dup)}"
-        start   = Time.now.to_f
-        raw_result  = execute(sql, "EXPLAIN")
-        ar_result = ActiveRecord::Result.new(raw_result[0].keys, raw_result)
-        elapsed = Time.now.to_f - start
-        ExplainPrettyPrinter.new.pp(ar_result, 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.values, 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 do |col|
-              cells_in_column = [col] + result.rows.map {|r| r[col].nil? ? 'NULL' : r[col].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
-
       def jdbc_connection_class(spec)
         ::ArJdbc::MySQL.jdbc_connection_class
       end
 
       def jdbc_column_class
-        ActiveRecord::ConnectionAdapters::MysqlColumn
+        MysqlColumn
       end
-
       alias_chained_method :columns, :query_cache, :jdbc_columns
 
-      protected
-      def exec_insert(sql, name, binds)
-        binds = binds.dup
+      # some QUOTING caching :
 
-        # Pretend to support bind parameters
-        unless binds.empty?
-          sql = sql.gsub('?') { quote(*binds.shift.reverse) }
+      @@quoted_table_names = {}
+
+      def quote_table_name(name)
+        unless quoted = @@quoted_table_names[name]
+          quoted = super
+          @@quoted_table_names[name] = quoted.freeze
         end
-        execute sql, name
+        quoted
       end
-      alias :exec_update :exec_insert
-      alias :exec_delete :exec_insert
 
+      @@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
   end
 end
 
-module Mysql                    # :nodoc:
-  remove_const(:Error) if const_defined?(:Error)
+# 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 Error < ::ActiveRecord::JDBCError
-  end
+module Mysql # :nodoc:
+  remove_const(:Error) if const_defined?(:Error)
+  class Error < ::ActiveRecord::JDBCError; end
 
   def self.client_version
-    50400                       # faked out for AR tests
+    50400 # faked out for AR tests
   end
 end