activerecord-jdbc-adapter 0.9.7-java → 1.0.0.beta1-java

data/lib/arjdbc/jdbc/quoted_primary_key.rb

@@ -0,0 +1,28 @@
+module ArJdbc
+  module QuotedPrimaryKeyExtension
+    def self.extended(base)
+      #       Rails 3 method           Rails 2 method
+      meth = [:arel_attributes_values, :attributes_with_quotes].detect do |m|
+        base.private_instance_methods.include?(m.to_s)
+      end
+      pk_hash_key = "self.class.primary_key"
+      pk_hash_value = '"?"'
+      if meth == :arel_attributes_values
+        pk_hash_key = "self.class.arel_table[#{pk_hash_key}]"
+        pk_hash_value = "Arel::SqlLiteral.new(#{pk_hash_value})"
+      end
+      if meth
+        base.module_eval <<-PK, __FILE__, __LINE__
+          alias :#{meth}_pre_pk :#{meth}
+          def #{meth}(include_primary_key = true, *args) #:nodoc:
+            aq = #{meth}_pre_pk(include_primary_key, *args)
+            if connection.is_a?(ArJdbc::Oracle) || connection.is_a?(ArJdbc::Mimer)
+              aq[#{pk_hash_key}] = #{pk_hash_value} if include_primary_key && aq[#{pk_hash_key}].nil?
+            end
+            aq
+          end
+        PK
+      end
+    end
+  end
+end

data/lib/{jdbc_adapter → arjdbc/jdbc}/railtie.rb

@@ -1,6 +1,6 @@
 require 'rails/railtie'
 
-module ::JdbcSpec
+module ::ArJdbc
   class Railtie < ::Rails::Railtie
     rake_tasks do
       load File.expand_path('../rake_tasks.rb', __FILE__)

data/lib/arjdbc/jdbc/require_driver.rb

@@ -0,0 +1,16 @@
+module Kernel
+  # load a JDBC driver library/gem, failing silently. If failed, trust
+  # that the driver jar is already present through some other means
+  def jdbc_require_driver(path, gem_name = nil)
+    gem_name ||= path.sub('/', '-')
+    2.times do
+      begin
+        require path
+        break
+      rescue LoadError
+        require 'rubygems'
+        begin; gem gem_name; rescue LoadError; end
+      end
+    end
+  end
+end

data/lib/arjdbc/jdbc/type_converter.rb

@@ -0,0 +1,119 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # I want to use JDBC's DatabaseMetaData#getTypeInfo to choose the best native types to
+    # use for ActiveRecord's Adapter#native_database_types in a database-independent way,
+    # but apparently a database driver can return multiple types for a given
+    # java.sql.Types constant.  So this type converter uses some heuristics to try to pick
+    # the best (most common) type to use.  It's not great, it would be better to just
+    # delegate to each database's existin AR adapter's native_database_types method, but I
+    # wanted to try to do this in a way that didn't pull in all the other adapters as
+    # dependencies.  Suggestions appreciated.
+    class JdbcTypeConverter
+      # The basic ActiveRecord types, mapped to an array of procs that are used to #select
+      # the best type.  The procs are used as selectors in order until there is only one
+      # type left.  If all the selectors are applied and there is still more than one
+      # type, an exception will be raised.
+      AR_TO_JDBC_TYPES = {
+        :string      => [ lambda {|r| Jdbc::Types::VARCHAR == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^varchar/i},
+                          lambda {|r| r['type_name'] =~ /^varchar$/i},
+                          lambda {|r| r['type_name'] =~ /varying/i}],
+        :text        => [ lambda {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^text$/i},     # For Informix
+                          lambda {|r| r['type_name'] =~ /^(text|clob)$/i},
+                          lambda {|r| r['type_name'] =~ /^character large object$/i},
+                          lambda {|r| r['sql_data_type'] == 2005}],
+        :integer     => [ lambda {|r| Jdbc::Types::INTEGER == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^integer$/i},
+                          lambda {|r| r['type_name'] =~ /^int4$/i},
+                          lambda {|r| r['type_name'] =~ /^int$/i}],
+        :decimal     => [ lambda {|r| Jdbc::Types::DECIMAL == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i},
+                          lambda {|r| r['type_name'] =~ /^numeric$/i},
+                          lambda {|r| r['type_name'] =~ /^number$/i},
+                          lambda {|r| r['type_name'] =~ /^real$/i},
+                          lambda {|r| r['precision'] == '38'},
+                          lambda {|r| r['data_type'] == '2'}],
+        :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE, Jdbc::Types::REAL].include?(r['data_type'].to_i)},
+                          lambda {|r| r['data_type'].to_i == Jdbc::Types::REAL}, #Prefer REAL to DOUBLE for Postgresql
+                          lambda {|r| r['type_name'] =~ /^float/i},
+                          lambda {|r| r['type_name'] =~ /^double$/i},
+                          lambda {|r| r['type_name'] =~ /^real$/i},
+                          lambda {|r| r['precision'] == '15'}],
+        :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^datetime$/i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^timestamp$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^time$/i},
+                          lambda {|r| r['type_name'] =~ /^datetime/i},  # For Informix
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver
+        :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^date$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i},
+                          lambda {|r| r['type_name'] =~ /^integer/i}],  #Num of milliseconds for SQLite3 JDBC Driver3
+        :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^blob/i},
+                          lambda {|r| r['type_name'] =~ /sub_type 0$/i}, # For FireBird
+                          lambda {|r| r['type_name'] =~ /^varbinary$/i}, # We want this sucker for Mimer
+                          lambda {|r| r['type_name'] =~ /^binary$/i}, ],
+        :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'].to_i)},
+                          lambda {|r| r['type_name'] =~ /^bool/i},
+                          lambda {|r| r['data_type'] == '-7'},
+                          lambda {|r| r['type_name'] =~ /^tinyint$/i},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i},
+                          lambda {|r| r['type_name'] =~ /^integer$/i}]
+      }
+
+      def initialize(types)
+        @types = types
+        @types.each {|t| t['type_name'] ||= t['local_type_name']} # Sybase driver seems to want 'local_type_name'
+      end
+
+      def choose_best_types
+        type_map = {}
+        @types.each do |row|
+          name = row['type_name'].downcase
+          k = name.to_sym
+          type_map[k] = { :name => name }
+          type_map[k][:limit] = row['precision'].to_i if row['precision']
+        end
+
+        AR_TO_JDBC_TYPES.keys.each do |k|
+          typerow = choose_type(k)
+          type_map[k] = { :name => typerow['type_name'].downcase }
+          case k
+          when :integer, :string, :decimal
+            type_map[k][:limit] = typerow['precision'] && typerow['precision'].to_i
+          when :boolean
+            type_map[k][:limit] = 1
+          end
+        end
+        type_map
+      end
+
+      def choose_type(ar_type)
+        procs = AR_TO_JDBC_TYPES[ar_type]
+        types = @types
+        procs.each do |p|
+          new_types = types.reject {|r| r["data_type"].to_i == Jdbc::Types::OTHER}
+          new_types = new_types.select(&p)
+          new_types = new_types.inject([]) do |typs,t|
+            typs << t unless typs.detect {|el| el['type_name'] == t['type_name']}
+            typs
+          end
+          return new_types.first if new_types.length == 1
+          types = new_types if new_types.length > 0
+        end
+        raise "unable to choose type for #{ar_type} from:\n#{types.collect{|t| t['type_name']}.inspect}"
+      end
+    end
+  end
+end

data/lib/arjdbc/mimer.rb

@@ -0,0 +1,2 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/mimer/adapter'

data/lib/{jdbc_adapter/jdbc_mimer.rb → arjdbc/mimer/adapter.rb}

@@ -1,11 +1,8 @@
-module JdbcSpec
+module ArJdbc
   module Mimer
     def self.extended(mod)
-      ActiveRecord::Base.extend JdbcSpec::QuotedPrimaryKeyExtension
-    end
-
-    def self.adapter_matcher(name, *)
-      name =~ /mimer/i ? self : false
+      require 'arjdbc/jdbc/quoted_primary_key'
+      ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
     end
 
     def modify_types(tp)
@@ -20,7 +17,7 @@ module JdbcSpec
       tp[:date] = { :name => "TIMESTAMP" }
       tp
     end
-    
+
     def default_sequence_name(table, column) #:nodoc:
       "#{table}_seq"
     end
@@ -54,13 +51,13 @@ module JdbcSpec
         log(sql, name) { @connection.execute_insert sql,pk }
       else # Assume the sql contains a bind-variable for the id
         id_value = select_one("SELECT NEXT_VALUE OF #{sequence_name} AS val FROM MIMER.ONEROW")['val']
-        log(sql, name) { 
+        log(sql, name) {
           execute_prepared_insert(sql,id_value)
         }
       end
       id_value
     end
-    
+
     def execute_prepared_insert(sql, id)
       @stmts ||= {}
       @stmts[sql] ||= @connection.ps(sql)
@@ -72,24 +69,24 @@ module JdbcSpec
 
     def quote(value, column = nil) #:nodoc:
       return value.quoted_id if value.respond_to?(:quoted_id)
-      
+
       if String === value && column && column.type == :binary
         return "X'#{quote_string(value.unpack("C*").collect {|v| v.to_s(16)}.join)}'"
       end
       case value
-      when String     
+      when String
         %Q{'#{quote_string(value)}'}
-      when NilClass   
+      when NilClass
         'NULL'
-      when TrueClass  
+      when TrueClass
         '1'
-      when FalseClass 
+      when FalseClass
         '0'
-      when Numeric    
+      when Numeric
         value.to_s
-      when Date, Time 
+      when Date, Time
         %Q{TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
-      else              
+      else
         %Q{'#{quote_string(value.to_yaml)}'}
       end
     end
@@ -106,7 +103,7 @@ module JdbcSpec
       @limit = options[:limit]
       @offset = options[:offset]
     end
-    
+
     def select_all(sql, name = nil)
       @offset ||= 0
       if !@limit || @limit == -1
@@ -118,7 +115,7 @@ module JdbcSpec
     ensure
       @limit = @offset = nil
     end
-    
+
     def select_one(sql, name = nil)
       @offset ||= 0
       select(sql, name)[@offset]

data/lib/arjdbc/mssql.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/jtds', 'jdbc-mssql'
+require 'arjdbc/mssql/connection_methods'
+require 'arjdbc/mssql/adapter'

data/lib/{jdbc_adapter/jdbc_mssql.rb → arjdbc/mssql/adapter.rb}

@@ -1,22 +1,7 @@
-require 'jdbc_adapter/tsql_helper'
-
-module ::JdbcSpec
-
-  module ActiveRecordExtensions
-
-    def mssql_connection(config)
-      require "active_record/connection_adapters/mssql_adapter"
-      config[:host] ||= "localhost"
-      config[:port] ||= 1433
-      config[:url] ||= "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
-      config[:driver] ||= "net.sourceforge.jtds.jdbc.Driver"
-      embedded_driver(config)
-    end
-
-  end
+require 'arjdbc/mssql/tsql_helper'
 
+module ::ArJdbc
   module MsSQL
-
     include TSqlMethods
 
     def self.extended(mod)
@@ -39,12 +24,8 @@ module ::JdbcSpec
       mod.add_version_specific_add_limit_offset
     end
 
-    def self.adapter_matcher(name, *)
-      name =~ /sqlserver|tds/i ? self : false
-    end
-
     def self.column_selector
-      [/sqlserver|tds/i, lambda {|cfg,col| col.extend(::JdbcSpec::MsSQL::Column)}]
+      [/sqlserver|tds/i, lambda {|cfg,col| col.extend(::ArJdbc::MsSQL::Column)}]
     end
 
     def self.jdbc_connection_class
@@ -102,7 +83,7 @@ module ::JdbcSpec
       def type_cast(value)
         return nil if value.nil? || value == "(null)" || value == "(NULL)"
         case type
-        when :integer then unquote(value).to_i rescue value ? 1 : 0
+        when :integer then value.to_i rescue unquote(value).to_i rescue value ? 1 : 0
         when :primary_key then value == true || value == false ? value == true ? 1 : 0 : value.to_i
         when :decimal   then self.class.value_to_decimal(unquote(value))
         when :datetime  then cast_to_datetime(value)
@@ -165,7 +146,7 @@ module ::JdbcSpec
       when String, ActiveSupport::Multibyte::Chars
         value = value.to_s
         if column && column.type == :binary
-          "'#{quote_string(JdbcSpec::MsSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
+          "'#{quote_string(ArJdbc::MsSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
         elsif column && [:integer, :float].include?(column.type)
           value = column.type == :integer ? value.to_i : value.to_f
           value.to_s
@@ -209,7 +190,7 @@ module ::JdbcSpec
           end_row = offset + limit.to_i
           order = (options[:order] || determine_order_clause(sql))
           sql.sub!(/ ORDER BY.*$/i, '')
-          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/i
+          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im
           whole, select, rest_of_query = find_select.match(sql).to_a
           if (start_row == 1) && (end_row ==1)
             new_sql = "#{select} TOP 1 #{rest_of_query}"
@@ -240,7 +221,7 @@ module ::JdbcSpec
           end_row = offset + limit.to_i
           order = (options[:order] || determine_order_clause(sql))
           sql.sub!(/ ORDER BY.*$/i, '')
-          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/i
+          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im
           whole, select, rest_of_query = find_select.match(sql).to_a
           new_sql = "#{select} t.* FROM (SELECT ROW_NUMBER() OVER(ORDER BY #{order}) AS row_num, #{rest_of_query}"
           new_sql << ") AS t WHERE t.row_num BETWEEN #{start_row.to_s} AND #{end_row.to_s}"
@@ -371,6 +352,12 @@ module ::JdbcSpec
       end
     end
 
+    def select(sql, name = nil)
+      log(sql, name) do
+        @connection.execute_query(sql)
+      end
+    end
+
     #SELECT .. FOR UPDATE is not supported on Microsoft SQL Server
     def add_lock!(sql, options)
       sql
@@ -452,17 +439,18 @@ module ::JdbcSpec
 
     def determine_order_clause(sql)
       return $1 if sql =~ /ORDER BY (.*)$/
-      sql =~ /FROM +(\w+?)\b/ || raise("can't determine table name")
-      table_name = $1
+      table_name = get_table_name(sql)
       "#{table_name}.#{determine_primary_key(table_name)}"
     end
 
     def determine_primary_key(table_name)
       primary_key = columns(table_name).detect { |column| column.primary || column.identity }
-      primary_key ? primary_key.name : "id"
+      return primary_key.name if primary_key
+      # Look for an id column.  Return it, without changing case, to cover dbs with a case-sensitive collation.
+      columns(table_name).each { |column| return column.name if column.name =~ /^id$/i }
+      # Give up and provide something which is going to crash almost certainly
+      "id"
     end
-
   end
-
 end
 

data/lib/arjdbc/mssql/connection_methods.rb

@@ -0,0 +1,13 @@
+class ActiveRecord::Base
+  class << self
+    def mssql_connection(config)
+      require "arjdbc/mssql"
+      config[:host] ||= "localhost"
+      config[:port] ||= 1433
+      config[:url] ||= "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      config[:driver] ||= "net.sourceforge.jtds.jdbc.Driver"
+      embedded_driver(config)
+    end
+    alias_method :jdbcmssql_connection, :mssql_connection
+  end
+end

data/lib/{jdbc_adapter → arjdbc/mssql}/tsql_helper.rb

@@ -12,7 +12,7 @@ module TSqlMethods
   def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
     return 'uniqueidentifier' if (type.to_s == 'uniqueidentifier')
     return super unless type.to_s == 'integer'
-    
+
     if limit.nil? || limit == 4
       'int'
     elsif limit == 2

data/lib/arjdbc/mysql.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/mysql'
+require 'arjdbc/mysql/connection_methods'
+require 'arjdbc/mysql/adapter'

data/lib/arjdbc/mysql/adapter.rb

@@ -0,0 +1,388 @@
+require 'active_record/connection_adapters/abstract/schema_definitions'
+
+module ::ArJdbc
+  module MySQL
+    def self.column_selector
+      [/mysql/i, lambda {|cfg,col| col.extend(::ArJdbc::MySQL::Column)}]
+    end
+
+    def self.extended(adapter)
+      adapter.configure_connection
+    end
+
+    def configure_connection
+      execute("SET SQL_AUTO_IS_NULL=0")
+    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)
+        return :boolean if field_type =~ /tinyint\(1\)|bit/i
+        return :string  if field_type =~ /enum/i
+        super
+      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
+            nil # 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
+        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
+    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
+
+    def adapter_name #:nodoc:
+      'MySQL'
+    end
+
+    def case_sensitive_equality_operator
+      "= BINARY"
+    end
+
+    # QUOTING ==================================================
+
+    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")}'"
+      else
+        super
+      end
+    end
+
+    def quoted_true
+        "1"
+    end
+
+    def quoted_false
+        "0"
+    end
+
+    def begin_db_transaction #:nodoc:
+      @connection.begin
+    rescue Exception
+      # Transactions aren't supported
+    end
+
+    def commit_db_transaction #:nodoc:
+      @connection.commit
+    rescue Exception
+      # Transactions aren't supported
+    end
+
+    def rollback_db_transaction #:nodoc:
+      @connection.rollback
+    rescue Exception
+      # Transactions aren't supported
+    end
+
+    def supports_savepoints? #:nodoc:
+      true
+    end
+
+    def create_savepoint
+      execute("SAVEPOINT #{current_savepoint_name}")
+    end
+
+    def rollback_to_savepoint
+      execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+    end
+
+    def release_savepoint
+      execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+    end
+
+    def disable_referential_integrity(&block) #:nodoc:
+      old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+      begin
+        update("SET FOREIGN_KEY_CHECKS = 0")
+        yield
+      ensure
+        update("SET FOREIGN_KEY_CHECKS = #{old}")
+      end
+    end
+
+    # SCHEMA STATEMENTS ========================================
+
+    def structure_dump #:nodoc:
+      if supports_views?
+        sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
+      else
+        sql = "SHOW TABLES"
+      end
+
+      select_all(sql).inject("") do |structure, table|
+        table.delete('Table_type')
+
+        hash = show_create_table(table.to_a.first.last)
+
+        if(table = hash["Create Table"])
+          structure += table + ";\n\n"
+        elsif(view = hash["Create View"])
+          structure += view + ";\n\n"
+        end
+      end
+    end
+
+    def recreate_database(name, options = {}) #:nodoc:
+      drop_database(name)
+      create_database(name, options)
+    end
+
+    def character_set(options) #:nodoc:
+      str = "CHARACTER SET `#{options[:charset] || 'utf8'}`"
+      str += " COLLATE `#{options[:collation]}`" if options[:collation]
+      str
+    end
+    private :character_set
+
+    def create_database(name, options = {}) #:nodoc:
+      execute "CREATE DATABASE `#{name}` DEFAULT #{character_set(options)}"
+    end
+
+    def drop_database(name) #:nodoc:
+      execute "DROP DATABASE IF EXISTS `#{name}`"
+    end
+
+    def current_database
+      select_one("SELECT DATABASE() as db")["db"]
+    end
+
+    def create_table(name, options = {}) #:nodoc:
+      super(name, {:options => "ENGINE=InnoDB #{character_set(options)}"}.merge(options))
+    end
+
+    def rename_table(name, new_name)
+      execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_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)
+      add_column_position!(add_column_sql, options)
+      execute(add_column_sql)
+    end
+
+    def change_column_default(table_name, column_name, default) #:nodoc:
+      column = column_for(table_name, column_name)
+      change_column table_name, column_name, column.sql_type, :default => default
+    end
+
+    def change_column_null(table_name, column_name, null, default = nil)
+      column = column_for(table_name, column_name)
+
+      unless null || default.nil?
+        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+      end
+
+      change_column table_name, column_name, column.sql_type, :null => null
+    end
+
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      column = column_for(table_name, column_name)
+
+      unless options_include_default?(options)
+        options[:default] = column.default
+      end
+
+      unless options.has_key?(:null)
+        options[:null] = column.null
+      end
+
+      change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      add_column_options!(change_column_sql, options)
+      add_column_position!(change_column_sql, options)
+      execute(change_column_sql)
+    end
+
+    def rename_column(table_name, column_name, new_column_name) #:nodoc:
+      options = {}
+      if column = columns(table_name).find { |c| c.name == column_name.to_s }
+        options[:default] = column.default
+        options[:null] = column.null
+      else
+        raise ActiveRecord::ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+      end
+      current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
+      rename_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
+      add_column_options!(rename_column_sql, options)
+      execute(rename_column_sql)
+    end
+
+    def add_limit_offset!(sql, options) #:nodoc:
+      limit, offset = options[:limit], options[:offset]
+      if limit && offset
+        sql << " LIMIT #{offset.to_i}, #{sanitize_limit(limit)}"
+      elsif limit
+        sql << " LIMIT #{sanitize_limit(limit)}"
+      elsif offset
+        sql << " OFFSET #{offset.to_i}"
+      end
+      sql
+    end
+
+    def show_variable(var)
+      res = execute("show variables like '#{var}'")
+      row = res.detect {|row| row["Variable_name"] == var }
+      row && row["Value"]
+    end
+
+    def charset
+      show_variable("character_set_database")
+    end
+
+    def collation
+      show_variable("collation_database")
+    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}")
+      end
+    end
+
+    def add_column_position!(sql, options)
+      if options[:first]
+        sql << " FIRST"
+      elsif options[:after]
+        sql << " AFTER #{quote_column_name(options[:after])}"
+      end
+    end
+
+    protected
+    def translate_exception(exception, message)
+      return super unless exception.respond_to?(:errno)
+
+      case exception.errno
+      when 1062
+        ::ActiveRecord::RecordNotUnique.new(message, exception)
+      when 1452
+        ::ActiveRecord::InvalidForeignKey.new(message, exception)
+      else
+        super
+      end
+    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 supports_views?
+      false
+    end
+  end
+end
+
+module ActiveRecord::ConnectionAdapters
+  class MysqlColumn < JdbcColumn
+    include ArJdbc::MySQL::Column
+
+    def initialize(name, *args)
+      if Hash === name
+        super
+      else
+        super(nil, name, *args)
+      end
+    end
+
+    def call_discovered_column_callbacks(*)
+    end
+  end
+
+  class MysqlAdapter < JdbcAdapter
+    include ArJdbc::MySQL
+
+    def initialize(*args)
+      super
+      configure_connection
+    end
+
+    def adapter_spec(config)
+      # return nil to avoid extending ArJdbc::MySQL, which we've already done
+    end
+
+    def jdbc_column_class
+      ActiveRecord::ConnectionAdapters::MysqlColumn
+    end
+  end
+end
+
+module Mysql                    # :nodoc:
+  def self.client_version
+    50400                       # faked out for AR tests
+  end
+end