ActiveRecord-JDBC 0.2.3 → 0.2.4

data/History.txt

@@ -1,3 +1,13 @@
+== 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

data/Manifest.txt

@@ -3,10 +3,8 @@ 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
@@ -16,26 +14,34 @@ 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
+lib/jdbc_adapter/missing_functionality_helper.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/jndi_config.rb
 test/db/logger.rb
 test/db/mysql.rb
+test/db/postgres.rb
+test/derby_simple_test.rb
+test/h2_simple_test.rb
+test/hsqldb_simple_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_simple_test.rb
+test/postgres_simple_test.rb
+test/simple.rb

data/Rakefile

@@ -3,9 +3,44 @@ require 'rake/testtask'
 
 task :default => :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
+
 desc "Run AR-JDBC tests"
 if RUBY_PLATFORM =~ /java/
-  task :test => [:test_mysql, :test_hsqldb, :test_derby]
+  # TODO: add more databases into the standard tests here.
+  task :test => [:java_compile, :test_mysql, :test_derby]
 else
   task :test => [:test_mysql]
 end
@@ -26,13 +61,30 @@ Rake::TestTask.new(:test_derby) do |t|
   t.libs << 'test'
 end
 
-begin
-  require 'hoe'
+Rake::TestTask.new(:test_postgresql) do |t|
+  t.test_files = FileList['test/postgres_simple_test.rb']
+  t.libs << 'test'
+end
 
+task :test_pgsql => [:test_postgresql]
+
+Rake::TestTask.new(:test_jndi) do |t|
+  t.test_files = FileList['test/jndi_test.rb']
+  t.libs << 'test'
+end
+
+begin
   MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 
-    "Rakefile", "LICENSE", "lib/**/*.rb", "test/**/*.rb"]
+    "Rakefile", "LICENSE", "lib/**/*.rb", "lib/jdbc_adapter_internal.jar", "test/**/*.rb"]
+
+  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
 
-  Hoe.new("ActiveRecord-JDBC", "0.2.3") do |p|
+  require 'hoe'
+  Hoe.new("ActiveRecord-JDBC", "0.2.4") 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"
@@ -41,15 +93,7 @@ begin
     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
+rescue LoadError
+  puts "You really need Hoe installed to be able to package this gem"
 end

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -1,11 +1,14 @@
 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
   class Base
     def self.jdbc_connection(config)
-      ConnectionAdapters::JdbcAdapter.new(ConnectionAdapters::JdbcConnection.new(config), logger, config)
+      connection = ConnectionAdapters::JdbcConnection.new(config)
+      ConnectionAdapters::JdbcAdapter.new(connection, logger, config)
     end
 
     alias :attributes_with_quotes_pre_oracle :attributes_with_quotes
@@ -66,41 +69,46 @@ module ActiveRecord
       # 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']},
+        :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'])},
+        :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']},
+        :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']},
-                          lambda {|r| r['type_name'] =~ /^decimal$/i}],
-        :float       => [ lambda {|r| [Jdbc::Types::FLOAT,Jdbc::Types::DOUBLE].include?(r['data_type'])},
+        :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['type_name'] =~ /^float/i},
                           lambda {|r| r['type_name'] =~ /^double$/i},
-                          lambda {|r| r['precision'] == 15}],
-        :datetime    => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type']},
+                          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}],
-        :timestamp   => [ lambda {|r| Jdbc::Types::TIMESTAMP == r['data_type']},
+        :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} ],
-        :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type']},
+        :time        => [ lambda {|r| Jdbc::Types::TIME == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^time$/i},
                           lambda {|r| r['type_name'] =~ /^datetime$/i}],
-        :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type']},
+        :date        => [ lambda {|r| Jdbc::Types::DATE == r['data_type'].to_i},
                           lambda {|r| r['type_name'] =~ /^date$/i}],
-        :binary      => [ lambda {|r| [Jdbc::Types::LONGVARBINARY,Jdbc::Types::BINARY,Jdbc::Types::BLOB].include?(r['data_type'])},
+        :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'])},
+        :boolean     => [ lambda {|r| [Jdbc::Types::TINYINT].include?(r['data_type'].to_i)},
                           lambda {|r| r['type_name'] =~ /^bool/i},
                           lambda {|r| r['type_name'] =~ /^tinyint$/i},
                           lambda {|r| r['type_name'] =~ /^decimal$/i}],
@@ -114,8 +122,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, :decimal].include?(k)
+          type_map[k] = { :name => typerow['type_name'].downcase }
+          type_map[k][:limit] = typerow['precision'] && typerow['precision'].to_i if [:integer, :string, :decimal].include?(k)
           type_map[k][:limit] = 1 if k == :boolean
         end
         type_map
@@ -129,7 +137,7 @@ module ActiveRecord
           return new_types.first if new_types.length == 1
           types = new_types if new_types.length > 0
         end
-        raise "unable to choose type from: #{types.collect{|t| [t['type_name'],t]}.inspect} for #{ar_type}"
+        raise "unable to choose type from: #{types.collect{|t| [t['type_name'],t]}.inspect} for #{ar_type}"        
       end
     end
 
@@ -146,8 +154,11 @@ module ActiveRecord
     end
 
     class JdbcColumn < Column
+      attr_writer :limit, :precision
+        
       COLUMN_TYPES = {
         /oracle/i => lambda {|cfg,col| col.extend(JdbcSpec::Oracle::Column)},
+        /mysql/i => lambda {|cfg,col| col.extend(JdbcSpec::MySQL::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)},
@@ -168,6 +179,10 @@ module ActiveRecord
           end
         end
         super(name,default_value(default),*args)
+        init_column(name, default, *args)
+      end
+
+      def init_column(*args)
       end
 
       def default_value(val)
@@ -176,95 +191,26 @@ module ActiveRecord
     end
 
     class JdbcConnection
+      attr_reader :adapter
+      
       def initialize(config)
-        @config = config.symbolize_keys
-        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"
+        @config = config.symbolize_keys!
+        if @config[:jndi]
+          configure_jndi
+        else
+          configure_jdbc
         end
-
-        JdbcDriver.load(driver)
-        @connection = Jdbc::DriverManager.getConnection(url, user, pass)
         set_native_database_types
-
         @stmts = {}
       rescue Exception => e
-        raise "The driver encounter an error: #{e}"
-      end
-
-      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
-      end
-
-      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 rescue kv.last)})}}
-        adapt.modify_types(types)
+        raise "The driver encountered an error: #{e}"
       end
-
-      def columns(table_name, name = nil)
-        metadata = @connection.getMetaData
-        table_name.upcase! if metadata.storesUpperCaseIdentifiers
-        table_name.downcase! if metadata.storesLowerCaseIdentifiers
-        results = metadata.getColumns(nil, nil, table_name, nil)
-        columns = []
-        unmarshal_result(results).each do |col|
-          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(&table_filter)
-        metadata = @connection.getMetaData
-        results = metadata.getTables(nil, nil, nil, nil)
-        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
+      
+      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.
@@ -277,7 +223,14 @@ module ActiveRecord
       # 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)
+        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, nil, table_name, false, false)
         primary_keys = primary_keys(table_name)
         indexes = []
         current_index = nil
@@ -311,180 +264,37 @@ module ActiveRecord
         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
-
-      def execute_update(sql)
-        stmt = @connection.createStatement
-        stmt.executeUpdate(sql)
-      rescue
-        if @connection.is_closed
-          reconnect!
-          retry
-        else
-          raise
-        end
-      ensure
-        stmt.close
-      end
-
-      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
-
-      def begin
-        @connection.setAutoCommit(false)
-      end
-
-      def commit
-        @connection.commit
-      ensure
-        @connection.setAutoCommit(true)
-      end
-
-      def rollback
-        @connection.rollback
-      ensure
-        @connection.setAutoCommit(true)
-      end
-
       private
-      def unmarshal_result(resultset, &row_filter)
-        metadata = resultset.getMetaData
-        column_count = metadata.getColumnCount
-        column_names = ['']
-        column_types = ['']
-        column_scale = ['']
-
-        1.upto(column_count) do |i|
-          column_names << metadata.getColumnName(i)
-          column_types << metadata.getColumnType(i)
-          column_scale << metadata.getScale(i)
+      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
-        
-        results = []
-
-        # take all rows if block not supplied
-        row_filter = lambda{|result_row| true} unless block_given?
-
-        while resultset.next
-          # 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
-        end
-
-        results
       end
 
-      def unmarshal_id_result(resultset)
-        metadata = resultset.getMetaData
-        column_count = metadata.getColumnCount
-        column_types = ['']
-        column_scale = ['']
-
-        1.upto(column_count) do |i|
-          column_types << metadata.getColumnType(i)
-          column_scale << metadata.getScale(i)
-        end
-
-        results = []
+      def configure_jdbc
+        driver = @config[:driver].to_s
+        user   = @config[:username].to_s
+        pass   = @config[:password].to_s
+        url    = @config[:url].to_s
 
-        while resultset.next
-          row = {}
-          1.upto(column_count) do |i|
-            row[i] = row[i.to_s] = convert_jdbc_type_to_ruby(i, column_types[i], column_scale[i], resultset)
-          end
-          results << row
+        unless driver && url
+          raise ArgumentError, "jdbc adapter requires driver class and url"
         end
-
-        results
-      end
-
-      def to_ruby_time(java_time)
-        if java_time
-          tm = java_time.getTime
-          Time.at(tm / 1000, (tm % 1000) * 1000)
+        
+        if driver =~ /mysql/i
+          div = url =~ /\?/ ? '&' : '?'
+          url = "#{url}#{div}zeroDateTimeBehavior=convertToNull&jdbcCompliantTruncation=false"
+          @config[:url] = url
         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
+        JdbcDriver.load(driver)
+        set_connection Jdbc::DriverManager.getConnection(url, user, pass)
       end
 
-      def convert_jdbc_type_to_ruby(row, type, scale, resultset)
-        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
-            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
@@ -515,6 +325,7 @@ module ActiveRecord
             func.call(@config,self)
           end
         end
+        connection.adapter = self
       end
 
       def modify_types(tp)
@@ -529,10 +340,14 @@ module ActiveRecord
         true
       end
 
-      def native_database_types #:nodoc
-        @connection.native_database_types(self)
+      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
@@ -568,13 +383,9 @@ module ActiveRecord
         return nil,nil
       end
 
-      def active?
-        true
-      end
-
       def reconnect!
         @connection.close rescue nil
-        @connection = JdbcConnection.new(@config,self)
+        @connection = JdbcConnection.new(@config)
       end
 
       def select_all(sql, name = nil)
@@ -587,22 +398,24 @@ module ActiveRecord
 
       def execute(sql, name = nil)
         log_no_bench(sql, name) do
-          if sql =~ /^(select|show)/i
-            @connection.execute_query(sql)
+          case sql.strip
+          when /^(select|show)/i:
+              @connection.execute_query(sql)
+          when /^insert/i:
+              @connection.execute_insert(sql)
           else
             @connection.execute_update(sql)
           end
         end
       end
 
-      alias :update :execute
-      alias :delete :execute
+      def update(sql, name = nil) #:nodoc:
+        execute(sql, name)
+      end
 
       def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        log_no_bench(sql, name) do
-          id = @connection.execute_insert(sql, pk)
-          id_value || id
-        end
+        id = execute(sql, name = nil)
+        id_value || id
       end
 
       def columns(table_name, name = nil)
@@ -627,7 +440,7 @@ module ActiveRecord
 
       private
       def select(sql, name=nil)
-        log_no_bench(sql, name) { @connection.execute_query(sql) }
+        execute(sql,name)
       end
 
       def log_no_bench(sql, name)