ActiveRecord-JDBC 0.2.2 → 0.2.3

data/History.txt

@@ -0,0 +1,13 @@
+== 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/Manifest.txt

@@ -0,0 +1,41 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+LICENSE
+lib/jdbc_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/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
+test/derby_simple_test.rb
+test/h2_simple_test.rb
+test/hsqldb_simple_test.rb
+test/manualTestDatabase.rb
+test/minirunit.rb
+test/mysql_simple_test.rb
+test/simple.rb
+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/logger.rb
+test/db/mysql.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/models/auto_id.rb
+test/models/data_types.rb
+test/models/entry.rb

data/README.txt

@@ -0,0 +1,94 @@
+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
+
+=== Standalone, with ActiveRecord
+
+1. Install the gem with JRuby:
+    jruby --command gem install ActiveRecord-JDBC
+2. Ensure the following code gets executed in your script:
+    require 'rubygems'
+    gem 'ActiveRecord-JDBC'
+    require 'jdbc_adapter'
+    require 'active_record'
+
+3. After this you can establish a JDBC connection like this:
+    ActiveRecord::Base.establish_connection(
+      :adapter => 'jdbc',
+      :driver => 'org.apache.derby.jdbc.EmbeddedDriver',
+      :url => 'jdbc:derby:test_ar;create=true'
+    )
+
+Provided you have the derby libraries in your classpath, this is enough
+to establish an in-memory JDBC connection. The required parameters to
+establish_connection for ActiveRecord JDBC are:
+
+* adapter
+* driver
+* url
+
+If provided, password and username will be used. After the connection is established
+Active Record can be used as usual.
+
+=== Inside Rails
+
+To use ActiveRecord-JDBC with JRuby on Rails:
+
+1. Install the gem with JRuby:
+    jruby --command gem install ActiveRecord-JDBC
+2. 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>.
+    require 'rubygems'
+    gem 'ActiveRecord-JDBC'
+    require 'jdbc_adapter'
+3. Configure your database.yml to use the <code>jdbc</code> adapter.  For now, 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
+
+== Running AR-JDBC's Tests
+
+By default hsql, mysql, and derby are run.  In order to run all tests you 
+must download each of the databases about put their JDBC drivers in your
+classpath.  Here is an example of I use:
+
+    CLASSPATH=~/opt/derby/lib/derby.jar:~/opt/mysql/mysql-connector-java-3.1.14-bin.jar:~/opt/hsqldb/lib/hsqldb.jar jruby ../jruby/bin/jruby --command rake
+
+== 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.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => :test
+
+desc "Run AR-JDBC tests"
+if RUBY_PLATFORM =~ /java/
+  task :test => [:test_mysql, :test_hsqldb, :test_derby]
+else
+  task :test => [:test_mysql]
+end
+
+Rake::TestTask.new(:test_mysql) do |t|
+  t.test_files = FileList['test/mysql_simple_test.rb']
+  t.libs << 'test'
+end
+
+Rake::TestTask.new(:test_hsqldb) do |t|
+  t.test_files = FileList['test/hsqldb_simple_test.rb']
+  t.libs << 'test'
+end
+
+Rake::TestTask.new(:test_derby) do |t|
+  t.test_files = FileList['test/derby_simple_test.rb', 
+    'test/activerecord/connection_adapters/type_conversion_test.rb']
+  t.libs << 'test'
+end
+
+begin
+  require 'hoe'
+
+  MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 
+    "Rakefile", "LICENSE", "lib/**/*.rb", "test/**/*.rb"]
+
+  Hoe.new("ActiveRecord-JDBC", "0.2.3") do |p|
+    p.rubyforge_name = "jruby-extras"
+    p.url = "http://jruby-extras.rubyforge.org/ActiveRecord-JDBC"
+    p.author = "Nick Sieger, Ola Bini and JRuby contributors"
+    p.email = "nick@nicksieger.com, ola.bini@ki.se"
+    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")
+    p.extra_deps.reject!{|d| d.first == "hoe"}
+  end.spec.files = MANIFEST
+
+  # Automated manifest
+  task :manifest do
+    File.open("Manifest.txt", "w") {|f| MANIFEST.each {|n| f << "#{n}\n"} }
+  end
+
+  task :package => :manifest
+rescue => e
+  # Install hoe in order to make a release
+  # puts e.inspect
+end

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -1,4 +1,5 @@
 require 'active_record/connection_adapters/abstract_adapter'
+require 'java'
 require 'active_record/connection_adapters/jdbc_adapter_spec'
 
 module ActiveRecord
@@ -19,16 +20,36 @@ module ActiveRecord
 
   module ConnectionAdapters
     module Java
-      include_class 'java.lang.Class'
-      include_class 'java.net.URL'
-      include_class 'java.net.URLClassLoader'
+      Class = java.lang.Class
+      URL = java.net.URL
+      URLClassLoader = java.net.URLClassLoader
     end
 
     module Jdbc
-      require 'java'
-      include_class 'java.sql.DriverManager'
-      include_class 'java.sql.Statement'
-      include_class 'java.sql.Types'
+      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
@@ -57,6 +78,8 @@ module ActiveRecord
                           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']},
+                          lambda {|r| r['type_name'] =~ /^decimal$/i}],
         :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE].include?(r['data_type'])},
                           lambda {|r| r['type_name'] =~ /^float/i},
                           lambda {|r| r['type_name'] =~ /^double$/i},
@@ -71,7 +94,7 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /^time$/i},
                           lambda {|r| r['type_name'] =~ /^datetime$/i}],
         :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type']},
-                          lambda {|r| r['type_name'] =~ /^datetime$/i}],
+                          lambda {|r| r['type_name'] =~ /^date$/i}],
         :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'])},
                           lambda {|r| r['type_name'] =~ /^blob/i},
                           lambda {|r| r['type_name'] =~ /sub_type 0$/i}, # For FireBird
@@ -80,7 +103,7 @@ module ActiveRecord
         :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'])},
                           lambda {|r| r['type_name'] =~ /^bool/i},
                           lambda {|r| r['type_name'] =~ /^tinyint$/i},
-                          lambda {|r| r['type_name'] =~ /^decimal$/i}]
+                          lambda {|r| r['type_name'] =~ /^decimal$/i}],
       }
 
       def initialize(types)
@@ -91,8 +114,8 @@ module ActiveRecord
         type_map = {}
         AR_TO_JDBC_TYPES.each_key do |k|
           typerow = choose_type(k)
-          type_map[k] = { :name => typerow['type_name']  }
-          type_map[k][:limit] = typerow['precision'] if [:integer, :string].include?(k)
+          type_map[k] = { :name => typerow['type_name'] }
+          type_map[k][:limit] = typerow['precision'] if [:integer, :string, :decimal].include?(k)
           type_map[k][:limit] = 1 if k == :boolean
         end
         type_map
@@ -123,28 +146,35 @@ module ActiveRecord
     end
 
     class JdbcColumn < Column
+      COLUMN_TYPES = {
+        /oracle/i => lambda {|cfg,col| col.extend(JdbcSpec::Oracle::Column)},
+        /postgre/i => lambda {|cfg,col| col.extend(JdbcSpec::PostgreSQL::Column)},
+        /sqlserver|tds/i => lambda {|cfg,col| col.extend(JdbcSpec::MsSQL::Column)},
+        /hsqldb|\.h2\./i => lambda {|cfg,col| col.extend(JdbcSpec::HSQLDB::Column)},
+        /derby/i => lambda {|cfg,col| col.extend(JdbcSpec::Derby::Column)},
+        /db2/i => lambda {|cfg,col|
+          if cfg[:url] =~ /^jdbc:derby:net:/
+            col.extend(JdbcSpec::Derby::Column)
+          else
+            col.extend(JdbcSpec::DB2::Column)
+          end }
+      }
+
       def initialize(config, name, default, *args)
-        case config[:driver].to_s
-          when /oracle/i: self.extend(JdbcSpec::Oracle::Column)
-          when /postgre/i: self.extend(JdbcSpec::PostgreSQL::Column)
-          when /sqlserver|tds/i: self.extend(JdbcSpec::MsSQL::Column)
-          when /hsqldb/i: self.extend(JdbcSpec::HSQLDB::Column)
-          when /derby/i: self.extend(JdbcSpec::Derby::Column)
-          when /db2/i: 
-            if config[:url] =~ /^jdbc:derby:net:/
-              self.extend(JdbcSpec::Derby::Column)
-            else
-              self.extend(JdbcSpec::DB2::Column)
-            end
+        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)
-      end    
+      end
 
       def default_value(val)
         val
       end
     end
-    
+
     class JdbcConnection
       def initialize(config)
         @config = config.symbolize_keys
@@ -169,7 +199,7 @@ module ActiveRecord
       def ps(sql)
         @connection.prepareStatement(sql)
       end
-      
+
       def set_native_database_types
         types = unmarshal_result(@connection.getMetaData.getTypeInfo)
         @native_types = JdbcTypeConverter.new(types).choose_best_types
@@ -177,10 +207,10 @@ module ActiveRecord
 
       def native_database_types(adapt)
         types = {}
-        @native_types.each_pair {|k,v| types[k] = v.inject({}) {|memo,kv| memo.merge({kv.first => kv.last.dup})}}
+        @native_types.each_pair {|k,v| types[k] = v.inject({}) {|memo,kv| memo.merge({kv.first => (kv.last.dup rescue kv.last)})}}
         adapt.modify_types(types)
       end
-      
+
       def columns(table_name, name = nil)
         metadata = @connection.getMetaData
         table_name.upcase! if metadata.storesUpperCaseIdentifiers
@@ -188,23 +218,112 @@ module ActiveRecord
         results = metadata.getColumns(nil, nil, table_name, nil)
         columns = []
         unmarshal_result(results).each do |col|
-          columns << ActiveRecord::ConnectionAdapters::JdbcColumn.new(@config,col['column_name'].downcase, col['column_def'],
-              "#{col['type_name']}(#{col['column_size']})", col['is_nullable'] != 'NO')
+          column_name = col['column_name']
+          column_name = column_name.downcase if metadata.storesUpperCaseIdentifiers
+          precision = col["column_size"]
+          scale = col["decimal_digits"]
+          coltype = col["type_name"]
+          if precision && precision > 0
+            coltype << "(#{precision}"
+            coltype << ",#{scale}" if scale && scale > 0
+            coltype << ")"
+          end
+          columns << ActiveRecord::ConnectionAdapters::JdbcColumn.new(@config, column_name, col['column_def'],
+              coltype, col['is_nullable'] != 'NO')
         end
         columns
+      rescue
+        if @connection.is_closed
+          reconnect!
+          retry
+        else
+          raise
+        end
       end
 
-      def tables
+      def tables(&table_filter)
         metadata = @connection.getMetaData
         results = metadata.getTables(nil, nil, nil, nil)
-        unmarshal_result(results).collect {|t| t['table_name']}
+        unmarshal_result(results, &table_filter).collect {|t| t['table_name'].downcase }
+      rescue
+        if @connection.is_closed
+          reconnect!
+          retry
+        else
+          raise
+        end
+      end
+
+      # Get a list of all primary keys associated with the given table
+      def primary_keys(table_name) 
+        meta_data = @connection.getMetaData
+        result_set = meta_data.get_primary_keys(nil, nil, table_name.to_s.upcase)
+        key_names = []
+
+        while result_set.next
+          key_names << result_set.get_string(Jdbc::PrimaryKeyMetaData::COLUMN_NAME).downcase
+        end
+
+        key_names
+      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.
+      def indexes(table_name, name = nil)
+        metadata = @connection.getMetaData
+        resultset = metadata.getIndexInfo(nil, nil, table_name.to_s.upcase, false, false)
+        primary_keys = primary_keys(table_name)
+        indexes = []
+        current_index = nil
+        while resultset.next
+          index_name = resultset.get_string(Jdbc::IndexMetaData::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
       end
 
+
       def execute_insert(sql, pk)
         stmt = @connection.createStatement
         stmt.executeUpdate(sql,Jdbc::Statement::RETURN_GENERATED_KEYS)
         row = unmarshal_id_result(stmt.getGeneratedKeys)
         row.first && row.first.values.first
+      rescue
+        if @connection.is_closed
+          reconnect!
+          retry
+        else
+          raise
+        end
       ensure
         stmt.close
       end
@@ -212,6 +331,13 @@ module ActiveRecord
       def execute_update(sql)
         stmt = @connection.createStatement
         stmt.executeUpdate(sql)
+      rescue
+        if @connection.is_closed
+          reconnect!
+          retry
+        else
+          raise
+        end
       ensure
         stmt.close
       end
@@ -219,6 +345,13 @@ module ActiveRecord
       def execute_query(sql)
         stmt = @connection.createStatement
         unmarshal_result(stmt.executeQuery(sql))
+      rescue
+        if @connection.is_closed
+          reconnect!
+          retry
+        else
+          raise
+        end
       ensure
         stmt.close
       end
@@ -240,7 +373,7 @@ module ActiveRecord
       end
 
       private
-      def unmarshal_result(resultset)
+      def unmarshal_result(resultset, &row_filter)
         metadata = resultset.getMetaData
         column_count = metadata.getColumnCount
         column_names = ['']
@@ -252,15 +385,22 @@ module ActiveRecord
           column_types << metadata.getColumnType(i)
           column_scale << metadata.getScale(i)
         end
-
+        
         results = []
 
+        # take all rows if block not supplied
+        row_filter = lambda{|result_row| true} unless block_given?
+
         while resultset.next
-          row = {}
-          1.upto(column_count) do |i|
-            row[column_names[i].downcase] = convert_jdbc_type_to_ruby(i, column_types[i], column_scale[i], resultset)
+          # let the supplied block look at this row from the resultset to
+          # see if we want to include it in our results
+          if row_filter.call(resultset)
+            row = {}
+            1.upto(column_count) do |i|
+              row[column_names[i].downcase] = convert_jdbc_type_to_ruby(i, column_types[i], column_scale[i], resultset)
+            end
+            results << row
           end
-          results << row
         end
 
         results
@@ -289,71 +429,98 @@ module ActiveRecord
 
         results
       end
-      
-      def to_ruby_time(java_date)
-        if java_date
-          tm = java_date.getTime
+
+      def to_ruby_time(java_time)
+        if java_time
+          tm = java_time.getTime
           Time.at(tm / 1000, (tm % 1000) * 1000)
         end
       end
 
+      def to_ruby_date(java_date)
+        if java_date
+          cal = java.util.Calendar.getInstance
+          cal.setTime(java_date)
+          Date.new(cal.get(java.util.Calendar::YEAR), cal.get(java.util.Calendar::MONTH)+1, cal.get(java.util.Calendar::DATE))
+        end
+      end
+
       def convert_jdbc_type_to_ruby(row, type, scale, resultset)
-        if scale != 0
-          decimal = resultset.getString(row)
-          decimal.to_f
-        else
-          case type
-          when Jdbc::Types::CHAR, Jdbc::Types::VARCHAR, Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB
-            resultset.getString(row)
-          when Jdbc::Types::SMALLINT, Jdbc::Types::INTEGER, Jdbc::Types::NUMERIC, Jdbc::Types::BIGINT
-            resultset.getInt(row)
-          when Jdbc::Types::BIT, Jdbc::Types::BOOLEAN, Jdbc::Types::TINYINT, Jdbc::Types::DECIMAL
-            resultset.getBoolean(row)
-          when Jdbc::Types::FLOAT, Jdbc::Types::DOUBLE
-            resultset.getDouble(row)
-          when Jdbc::Types::TIMESTAMP
-            to_ruby_time(resultset.getTimestamp(row))
-          when Jdbc::Types::TIME
-            to_ruby_time(resultset.getTime(row))
-          when Jdbc::Types::DATE
-            to_ruby_time(resultset.getDate(row))
-          when Jdbc::Types::LONGVARBINARY, Jdbc::Types::BLOB, Jdbc::Types::BINARY, Jdbc::Types::VARBINARY
-            resultset.getString(row)
+        value = case type
+        when Jdbc::Types::CHAR, Jdbc::Types::VARCHAR, Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB
+          resultset.getString(row)
+        when Jdbc::Types::NUMERIC, Jdbc::Types::BIGINT
+          if scale != 0
+            BigDecimal.new(resultset.getBigDecimal(row).toString)
           else
-            types = Jdbc::Types.constants
-            name = types.find {|t| Jdbc::Types.const_get(t.to_sym) == type}
-            raise "jdbc_adapter: type #{name} not supported yet"
+            resultset.getLong(row)
           end
+        when Jdbc::Types::DECIMAL
+          BigDecimal.new(resultset.getBigDecimal(row).toString)
+        when Jdbc::Types::SMALLINT, Jdbc::Types::INTEGER
+          resultset.getInt(row) 
+        when Jdbc::Types::BIT, Jdbc::Types::BOOLEAN, Jdbc::Types::TINYINT
+          resultset.getBoolean(row)
+        when Jdbc::Types::FLOAT, Jdbc::Types::DOUBLE
+          resultset.getDouble(row)
+        when Jdbc::Types::TIMESTAMP
+          # FIXME: This should not be a catchall and it should move this to mysql since it
+          # is catching non-existent date 0000-00:00:00
+          begin         
+            to_ruby_time(resultset.getTimestamp(row))
+          rescue java.sql.SQLException
+            nil
+          end
+        when Jdbc::Types::TIME
+          to_ruby_time(resultset.getTime(row))
+        when Jdbc::Types::DATE
+          to_ruby_date(resultset.getDate(row))
+        when Jdbc::Types::LONGVARBINARY, Jdbc::Types::BLOB, Jdbc::Types::BINARY, Jdbc::Types::VARBINARY
+          resultset.getString(row)
+        else
+          raise "jdbc_adapter: type #{jdbc_type_name(type)} not supported yet"
         end
+        resultset.wasNull ? nil : value
+      end
+      def jdbc_type_name(type)
+        Jdbc::Types.constants.find {|t| Jdbc::Types.const_get(t.to_sym) == type}
       end
     end
 
     class JdbcAdapter < AbstractAdapter
+      ADAPTER_TYPES = {
+        /oracle/i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::Oracle)},
+        /mimer/i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::Mimer)},
+        /postgre/i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::PostgreSQL)},
+        /mysql/i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::MySQL)},
+        /sqlserver|tds/i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::MsSQL)},
+        /hsqldb|\.h2\./i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::HSQLDB)},
+        /derby/i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::Derby)},
+        /db2/i => lambda{|cfg,adapt|
+          if cfg[:url] =~ /^jdbc:derby:net:/
+            adapt.extend(JdbcSpec::Derby)
+          else
+            adapt.extend(JdbcSpec::DB2)
+          end},
+        /firebird/i => lambda{|cfg,adapt| adapt.extend(JdbcSpec::FireBird)}
+
+      }
+
       def initialize(connection, logger, config)
         super(connection, logger)
         @config = config
-        case config[:driver].to_s
-          when /oracle/i: self.extend(JdbcSpec::Oracle)
-          when /mimer/i: self.extend(JdbcSpec::Mimer)
-          when /postgre/i: self.extend(JdbcSpec::PostgreSQL)
-          when /mysql/i: self.extend(JdbcSpec::MySQL)
-          when /sqlserver|tds/i: self.extend(JdbcSpec::MsSQL)
-          when /hsqldb/i: self.extend(JdbcSpec::HSQLDB)
-          when /derby/i: self.extend(JdbcSpec::Derby)
-          when /db2/i: 
-            if config[:url] =~ /^jdbc:derby:net:/
-              self.extend(JdbcSpec::Derby)
-            else
-              self.extend(JdbcSpec::DB2)
-            end
-          when /firebird/i: self.extend(JdbcSpec::FireBird)
+        ds = config[:driver].to_s
+        for reg, func in ADAPTER_TYPES
+          if reg === ds
+            func.call(@config,self)
+          end
         end
       end
 
       def modify_types(tp)
         tp
       end
-      
+
       def adapter_name #:nodoc:
         'JDBC'
       end
@@ -400,7 +567,7 @@ module ActiveRecord
         end
         return nil,nil
       end
-      
+
       def active?
         true
       end
@@ -439,7 +606,7 @@ module ActiveRecord
       end
 
       def columns(table_name, name = nil)
-        @connection.columns(table_name)
+        @connection.columns(table_name.to_s)
       end
 
       def tables