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

data/lib/arjdbc/mssql/lock_methods.rb

@@ -0,0 +1,77 @@
+require 'strscan'
+
+module ArJdbc
+  module MSSQL
+    module LockMethods
+
+      # @private
+      SELECT_FROM_WHERE_RE = /\A(\s*SELECT\s.*?)(\sFROM\s)(.*?)(\sWHERE\s.*|)\Z/mi
+
+      # Microsoft SQL Server uses its own syntax for SELECT .. FOR UPDATE:
+      # SELECT .. FROM table1 WITH(ROWLOCK,UPDLOCK), table2 WITH(ROWLOCK,UPDLOCK) WHERE ..
+      #
+      # This does in-place modification of the passed-in string.
+      def add_lock!(sql, options)
+        if (lock = options[:lock]) && sql =~ /\A\s*SELECT/mi
+          # Check for and extract the :limit/:offset sub-query
+          if sql =~ /\A(\s*SELECT t\.\* FROM \()(.*)(\) AS t WHERE t._row_num BETWEEN \d+ AND \d+\s*)\Z/m
+            prefix, subselect, suffix = [$1, $2, $3]
+            add_lock!(subselect, options)
+            return sql.replace(prefix + subselect + suffix)
+          end
+          unless sql =~ SELECT_FROM_WHERE_RE
+            # If you get this error, this driver probably needs to be fixed.
+            raise NotImplementedError, "Don't know how to add_lock! to SQL statement: #{sql.inspect}"
+          end
+          select_clause, from_word, from_tables, where_clause = $1, $2, $3, $4
+          with_clause = lock.is_a?(String) ? " #{lock} " : " WITH(ROWLOCK,UPDLOCK) "
+
+          # Split the FROM clause into its constituent tables, and add the with clause after each one.
+          new_from_tables = []
+          scanner = StringScanner.new(from_tables)
+          until scanner.eos?
+            prev_pos = scanner.pos
+            if scanner.scan_until(/,|(INNER\s+JOIN|CROSS\s+JOIN|(LEFT|RIGHT|FULL)(\s+OUTER)?\s+JOIN)\s+/mi)
+              join_operand = scanner.pre_match[prev_pos..-1]
+              join_operator = scanner.matched
+            else
+              join_operand = scanner.rest
+              join_operator = ""
+              scanner.terminate
+            end
+
+            # At this point, we have something like:
+            #   join_operand == "appointments "
+            #   join_operator == "INNER JOIN "
+            # or:
+            #   join_operand == "appointment_details AS d1 ON appointments.[id] = d1.[appointment_id]"
+            #   join_operator == ""
+            if join_operand =~ /\A(.*)(\s+ON\s+.*)\Z/mi
+              table_spec, on_clause = $1, $2
+            else
+              table_spec = join_operand
+              on_clause = ""
+            end
+
+            # Add the "WITH(ROWLOCK,UPDLOCK)" option to the table specification
+            table_spec << with_clause unless table_spec =~ /\A\(\s*SELECT\s+/mi # HACK - this parser isn't so great
+            join_operand = table_spec + on_clause
+
+            # So now we have something like:
+            #   join_operand == "appointments  WITH(ROWLOCK,UPDLOCK) "
+            #   join_operator == "INNER JOIN "
+            # or:
+            #   join_operand == "appointment_details AS d1 WITH(ROWLOCK,UPDLOCK)  ON appointments.[id] = d1.[appointment_id]"
+            #   join_operator == ""
+
+            new_from_tables << join_operand
+            new_from_tables << join_operator
+          end
+          sql.replace( select_clause.to_s << from_word.to_s << new_from_tables.join << where_clause.to_s )
+        end
+        sql
+      end
+
+    end
+  end
+end

data/lib/arjdbc/mssql/utils.rb

@@ -1,15 +1,15 @@
-# NOTE: lot of code kindly borrowed from __activerecord-sqlserver-adapter__
 module ArJdbc
   module MSSQL
+    # @note Lot of code kindly borrowed from **activerecord-sqlserver-adapter**.
     module Utils
-      
+
       module_function
-      
-      GET_TABLE_NAME_INSERT_UPDATE_RE = 
+
+      GET_TABLE_NAME_INSERT_UPDATE_RE =
         /^\s*(INSERT|EXEC sp_executesql N'INSERT)\s+INTO\s+([^\(\s,]+)\s*|^\s*update\s+([^\(\s,]+)\s*/i
-      
+
       GET_TABLE_NAME_FROM_RE = /\bFROM\s+([^\(\)\s,]+)\s*/i
-      
+
       def get_table_name(sql, qualified = nil)
         if sql =~ GET_TABLE_NAME_INSERT_UPDATE_RE
           tn = $2 || $3
@@ -20,21 +20,21 @@ module ArJdbc
           nil
         end
       end
-      
+
       # protected
 
       def unquote_table_name(table_name)
         unquote_column_name(table_name)
       end
-      
+
       def unquote_column_name(column_name)
         column_name.to_s.tr('[]', '')
       end
-      
+
       def unquote_string(string)
         string.to_s.gsub("''", "'")
       end
-      
+
       def unqualify_table_name(table_name)
         table_name.to_s.split('.').last.tr('[]', '')
       end
@@ -47,7 +47,7 @@ module ArJdbc
         table_names = table_name.to_s.split('.')
         table_names.length == 3 ? table_names.first.tr('[]', '') : nil
       end
-      
+
     end
   end
 end

data/lib/arjdbc/mysql/adapter.rb

@@ -2,11 +2,31 @@ ArJdbc.load_java_part :MySQL
 
 require 'bigdecimal'
 require 'active_record/connection_adapters/abstract/schema_definitions'
+require 'arjdbc/mysql/column'
 require 'arjdbc/mysql/explain_support'
 
 module ArJdbc
   module MySQL
-    
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
+    end
+
+    # @private
+    def init_connection(jdbc_connection)
+      meta = jdbc_connection.meta_data
+      if meta.driver_major_version < 5
+        raise ::ActiveRecord::ConnectionFailed,
+          "MySQL adapter requires driver >= 5.0 got: '#{meta.driver_version}'"
+      elsif meta.driver_major_version == 5 && meta.driver_minor_version < 1
+        config[:connection_alive_sql] ||= 'SELECT 1' # need 5.1 for JDBC 4.0
+      else
+        # NOTE: since the loaded Java driver class can't change :
+        MySQL.send(:remove_method, :init_connection) rescue nil
+      end
+    end
+
     def configure_connection
       variables = config[:variables] || {}
       # By default, MySQL 'where id is null' selects the last inserted id. Turn this off.
@@ -42,161 +62,68 @@ module ArJdbc
       # ...and send them all in one query
       execute("SET #{encoding} #{variable_assignments}", :skip_logging)
     end
-    
-    def self.column_selector
-      [ /mysql/i, lambda { |_,column| column.extend(::ArJdbc::MySQL::Column) } ]
-    end
-
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
-    end
 
     def strict_mode? # strict_mode is default since AR 4.0
       config.key?(:strict) ? config[:strict] : ::ActiveRecord::VERSION::MAJOR > 3
     end
-    
+
+    # @private
     @@emulate_booleans = true
-    
+
     # Boolean emulation can be disabled using (or using the adapter method) :
-    # 
+    #
     #   ArJdbc::MySQL.emulate_booleans = false
-    # 
+    #
     # @see ActiveRecord::ConnectionAdapters::MysqlAdapter#emulate_booleans
     def self.emulate_booleans; @@emulate_booleans; end
     def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
-    
-    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
-        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
 
-    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" },
+      # :double => { :name=>"double", :limit=>17 }
+      # :real => { :name=>"real", :limit=>17 }
+      :numeric => { :name => "numeric" }, # :limit => 65
+      :decimal => { :name => "decimal" }, # :limit => 65
       :datetime => { :name => "datetime" },
+      # TIMESTAMP has varying properties depending on MySQL version (SQL mode)
       :timestamp => { :name => "datetime" },
       :time => { :name => "time" },
       :date => { :name => "date" },
       :binary => { :name => "blob" },
-      :boolean => { :name => "tinyint", :limit => 1 }
+      :boolean => { :name => "tinyint", :limit => 1 },
+      # AR-JDBC added :
+      :bit => { :name => "bit" }, # :limit => 1
+      :enum => { :name => "enum" },
+      :set => { :name => "set" }, # :limit => 64
+      :char => { :name => "char" }, # :limit => 255
     }
 
+    # @override
     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:
+
+    # @override
+    def adapter_name
       ADAPTER_NAME
     end
 
-    def self.arel2_visitors(config)
-      {
-        'mysql' => ::Arel::Visitors::MySQL,
-        'mysql2' => ::Arel::Visitors::MySQL,
-        'jdbcmysql' => ::Arel::Visitors::MySQL
-      }
+    def self.arel_visitor_type(config = nil)
+      ::Arel::Visitors::MySQL
     end
 
-    def new_visitor(config = nil)
-      visitor = ::Arel::Visitors::MySQL
-      ( prepared_statements? ? visitor : bind_substitution(visitor) ).new(self)
-    end if defined? ::Arel::Visitors::MySQL
-    
-    # @see #bind_substitution
-    class BindSubstitution < Arel::Visitors::MySQL # :nodoc:
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#bind_substitution
+    # @private
+    class BindSubstitution < Arel::Visitors::MySQL
       include Arel::Visitors::BindVisitor
     end if defined? Arel::Visitors::BindVisitor
-    
+
     def case_sensitive_equality_operator
       "= BINARY"
     end
@@ -211,10 +138,11 @@ module ArJdbc
 
     # QUOTING ==================================================
 
+    # @override
     def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
       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)
@@ -223,67 +151,80 @@ module ArJdbc
         super
       end
     end
-    
-    def quote_column_name(name) # :nodoc:
+
+    # @override
+    def quote_column_name(name)
       "`#{name.to_s.gsub('`', '``')}`"
     end
-    
-    def quote_table_name(name) # :nodoc:
+
+    # @override
+    def quote_table_name(name)
       quote_column_name(name).gsub('.', '`.`')
     end
-    
-    # Returns true, since this connection adapter supports migrations.
+
+    # @override
     def supports_migrations?
       true
     end
 
-    def supports_primary_key? # :nodoc:
+    # @override
+    def supports_primary_key?
       true
     end
 
-    def supports_bulk_alter? # :nodoc:
+    # @override
+    def supports_bulk_alter?
       true
     end
 
-    # 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:
+    # @override
+    def supports_index_sort_order?
+      # Technically MySQL allows to create indexes with the sort order syntax
+      # but at the moment (5.5) it doesn't yet implement them.
       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:
+    # @override
+    def supports_transaction_isolation?
+      # 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
       version[0] && version[0] >= 5
     end
-    
-    def supports_views? # :nodoc:
+
+    # @override
+    def supports_views?
       version[0] && version[0] >= 5
     end
-    
-    def supports_savepoints? # :nodoc:
-      true
-    end
 
+    # @override
     def supports_transaction_isolation?(level = nil)
       version[0] >= 5 # MySQL 5+
     end
-    
-    def create_savepoint
-      execute("SAVEPOINT #{current_savepoint_name}")
+
+    # NOTE: handled by JdbcAdapter we override only to have save-point in logs :
+
+    # @override
+    def supports_savepoints?
+      true
+    end
+
+    # @override
+    def create_savepoint(name = current_savepoint_name(true))
+      log("SAVEPOINT #{name}", 'Savepoint') { super }
     end
 
-    def rollback_to_savepoint
-      execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+    # @override
+    def rollback_to_savepoint(name = current_savepoint_name)
+      log("ROLLBACK TO SAVEPOINT #{name}", 'Savepoint') { super }
     end
 
-    def release_savepoint
-      execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+    # @override
+    def release_savepoint(name = current_savepoint_name)
+      log("RELEASE SAVEPOINT #{name}", 'Savepoint') { super }
     end
 
-    def disable_referential_integrity # :nodoc:
+    def disable_referential_integrity
       fk_checks = select_value("SELECT @@FOREIGN_KEY_CHECKS")
       begin
         update("SET FOREIGN_KEY_CHECKS = 0")
@@ -293,56 +234,44 @@ module ArJdbc
       end
     end
 
-    # DATABASE STATEMENTS ======================================
-    
-    def exec_insert(sql, name, binds, pk = nil, sequence_name = nil) # :nodoc:
-      execute sql, name, binds
-    end
-    
-    def exec_update(sql, name, binds) # :nodoc:
-      execute sql, name, binds
-    end
-    
-    def exec_delete(sql, name, binds) # :nodoc:
-      execute sql, name, binds
-    end
-    
-    # Make it public just like native MySQL adapter does.
-    def update_sql(sql, name = nil) # :nodoc:
+    # @override make it public just like native MySQL adapter does
+    def update_sql(sql, name = nil)
       super
     end
-    
+
     # SCHEMA STATEMENTS ========================================
-    
-    def structure_dump # :nodoc:
+
+    # @deprecated no longer used - handled with (AR built-in) Rake tasks
+    def structure_dump
+      # NOTE: due AR (2.3-3.2) compatibility views are not included
       if supports_views?
         sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
       else
         sql = "SHOW TABLES"
       end
 
-      select_all(sql).inject("") do |structure, table|
+      @connection.execute_query_raw(sql).map do |table|
+        # e.g. { "Tables_in_arjdbc_test"=>"big_fields", "Table_type"=>"BASE TABLE" }
         table.delete('Table_type')
+        table_name = table.to_a.first.last
 
-        hash = show_create_table(table.to_a.first.last)
+        create_table = select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")
 
-        if(table = hash["Create Table"])
-          structure += table + ";\n\n"
-        elsif(view = hash["Create View"])
-          structure += view + ";\n\n"
-        end
-      end
+        "#{create_table['Create Table']};\n\n"
+      end.join
     end
 
-    # Returns just a table's primary key
+    # Returns just a table's primary key.
+    # @override
     def primary_key(table)
       #pk_and_sequence = pk_and_sequence_for(table)
       #pk_and_sequence && pk_and_sequence.first
       @connection.primary_keys(table).first
     end
-    
+
     # Returns a table's primary key and belonging sequence.
-    # @note not used only here for potential compatibility with AR's adapter.
+    # @note Not used, only here for potential compatibility with native adapter.
+    # @override
     def pk_and_sequence_for(table)
       result = execute("SHOW CREATE TABLE #{quote_table_name(table)}", 'SCHEMA').first
       if result['Create Table'].to_s =~ /PRIMARY KEY\s+(?:USING\s+\w+\s+)?\((.+)\)/
@@ -352,18 +281,20 @@ module ArJdbc
         return nil
       end
     end
-    
+
+    # @private
     IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
-    
+
     if ::ActiveRecord::VERSION::MAJOR > 3
-      
+
     INDEX_TYPES = [ :fulltext, :spatial ]
     INDEX_USINGS = [ :btree, :hash ]
-    
+
     end
-      
+
     # Returns an array of indexes for the given table.
-    def indexes(table_name, name = nil) # :nodoc:
+    # @override
+    def indexes(table_name, name = nil)
       indexes = []
       current_index = nil
       result = execute("SHOW KEYS FROM #{quote_table_name(table_name)}", name || 'SCHEMA')
@@ -372,7 +303,7 @@ module ArJdbc
         if current_index != key_name
           next if key_name == 'PRIMARY' # skip the primary key
           current_index = key_name
-          indexes <<  
+          indexes <<
             if self.class.const_defined?(:INDEX_TYPES) # AR 4.0
               mysql_index_type = row['Index_type'].downcase.to_sym
               index_type = INDEX_TYPES.include?(mysql_index_type) ? mysql_index_type : nil
@@ -388,8 +319,9 @@ module ArJdbc
       end
       indexes
     end
-    
-    def columns(table_name, name = nil) # :nodoc:
+
+    # @override
+    def columns(table_name, name = nil)
       sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
       column = ::ActiveRecord::ConnectionAdapters::MysqlAdapter::Column
       result = execute(sql, name || 'SCHEMA')
@@ -399,12 +331,14 @@ module ArJdbc
       result
     end
 
-    def recreate_database(name, options = {}) # :nodoc:
+    # @private
+    def recreate_database(name, options = {})
       drop_database(name)
       create_database(name, options)
     end
 
-    def create_database(name, options = {}) # :nodoc:
+    # @override
+    def create_database(name, options = {})
       if options[:collation]
         execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
       else
@@ -412,7 +346,8 @@ module ArJdbc
       end
     end
 
-    def drop_database(name) #:nodoc:
+    # @override
+    def drop_database(name)
       execute "DROP DATABASE IF EXISTS `#{name}`"
     end
 
@@ -420,20 +355,24 @@ module ArJdbc
       select_one("SELECT DATABASE() as db")["db"]
     end
 
-    def create_table(name, options = {}) #:nodoc:
+    # @override
+    def create_table(name, options = {})
       super(name, {:options => "ENGINE=InnoDB DEFAULT CHARSET=utf8"}.merge(options))
     end
 
+    # @override
     def rename_table(table_name, new_name)
       execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
       rename_table_indexes(table_name, new_name) if respond_to?(:rename_table_indexes) # AR-4.0 SchemaStatements
     end
-    
-    def remove_index!(table_name, index_name) #:nodoc:
+
+    # @override
+    def remove_index!(table_name, index_name)
       # missing table_name quoting in AR-2.3
       execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
     end
-    
+
+    # @override
     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)
@@ -441,7 +380,7 @@ module ArJdbc
       execute(add_column_sql)
     end
 
-    def change_column_default(table_name, column_name, default) #:nodoc:
+    def change_column_default(table_name, column_name, default)
       column = column_for(table_name, column_name)
       change_column table_name, column_name, column.sql_type, :default => default
     end
@@ -456,7 +395,8 @@ module ArJdbc
       change_column table_name, column_name, column.sql_type, :null => null
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    # @override
+    def change_column(table_name, column_name, type, options = {})
       column = column_for(table_name, column_name)
 
       unless options_include_default?(options)
@@ -473,7 +413,8 @@ module ArJdbc
       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)
       options = {}
       if column = columns(table_name).find { |c| c.name == column_name.to_s }
         options[:default] = column.default; options[:null] = column.null
@@ -486,8 +427,10 @@ module ArJdbc
       execute(rename_column_sql)
       rename_column_indexes(table_name, column_name, new_column_name) if respond_to?(:rename_column_indexes) # AR-4.0 SchemaStatements
     end
-    
-    def add_limit_offset!(sql, options) #:nodoc:
+
+    # @note Only used with (non-AREL) ActiveRecord **2.3**.
+    # @see Arel::Visitors::MySQL
+    def add_limit_offset!(sql, options)
       limit, offset = options[:limit], options[:offset]
       if limit && offset
         sql << " LIMIT #{offset.to_i}, #{sanitize_limit(limit)}"
@@ -497,16 +440,15 @@ module ArJdbc
         sql << " OFFSET #{offset.to_i}"
       end
       sql
-    end
+    end if ::ActiveRecord::VERSION::MAJOR < 3
 
-    # Taken from: https://github.com/gfmurphy/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb#L540
-    #
     # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
     # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
     # these, we must use a subquery. However, MySQL is too stupid to create a
     # temporary table for this automatically, so we have to give it some prompting
     # in the form of a subsubquery. Ugh!
-    def join_to_update(update, select) #:nodoc:
+    # @private based on mysql_adapter.rb from 3.1-stable
+    def join_to_update(update, select)
       if select.limit || select.offset || select.orders.any?
         subsubselect = select.clone
         subsubselect.projections = [update.key]
@@ -575,10 +517,11 @@ module ArJdbc
       end
     end
 
+    # @override
     def empty_insert_statement_value
       "VALUES ()"
     end
-    
+
     protected
     def quoted_columns_for_index(column_names, options = {})
       length = options[:length] if options.is_a?(Hash)
@@ -593,6 +536,7 @@ module ArJdbc
       end
     end
 
+    # @override
     def translate_exception(exception, message)
       return super unless exception.respond_to?(:errno)
 
@@ -607,18 +551,14 @@ 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}"
       end
       column
     end
-    
-    def show_create_table(table)
-      select_one("SHOW CREATE TABLE #{quote_table_name(table)}")
-    end
-    
+
     def version
       return @version ||= begin
         version = []
@@ -633,7 +573,7 @@ module ArJdbc
         version
       end
     end
-    
+
   end
 end
 
@@ -641,19 +581,19 @@ module ActiveRecord
   module ConnectionAdapters
     # Remove any vestiges of core/Ruby MySQL adapter
     remove_const(:MysqlAdapter) if const_defined?(:MysqlAdapter)
-    
+
     class MysqlAdapter < JdbcAdapter
       include ::ArJdbc::MySQL
       include ::ArJdbc::MySQL::ExplainSupport
-      
-      # By default, the MysqlAdapter will consider all columns of type 
-      # <tt>tinyint(1)</tt> as boolean. If you wish to disable this :
-      #
+
+      # By default, the MysqlAdapter will consider all columns of type
+      # __tinyint(1)__ as boolean. If you wish to disable this :
+      # ```
       #   ActiveRecord::ConnectionAdapters::Mysql[2]Adapter.emulate_booleans = false
-      #
+      # ```
       def self.emulate_booleans; ::ArJdbc::MySQL.emulate_booleans; end
       def self.emulate_booleans=(emulate); ::ArJdbc::MySQL.emulate_booleans = emulate; end
-      
+
       class Column < JdbcColumn
         include ::ArJdbc::MySQL::Column
 
@@ -669,9 +609,9 @@ module ActiveRecord
         def adapter
           MysqlAdapter
         end
-        
+
       end
-      
+
       def initialize(*args)
         super
         # configure_connection happens in super
@@ -685,30 +625,8 @@ module ActiveRecord
         Column
       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
-      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
-    
+
     if ActiveRecord::VERSION::MAJOR < 3 ||
         ( ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1 )
       remove_const(:MysqlColumn) if const_defined?(:MysqlColumn)
@@ -724,6 +642,6 @@ module ActiveRecord
         Mysql2Column = MysqlAdapter::Column
       end
     end
-    
+
   end
 end