activerecord-jdbc-adapter 0.6 → 0.7

data/History.txt

@@ -1,61 +1,80 @@
+== 0.7
+
+- PLEASE NOTE: This release is not compatible with JRuby releases earlier than
+  1.0.3 or 1.1b2. If you must use JRuby 1.0.2 or earlier, please install the
+  0.6 release.
+- Release coincides with JRuby 1.0.3 and JRuby 1.1b2 releases
+- Simultaneous support for JRuby trunk and 1.0 branch
+- Get rid of log_no_bench method, so we time SQL execution again.
+- Implement #select_rows
+- MySQL migration and quoting updates
+
 == 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.
+- 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.
+- 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.
+- 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)
+- 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
+- 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
+- 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 
+- 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
+- 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
+- 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
+- Early releases, added better support for multiple databases
 
 == 0.0.1
 
-* Initial, very alpha release
+- Initial, very alpha release

data/Manifest.txt

@@ -24,7 +24,7 @@ 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
+lib/jdbc_adapter/jdbc_adapter_internal.jar
 test/activerecord/connection_adapters/type_conversion_test.rb
 test/activerecord/connections/native_jdbc_mysql/connection.rb
 test/db/derby.rb
@@ -39,6 +39,7 @@ test/derby_multibyte_test.rb
 test/derby_simple_test.rb
 test/generic_jdbc_connection_test.rb
 test/h2_simple_test.rb
+test/has_many_through.rb
 test/hsqldb_simple_test.rb
 test/jdbc_adapter/jdbc_db2_test.rb
 test/jdbc_common.rb
@@ -59,6 +60,8 @@ 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
+src/java/jdbc_adapter/JdbcAdapterInternalService.java
+src/java/jdbc_adapter/JdbcConnectionFactory.java
+src/java/jdbc_adapter/JdbcDerbySpec.java
+src/java/jdbc_adapter/JdbcMySQLSpec.java
+src/java/jdbc_adapter/SQLBlock.java

data/Rakefile

@@ -13,22 +13,23 @@ def java_classpath_arg # myriad of ways to discover JRuby classpath
     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}" : ""
+  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/ ."
+  sh "jar cf lib/jdbc_adapter/jdbc_adapter_internal.jar -C pkg/classes/ ."
 end
-file "lib/jdbc_adapter_internal.jar" => :java_compile
+file "lib/jdbc_adapter/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']
+  rm_f FileList['lib/**/*.jar']
+  rm_f "manifest.mf"
 end
 
 task :clean => :more_clean
@@ -72,7 +73,7 @@ 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",
+  "Rakefile", "LICENSE", "lib/**/*.rb", "lib/jdbc_adapter/jdbc_adapter_internal.jar", "test/**/*.rb",
    "lib/**/*.rake", "src/**/*.java"]
 
 file "Manifest.txt" => :manifest

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -1,7 +1,7 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'java'
 require 'active_record/connection_adapters/jdbc_adapter_spec'
-require 'jdbc_adapter_internal'
+require 'jdbc_adapter/jdbc_adapter_internal'
 require 'bigdecimal'
 
 module ActiveRecord
@@ -10,7 +10,7 @@ module ActiveRecord
       # 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]
+        native = native_database_types[type.to_s.downcase.to_sym]
         column_type_sql = native.is_a?(Hash) ? native[:name] : native
         if type == :decimal # ignore limit, use precison and scale
           precision ||= native[:precision]
@@ -56,10 +56,10 @@ module ActiveRecord
     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)
+    def attributes_with_quotes(*args) #:nodoc:
+      aq = attributes_with_quotes_pre_oracle(*args)
       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?
+        aq[self.class.primary_key] = "?" if args.first && aq[self.class.primary_key].nil?
       end
       aq
     end
@@ -171,7 +171,14 @@ module ActiveRecord
 
       def choose_best_types
         type_map = {}
-        AR_TO_JDBC_TYPES.each_key do |k|
+        @types.each do |row|
+          name = row['type_name'].downcase
+          k = name.to_sym
+          type_map[k] = { :name => name }
+          type_map[k][:limit] = row['precision'].to_i if row['precision']
+        end
+
+        AR_TO_JDBC_TYPES.keys.each do |k|
           typerow = choose_type(k)
           type_map[k] = { :name => typerow['type_name'].downcase }
           case k
@@ -203,19 +210,19 @@ module ActiveRecord
 
       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
+          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
@@ -265,11 +272,15 @@ module ActiveRecord
       end
     end
 
+    include_class "jdbc_adapter.JdbcConnectionFactory"
+
     class JdbcConnection
-      attr_reader :adapter, :connection
+      attr_reader :adapter, :connection_factory
 
       def initialize(config)
         @config = config.symbolize_keys!
+        @config[:retry_count] ||= 5
+        @config[:connection_alive_sql] ||= "select 1"
         if @config[:jndi]
           begin
             configure_jndi
@@ -280,16 +291,13 @@ module ActiveRecord
         else
           configure_jdbc
         end
+        connection # force the connection to load
         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 = {}
@@ -305,71 +313,60 @@ module ActiveRecord
       # 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, [])
+        with_connection_retry_guard do |conn|
+          metadata = conn.getMetaData
+          begin
+            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
+          ensure
+            metadata.close rescue nil
           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
+        @connection_factory = JdbcConnectionFactory.impl do
+          ds.connection
+        end
         unless @config[:driver]
-          @config[:driver] = @connection.meta_data.connection.java_class.name
+          @config[:driver] = connection.meta_data.connection.java_class.name
         end
       end
 
@@ -380,19 +377,20 @@ module ActiveRecord
         url    = @config[:url].to_s
 
         unless driver && url
-          raise ArgumentError, "jdbc adapter requires driver class and url"
+          raise ::ActiveRecord::ConnectionFailed, "jdbc adapter requires driver class and url"
         end
 
-        if driver =~ /mysql/i
+        if driver =~ /mysql/i && url !~ /#{Regexp.quote(JdbcSpec::MySQL::URL_OPTIONS)}/
           div = url =~ /\?/ ? '&' : '?'
-          url = "#{url}#{div}zeroDateTimeBehavior=convertToNull&jdbcCompliantTruncation=false&useUnicode=true&characterEncoding=utf8"
+          url = "#{url}#{div}#{JdbcSpec::MySQL::URL_OPTIONS}"
           @config[:url] = url
         end
 
         jdbc_driver = JdbcDriver.new(driver)
         jdbc_driver.load
-        connection = jdbc_driver.connection(url, user, pass)
-        set_connection connection
+        @connection_factory = JdbcConnectionFactory.impl do
+          jdbc_driver.connection(url, user, pass)
+        end
       end
 
     end
@@ -474,22 +472,30 @@ module ActiveRecord
       end
 
       def reconnect!
-        @connection.close rescue nil
-        @connection = JdbcConnection.new(@config)
-        @connection.adapter = self
+        @connection.reconnect!
         @connection
       end
+      
+      def disconnect!
+        @connection.disconnect!
+      end
 
       def select_all(sql, name = nil)
         select(sql, name)
       end
 
+      def select_rows(sql, name = nil)
+        rows = []
+        select(sql, name).each {|row| rows << row.values }
+        rows
+      end
+
       def select_one(sql, name = nil)
         select(sql, name).first
       end
 
       def execute(sql, name = nil)
-        log_no_bench(sql, name) do
+        log(sql, name) do
           _execute(sql,name)
         end
       end
@@ -549,27 +555,6 @@ module ActiveRecord
       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