activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/rails_generators/jdbc_generator.rb

@@ -10,6 +10,6 @@ class JdbcGenerator < Rails::Generator::Base
 
   protected
   def banner
-    "Usage: #{$0} jdbc\nGenerate JDBC bootstrapping files for your Rails application."
+    "Usage: #{$0} jdbc\nGenerate JDBC bootstrapping files for your Rails (2.x) application."
   end
 end

data/rails_generators/templates/config/initializers/jdbc.rb

@@ -1,7 +1,10 @@
-# This file was generated by the "jdbc" generator, which is provided
-# by the activerecord-jdbc-adapter gem.
+# This file was generated by the "jdbc" generator, which is provided by the 
+# activerecord-jdbc-adapter gem.
 #
-# This file allows the JDBC drivers to be hooked into ActiveRecord
-# such that you don't have to change anything else in your Rails
-# application.
+# This file allows the JDBC adapters to be hooked into ActiveRecord such that 
+# you don't have to change anything else in your Rails application.
+# 
+# NOTE: This is only needed on Rails 2.x - without Bundler since when you're
+# using Bundler than `gem 'activerecord-jdbc-adapter'` will automatically 
+# `require 'arjdbc'` by default (unless you set it to `require: false`).
 require 'arjdbc' if defined?(JRUBY_VERSION)

data/rails_generators/templates/lib/tasks/jdbc.rake

@@ -1,8 +1,11 @@
-# This file was generated by the "jdbc" generator, which is provided
-# by the activerecord-jdbc-adapter gem.
+# This file was generated by the "jdbc" generator, which is provided by the 
+# activerecord-jdbc-adapter gem.
 #
-# This file allows you to use Rails' various db:* tasks with JDBC.
+# This file allows you to use Rails' various db:* tasks with the JDBC adapters.
+# 
+# NOTE: Only needed on Rails 2.x and it's fine to delete this file otherwise,
+# since on Rails 3.x AR-JDBC provides a Railtie that loads the Rake tasks.
 if defined?(JRUBY_VERSION)
   require 'arjdbc'
-  require 'arjdbc/jdbc/rake_tasks'
+  require 'arjdbc/tasks'
 end

data/rakelib/01-tomcat.rake

@@ -0,0 +1,51 @@
+namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
+
+  TOMCAT_MAVEN_REPO = 'http://repo2.maven.org/maven2/org/apache/tomcat'
+  TOMCAT_VERSION = '7.0.54'
+
+  DOWNLOAD_DIR = File.expand_path('../test/jars', File.dirname(__FILE__))
+
+  #tomcat_jar = "tomcat-embed-core.jar"
+  #tomcat_uri = "#{TOMCAT_MAVEN_REPO}/embed/tomcat-embed-core/#{TOMCAT_VERSION}/tomcat-embed-core-#{TOMCAT_VERSION}.jar"
+
+  catalina_jar = "tomcat-catalina.jar"
+  catalina_uri = "#{TOMCAT_MAVEN_REPO}/tomcat-catalina/#{TOMCAT_VERSION}/tomcat-catalina-#{TOMCAT_VERSION}.jar"
+
+  juli_jar = "tomcat-juli.jar"
+  juli_uri = "#{TOMCAT_MAVEN_REPO}/tomcat-juli/#{TOMCAT_VERSION}/tomcat-juli-#{TOMCAT_VERSION}.jar"
+
+  task :download do
+    require 'open-uri'; require 'tmpdir'
+
+    temp_dir = File.join(Dir.tmpdir, (Time.now.to_f * 1000).to_i.to_s)
+    FileUtils.mkdir temp_dir
+
+    downloads = Hash.new
+    downloads[juli_jar] = juli_uri
+    downloads[catalina_jar] = catalina_uri
+
+    Dir.chdir(temp_dir) do
+      FileUtils.mkdir DOWNLOAD_DIR unless File.exist?(DOWNLOAD_DIR)
+      downloads.each do |jar, uri|
+        puts "downloading #{uri}"
+        file = open(uri)
+        FileUtils.cp file.path, File.join(DOWNLOAD_DIR, jar)
+      end
+    end
+
+    FileUtils.rm_r temp_dir
+  end
+
+  task :check do
+    jar_path = File.join(DOWNLOAD_DIR, catalina_jar)
+    unless File.exist?(jar_path)
+      Rake::Task['tomcat-jndi:download'].invoke
+    end
+  end
+
+  task :clear do
+    jar_path = File.join(DOWNLOAD_DIR, catalina_jar)
+    rm jar_path if File.exist?(jar_path)
+  end
+
+end

data/rakelib/02-test.rake

@@ -0,0 +1,132 @@
+
+test_tasks = [ 'test_mysql', 'test_sqlite3', 'test_postgresql_with_hint' ]
+if defined?(JRUBY_VERSION)
+  test_tasks.push :test_derby, :test_hsqldb, :test_h2
+  test_tasks.push :test_jndi, :test_jdbc
+end
+
+desc "Run \"most\" available test_xxx tasks"
+task :test => test_tasks
+
+task 'test_postgresql_with_hint' do
+  require File.expand_path('../../test/shared_helper', __FILE__)
+  if PostgresHelper.have_postgres?(false)
+    Rake::Task['test_postgresql'].invoke
+  else
+    puts "NOTE: won't run test_postgresql"
+  end
+end
+
+Rake::TestTask.class_eval { attr_reader :test_files }
+
+def test_task_for(adapter, options = {})
+  desc = options[:desc] || options[:comment] || "Run tests against #{options[:database_name] || adapter}"
+  adapter = adapter.to_s.downcase
+  driver = adapter if ( driver = options[:driver] ).nil?
+  prereqs = options[:prereqs] || []
+  unless prereqs.frozen?
+    prereqs = [ prereqs ].flatten; # prereqs << 'test_appraisal_hint'
+  end
+  name = options[:name] || "test_#{adapter}"
+  test_task = Rake::TestTask.new(name => prereqs) do |test_task|
+    files = options[:files] || begin
+      FileList["test/#{adapter}*_test.rb"] + FileList["test/db/#{adapter}/**/*_test.rb"]
+    end
+    test_task.test_files = files
+    test_task.libs = []
+    if defined?(JRUBY_VERSION)
+      test_task.libs << 'lib'
+      test_task.libs << "jdbc-#{driver}/lib" if driver && File.exists?("jdbc-#{driver}/lib")
+      test_task.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
+    end
+    test_task.libs << 'test'
+    test_task.options = '--use-color=t'
+    test_task.verbose = true if $VERBOSE
+    yield(test_task) if block_given?
+  end
+  task = Rake::Task[name]
+  # reset the description set-up by Rake::TestTask :
+  if task.instance_variable_defined? :@full_comment
+    task.instance_variable_set(:@full_comment, nil)
+  else
+    task.instance_variable_get(:@comments).clear
+  end
+  task.add_description(desc)
+  test_task
+end
+
+test_task_for :Derby, :desc => 'Run tests against (embedded) DerbyDB'
+test_task_for :H2, :desc => 'Run tests against H2 database engine'
+test_task_for :HSQLDB, :desc => 'Run tests against HyperSQL (Java) database'
+test_task_for :MSSQL, :driver => :jtds, :database_name => 'MS-SQL (SQLServer)'
+test_task_for :MySQL #, :prereqs => 'db:mysql'
+task :test_mysql2 => :test_mysql
+test_task_for :PostgreSQL, :driver => ENV['JDBC_POSTGRES_VERSION'] || 'postgres' #, :prereqs => 'db:postgresql'
+task :test_postgres => :test_postgresql # alias
+test_task_for :SQLite3, :driver => ENV['JDBC_SQLITE_VERSION']
+task :test_sqlite => :test_sqlite3 # alias
+test_task_for :Firebird
+
+test_task_for :MariaDB, :files => FileList["test/db/mysql/*_test.rb"] do |test_task| #, :prereqs => 'db:mysql'
+  test_task.ruby_opts << '-rdb/mariadb_config'
+end
+
+# ensure driver for these DBs is on your class-path
+[ :Oracle, :DB2, :Informix, :CacheDB ].each do |adapter|
+  test_task_for adapter, :desc => "Run tests against #{adapter} (ensure driver is on class-path)"
+end
+
+#test_task_for :MSSQL, :name => 'test_sqlserver', :driver => nil, :database_name => 'MS-SQL using SQLJDBC'
+
+test_task_for :AS400, :desc => "Run tests against AS400 (DB2) (ensure driver is on class-path)",
+              :files => FileList["test/db2*_test.rb"] + FileList["test/db/db2/*_test.rb"]
+
+#task :test_jdbc => [ :test_jdbc_mysql, :test_jdbc_derby ] if defined?(JRUBY_VERSION)
+
+test_task_for 'JDBC', :desc => 'Run tests against plain JDBC adapter (uses MySQL and Derby)',
+  :prereqs => [ 'db:mysql' ], :files => FileList['test/*jdbc_*test.rb'] do |test_task|
+  test_task.libs << 'jdbc-mysql/lib' << 'jdbc-derby/lib'
+end
+
+# TODO since Derby AR 5.x support is not implemented we only run JNDI with MySQL :
+#task :test_jndi => [ :test_jndi_mysql, :test_jndi_derby ] if defined?(JRUBY_VERSION)
+task :test_jndi => [ :test_jndi_mysql ] if defined?(JRUBY_VERSION)
+
+jndi_classpath = [ 'test/jars/tomcat-juli.jar', 'test/jars/tomcat-catalina.jar' ]
+
+jndi_classpath.each do |jar_path|
+  file(jar_path) { Rake::Task['tomcat-jndi:download'].invoke }
+end
+
+get_jndi_classpath_opt = lambda do
+  cp = jndi_classpath.map { |jar_path| File.expand_path("../#{jar_path}", File.dirname(__FILE__)) }
+  "-J-cp \"#{cp.join(File::PATH_SEPARATOR)}\""
+end
+
+test_task_for 'JNDI_Derby', :desc => 'Run tests against a Derby JNDI connection',
+  :prereqs => jndi_classpath, :files => FileList['test/*jndi_derby*test.rb'] do |test_task|
+  test_task.libs << 'jdbc-derby/lib'
+  test_task.ruby_opts << get_jndi_classpath_opt.call
+  #test_task.verbose = true
+end
+
+test_task_for 'JNDI_MySQL', :desc => 'Run tests against a MySQL JNDI connection',
+  :prereqs => [ 'db:mysql' ] + jndi_classpath, :files => FileList['test/*jndi_mysql*test.rb'] do |test_task|
+  test_task.libs << 'jdbc-mysql/lib'
+  test_task.ruby_opts << get_jndi_classpath_opt.call
+end
+
+test_task_for :MySQL, :name => 'test_jdbc_mysql',
+  :prereqs => 'db:mysql', :database_name => 'MySQL (using adapter: jdbc)' do |test_task|
+  test_task.ruby_opts << '-rdb/jdbc_mysql' # replaces require 'db/mysql'
+end
+test_task_for :PostgreSQL, :name => 'test_jdbc_postgresql', :driver => 'postgres',
+  :prereqs => 'db:postgresql', :database_name => 'PostgreSQL (using adapter: jdbc)' do |test_task|
+  test_task.ruby_opts << '-rdb/jdbc_postgres' # replaces require 'db/postgres'
+end
+
+# NOTE: Sybase testing is currently broken, please fix it if you're on Sybase :
+#test_task_for :Sybase, :desc => "Run tests against Sybase (using jTDS driver)"
+#task :test_sybase_jtds => :test_sybase # alias
+#test_task_for :Sybase, :name => 'sybase_jconnect',
+#  :desc => "Run tests against Sybase (ensure jConnect driver is on class-path)"

data/rakelib/bundler_ext.rb

@@ -0,0 +1,11 @@
+module Bundler
+  class GemHelper
+    def guard_already_tagged
+      # parent project performs the tag
+    end
+    def tag_version
+      Bundler.ui.confirm "Parent project tagged #{version_tag}"
+      yield if block_given?
+    end
+  end
+end

data/rakelib/compile.rake

@@ -1,25 +1,70 @@
-def java_classpath_arg # myriad of ways to discover JRuby classpath
-  begin
-    cpath  = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
-    cpath += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
-    jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
-  rescue => e
-  end
-  unless jruby_cpath
-    jruby_cpath = ENV['JRUBY_PARENT_CLASSPATH'] || ENV['JRUBY_HOME'] &&
-      FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
-  end
-  jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
-end
+jar_file = File.join(*%w(lib arjdbc jdbc adapter_java.jar))
+begin
+  require 'ant'
+  directory classes = "pkg/classes"
+  CLEAN << classes
+
+  driver_jars = []
+  # PostgreSQL driver :
+  driver_jars << Dir.glob("jdbc-postgres/lib/*.jar").sort.last
+  
+  file jar_file => FileList['src/java/**/*.java', 'pkg/classes'] do
+    rm_rf FileList["#{classes}/**/*"]
+    ant.javac :srcdir => "src/java", :destdir => "pkg/classes",
+      :source => "7", :target => "7", :debug => true, :deprecation => true,
+      :classpath => "${java.class.path}:${sun.boot.class.path}:#{driver_jars.join(':')}",
+      :includeantRuntime => false
+
+    ant.tstamp do |ts|
+      ts.format(:property => 'TODAY', :pattern => 'yyyy-MM-dd HH:mm:ss')
+    end
 
-jar_name = File.join(*%w(lib arjdbc jdbc adapter_java.jar))
+    begin
+      require 'arjdbc/version'
+    rescue LoadError
+      path = File.expand_path('../lib', File.dirname(__FILE__))
+      unless $LOAD_PATH.include?(path)
+        $LOAD_PATH << path; retry
+      end
+    end
 
-desc "Compile the native Java code."
-task :java_compile do
-  debug = ENV['DEBUG'] ? '-g' : ''
-  pkg_classes = File.join(*%w(pkg classes))
-  mkdir_p pkg_classes
-  sh "javac -target 1.5 -source 1.5 #{debug} -d pkg/classes #{java_classpath_arg} #{FileList['src/java/**/*.java'].join(' ')}"
-  sh "jar cf #{jar_name} -C #{pkg_classes} ."
+    gem_version = Gem::Version.create(ArJdbc::VERSION)
+    if gem_version.segments.last == 'DEV'
+      version = gem_version.segments[0...-1] # 1.3.0.DEV -> 1.3.0
+    else
+      version = gem_version.segments.dup
+    end
+    version = version.join('.')
+    
+    ant.manifest :file => 'MANIFEST.MF' do |mf|
+      mf.attribute :name => 'Built-By', :value => '${user.name}'
+      mf.attribute :name => 'Built-Time', :value => '${TODAY}'
+      mf.attribute :name => 'Built-Jdk', :value => '${java.version}'
+      mf.attribute :name => 'Built-JRuby', :value => JRUBY_VERSION
+      
+      mf.attribute :name => 'Specification-Title', :value => 'ActiveRecord-JDBC'
+      mf.attribute :name => 'Specification-Version', :value => '1.3'
+      mf.attribute :name => 'Specification-Vendor', :value => 'JRuby'
+      mf.attribute :name => 'Implementation-Version', :value => version
+      mf.attribute :name => 'Implementation-Vendor', :value => 'The JRuby Team'
+    end
+    
+    ant.jar :basedir => "pkg/classes", :includes => "**/*.class", 
+            :destfile => jar_file, :manifest => 'MANIFEST.MF'
+  end
+
+  desc "Compile the native Java code."
+  task :jar => jar_file
+  
+  namespace :jar do
+    task :force do
+      rm jar_file if File.exist?(jar_file)
+      Rake::Task['jar'].invoke
+    end
+  end
+  
+rescue LoadError
+  task :jar do
+    puts "Run 'jar' with JRuby to re-compile the agent extension class"
+  end
 end
-file jar_name => :java_compile

data/rakelib/db.rake

@@ -0,0 +1,61 @@
+namespace :db do
+
+  desc "Creates the test database for MySQL"
+  task :mysql do
+    require File.expand_path('../../test/shared_helper', __FILE__)
+    fail "could not create test database: mysql executable not found" unless mysql = which('mysql')
+    load 'test/db/mysql_config.rb' # rescue nil
+    enc = MYSQL_CONFIG[:encoding] || 'utf8' # 'utf8mb4'
+    puts MYSQL_CONFIG.inspect if $VERBOSE
+    # DROP USER arjdbc@localhost; __ERROR 1396 (HY000): Operation CREATE USER failed__
+    script = sql_script <<-SQL, 'mysql'
+DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
+CREATE DATABASE `#{MYSQL_CONFIG[:database]}` DEFAULT CHARACTER SET `#{enc}` COLLATE `#{enc}_general_ci`;
+GRANT ALL PRIVILEGES ON `#{MYSQL_CONFIG[:database]}`.* TO #{MYSQL_CONFIG[:username]}@localhost;
+GRANT ALL PRIVILEGES ON `test\_%`.* TO #{MYSQL_CONFIG[:username]}@localhost;
+SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG[:password]}');
+    SQL
+    params = { '-u' => 'root' }
+    if ENV['DATABASE_YML']; require 'yaml'
+    params['-p'] = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
+    end
+    params['-u'] = ENV['MY_USER'] if ENV['MY_USER']
+    params['-p'] = ENV['MY_PASSWORD'] if ENV['MY_PASSWORD']
+    puts "Creating MySQL (test) database: #{MYSQL_CONFIG[:database]}"
+    sh "cat #{script.path} | #{mysql} -f #{params.map {|k, v| "#{k}#{v}"}.join(' ')}", :verbose => $VERBOSE # so password is not echoed
+  end
+
+  desc "Creates the test database for PostgreSQL"
+  task :postgresql do
+    require File.expand_path('../../test/shared_helper', __FILE__)
+    fail 'could not create test database: psql executable not found' unless psql = which('psql')
+    fail 'could not create test database: missing "postgres" role' unless PostgresHelper.postgres_role?
+    load 'test/db/postgres_config.rb' # rescue nil
+    puts POSTGRES_CONFIG.inspect if $VERBOSE
+    script = sql_script <<-SQL, 'psql'
+DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
+DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};
+CREATE USER #{POSTGRES_CONFIG[:username]} CREATEDB SUPERUSER LOGIN PASSWORD '#{POSTGRES_CONFIG[:password]}';
+CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]}
+       TEMPLATE template0
+       ENCODING '#{POSTGRES_CONFIG[:encoding]}' LC_COLLATE '#{POSTGRES_CONFIG[:collate]}' LC_CTYPE '#{POSTGRES_CONFIG[:collate]}';
+    SQL
+    params = { '-U' => ENV['PSQL_USER'] || 'postgres' }
+    params['-q'] = nil unless $VERBOSE
+    puts "Creating PostgreSQL (test) database: #{POSTGRES_CONFIG[:database]}"
+    sh "cat #{script.path} | #{psql} #{params.to_a.join(' ')}", :verbose => $VERBOSE
+  end
+  task :postgres => :postgresql
+
+  private
+
+  def sql_script(sql_content, name = 'sql_script')
+    require 'tempfile'; script = Tempfile.new(name)
+    script.puts sql_content
+    yield(script) if block_given?
+    script.close
+    at_exit { script.unlink }
+    script
+  end
+
+end

data/rakelib/rails.rake

@@ -1,41 +1,216 @@
 namespace :rails do
-  def _adapter(n)
-    case n
-    when /postgres/
-      'postgresql'
-    else
-      n
+
+  %w(MySQL SQLite3 PostgreSQL).each do |adapter|
+
+    desc "Run Rails ActiveRecord tests with #{adapter} (JDBC)"
+    task "test_#{adapter = adapter.downcase}" do
+      puts "Use TESTOPTS=\"--verbose\" to pass --verbose to runners." if ARGV.include? '--verbose'
+
+      if ENV['RAILS']
+        ar_path = File.join(ENV['RAILS'], 'activerecord')
+      end
+      
+      unless ar_path && File.exist?(ar_path)
+        ar_path = `bundle info --path activerecord`.chomp
+      end
+
+      unless File.exist? ar_test_dir = File.join(ar_path, 'test')
+        raise "can not directly load Rails tests;" +
+              " try setting a local repository path e.g. export RAILS=`pwd`/../rails"
+      end
+
+      driver = "jdbc-#{ENV['DRIVER'] ? ENV['DRIVER'].downcase : (adapter =~ /postgres/i ? 'postgres' : adapter)}"
+      adapter = 'mysql2' if adapter.eql?('mysql')
+
+      root_dir = File.expand_path('..', File.dirname(__FILE__))
+      env = {}
+      env['ARCONFIG'] = ENV['ARCONFIG'] || File.join(root_dir, 'test/rails', 'config.yml')
+      env['ARCONN'] = adapter
+      env['BUNDLE_GEMFILE'] = ENV['BUNDLE_GEMFILE'] || File.join(root_dir, 'Gemfile') # use AR-JDBC's with Rails tests
+      env['EXCLUDE_DIR'] = File.join(root_dir, 'test/rails/excludes', adapter) # minitest-excludes
+
+      libs = [
+          File.join(root_dir, 'lib'),
+          File.join(root_dir, driver, 'lib'),
+          File.join(root_dir, 'test/rails'),
+          ar_test_dir
+      ]
+
+      test_files_finder = lambda do
+        Dir.chdir(ar_path) do # taken from Rails' *activerecord/Rakefile* :
+          ( Dir.glob("test/cases/**/*_test.rb").reject { |x| x =~ /\/adapters\// } +
+            Dir.glob("test/cases/adapters/#{adapter}/**/*_test.rb") )
+        end
+      end
+
+      task_stub = Class.new(Rake::TestTask) { def define; end }.new # no-op define
+      test_loader_code = task_stub.run_code # :rake test-loader
+
+      ruby_opts_string = "-I\"#{libs.join(File::PATH_SEPARATOR)}\""
+      ruby_opts_string += " -C \"#{ar_path}\""
+      ruby_opts_string += " -rbundler/setup"
+      ruby_opts_string += " -rminitest -rminitest/excludes" unless ENV['NO_EXCLUDES'].eql?('true')
+      file_list = ENV["TEST"] ? FileList[ ENV["TEST"] ] : test_files_finder.call
+      file_list_string = file_list.map { |fn| "\"#{fn}\"" }.join(' ')
+      # test_loader_code = "-e \"ARGV.each{|f| require f}\"" # :direct
+      option_list = ( ENV["TESTOPTS"] || ENV["TESTOPT"] || ENV["TEST_OPTS"] || '' )
+
+      args = "#{ruby_opts_string} #{test_loader_code} #{file_list_string} #{option_list}"
+      env_sh env, "#{FileUtils::RUBY} #{args}" do |ok, status|
+        if !ok && status.respond_to?(:signaled?) && status.signaled?
+          raise SignalException.new(status.termsig)
+        elsif !ok
+          fail "Command failed with status (#{status.exitstatus})"
+        end
+      end
     end
-  end
+    task :test_mysql2 => :test_mysql
+
+    FileUtils.module_eval do
+
+      def env_sh(env, *cmd, &block)
+        options = (Hash === cmd.last) ? cmd.pop : {}
+        shell_runner = block_given? ? block : create_shell_runner(cmd)
+        set_verbose_option(options)
+        options[:noop] ||= Rake::FileUtilsExt.nowrite_flag
+        Rake.rake_check_options options, :noop, :verbose
+
+        cmd = env.map { |k,v| "#{k}=\"#{v}\"" }.join(' ') + ' ' + cmd.join(' ')
+        Rake.rake_output_message cmd if options[:verbose]
+
+        unless options[:noop]
+          res = Kernel.system(cmd)
+          status = $?
+          status = Rake::PseudoStatus.new(1) if !res && status.nil?
+          shell_runner.call(res, status)
+        end
+      end
+
+      def env_system(env, cmd)
+        Kernel.system(env.map { |k,v| "#{k}=\"#{v}\"" }.join(' ') + ' ' + cmd)
+      end
 
-  def _driver(n)
-    case n
-    when /postgres/
-      'postgres'
-    else
-      n
     end
+
   end
 
-  def _target(n)
-    case n
-    when /postgres/
-      'test_jdbcpostgresql'
-    else
-      "test_jdbc#{n}"
+  namespace :db do
+    namespace :mysql do
+      desc 'Build the MySQL test databases'
+      task :build do
+        config = ARTest.config['connections']['mysql2']
+        %x( mysql --user=#{config['arunit']['username']} --password=#{config['arunit']['password']} -e "create DATABASE #{config['arunit']['database']} DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
+        %x( mysql --user=#{config['arunit2']['username']} --password=#{config['arunit2']['password']} -e "create DATABASE #{config['arunit2']['database']} DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci ")
+      end
+
+      desc 'Drop the MySQL test databases'
+      task :drop do
+        config = ARTest.config['connections']['mysql2']
+        %x( mysqladmin --user=#{config['arunit']['username']} --password=#{config['arunit']['password']} -f drop #{config['arunit']['database']} )
+        %x( mysqladmin --user=#{config['arunit2']['username']} --password=#{config['arunit2']['password']} -f drop #{config['arunit2']['database']} )
+      end
+
+      desc 'Rebuild the MySQL test databases'
+      task :rebuild => [:drop, :build]
+    end
+
+    namespace :postgresql do
+      desc 'Build the PostgreSQL test databases'
+      task :build do
+        config = ARTest.config['connections']['postgresql']
+        %x( createdb -E UTF8 -T template0 #{config['arunit']['database']} )
+        %x( createdb -E UTF8 -T template0 #{config['arunit2']['database']} )
+
+        # prepare hstore
+        if %x( createdb --version ).strip.gsub(/(.*)(\d\.\d\.\d)$/, "\\2") < "9.1.0"
+          puts "Please prepare hstore data type. See http://www.postgresql.org/docs/current/static/hstore.html"
+        end
+      end
+
+      desc 'Drop the PostgreSQL test databases'
+      task :drop do
+        config = ARTest.config['connections']['postgresql']
+        %x( dropdb #{config['arunit']['database']} )
+        %x( dropdb #{config['arunit2']['database']} )
+      end
+
+      desc 'Rebuild the PostgreSQL test databases'
+      task :rebuild => [:drop, :build]
     end
   end
 
-  task :test => "java_compile" do
-    driver = ENV['DRIVER']
-    raise "need a DRIVER" unless driver
-    activerecord = ENV['RAILS']
-    raise "need location of RAILS source code" unless activerecord
-    activerecord = File.join(activerecord, 'activerecord') unless activerecord =~ /activerecord$/
-    ar_jdbc = File.expand_path(File.dirname(__FILE__) + '/..')
-    rubylib = "#{ar_jdbc}/lib:#{ar_jdbc}/drivers/#{_driver(driver)}/lib:#{ar_jdbc}/adapters/#{_adapter(driver)}/lib"
-    Dir.chdir(activerecord) do
-      rake "RUBYLIB=#{rubylib}", "#{_target(driver)}"
+  # NOTE: we expect to, hopefully, not be using these anymore - delete at WILL!
+  namespace :test do
+    task :all do
+      driver = ENV['DRIVER'] || ENV['ADAPTER']
+      raise "need a DRIVER (DRIVER=mysql)" unless driver
+      rails_dir = _rails_dir
+      ENV['ARCONFIG'] = File.join(_ar_jdbc_dir, 'test', 'rails', 'config.yml')
+
+      Dir.chdir(File.join(rails_dir, 'activerecord')) do
+        sh FileUtils::RUBY, '-S', 'rake',
+           "RUBYLIB=#{_ruby_lib(rails_dir, driver)}",
+           _target(driver)
+      end
+    end
+
+    %w(MySQL SQLite3 Postgres).each do |adapter|
+      task adapter.downcase do
+        ENV['ADAPTER'] = adapter
+        Rake::Task['rails:test:all'].invoke
+      end
+
+      namespace adapter.downcase do
+        task "base_test" do
+          ENV['TEST'] ||= 'test/cases/base_test.rb'
+          ENV['ADAPTER'] = adapter
+          Rake::Task['rails:test:all'].invoke
+        end
+      end
+    end
+
+    private
+
+    def _ar_jdbc_dir
+      @ar_jdbc_dir ||= File.expand_path('..', File.dirname(__FILE__))
+    end
+
+    def _rails_dir
+      rails_dir = ENV['RAILS'] || File.join('..', 'rails')
+      unless File.directory? rails_dir
+        raise "can't find RAILS source at '#{rails_dir}' (maybe set ENV['RAILS'])"
+      end
+      rails_dir = File.join(rails_dir, '..') if rails_dir =~ /activerecord$/
+      File.expand_path(rails_dir)
+    end
+
+    def _ruby_lib(rails_dir, driver)
+      ar_jdbc_dir = _ar_jdbc_dir
+
+      if driver =~ /postgres/i
+        adapter, driver = 'postgresql', 'postgres'
+      else
+        adapter, driver = driver.downcase, adapter
+      end
+
+      [File.join(ar_jdbc_dir, 'lib'),
+       File.join(ar_jdbc_dir, 'test', 'rails'),
+       File.join(ar_jdbc_dir, "jdbc-#{driver}", 'lib'),
+       File.join(ar_jdbc_dir, "activerecord-jdbc#{adapter}-adapter", 'lib'),
+       File.expand_path('activesupport/lib', rails_dir),
+       File.expand_path('activemodel/lib', rails_dir),
+       File.expand_path('activerecord/lib', rails_dir)
+      ].join(':')
     end
+
+    def _target(name)
+      case name
+      when /postgres/i
+        'test_postgresql'
+      else
+        "test_jdbc#{name.downcase}"
+      end
+    end
+
   end
 end