activerecord-jdbc-adapter 0.6

data/History.txt

@@ -0,0 +1,61 @@
+== 0.6
+
+- Gem is renamed to "activerecord-jdbc-adapter" to follow new conventions introduced in Rails 2.0 for third-party adapters. Rails 2.0 compatibility is introduced.
+- Add dependency on ActiveRecord >= 1.14 (from the Rails 1.1.x release)
+- New drivers (jdbc-XXX) and adapter (activerecord-jdbcXXX-adapter) gems available separately. See the README.txt file for details.
+- Plain "jdbc" driver is still available if you want to use the full driver/url way of specifying the driver.
+- More bugfixes to Oracle and SQLServer courtesy of Ola & ThoughtWorks
+
+== 0.5
+
+- Release coincides with JRuby 1.0.1 release
+- It is no longer necessary to specify :driver and :url configuration parameters for the mysql, 
+  postgresql, oracle, derby, hsqldb, and h2 adapters.  The previous configuration is still
+  valid and compatible, but for new applications, this makes it possible to use the exact same
+  database.yml configuration as Rails applications running under native Ruby.
+- JDBC drivers can now be dynamically loaded by Ruby code, without being on the classpath prior to
+  launching JRuby. Simply use "require 'jdbc-driver.jar'" in JRuby code to add it to the runtime
+  classpath.
+- Updates to HSQL, MS SQLServer, Postgres, Oracle and Derby adapters
+
+== 0.4
+
+- Release coincides with JRuby 1.0 release
+- Shoring up PostgreSQL (courtesy Dudley Flanders) and HSQL (courtesy Matthew Williams)
+- Fix timestamps on Oracle to use DATE (as everything else)
+- Derby fixes: Fix for open result set issue, better structure dump, quoting, column type changing
+- Sybase type recognition fix (courtesy Dean Mao)
+
+== 0.3.1
+
+* Derby critical fixes shortly after 0.3
+
+== 0.3
+
+* Release coincides with JRuby 1.0.0RC1 release
+* Improvements for Derby, Postgres, and Oracle, all of which are running 
+  > 95% of AR tests
+
+== 0.2.4
+
+* Release coincides with JRuby 0.9.9 release
+* JRuby 0.9.9 is required
+* MySQL close to 100% working
+* Derby improvements
+* DECIMAL/NUMERIC/FLOAT/REAL bugs fixed with type recognition for Oracle, Postgres, etc.
+* HSQLDB has regressed this release and may not be functioning; we'll get it fixed for the
+  next one
+
+== 0.2.3
+
+* Release coincides (and compatible) with JRuby 0.9.8 release
+* 8 bugs fixed: see http://rubyurl.com/0Da
+* Improvements and compatibility fixes for Rails 1.2.x
+
+== 0.2.1, 0.2.2
+
+* Early releases, added better support for multiple databases
+
+== 0.0.1
+
+* Initial, very alpha release

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006-2007 Nick Sieger <nick@nicksieger.com>
+Copyright (c) 2006-2007 Ola Bini <ola@ologix.com>
+
+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.

data/Manifest.txt

@@ -0,0 +1,64 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+LICENSE
+lib/active_record/connection_adapters/derby_adapter.rb
+lib/active_record/connection_adapters/h2_adapter.rb
+lib/active_record/connection_adapters/hsqldb_adapter.rb
+lib/active_record/connection_adapters/jdbc_adapter.rb
+lib/active_record/connection_adapters/jdbc_adapter_spec.rb
+lib/active_record/connection_adapters/jndi_adapter.rb
+lib/active_record/connection_adapters/mysql_adapter.rb
+lib/active_record/connection_adapters/oracle_adapter.rb
+lib/active_record/connection_adapters/postgresql_adapter.rb
+lib/jdbc_adapter/jdbc_db2.rb
+lib/jdbc_adapter/jdbc_derby.rb
+lib/jdbc_adapter/jdbc_firebird.rb
+lib/jdbc_adapter/jdbc_hsqldb.rb
+lib/jdbc_adapter/jdbc_mimer.rb
+lib/jdbc_adapter/jdbc_mssql.rb
+lib/jdbc_adapter/jdbc_mysql.rb
+lib/jdbc_adapter/jdbc_oracle.rb
+lib/jdbc_adapter/jdbc_postgre.rb
+lib/jdbc_adapter/missing_functionality_helper.rb
+lib/jdbc_adapter/version.rb
+lib/jdbc_adapter.rb
+lib/jdbc_adapter_internal.jar
+test/activerecord/connection_adapters/type_conversion_test.rb
+test/activerecord/connections/native_jdbc_mysql/connection.rb
+test/db/derby.rb
+test/db/h2.rb
+test/db/hsqldb.rb
+test/db/jdbc.rb
+test/db/jndi_config.rb
+test/db/logger.rb
+test/db/mysql.rb
+test/db/postgres.rb
+test/derby_multibyte_test.rb
+test/derby_simple_test.rb
+test/generic_jdbc_connection_test.rb
+test/h2_simple_test.rb
+test/hsqldb_simple_test.rb
+test/jdbc_adapter/jdbc_db2_test.rb
+test/jdbc_common.rb
+test/jndi_test.rb
+test/manualTestDatabase.rb
+test/minirunit/testConnect.rb
+test/minirunit/testH2.rb
+test/minirunit/testHsqldb.rb
+test/minirunit/testLoadActiveRecord.rb
+test/minirunit/testMysql.rb
+test/minirunit/testRawSelect.rb
+test/minirunit.rb
+test/models/auto_id.rb
+test/models/data_types.rb
+test/models/entry.rb
+test/mysql_multibyte_test.rb
+test/mysql_simple_test.rb
+test/postgres_simple_test.rb
+test/simple.rb
+lib/tasks/jdbc_databases.rake
+src/java/JdbcAdapterInternalService.java
+src/java/JDBCDerbySpec.java
+src/java/JDBCMySQLSpec.java

data/README.txt

@@ -0,0 +1,116 @@
+ActiveRecord-JDBC is a database adapter for Rails' ActiveRecord component that can be used with JRuby[http://www.jruby.org/].  It allows use of virtually any JDBC-compliant database with your JRuby on Rails application.
+
+ActiveRecord-JDBC is a sub-project of jruby-extras at RubyForge.
+
+== Databases
+
+What's there, and what is not there:
+
+* MySQL - Complete support
+* PostgreSQL - Complete support
+* Oracle - Complete support
+* Microsoft SQL Server - Complete support except for change_column_default
+* DB2 - Complete, except for the migrations:
+  * change_column 
+  * change_column_default
+  * remove_column
+  * rename_column
+  * add_index
+  * remove_index
+  * rename_table
+* FireBird - Complete, except for change_column_default and rename_column
+* Derby - Complete, except for:
+  * change_column
+  * change_column_default
+  * remove_column
+  * rename_column
+* HSQLDB - Complete
+
+Other databases will require testing and likely a custom configuration module. Please join the jruby-extras mailing-list[http://rubyforge.org/mail/?group_id=2014] to help us discover support for more databases.
+
+== Using ActiveRecord JDBC
+
+=== Inside Rails
+
+To use ActiveRecord-JDBC with JRuby on Rails:
+
+1. Choose the adapter you wish to gem install.  The following pre-packaged adapters are available:
+
+  * base jdbc (<tt>activerecord-jdbc-adapter</tt>). Supports all available databases via JDBC, but requires you to download and manually install the database vendor's JDBC driver .jar file.
+  * mysql (<tt>activerecord-jdbcmysql-adapter</tt>)
+  * postgresql (<tt>activerecord-jdbcpostgresql-adapter</tt>)
+  * derby (<tt>activerecord-jdbcderby-adapter</tt>)
+  * hsqldb (<tt>activerecord-jdbchsqldb-adapter</tt>)
+
+2. If you're using Rails 2.0, you may skip to the next step. For Rails prior to version 2.0, you'll need to add one-time setup to your config/environment.rb file in your Rails application. Add the following lines just before the <code>Rails::Initializer</code>. (If you're using ActiveRecord-JDBC under the old gem name used in versions 0.5 and earlier, replace 'activerecord-jdbc-adapter' with 'ActiveRecord-JDBC' below.)
+
+    if RUBY_PLATFORM =~ /java/
+      require 'rubygems'
+      gem 'activerecord-jdbc-adapter'
+      require 'jdbc_adapter'
+    end
+
+3. Configure your database.yml to use the <code>jdbc</code> adapter.
+For mysql, postgres, derby, oracle, hsqldb and h2 you can simply configure the database in the normal Rails style. If you use one of the convenience 'activerecord-jdbcXXX-adapter' adapters, be sure and put a 'jdbc' prefix in front of the databas adapter name as below.
+
+    development:
+      adapter: jdbcmysql
+      username: blog
+      password:
+      hostname: localhost
+      database: weblog_development
+
+For other databases, you'll need to know the database driver class and URL.  Example:
+
+    development:
+      adapter: jdbc
+      username: blog
+      password:
+      driver: com.mysql.jdbc.Driver
+      url: jdbc:mysql://localhost:3306/weblog_development
+
+=== Standalone, with ActiveRecord
+
+1. Install the gem with JRuby:
+
+    jruby -S gem install activerecord-jdbc-adapter
+
+   If you wish to use the adapter for a specific database, you can install it directly and a driver gem will be installed as well:
+
+    jruby -S gem install activerecord-jdbcderby-adapter
+
+2. If using ActiveRecord 2.0 (Rails 2.0) or greater, you can skip to the next step. Otherwise, ensure the following code gets executed in your script:
+
+    require 'rubygems'
+    gem 'activerecord-jdbc-adapter'
+    require 'jdbc_adapter'
+    require 'active_record'
+
+3. After this you can establish a JDBC connection like this:
+
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'jdbcderby',
+      :database => "db/my-database"
+    )
+
+   or like this (but requires that you manually put the driver jar on the classpath):
+
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'jdbc',
+      :driver => 'org.apache.derby.jdbc.EmbeddedDriver',
+      :url => 'jdbc:derby:test_ar;create=true'
+    )
+
+== Running AR-JDBC's Tests
+
+Drivers for 4 open-source databases are included.  Provided you have MySQL installed, you can simply type <tt>jruby -S rake</tt> to run the tests.  A database named <tt>weblog_development</tt> is needed beforehand with a connection user of "blog" and password empty.
+
+== Authors
+
+This project was written by Nick Sieger <nick@nicksieger.com> and Ola Bini <ola@ologix.com> with lots of help from the JRuby community.
+
+== License
+
+ActiveRecord-JDBC is released under a BSD license.  See the LICENSE file included with the distribution for details.
+
+Open-source driver gems for ActiveRecord JDBC are licensed under the same license the database's drivers are licensed.  See each driver gem's LICENSE.txt file for details.

data/Rakefile

@@ -0,0 +1,146 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:java_compile, :test]
+
+def java_classpath_arg # myriad of ways to discover JRuby classpath
+  begin
+    require 'java' # already running in a JRuby JVM
+    jruby_cpath = Java::java.lang.System.getProperty('java.class.path')
+  rescue LoadError
+  end
+  unless jruby_cpath
+    jruby_cpath = ENV['JRUBY_PARENT_CLASSPATH'] || ENV['JRUBY_HOME'] &&
+      FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
+  end
+  cpath_arg = jruby_cpath ? "-cp #{jruby_cpath}" : ""
+end
+
+desc "Compile the native Java code."
+task :java_compile do
+  mkdir_p "pkg/classes"
+  sh "javac -target 1.4 -source 1.4 -d pkg/classes #{java_classpath_arg} #{FileList['src/java/**/*.java'].join(' ')}"
+  sh "jar cf lib/jdbc_adapter_internal.jar -C pkg/classes/ ."
+end
+file "lib/jdbc_adapter_internal.jar" => :java_compile
+
+task :more_clean do
+  rm_rf FileList['derby*']
+  rm_rf FileList['test.db.*']
+  rm_rf "test/reports"
+  rm_f FileList['lib/*.jar']
+end
+
+task :clean => :more_clean
+
+task :filelist do
+  puts FileList['pkg/**/*'].inspect
+end
+
+if RUBY_PLATFORM =~ /java/
+  # TODO: add more databases into the standard tests here.
+  task :test => [:test_mysql, :test_jdbc, :test_derby, :test_hsqldb]
+else
+  task :test => [:test_mysql]
+end
+
+FileList['drivers/*'].each do |d|
+  next unless File.directory?(d)
+  driver = File.basename(d)
+  Rake::TestTask.new("test_#{driver}") do |t|
+    files = FileList["test/#{driver}*test.rb"]
+    if driver == "derby"
+      files << 'test/activerecord/connection_adapters/type_conversion_test.rb'
+    end
+    t.ruby_opts << "-rjdbc/#{driver}"
+    t.test_files = files
+    t.libs << "test" << "#{d}/lib"
+  end
+end
+
+Rake::TestTask.new(:test_jdbc) do |t|
+  t.test_files = FileList['test/generic_jdbc_connection_test.rb']
+  t.libs << 'test' << 'drivers/mysql/lib'
+end
+
+Rake::TestTask.new(:test_jndi) do |t|
+  t.test_files = FileList['test/jndi_test.rb']
+  t.libs << 'test' << 'drivers/derby/lib'
+end
+
+task :test_postgresql => [:test_postgres]
+task :test_pgsql => [:test_postgres]
+
+MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 
+  "Rakefile", "LICENSE", "lib/**/*.rb", "lib/jdbc_adapter_internal.jar", "test/**/*.rb",
+   "lib/**/*.rake", "src/**/*.java"]
+
+file "Manifest.txt" => :manifest
+task :manifest do
+  File.open("Manifest.txt", "w") {|f| MANIFEST.each {|n| f << "#{n}\n"} }
+end
+Rake::Task['manifest'].invoke # Always regen manifest, so Hoe has up-to-date list of files
+
+require File.dirname(__FILE__) + "/lib/jdbc_adapter/version"
+begin
+  require 'hoe'
+  Hoe.new("activerecord-jdbc-adapter", JdbcAdapter::Version::VERSION) do |p|
+    p.rubyforge_name = "jruby-extras"
+    p.url = "http://jruby-extras.rubyforge.org/activerecord-jdbc-adapter"
+    p.author = "Nick Sieger, Ola Bini and JRuby contributors"
+    p.email = "nick@nicksieger.com, ola.bini@gmail.com"
+    p.summary = "JDBC adapter for ActiveRecord, for use within JRuby on Rails."
+    p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+    p.description = p.paragraphs_of('README.txt', 0...1).join("\n\n")
+  end.spec.dependencies.delete_if { |dep| dep.name == "hoe" }
+rescue LoadError
+  puts "You really need Hoe installed to be able to package this gem"
+rescue => e
+  puts "ignoring error while loading hoe: #{e.to_s}"
+end
+
+def rake(*args)
+  ruby "-S", "rake", *args
+end
+
+%w(test package install_gem release clean).each do |task|
+  desc "Run rake #{task} on all available adapters and drivers"
+  task "all:#{task}" => task
+end
+
+(Dir["drivers/*/Rakefile"] + Dir["adapters/*/Rakefile"]).each do |rakefile|
+  dir = File.dirname(rakefile)
+  prefix = dir.sub(%r{/}, ':')
+  tasks = %w(package install_gem debug_gem clean)
+  tasks << "test" if File.directory?(File.join(dir, "test"))
+  tasks.each do |task|
+    desc "Run rake #{task} on #{dir}"
+    task "#{prefix}:#{task}" do
+      Dir.chdir(dir) do
+        rake task
+      end
+    end
+    task "#{File.dirname(dir)}:#{task}" => "#{prefix}:#{task}"
+    task "all:#{task}" => "#{prefix}:#{task}"
+  end
+  desc "Run rake release on #{dir}"
+  task "#{prefix}:release" do
+    Dir.chdir(dir) do
+      version = nil
+      if dir =~ /adapters/
+        version = ENV['VERSION']
+      else
+        Dir["lib/**/*.rb"].each do |file|
+          version ||= File.open(file) {|f| f.read =~ /VERSION = "([^"]+)"/ && $1}
+        end
+      end
+      rake "release", "VERSION=#{version}"
+    end
+  end
+  # Only release adapters synchronously with main release. Drivers are versioned
+  # according to their JDBC driver versions.
+  if dir =~ /adapters/
+    task "adapters:release" => "#{prefix}:release"
+    task "all:release" => "#{prefix}:release"
+  end
+end

data/lib/active_record/connection_adapters/derby_adapter.rb

@@ -0,0 +1,13 @@
+tried_gem = false
+begin
+  require "jdbc/derby"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-derby"
+    tried_gem = true
+    retry
+  end
+  # trust that the derby jar is already present
+end
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/h2_adapter.rb

@@ -0,0 +1 @@
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/hsqldb_adapter.rb

@@ -0,0 +1,13 @@
+tried_gem = false
+begin
+  require "jdbc/hsqldb"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-hsqldb"
+    tried_gem = true
+    retry
+  end
+  # trust that the hsqldb jar is already present
+end
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -0,0 +1,575 @@
+require 'active_record/connection_adapters/abstract_adapter'
+require 'java'
+require 'active_record/connection_adapters/jdbc_adapter_spec'
+require 'jdbc_adapter_internal'
+require 'bigdecimal'
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+      # The original implementation of this had a bug, which modifies native_database_types.
+      # This version allows us to cache that value.
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        native = native_database_types[type]
+        column_type_sql = native.is_a?(Hash) ? native[:name] : native
+        if type == :decimal # ignore limit, use precison and scale
+          precision ||= native[:precision]
+          scale ||= native[:scale]
+          if precision
+            if scale
+              column_type_sql += "(#{precision},#{scale})"
+            else
+              column_type_sql += "(#{precision})"
+            end
+          else
+            raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified" if scale
+          end
+          column_type_sql
+        else
+          limit ||= native[:limit]
+          column_type_sql += "(#{limit})" if limit
+          column_type_sql
+        end
+      end
+    end
+  end
+end
+
+module JdbcSpec
+  module ActiveRecordExtensions
+    def jdbc_connection(config)
+      connection = ::ActiveRecord::ConnectionAdapters::JdbcConnection.new(config)
+      ::ActiveRecord::ConnectionAdapters::JdbcAdapter.new(connection, logger, config)
+    end
+    alias jndi_connection jdbc_connection
+
+    def embedded_driver(config)
+      config[:username] ||= "sa"
+      config[:password] ||= ""
+      jdbc_connection(config)
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    extend JdbcSpec::ActiveRecordExtensions
+
+    alias :attributes_with_quotes_pre_oracle :attributes_with_quotes
+    def attributes_with_quotes(include_primary_key = true) #:nodoc:
+      aq = attributes_with_quotes_pre_oracle(include_primary_key)
+      if connection.class == ConnectionAdapters::JdbcAdapter && (connection.is_a?(JdbcSpec::Oracle) || connection.is_a?(JdbcSpec::Mimer))
+        aq[self.class.primary_key] = "?" if include_primary_key && aq[self.class.primary_key].nil?
+      end
+      aq
+    end
+  end
+
+  module ConnectionAdapters
+    module Java
+      Class = java.lang.Class
+      URL = java.net.URL
+      URLClassLoader = java.net.URLClassLoader
+    end
+
+    module Jdbc
+      Mutex = java.lang.Object.new
+      DriverManager = java.sql.DriverManager
+      Statement = java.sql.Statement
+      Types = java.sql.Types
+
+      # some symbolic constants for the benefit of the JDBC-based
+      # JdbcConnection#indexes method
+      module IndexMetaData
+        INDEX_NAME  = 6
+        NON_UNIQUE  = 4
+        TABLE_NAME  = 3
+        COLUMN_NAME = 9
+      end
+
+      module TableMetaData
+        TABLE_CAT   = 1
+        TABLE_SCHEM = 2
+        TABLE_NAME  = 3
+        TABLE_TYPE  = 4
+      end
+
+      module PrimaryKeyMetaData
+        COLUMN_NAME = 4
+      end
+
+    end
+
+    # 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|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['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}],
+        :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}],
+        :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
+                          lambda {|r| r['type_name'] =~ /^time$/i},
+                          lambda {|r| r['type_name'] =~ /^date/i}],
+        :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}],
+        :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}]
+      }
+
+      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 = {}
+        AR_TO_JDBC_TYPES.each_key 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.select(&p)
+          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
+
+    class JdbcDriver
+      def initialize(name)
+        @name = name
+      end
+
+      def driver_class
+        @driver_class ||= begin
+                            driver_class_const = (@name[0...1].capitalize + @name[1..@name.length]).gsub(/\./, '_')
+                            Jdbc::Mutex.synchronized do
+                              unless Jdbc.const_defined?(driver_class_const)
+                                driver_class_name = @name
+                                Jdbc.module_eval do
+                                  include_class(driver_class_name) { driver_class_const }
+                                end
+                              end
+                            end
+                            driver_class = Jdbc.const_get(driver_class_const)
+                            raise "You specify a driver for your JDBC connection" unless driver_class
+                            driver_class
+                          end
+      end
+
+      def load
+        Jdbc::DriverManager.registerDriver(create)
+      end
+
+      def connection(url, user, pass)
+        Jdbc::DriverManager.getConnection(url, user, pass)
+      rescue
+        # bypass DriverManager to get around problem with dynamically loaded jdbc drivers
+        props = java.util.Properties.new
+        props.setProperty("user", user)
+        props.setProperty("password", pass)
+        create.connect(url, props)
+      end
+
+      def create
+        driver_class.new
+      end
+    end
+
+    class JdbcColumn < Column
+      attr_writer :limit, :precision
+
+      COLUMN_TYPES = ::JdbcSpec.constants.map{|c|
+        ::JdbcSpec.const_get c }.select{ |c|
+        c.respond_to? :column_selector }.map{|c|
+        c.column_selector }.inject({}) { |h,val|
+        h[val[0]] = val[1]; h }
+
+      def initialize(config, name, default, *args)
+        ds = config[:driver].to_s
+        for reg, func in COLUMN_TYPES
+          if reg === ds
+            func.call(config,self)
+          end
+        end
+        super(name,default_value(default),*args)
+        init_column(name, default, *args)
+      end
+
+      def init_column(*args)
+      end
+
+      def default_value(val)
+        val
+      end
+    end
+
+    class JdbcConnection
+      attr_reader :adapter, :connection
+
+      def initialize(config)
+        @config = config.symbolize_keys!
+        if @config[:jndi]
+          begin
+            configure_jndi
+          rescue => e
+            warn "JNDI data source unavailable: #{e.message}; trying straight JDBC"
+            configure_jdbc
+          end
+        else
+          configure_jdbc
+        end
+        set_native_database_types
+        @stmts = {}
+      rescue Exception => e
+        raise "The driver encountered an error: #{e}"
+      end
+
+      def reconnect!
+        self.adapter.reconnect!
+      end
+
+      def adapter=(adapt)
+        @adapter = adapt
+        @tps = {}
+        @native_types.each_pair {|k,v| @tps[k] = v.inject({}) {|memo,kv| memo.merge({kv.first => (kv.last.dup rescue kv.last)})}}
+        adapt.modify_types(@tps)
+      end
+
+      # Default JDBC introspection for index metadata on the JdbcConnection.
+      # This is currently used for migrations by JdbcSpec::HSQDLB and JdbcSpec::Derby
+      # indexes with a little filtering tacked on.
+      #
+      # JDBC index metadata is denormalized (multiple rows may be returned for
+      # one index, one row per column in the index), so a simple block-based
+      # filter like that used for tables doesn't really work here.  Callers
+      # should filter the return from this method instead.
+      #
+      # TODO: fix to use reconnect correctly
+      def indexes(table_name, name = nil, schema_name = nil)
+        metadata = @connection.getMetaData
+        unless String === table_name
+          table_name = table_name.to_s
+        else
+          table_name = table_name.dup
+        end
+        table_name.upcase! if metadata.storesUpperCaseIdentifiers
+        table_name.downcase! if metadata.storesLowerCaseIdentifiers
+        resultset = metadata.getIndexInfo(nil, schema_name, table_name, false, false)
+        primary_keys = primary_keys(table_name)
+        indexes = []
+        current_index = nil
+        while resultset.next
+          index_name = resultset.get_string(Jdbc::IndexMetaData::INDEX_NAME)
+          next unless index_name
+          index_name.downcase!
+          column_name = resultset.get_string(Jdbc::IndexMetaData::COLUMN_NAME).downcase
+
+          next if primary_keys.include? column_name
+
+          # We are working on a new index
+          if current_index != index_name
+            current_index = index_name
+            table_name = resultset.get_string(Jdbc::IndexMetaData::TABLE_NAME).downcase
+            non_unique = resultset.get_boolean(Jdbc::IndexMetaData::NON_UNIQUE)
+
+            # empty list for column names, we'll add to that in just a bit
+            indexes << IndexDefinition.new(table_name, index_name, !non_unique, [])
+          end
+
+          # One or more columns can be associated with an index
+          indexes.last.columns << column_name
+        end
+        resultset.close
+        indexes
+      rescue
+        if @connection.is_closed
+          reconnect!
+          retry
+        else
+          raise
+        end
+      ensure
+        metadata.close rescue nil
+      end
+
+#      def self.insert?(sql)
+#        /\A\s*insert/i =~ sql
+#      end
+      
+#      def self.select?(sql)
+#        /\A\s*\(?\s*(select|show)/i =~ sql
+#      end
+
+      private
+      def configure_jndi
+        jndi = @config[:jndi].to_s
+        ctx = javax.naming.InitialContext.new
+        ds = ctx.lookup(jndi)
+        set_connection ds.connection
+        unless @config[:driver]
+          @config[:driver] = @connection.meta_data.connection.java_class.name
+        end
+      end
+
+      def configure_jdbc
+        driver = @config[:driver].to_s
+        user   = @config[:username].to_s
+        pass   = @config[:password].to_s
+        url    = @config[:url].to_s
+
+        unless driver && url
+          raise ArgumentError, "jdbc adapter requires driver class and url"
+        end
+
+        if driver =~ /mysql/i
+          div = url =~ /\?/ ? '&' : '?'
+          url = "#{url}#{div}zeroDateTimeBehavior=convertToNull&jdbcCompliantTruncation=false&useUnicode=true&characterEncoding=utf8"
+          @config[:url] = url
+        end
+
+        jdbc_driver = JdbcDriver.new(driver)
+        jdbc_driver.load
+        connection = jdbc_driver.connection(url, user, pass)
+        set_connection connection
+      end
+
+    end
+
+    class JdbcAdapter < AbstractAdapter
+      attr_reader :config
+
+      ADAPTER_TYPES = ::JdbcSpec.constants.map{|c|
+        ::JdbcSpec.const_get c }.select{ |c|
+        c.respond_to? :adapter_selector }.map{|c|
+        c.adapter_selector }.inject({}) { |h,val|
+        h[val[0]] = val[1]; h }
+
+      def initialize(connection, logger, config)
+        super(connection, logger)
+        @config = config
+        ds = config[:driver].to_s
+        for reg, func in ADAPTER_TYPES
+          if reg === ds
+            func.call(@config,self)
+          end
+        end
+        connection.adapter = self
+      end
+
+      def modify_types(tp)
+        tp
+      end
+
+      def adapter_name #:nodoc:
+        'JDBC'
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def native_database_types #:nodoc:
+        @connection.native_database_types
+      end
+
+      def database_name #:nodoc:
+        @connection.database_name
+      end
+
+      def native_sql_to_type(tp)
+        if /^(.*?)\(([0-9]+)\)/ =~ tp
+          tname = $1
+          limit = $2.to_i
+          ntype = native_database_types
+          if ntype[:primary_key] == tp
+            return :primary_key,nil
+          else
+            ntype.each do |name,val|
+              if name == :primary_key
+                next
+              end
+              if val[:name].downcase == tname.downcase && (val[:limit].nil? || val[:limit].to_i == limit)
+                return name,limit
+              end
+            end
+          end
+        elsif /^(.*?)/ =~ tp
+          tname = $1
+          ntype = native_database_types
+          if ntype[:primary_key] == tp
+            return :primary_key,nil
+          else
+            ntype.each do |name,val|
+              if val[:name].downcase == tname.downcase && val[:limit].nil?
+                return name,nil
+              end
+            end
+          end
+        else
+          return :string,255
+        end
+        return nil,nil
+      end
+
+      def reconnect!
+        @connection.close rescue nil
+        @connection = JdbcConnection.new(@config)
+        @connection.adapter = self
+        @connection
+      end
+
+      def select_all(sql, name = nil)
+        select(sql, name)
+      end
+
+      def select_one(sql, name = nil)
+        select(sql, name).first
+      end
+
+      def execute(sql, name = nil)
+        log_no_bench(sql, name) do
+          _execute(sql,name)
+        end
+      end
+      
+      
+      # we need to do it this way, to allow Rails stupid tests to always work
+      # even if we define a new execute method. Instead of mixing in a new
+      # execute, an _execute should be mixed in.
+      def _execute(sql, name = nil)
+        if JdbcConnection::select?(sql)
+          @connection.execute_query(sql)
+        elsif JdbcConnection::insert?(sql)
+          @connection.execute_insert(sql)
+        else
+          @connection.execute_update(sql)
+        end
+      end
+
+      def update(sql, name = nil) #:nodoc:
+        execute(sql, name)
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        id = execute(sql, name = nil)
+        id_value || id
+      end
+
+      def columns(table_name, name = nil)
+        @connection.columns(table_name.to_s)
+      end
+
+      def tables
+        @connection.tables
+      end
+
+      def indexes(table_name)
+        @connection.indexes(table_name)
+      end
+
+      def begin_db_transaction
+        @connection.begin
+      end
+
+      def commit_db_transaction
+        @connection.commit
+      end
+
+      def rollback_db_transaction
+        @connection.rollback
+      end
+
+      def write_large_object(*args)
+        @connection.write_large_object(*args)
+      end
+
+      private
+      def select(sql, name=nil)
+        execute(sql,name)
+      end
+
+      def log_no_bench(sql, name)
+        if block_given?
+          if @logger and @logger.level <= Logger::INFO
+            result = yield
+            log_info(sql, name, 0)
+            result
+          else
+            yield
+          end
+        else
+          log_info(sql, name, 0)
+          nil
+        end
+      rescue Exception => e
+        # Log message and raise exception.
+        message = "#{e.class.name}: #{e.message}: #{sql}"
+
+        log_info(message, name, 0)
+        raise ActiveRecord::StatementInvalid, message
+      end
+    end
+  end
+end