activerecord-jdbc-adapter 0.9.0.1 → 0.9.1

data/History.txt

@@ -1,3 +1,34 @@
+== 0.9.1
+
+- We did a lot of internal cleanup this release in the hopes of
+  simplifying the code and increasing performance.
+- Many SQLite updates (thanks Nils Christian Haugen)
+- JRUBY-2912: Fix MSSQL create/drop database (Joern Hartmann)
+- JRUBY-2767: Mistake in selecting identity with H2/HSQLDB
+- JRUBY-2884: jdbc_postgre.rb issue handling nil booleans (also a fix
+  for hsqldb/h2) + tests
+- JRUBY-2995: activerecord jdbc derby adapter should quote columns
+  called 'year'
+- JRUBY-2897:  jdbc_postgre.rb needs microsecond support
+- JRUBY-3282: Upgrade to derby 10.4.2.0 to allow unique constraints
+  with nullable columns
+- Update h2 from 1.0.63 to 1.1.107 in driver
+- JRUBY-3026: [Derby] Allow select/delete/update conditions with
+  comparison to NULL using '='
+- JRUBY-2996: ...(actually this fixes only remaining issue of this bug
+  which was symbols making into quote were exploding
+- JRUBY-2691: Update sybase driver to pass simple unit tests with jtds
+  and verify it works with the new dialect keyword. patch by Leigh
+  Kennedy
+- Make :float type work on h2,hsql [returned as string]. Make :float
+  work on hsqldb (no paren value supported). Make REAL_TYPE just
+  return RubyFloat
+- JRUBY-3222: Upgrade #type_to_sql to variation of AR 2.1.2 version
+- Add patch supplied in JRUBY-3489 (patch by Jean-Dominique Morani)
+- Various Oracle fixes by edsono
+- JRUBY-2688: Don't hard-code MySQL connection character encoding to
+  utf8
+
 == 0.9
 
 - Now updated to support ActiveRecord 2.2. JNDI-based connections will

data/Manifest.txt

@@ -52,6 +52,7 @@ test/db/oracle.rb
 test/db/postgres.rb
 test/db/sqlite3.rb
 test/db2_simple_test.rb
+test/derby_migration_test.rb
 test/derby_multibyte_test.rb
 test/derby_simple_test.rb
 test/generic_jdbc_connection_test.rb
@@ -76,18 +77,24 @@ test/models/add_not_null_column_to_table.rb
 test/models/auto_id.rb
 test/models/data_types.rb
 test/models/entry.rb
+test/models/mixed_case.rb
 test/models/reserved_word.rb
 test/mssql_simple_test.rb
 test/mysql_multibyte_test.rb
 test/mysql_simple_test.rb
 test/oracle_simple_test.rb
+test/postgres_mixed_case_test.rb
 test/postgres_reserved_test.rb
 test/postgres_simple_test.rb
 test/simple.rb
 test/sqlite3_simple_test.rb
+test/sybase_jtds_simple_test.rb
 lib/jdbc_adapter/jdbc.rake
 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/PostgresRubyJdbcConnection.java
+src/java/jdbc_adapter/RubyJdbcConnection.java
 src/java/jdbc_adapter/SQLBlock.java
+src/java/jdbc_adapter/Sqlite3RubyJdbcConnection.java

data/README.txt

@@ -30,8 +30,8 @@ What's there, and what is not there:
 * Informix - Fairly complete support, all tests pass and migrations appear to work.  Comments welcome.
 
 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
+Please join the activerecord-jdbc
+mailing-lists[http://kenai.com/projects/activerecord-jdbc/lists] to help us discover
 support for more databases.
 
 == Using ActiveRecord JDBC
@@ -133,6 +133,19 @@ 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.
 
+If you want rails logging enabled during these test runs you can edit 
+test/jdbc_common.rb and add the following line:
+
+require 'db/logger'
+
+== Running AR Tests
+
+  # If you want to run MRI against Rails remember to re-export RUBYLIB to be
+  # empty (or whatever you normally have it set to when you are done).
+  export RUBYLIB=$(find $HOME/NetbeansProjects/activerecord-jdbc-adapter -name lib -type d | grep -v pkg | ruby -e 'puts $stdin.readlines.map{|l| l.chomp}.join(":")')
+  cd active_record_source_dir
+  jruby -S rake test_jdbcmysql (or specific adapter you want to test)
+
 == Authors
 
 This project was written by Nick Sieger <nick@nicksieger.com> and Ola Bini

data/Rakefile

@@ -31,7 +31,7 @@ task :filelist do
   puts FileList['pkg/**/*'].inspect
 end
 
-if RUBY_PLATFORM =~ /java/
+if defined?(JRUBY_VERSION)
   # TODO: add more databases into the standard tests here.
   task :test => [:test_mysql, :test_jdbc, :test_derby, :test_hsqldb, :test_h2, :test_sqlite3]
 else
@@ -46,9 +46,15 @@ FileList['drivers/*'].each do |d|
     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"
+    t.libs = []
+    if defined?(JRUBY_VERSION)
+      t.ruby_opts << "-rjdbc/#{driver}"
+      t.libs << "lib" << "#{d}/lib"
+      t.libs.push *FileList["adapters/#{driver}*/lib"]
+    end
+    t.libs << "test"
+    t.verbose = true
   end
 end
 
@@ -65,40 +71,32 @@ end
 task :test_postgresql => [:test_postgres]
 task :test_pgsql => [:test_postgres]
 
-# Ensure oracle driver is on your classpath before launching rake
-Rake::TestTask.new(:test_oracle) do |t|
-  t.test_files = FileList['test/oracle_simple_test.rb']
-  t.libs << 'test'
-end
-
-# Ensure DB2 driver is on your classpath before launching rake
-Rake::TestTask.new(:test_db2) do |t|
-  t.test_files = FileList['test/db2_simple_test.rb']
-  t.libs << 'test'
-end
-
-# Ensure InterSystems CacheDB driver is on your classpath before launching rake
-Rake::TestTask.new(:test_cachedb) do | t |
-  t.test_files = FileList[ 'test/cachedb_simple_test.rb' ]
-  t.libs << 'test'
+# Ensure driver for these DBs is on your classpath
+%w(oracle db2 cachedb mssql informix).each do |d|
+  Rake::TestTask.new("test_#{d}") do |t|
+    t.test_files = FileList["test/#{d}_simple_test.rb"]
+    t.libs = []
+    t.libs << 'lib' if defined?(JRUBY_VERSION)
+    t.libs << 'test'
+  end
 end
 
-# Ensure that the jTDS driver in on your classpath before launching rake
-Rake::TestTask.new(:test_mssql) do | t |
-  t.test_files = FileList[ 'test/mssql_simple_test.rb' ]
+# Tests for JDBC adapters that don't require a database.
+Rake::TestTask.new(:test_jdbc_adapters) do | t |
+  t.test_files = FileList[ 'test/jdbc_adapter/jdbc_sybase_test.rb' ]
   t.libs << 'test'
 end
 
-# Ensure that the Informix driver is on your classpath before launching rake
-Rake::TestTask.new(:test_informix) do |t|
-  t.test_files = FileList[ 'test/informix_simple_test.rb' ]
-  t.libs << 'test'
+# Ensure that the jTDS driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jtds) do |t|
+  t.test_files = FileList['test/sybase_jtds_simple_test.rb']
+  t.libs << 'test' 
 end
 
-# Tests for JDBC adapters that don't require a database.
-Rake::TestTask.new(:test_jdbc_adapters) do | t |
-  t.test_files = FileList[ 'test/jdbc_adapter/jdbc_sybase_test.rb' ]
-  t.libs << 'test'
+# Ensure that the jConnect driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jconnect) do |t|
+  t.test_files = FileList['test/sybase_jconnect_simple_test.rb']
+  t.libs << 'test' 
 end
 
 MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 

data/lib/active_record/connection_adapters/h2_adapter.rb

@@ -1 +1,13 @@
-require 'active_record/connection_adapters/jdbc_adapter'
+tried_gem = false
+begin
+  require "jdbc/h2"
+rescue LoadError
+  unless tried_gem
+    require 'rubygems'
+    gem "jdbc-h2"
+    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

@@ -9,31 +9,38 @@ begin
 rescue LoadError
 end if defined?(RAILS_ROOT)
 
-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.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]
-          scale ||= native[:scale]
-          if precision
-            if scale
-              column_type_sql += "(#{precision},#{scale})"
-            else
-              column_type_sql += "(#{precision})"
+# AR's 2.2 version of this method is sufficient, but we need it for
+# older versions
+if ActiveRecord::VERSION::MAJOR <= 2 && ActiveRecord::VERSION::MINOR < 2
+  module ActiveRecord
+    module ConnectionAdapters # :nodoc:
+      module SchemaStatements
+        # Convert the speficied column type to a SQL string.
+        def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+          if native = native_database_types[type]
+            column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
+
+            if type == :decimal # ignore limit, use precision and scale
+              scale ||= native[:scale]
+
+              if precision ||= native[:precision]
+                if scale
+                  column_type_sql << "(#{precision},#{scale})"
+                else
+                  column_type_sql << "(#{precision})"
+                end
+              elsif scale
+                raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified"
+              end
+
+            elsif limit ||= native.is_a?(Hash) && native[:limit]
+              column_type_sql << "(#{limit})"
             end
+
+            column_type_sql
           else
-            raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified" if scale
+            type
           end
-          column_type_sql
-        else
-          limit ||= native[:limit]
-          column_type_sql += "(#{limit})" if limit
-          column_type_sql
         end
       end
     end
@@ -43,8 +50,7 @@ end
 module JdbcSpec
   module ActiveRecordExtensions
     def jdbc_connection(config)
-      connection = ::ActiveRecord::ConnectionAdapters::JdbcConnection.new(config)
-      ::ActiveRecord::ConnectionAdapters::JdbcAdapter.new(connection, logger, config)
+      ::ActiveRecord::ConnectionAdapters::JdbcAdapter.new(nil, logger, config)
     end
     alias jndi_connection jdbc_connection
 
@@ -208,7 +214,8 @@ module ActiveRecord
         procs = AR_TO_JDBC_TYPES[ar_type]
         types = @types
         procs.each do |p|
-          new_types = types.select(&p)
+          new_types = types.reject {|r| r["data_type"].to_i == Jdbc::Types::OTHER}
+          new_types = new_types.select(&p)
           new_types = new_types.inject([]) do |typs,t|
             typs << t unless typs.detect {|el| el['type_name'] == t['type_name']}
             typs
@@ -294,6 +301,14 @@ module ActiveRecord
     class JdbcConnection
       attr_reader :adapter, :connection_factory
 
+      # @native_database_types - setup properly by adapter= versus set_native_database_types.
+      #   This contains type information for the adapter.  Individual adapters can make tweaks
+      #   by defined modify_types
+      #
+      # @native_types - This is the default type settings sans any modifications by the 
+      # individual adapter.  My guess is that if we loaded two adapters of different types
+      # then this is used as a base to be tweaked by each adapter to create @native_database_types
+
       def initialize(config)
         @config = config.symbolize_keys!
         @config[:retry_count] ||= 5
@@ -315,64 +330,25 @@ module ActiveRecord
         raise "The driver encountered an error: #{e}"
       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)
+      def adapter=(adapter)
+        @adapter = adapter
+        @native_database_types = dup_native_types
+        @adapter.modify_types(@native_database_types)
       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, schema_name = nil)
-        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
+      # Duplicate all native types into new hash structure so it can be modified
+      # without destroying original structure.  
+      def dup_native_types
+        types = {}
+        @native_types.each_pair do |k, v| 
+          types[k] = v.inject({}) do |memo, kv|
+            memo[kv.first] = begin kv.last.dup rescue kv.last end
+            memo
           end
         end
+        types
       end
+      private :dup_native_types
 
       def jndi_connection?
         @jndi_connection
@@ -402,12 +378,6 @@ module ActiveRecord
           raise ::ActiveRecord::ConnectionFailed, "jdbc adapter requires driver class and url"
         end
 
-        if driver =~ /mysql/i && url !~ /#{Regexp.quote(JdbcSpec::MySQL::URL_OPTIONS)}/
-          div = url =~ /\?/ ? '&' : '?'
-          url = "#{url}#{div}#{JdbcSpec::MySQL::URL_OPTIONS}"
-          @config[:url] = url
-        end
-
         jdbc_driver = JdbcDriver.new(driver)
         jdbc_driver.load
         @connection_factory = JdbcConnectionFactory.impl do
@@ -479,25 +449,37 @@ module ActiveRecord
 
       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
-        dialect = config[:dialect] || config[:driver]
-        for reg, func in ADAPTER_TYPES
-          if reg === dialect.to_s
-            func.call(@config,self)
-          end
+        spec = adapter_spec config
+        unless connection
+          connection_class = jdbc_connection_class spec
+          connection = connection_class.new config
         end
+        super(connection, logger)
+        extend spec if spec
         connection.adapter = self
         JndiConnectionPoolCallbacks.prepare(self, connection)
       end
 
+      def jdbc_connection_class(spec)
+        connection_class = spec.jdbc_connection_class if spec && spec.respond_to?(:jdbc_connection_class)
+        connection_class = ::ActiveRecord::ConnectionAdapters::JdbcConnection unless connection_class
+        connection_class
+      end
+
+      # Locate specialized adapter specification if one exists based on config data
+      def adapter_spec(config)
+        dialect = (config[:dialect] || config[:driver]).to_s
+        ::JdbcSpec.constants.map { |name| ::JdbcSpec.const_get name }.each do |constant|
+          if constant.respond_to? :adapter_matcher
+            spec = constant.adapter_matcher(dialect, config)
+            return spec if spec
+          end
+        end
+        nil
+      end
+
       def modify_types(tp)
         tp
       end

data/lib/jdbc_adapter/jdbc.rake

@@ -2,11 +2,17 @@ def redefine_task(*args, &block)
   task_name = Hash === args.first ? args.first.keys[0] : args.first
   existing_task = Rake.application.lookup task_name
   if existing_task
-    class << existing_task; public :instance_variable_set; end
-    existing_task.instance_variable_set "@prerequisites", FileList[]
+    class << existing_task
+      public :instance_variable_set
+      attr_reader :actions
+    end
+    existing_task.instance_variable_set "@prerequisites", FileList[]    
+    existing_task.actions.shift
+    enhancements = existing_task.actions
     existing_task.instance_variable_set "@actions", []
   end
-  task(*args, &block)
+  redefined_task = task(*args, &block)
+  enhancements.each {|enhancement| redefined_task.actions << enhancement}
 end
 
 namespace :db do
@@ -68,7 +74,11 @@ namespace :db do
       ActiveRecord::Base.establish_connection(abcs["test"])
       ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0') if abcs["test"]["adapter"] =~ /mysql/i
       IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split(";\n\n").each do |ddl|
-        ActiveRecord::Base.connection.execute(ddl.chomp(';'))
+        begin
+          ActiveRecord::Base.connection.execute(ddl.chomp(';'))
+        rescue Exception => ex
+          puts ex.message
+        end
       end
     end
 
@@ -78,7 +88,7 @@ namespace :db do
       if config['adapter'] =~ /postgresql/i
         if config['url']
           db = config['url'][/\/([^\/]*)$/, 1]
-          config['url'][/\/([^\/]*)$/, 1] if db_name
+          config['url'][/\/([^\/]*)$/, 1] = 'postgres' if db
         else
           db = config['database']
           config['database'] = 'postgres'