activerecord-jdbc-adapter-ficoh 1.3.21-java

data/rails_generators/jdbc_generator.rb

@@ -0,0 +1,15 @@
+class JdbcGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory 'config/initializers'
+      m.template 'config/initializers/jdbc.rb', File.join('config', 'initializers', 'jdbc.rb')
+      m.directory 'lib/tasks'
+      m.template 'lib/tasks/jdbc.rake', File.join('lib', 'tasks', 'jdbc.rake')
+    end
+  end
+
+  protected
+  def banner
+    "Usage: #{$0} jdbc\nGenerate JDBC bootstrapping files for your Rails (2.x) application."
+  end
+end

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

@@ -0,0 +1,10 @@
+# This file was generated by the "jdbc" generator, which is provided by the 
+# activerecord-jdbc-adapter gem.
+#
+# 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

@@ -0,0 +1,11 @@
+# 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 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/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.61'
+
+  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,151 @@
+
+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
+
+task 'test_appraisal_hint' do
+  next if File.exists?('.disable-appraisal-hint')
+  unless (ENV['BUNDLE_GEMFILE'] || '') =~ /gemfiles\/.*?\.gemfile/
+    appraisals = []; Appraisal::File.each { |file| appraisals << file.name }
+    puts "HINT: specify AR version with `rake appraisal:{version} test_{adapter}'" +
+         " where version=(#{appraisals.join('|')}) (`touch .disable-appraisal-hint' to disable)"
+  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.ruby_opts << '-v' if RUBY_VERSION.index('1.8') == 0
+    # set current Ruby compatibility version on JRuby <= 1.7 :
+    if defined?(JRUBY_VERSION) && JRUBY_VERSION.index('1.7') == 0
+      test_task.ruby_opts << "--#{RUBY_VERSION[/^(\d+\.\d+)/, 1]}"
+    end
+    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'
+test_task_for :PostgreSQL, :driver => '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, :prereqs => 'db:mysql', :files => FileList["test/db/mysql/*_test.rb"]
+
+# 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
+
+task :test_jndi => [ :test_jndi_mysql, :test_jndi_derby ] if defined?(JRUBY_VERSION)
+
+jndi_classpath = []
+jndi_classpath << 'test/jars/tomcat-juli.jar'
+jndi_classpath << '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 do |jar_path|
+    File.expand_path("../#{jar_path}", File.dirname(__FILE__))
+  end
+  "-J-cp \"#{cp.join(windows? ? ';' : ':')}\""
+end
+
+def windows?; require 'rbconfig'; RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw/ 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
+
+# TODO 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/db.rake

@@ -0,0 +1,58 @@
+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'
+    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'
+      password = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
+      params['--password'] = password
+    end
+    puts "Creating MySQL (test) database: #{MYSQL_CONFIG[:database]}"
+    sh "cat #{script.path} | #{mysql} #{params.to_a.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
+    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

@@ -0,0 +1,77 @@
+namespace :rails do
+  
+  task :test do
+    raise "need a DRIVER e.g. DRIVER=mysql" unless driver = ENV['DRIVER'] || ENV['ADAPTER']
+    raise "need location of RAILS source code e.g. RAILS=../rails" unless rails_dir = ENV['RAILS']
+    rails_dir = File.join(rails_dir, '..') if rails_dir =~ /activerecord$/
+    activerecord_dir = File.join(rails_dir, 'activerecord') # rails/activerecord
+
+    ar_jdbc_dir = File.expand_path('..', File.dirname(__FILE__))
+    
+    ruby_lib = [ 
+      "#{ar_jdbc_dir}/lib",
+      "#{ar_jdbc_dir}/test/rails",
+      "#{ar_jdbc_dir}/jdbc-#{_driver(driver)}/lib",
+      "#{ar_jdbc_dir}/activerecord-jdbc#{_adapter(driver)}-adapter/lib"
+    ]
+    ruby_lib << File.expand_path('activesupport/lib', rails_dir)
+    ruby_lib << File.expand_path('activemodel/lib', rails_dir)
+    ruby_lib << File.expand_path(File.join(activerecord_dir, 'lib'))
+    requires = _requires(driver) || []
+
+    Dir.chdir(activerecord_dir) do
+      ruby = FileUtils::RUBY
+      rubylib = ruby_lib.join(':') # i_lib = "-I#{rubylib}"
+      r_requires = requires.map { |feat| "-r#{feat}" }.join(' ')
+      sh "#{ruby} -S rake RUBYLIB=#{rubylib} RUBYOPT=\"#{r_requires}\" #{_target(driver)}"
+    end
+  end
+  
+  %w(MySQL SQLite3 Postgres).each do |adapter|
+    desc "Run Rails' ActiveRecord tests with #{adapter} (JDBC)"
+    task "test_#{adapter.downcase}" do
+      ENV['ADAPTER'] = adapter; Rake::Task['rails:test'].invoke
+    end
+  end
+  
+  private
+  
+  def _adapter(name)
+    case name
+    when /postgres/i
+      'postgresql'
+    else
+      name.downcase
+    end
+  end
+
+  def _driver(name)
+    case name
+    when /postgres/i
+      'postgres'
+    else
+      name.downcase
+    end
+  end
+
+  def _target(name)
+    case name
+    when /postgres/i
+      'test_jdbcpostgresql'
+    else
+      "test_jdbc#{name.downcase}"
+    end
+  end
+
+  def _requires(name)
+    requires = []
+    requires << 'ubygems'
+    requires << 'active_support/json' # avoid uninitialized constant BasicsTest::JSON
+    case name
+    when /mysql/i
+      requires << 'mysql' # -rmysql - so Rails tests do not complain about Mysql
+    end
+    requires
+  end
+  
+end

data/src/java/arjdbc/ArJdbcModule.java

@@ -0,0 +1,288 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2013-2014 Karol Bucek.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package arjdbc;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.jruby.NativeException;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+import arjdbc.jdbc.RubyJdbcConnection;
+import static arjdbc.jdbc.RubyJdbcConnection.getJdbcConnection;
+
+/**
+ * ::ArJdbc
+ *
+ * @author kares
+ */
+@JRubyModule(name = "ArJdbc")
+public class ArJdbcModule {
+
+    public static RubyModule load(final Ruby runtime) {
+        final RubyModule arJdbc = runtime.getOrCreateModule("ArJdbc");
+        arJdbc.defineAnnotatedMethods( ArJdbcModule.class );
+        return arJdbc;
+    }
+
+    public static RubyModule get(final Ruby runtime) {
+        return runtime.getModule("ArJdbc");
+    }
+
+    public static void warn(final ThreadContext context, final String message) {
+        final Ruby runtime = context.runtime;
+        get(runtime).callMethod(context, "warn", runtime.newString(message));
+    }
+
+    /**
+     * Load the Java parts for the given adapter spec module, e.g. to load
+     * ArJdbc::MySQL's Java part: <code>ArJdbc.load_java_part :MySQL</code>
+     *
+     * NOTE: this method is not intended to be called twice for a given adapter !
+     * @param context
+     * @param self
+     * @param args ( moduleName, [ connectionClass, moduleClass ] )
+     * @return true
+     */
+    @JRubyMethod(name = "load_java_part", meta = true, required = 1, optional = 2)
+    public static IRubyObject load_java_part(final ThreadContext context,
+        final IRubyObject self, final IRubyObject[] args) {
+        final Ruby runtime = context.runtime;
+
+        String connectionClass = args.length > 1 ? args[1].toString() : null;
+        String moduleClass = args.length > 2 ? args[2].toString() : null;
+
+        final String moduleName = args[0].toString(); // e.g. 'MySQL'
+        final String packagePrefix = "arjdbc." + moduleName.toLowerCase() + "."; // arjdbc.mysql
+
+        // NOTE: due previous (backwards compatible) conventions there are
+        // 2 things we load, the adapter spec module's Java implemented methods
+        // and a custom JdbcConnection class (both are actually optional) e.g. :
+        //
+        //   MySQLModule.load(RubyModule); // 'arjdbc.mysql' package is assumed
+        //   MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(Ruby, RubyClass);
+        //
+
+        if (moduleClass == null) {
+             // 'arjdbc.mysql.' + 'MySQL' + 'Module'
+            moduleClass = packagePrefix + moduleName + "Module";
+        }
+
+        final Class<?> module;
+        try {
+            module = Class.forName(moduleClass);
+            // new convention MySQLModule.load( Ruby runtime ) :
+            try {
+                invokeStatic(runtime, module, "load", Ruby.class, runtime);
+            }
+            catch (NoSuchMethodException e) {
+                // old convention MySQLModule.load( RubyModule arJdbc ) :
+                invokeStatic(runtime, module, "load", RubyModule.class, get(runtime));
+            }
+        }
+        catch (ClassNotFoundException e) { /* ignored */ }
+        catch (NoSuchMethodException e) {
+            throw newNativeException(runtime, e);
+        }
+
+        String connectionClass2 = null;
+        if (connectionClass == null) {
+             // 'arjdbc.mysql.' + 'MySQL' + 'RubyJdbcConnection'
+            connectionClass = packagePrefix + moduleName + "RubyJdbcConnection";
+            connectionClass2 = packagePrefix + moduleName + "JdbcConnection";
+        }
+
+        try {
+            Class<?> connection = null;
+            try {
+                connection = Class.forName(connectionClass);
+            }
+            catch (ClassNotFoundException e) {
+                if ( connectionClass2 != null ) {
+                    connection = Class.forName(connectionClass2);
+                }
+            }
+            if ( connection != null ) {
+                // convention e.g. MySQLRubyJdbcConnection.load( Ruby runtime ) :
+                try {
+                    invokeStatic(runtime, connection, "load", Ruby.class, runtime);
+                }
+                catch (NoSuchMethodException e) {
+                    // "old" e.g. MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(runtime, jdbcConnection)
+                    connection.getMethod("create" + moduleName + "JdbcConnectionClass", Ruby.class, RubyClass.class).
+                        invoke(null, runtime, getJdbcConnection(runtime));
+                }
+            }
+        }
+        catch (ClassNotFoundException e) { /* ignored */ }
+        catch (NoSuchMethodException e) {
+            throw newNativeException(runtime, e);
+        }
+        catch (IllegalAccessException e) {
+            throw newNativeException(runtime, e);
+        }
+        catch (InvocationTargetException e) {
+            throw newNativeException(runtime, e);
+        }
+
+        return runtime.getTrue();
+    }
+
+    /**
+     * <code>ArJdbc.modules</code>
+     * @param context
+     * @param self
+     * @return nested constant values that are modules
+     */
+    @JRubyMethod(name = "modules", meta = true)
+    public static IRubyObject modules(final ThreadContext context, final IRubyObject self) {
+        final Ruby runtime = context.runtime;
+        final RubyModule arJdbc = (RubyModule) self;
+
+        final Collection<String> constants = arJdbc.getConstantNames();
+        final RubyArray modules = runtime.newArray( constants.size() );
+
+        for ( final String name : constants ) {
+           final IRubyObject constant = arJdbc.getConstant(name, false);
+           // isModule: return false for Ruby Classes
+           if ( constant != null && constant.isModule() ) {
+               if ( "Util".equals(name) ) continue;
+               if ( "SerializedAttributesHelper".equals(name) ) continue; // deprecated
+               if ( "Version".equals(name) ) continue; // deprecated
+               modules.append( constant );
+           }
+        }
+        return modules;
+    }
+
+    // JDBC "driver" gem helper(s) :
+
+    @JRubyMethod(name = "load_driver", meta = true)
+    public static IRubyObject load_driver(final ThreadContext context, final IRubyObject self,
+        final IRubyObject const_name) { // e.g. load_driver(:MySQL)
+        IRubyObject loaded = loadDriver(context, self, const_name.toString());
+        return loaded == null ? context.nil : loaded;
+    }
+
+    // NOTE: probably useless - only to be useful for the pooled runtime mode when jar at WEB-INF/lib
+    static final Map<Ruby, Map<String, Boolean>> loadedDrivers = new WeakHashMap<Ruby, Map<String, Boolean>>(8);
+
+    private static IRubyObject loadDriver(final ThreadContext context, final IRubyObject self,
+        final String constName) {
+        final Ruby runtime = context.runtime;
+        // look for "cached" loading result :
+        Map<String, Boolean> loadedMap = loadedDrivers.get(runtime);
+        if ( loadedMap == null ) {
+            synchronized (ArJdbcModule.class) {
+                loadedMap = loadedDrivers.get(runtime);
+                if ( loadedMap == null ) {
+                    loadedMap = new HashMap<String, Boolean>(4);
+                    loadedDrivers.put(runtime, loadedMap);
+                }
+            }
+        }
+
+        final Boolean driverLoaded = loadedMap.get(constName);
+        if ( driverLoaded != null ) {
+            if ( driverLoaded.booleanValue() ) return runtime.getFalse();
+            return runtime.getNil();
+        }
+
+        try { // require 'jdbc/mysql'
+            final byte[] name = new byte[5 + constName.length()]; // 'j','d','b','c','/'
+            name[0] = 'j'; name[1] = 'd'; name[2] = 'b'; name[3] = 'c'; name[4] = '/';
+            for ( int i = 0; i < constName.length(); i++ ) {
+                name[ 5 + i ] = (byte) Character.toLowerCase( constName.charAt(i) );
+            }
+            final RubyString strName = RubyString.newString(runtime, new ByteList(name, false));
+            self.callMethod(context, "require", strName); // require 'jdbc/mysql'
+        }
+        catch (RaiseException e) { // LoadError
+            synchronized (loadedMap) {
+                loadedMap.put(constName, Boolean.FALSE);
+            }
+            return null;
+        }
+
+        final RubyModule jdbc = runtime.getModule("Jdbc");
+        if ( jdbc != null ) { // Jdbc::MySQL
+            final RubyModule constant = (RubyModule) jdbc.getConstantAt(constName);
+            if ( constant != null ) { // ::Jdbc::MySQL.load_driver :
+                if ( constant.respondsTo("load_driver") ) {
+                    IRubyObject result = constant.callMethod("load_driver");
+                    synchronized (loadedMap) {
+                        loadedMap.put(constName, Boolean.TRUE);
+                    }
+                    return result;
+                }
+            }
+        }
+
+        synchronized (loadedMap) {
+            loadedMap.put(constName, Boolean.FALSE);
+        }
+        return null;
+    }
+
+    private static Object invokeStatic(final Ruby runtime,
+        final Class<?> klass, final String name, final Class<?> argType, final Object arg)
+        throws NoSuchMethodException {
+        try {
+            return klass.getMethod(name, argType).invoke(null, arg);
+        }
+        catch (IllegalAccessException e) {
+            throw newNativeException(runtime, e);
+        }
+        catch (InvocationTargetException e) {
+            throw newNativeException(runtime, e);
+        }
+    }
+
+    private static RaiseException newNativeException(final Ruby runtime, final Throwable cause) {
+        RubyClass nativeClass = runtime.getClass(NativeException.CLASS_NAME);
+        NativeException nativeException = new NativeException(runtime, nativeClass, cause);
+        return new RaiseException(cause, nativeException);
+    }
+
+    @JRubyMethod(meta = true)
+    public static IRubyObject with_meta_data_from_data_source_if_any(final ThreadContext context,
+        final IRubyObject self, final IRubyObject config, final Block block) {
+        return RubyJdbcConnection.with_meta_data_from_data_source_if_any(context, self, config, block);
+    }
+
+}