ActiveRecord-JDBC 0.4 → 0.5

data/History.txt

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

data/Manifest.txt

@@ -3,8 +3,15 @@ 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
@@ -22,14 +29,17 @@ 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
@@ -47,3 +57,6 @@ 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/Rakefile

@@ -40,7 +40,7 @@ end
 desc "Run AR-JDBC tests"
 if RUBY_PLATFORM =~ /java/
   # TODO: add more databases into the standard tests here.
-  task :test => [:test_mysql, :test_derby, :test_hsqldb]
+  task :test => [:test_mysql, :test_jdbc, :test_derby, :test_hsqldb]
 else
   task :test => [:test_mysql]
 end
@@ -50,6 +50,11 @@ Rake::TestTask.new(:test_mysql) do |t|
   t.libs << 'test'
 end
 
+Rake::TestTask.new(:test_jdbc) do |t|
+  t.test_files = FileList['test/generic_jdbc_connection_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'
@@ -73,18 +78,19 @@ Rake::TestTask.new(:test_jndi) do |t|
   t.libs << 'test'
 end
 
-begin
-  MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", 
-    "Rakefile", "LICENSE", "lib/**/*.rb", "lib/jdbc_adapter_internal.jar", "test/**/*.rb", "lib/**/*.rake"]
+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
+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
 
+begin
   require 'hoe'
-  Hoe.new("ActiveRecord-JDBC", "0.4") do |p|
+  Hoe.new("ActiveRecord-JDBC", "0.5") 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"
@@ -95,4 +101,6 @@ begin
   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

data/lib/active_record/connection_adapters/derby_adapter.rb

@@ -0,0 +1 @@
+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 @@
+require 'active_record/connection_adapters/jdbc_adapter'

data/lib/active_record/connection_adapters/jdbc_adapter.rb

@@ -5,11 +5,55 @@ require 'jdbc_adapter_internal'
 require 'bigdecimal'
 
 module ActiveRecord
-  class Base
-    def self.jdbc_connection(config)
-      connection = ConnectionAdapters::JdbcConnection.new(config)
-      ConnectionAdapters::JdbcAdapter.new(connection, logger, config)
+  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:
@@ -29,6 +73,7 @@ module ActiveRecord
     end
 
     module Jdbc
+      Mutex = java.lang.Object.new
       DriverManager = java.sql.DriverManager
       Statement = java.sql.Statement
       Types = java.sql.Types
@@ -105,7 +150,8 @@ module ActiveRecord
                           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},
+                          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
@@ -147,35 +193,43 @@ module ActiveRecord
     end
 
     class JdbcDriver
-      def self.load(driver)
-        driver_class_const = (driver[0...1].capitalize + driver[1..driver.length]).gsub(/\./, '_')
-        unless Jdbc.const_defined?(driver_class_const)
-          Jdbc.module_eval do
-            include_class(driver) {|p,c| driver_class_const }
+      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
-          Jdbc::DriverManager.registerDriver(Jdbc.const_get(driver_class_const).new)
+          Jdbc.const_get(driver_class_const)
         end
       end
+      
+      def load
+        Jdbc::DriverManager.registerDriver(create)
+      end
+      
+      def create
+        driver_class.new
+      end
     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)},
-        /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 }
-      }
-
+      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
@@ -210,6 +264,10 @@ module ActiveRecord
       rescue Exception => e
         raise "The driver encountered an error: #{e}"
       end
+
+      def reconnect!
+        self.adapter.reconnect!
+      end
       
       def adapter=(adapt)
         @adapter = adapt
@@ -226,7 +284,9 @@ 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.
-      def indexes(table_name, name = nil)
+      #
+      # 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 
@@ -235,12 +295,14 @@ module ActiveRecord
         end
         table_name.upcase! if metadata.storesUpperCaseIdentifiers
         table_name.downcase! if metadata.storesLowerCaseIdentifiers
-        resultset = metadata.getIndexInfo(nil, nil, table_name, false, false)
+        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).downcase
+          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
@@ -298,30 +360,30 @@ module ActiveRecord
           @config[:url] = url
         end
 
-        JdbcDriver.load(driver)
-        set_connection Jdbc::DriverManager.getConnection(url, user, pass)
+        jdbc_driver = JdbcDriver.new(driver)
+        jdbc_driver.load
+        connection = begin
+            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)
+            jdbc_driver.create.connect(url, props)
+          end
+        set_connection connection
       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)}
+      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)
@@ -393,6 +455,8 @@ module ActiveRecord
       def reconnect!
         @connection.close rescue nil
         @connection = JdbcConnection.new(@config)
+        @connection.adapter = self
+        @connection
       end
 
       def select_all(sql, name = nil)
@@ -404,25 +468,25 @@ module ActiveRecord
       end
 
       def execute(sql, name = nil)
-        _execute(sql,name)
+        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)
-        log_no_bench(sql, name) do
-          case sql.strip
-          when /^insert/i:
+        case sql.strip
+        when /\Ainsert/i:
             @connection.execute_insert(sql)
-          when /^\(?\s*(select|show)/i:
+        when /\A\(?\s*(select|show)/i:
             @connection.execute_query(sql)
-          else
-            @connection.execute_update(sql)
-          end
+        else
+          @connection.execute_update(sql)
         end
       end
-      
+
       def update(sql, name = nil) #:nodoc:
         execute(sql, name)
       end
@@ -455,6 +519,10 @@ module ActiveRecord
       def rollback_db_transaction
         @connection.rollback
       end
+      
+      def write_large_object(*args)
+        @connection.write_large_object(*args)
+      end
 
       private
       def select(sql, name=nil)

data/lib/active_record/connection_adapters/jndi_adapter.rb

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

data/lib/active_record/connection_adapters/mysql_adapter.rb

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

data/lib/active_record/connection_adapters/oracle_adapter.rb

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

data/lib/active_record/connection_adapters/postgresql_adapter.rb

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

data/lib/jdbc_adapter/jdbc_db2.rb

@@ -1,5 +1,23 @@
 module JdbcSpec
   module DB2
+    def self.column_selector
+      [/db2/i, lambda {|cfg,col|
+         if cfg[:url] =~ /^jdbc:derby:net:/
+           col.extend(::JdbcSpec::Derby::Column)
+         else
+           col.extend(::JdbcSpec::DB2::Column)
+         end }]
+    end
+
+    def self.adapter_selector
+      [/db2/i, lambda {|cfg,adapt|
+         if cfg[:url] =~ /^jdbc:derby:net:/
+           adapt.extend(::JdbcSpec::Derby)
+         else
+           adapt.extend(::JdbcSpec::DB2)
+         end }]
+    end
+    
     module Column
       def type_cast(value)
         return nil if value.nil? || value =~ /^\s*null\s*$/i
@@ -57,6 +75,9 @@ module JdbcSpec
       if column && column.type == :primary_key
         return value.to_s
       end
+      if column && column.type == :decimal && value
+        return value.to_s
+      end
       case value
       when String                
         if column && column.type == :binary

data/lib/jdbc_adapter/jdbc_derby.rb

@@ -1,7 +1,23 @@
 require 'jdbc_adapter/missing_functionality_helper'
 
-module JdbcSpec
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def derby_connection(config)
+      config[:url] ||= "jdbc:derby:#{config[:database]};create=true"
+      config[:driver] ||= "org.apache.derby.jdbc.EmbeddedDriver"
+      embedded_driver(config)
+    end
+  end 
+
   module Derby
+    def self.column_selector
+      [/derby/i, lambda {|cfg,col| col.extend(::JdbcSpec::Derby::Column)}]
+    end
+
+    def self.adapter_selector
+      [/derby/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::Derby)}]
+    end
+      
     def self.monkey_rails
       unless @already_monkeyd
         # Needed because Rails is broken wrt to quoting of 
@@ -32,23 +48,8 @@ module JdbcSpec
     end
     
     module Column
-      def type_cast(value)
-        return nil if value.nil? || value =~ /^\s*null\s*$/i
-        case type
-        when :string    then value
-        when :text    then value
-        when :integer   then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
-        when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0) 
-        when :decimal   then self.class.value_to_decimal(value)
-        when :float     then value.to_f
-        when :datetime  then cast_to_date_or_time(value)
-        when :date      then self.class.string_to_date(value)
-        when :timestamp then cast_to_time(value)
-        when :binary    then value.scan(/[0-9A-Fa-f]{2}/).collect {|v| v.to_i(16)}.pack("C*")
-        when :time      then cast_to_time(value)
-        when :boolean   then self.class.value_to_boolean(value)
-        else value
-        end
+      def value_to_binary(value)
+        value.scan(/[0-9A-Fa-f]{2}/).collect {|v| v.to_i(16)}.pack("C*")
       end
       
       def cast_to_date_or_time(value)
@@ -85,22 +86,6 @@ module JdbcSpec
       tp[:boolean] = {:name => "smallint"}
       tp
     end
-
-    def add_limit_offset!(sql, options) # :nodoc:
-      @limit = options[:limit]
-      @offset = options[:offset]
-    end
-    
-    def select_all(sql, name = nil)
-      execute(sql, name)
-    end
-    
-    def select_one(sql, name = nil)
-      @limit ||= 1
-      execute(sql, name).first
-    ensure
-      @limit = nil
-    end
     
     def classes_for_table_name(table)
       ActiveRecord::Base.send(:subclasses).select {|klass| klass.table_name == table}
@@ -121,29 +106,6 @@ module JdbcSpec
       end
     end
     
-    def _execute(sql, name = nil)
-      log_no_bench(sql, name) do
-        case sql.strip
-        when /^insert/i:
-          @connection.execute_insert(sql)
-        when /^\(?\s*(select|show)/i:
-          @offset ||= 0
-          if !@limit || @limit == -1
-            range = @offset..-1
-            max = 0
-          else
-            range = @offset...(@offset+@limit)
-            max = @offset+@limit+1
-          end
-          @connection.execute_query(sql,max)[range] || []
-        else
-          @connection.execute_update(sql)
-        end
-      end
-    ensure
-      @limit = @offset = nil
-    end
-
     def primary_key(table_name) #:nodoc:
       primary_keys(table_name).first
     end
@@ -372,51 +334,8 @@ module JdbcSpec
         drop_table t
       end
     end
-    
-    def quote(value, column = nil) # :nodoc:
-      return value.to_s if column && column.type == :primary_key
-
-      case value
-      when String
-        if column 
-          case column.type
-          when :binary
-            "CAST(x'#{quote_string(value).unpack("C*").collect {|v| v.to_s(16)}.join}' AS BLOB)"
-          when :text
-            "CAST('#{quote_string(value)}' AS CLOB)"
-          when :string
-            "'#{quote_string(value)}'"
-          else
-            vi = value.to_i
-            if vi.to_s == value
-              value
-            else
-              super
-            end
-          end
-        else
-          super
-        end
-      when Float, Fixnum, Bignum
-          if column
-            case column.type
-            when :string
-              "'#{quote_string(value.to_s)}'"
-            else
-              super
-            end
-          else
-            super
-          end
-      else super
-      end
-    end
 
-    def quote_string(s)
-      s.gsub(/'/, "''") # ' (for ruby-mode)
-    end
-    
-# For DDL it appears you can quote "" column names, but in queries (like insert it errors out?)
+    # For DDL it appears you can quote "" column names, but in queries (like insert it errors out?)
     def quote_column_name(name) #:nodoc:
       if /^references$/i =~ name
         %Q{"#{name.upcase}"}
@@ -424,6 +343,8 @@ module JdbcSpec
         %Q{"#{name}"}
       elsif name =~ /\s/
         %Q{"#{name.upcase}"}
+      elsif name =~ /^[_\d]/
+        %Q{"#{name.upcase}"}
       else
         name
       end