activerecord-jdbc-adapter 52.0-java → 52.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: d4e30effdf5519398605801e776e032f385bba8da0008c15bdda99426ac0b2ee
-  data.tar.gz: 5c3075c02b57070186442fd4d8e88252ffab2db0f06ebed390dcdeb7556a27ba
+SHA1:
+  metadata.gz: ce3b01a3484aa192fc9a22b788e3117aa44adedd
+  data.tar.gz: 48b8197f1de856fe9994bfdf798c078eb92b6e2d
 SHA512:
-  metadata.gz: 01c8df592aec36d47474c1968ff73e39f68414a3a3fbde27fcaa5c24fe078ee8cddb2b3f750d580660d567fb3323511e7ad9781913bb6fe658797a9445b42bce
-  data.tar.gz: 1940e41e96e0ac3af73bb0bbdd1dcc75c9c07554e2d3c05a8cc3bf3562cbd9fa9593919a8159c151577463ad676be42b92b2b61089efdebc9ad94fff34596ec7
+  metadata.gz: d1cc13e79b76c8cef827ce7af505720845f5ad7e66c8ffd4bd07dbf4da6563e3d5450c3351ba7dd95b37c096d10b417e28bc3487fba5319d70bbe9776407b0a9
+  data.tar.gz: fab5dc5990fb886dda12232efebcdeed0701bddb4e7b605514a07a955149b34b41bde32f7b18b99aa9274e6ced874733ceddbd72c58302dad0781aeacf2f955f

data/.travis.yml

@@ -21,8 +21,8 @@ before_script:
     mysql -e "grant all privileges on activerecord_unittest.* to rails@localhost;" && \
     mysql -e "grant all privileges on activerecord_unittest2.* to rails@localhost;" && \
     mysql -e "grant all privileges on inexistent_activerecord_unittest.* to rails@localhost;" && \
-    mysql -e "CREATE DATABASE activerecord_unittest;" && \
-    mysql -e "CREATE DATABASE activerecord_unittest2;" \
+    mysql -e "CREATE DATABASE activerecord_unittest DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;" && \
+    mysql -e "CREATE DATABASE activerecord_unittest2 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;" \
     || true
   - |
     [ "$DB" == "postgresql" ] && [ "$TEST_PREFIX" == "rails:" ] && \
@@ -33,6 +33,8 @@ rvm:
   - jruby-9.1.16.0
 jdk:
   - openjdk8
+addons:
+  postgresql: "9.4"
 env:
   - DB=mysql2 PREPARED_STATEMENTS=false
   - DB=mysql2 PREPARED_STATEMENTS=true

data/Rakefile

@@ -236,19 +236,16 @@ if defined? JRUBY_VERSION
     end
 
     classpath = []
-    ENV_PATHS = [ 'java.class.path', 'sun.boot.class.path' ]
-    ENV_PATHS.map { |key| ENV_JAVA[key] }.compact.each do |v|
-      classpath += v.split(File::PATH_SEPARATOR).find_all { |jar| jar =~ /jruby/i }
+    [ 'java.class.path', 'sun.boot.class.path' ].map { |key| ENV_JAVA[key] }.each do |v|
+      classpath += v.split(File::PATH_SEPARATOR).find_all { |jar| jar =~ /jruby/i } if v
     end
-
-    # Using Java 9+.  Let's try and infer jruby jar location from rbconfig
-    if classpath.empty?
-      require 'rbconfig'
-      libdir = RbConfig::CONFIG["libdir"]
-      if libdir.start_with? "classpath:"
+    # Using Java 9+.  Let's try and infer jruby.jar location from rbconfig
+    if classpath.empty?; require 'rbconfig'
+      libdir = RbConfig::CONFIG['libdir']
+      if libdir.start_with? 'classpath:'
         error "Cannot build activerecord-jdbc with jruby-complete"
       end
-      classpath << File.join(libdir, "jruby.jar")
+      classpath << File.join(libdir, 'jruby.jar')
     end
     
     classpath += driver_jars
@@ -256,11 +253,26 @@ if defined? JRUBY_VERSION
 
     source_files = FileList[ 'src/java/**/*.java' ]
 
-    require 'tmpdir'
+    version = lambda do
+      begin
+        require 'arjdbc/version'
+      rescue LoadError
+        path = File.expand_path('../lib', File.dirname(__FILE__))
+        unless $LOAD_PATH.include?(path)
+          $LOAD_PATH << path; retry
+        end
+      end
+
+      gem_version = Gem::Version.create(ArJdbc::VERSION)
+      if gem_version.segments.last == 'DEV'
+        gem_version.segments[0...-1] # 50.0.DEV -> 50.0
+      else
+        gem_version.segments.dup
+      end
+    end
 
-    Dir.mktmpdir do |classes_dir|
-      # Cross-platform way of finding an executable in the $PATH.
-      # Thanks to @mislav
+    require 'tmpdir'; Dir.mktmpdir do |classes_dir|
+      # Cross-platform way of finding an executable in the $PATH. Thanks to @mislav
       which = lambda do |cmd|
         exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
         ENV['PATH'].split(File::PATH_SEPARATOR).map do |path|
@@ -284,7 +296,24 @@ if defined? JRUBY_VERSION
       # avoid environment variable expansion using backslash
       # class_files.gsub!('$', '\$') unless windows?
       # args = class_files.map { |path| [ "-C #{classes_dir}", path ] }.flatten
-      args = [ '-C', "#{classes_dir}/ ." ] # args = class_files
+
+      if ENV['RELEASE'] == 'true'; require 'tempfile'
+        manifest  = "Built-Time: #{Time.now.utc.strftime('%Y-%m-%d %H:%M:%S')}\n"
+        manifest += "Built-JRuby: #{JRUBY_VERSION}\n"
+        manifest += "Specification-Title: ActiveRecord-JDBC\n"
+        manifest += "Specification-Vendor: JRuby\n"
+        manifest += "Specification-Version: #{version.call[0].to_s.split('').join('.')}\n" # AR VERSION (52 -> 5.2)
+        manifest += "Implementation-Vendor: The JRuby Team\n"
+        manifest += "Implementation-Version: #{version.call.join('.')}\n"
+        manifest  = Tempfile.new('MANIFEST').tap { |f| f << manifest; f.close }.path
+      end
+
+      args = []; opts = '-cf'
+      if manifest
+        opts = "#{opts}m"
+        args = [ "#{manifest}" ]
+      end
+      args += [ '-C', "#{classes_dir}/ ." ]
 
       jar_path = jar_file
       if ext_lib_dir = ENV['RUBYLIBDIR']
@@ -294,7 +323,7 @@ if defined? JRUBY_VERSION
       unless jar = which.call('jar')
         warn "could not find jar tool, please make sure it's on the PATH"
       end
-      sh("#{jar} cf #{jar_path} #{args.join(' ')}") do |ok|
+      sh("#{jar} #{opts} #{jar_path} #{args.join(' ')}") do |ok|
         raise 'could not build .jar extension - packaging failure' unless ok
       end
       cp jar_path, jar_file if ext_lib_dir # NOTE: hopefully RG won't mind?!
@@ -302,6 +331,6 @@ if defined? JRUBY_VERSION
   end
 else
   task :jar do
-    puts "please run `rake jar' under JRuby to re-compile the native (Java) extension"
+    warn "please run `rake jar' under JRuby to re-compile the native (Java) extension"
   end
 end

data/lib/arjdbc/abstract/core.rb

@@ -60,7 +60,17 @@ module ArJdbc
         end
       end
 
+      def extract_raw_bind_values(binds)
+        binds.map(&:value_for_database)
+      end
 
+      # this version of log() automatically fills type_casted_binds from binds if necessary
+      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+        if binds.any? && (type_casted_binds.nil? || type_casted_binds.empty?)
+          type_casted_binds = ->{ extract_raw_bind_values(binds) }
+        end
+        super
+      end
     end
   end
 end

data/lib/arjdbc/abstract/database_statements.rb

@@ -27,7 +27,7 @@ module ArJdbc
         else
           log(sql, name, binds) do
             # It seems that #supports_statement_cache? is defined but isn't checked before setting "prepare" (AR 5.0)
-            cached_statement = fetch_cached_statement(sql) if prepare && supports_statement_cache?
+            cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
             @connection.execute_prepared_query(sql, binds, cached_statement)
           end
         end

data/lib/arjdbc/abstract/statement_cache.rb

@@ -42,6 +42,7 @@ module ArJdbc
       end
 
       def supports_statement_cache?
+        ActiveSupport::Deprecation.deprecation_warning(__method__)
         @jdbc_statement_cache_enabled
       end
 

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -4,15 +4,8 @@ module ArJdbc
   ConnectionMethods.module_eval do
 
     def jdbc_connection(config)
-      adapter_class = config[:adapter_class]
-      adapter_class ||= ::ActiveRecord::ConnectionAdapters::JdbcAdapter
-
-      # Once all adapters converted to AR5 then this rescue can be removed
-      begin
-        adapter_class.new(nil, logger, nil, config)
-      rescue ArgumentError
-        adapter_class.new(nil, logger, config)
-      end
+      adapter_class = config[:adapter_class] || ::ActiveRecord::ConnectionAdapters::JdbcAdapter
+      adapter_class.new(nil, logger, nil, config)
     end
 
     def jndi_connection(config); jdbc_connection(config) end

data/lib/arjdbc/mysql/adapter.rb

@@ -31,8 +31,8 @@ module ActiveRecord
 
       include ArJdbc::MySQL
 
-      def initialize(connection, logger, config)
-        super(connection, logger, nil, config)
+      def initialize(connection, logger, connection_parameters, config)
+        super
         @prepared_statements = false unless config.key?(:prepared_statements)
         # configure_connection taken care of at ArJdbc::Abstract::Core
       end

data/lib/arjdbc/mysql/connection_methods.rb

@@ -13,11 +13,14 @@ ArJdbc::ConnectionMethods.module_eval do
     driver = config[:driver] ||=
       defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
 
+    mysql_driver = driver.start_with?('com.mysql.')
+    mariadb_driver = ! mysql_driver && driver.start_with?('org.mariadb.')
+
     begin
       require 'jdbc/mysql'
       ::Jdbc::MySQL.load_driver(:require) if defined?(::Jdbc::MySQL.load_driver)
     rescue LoadError # assuming driver.jar is on the class-path
-    end if mysql_driver = driver[0, 10] == 'com.mysql.'
+    end if mysql_driver
 
     config[:username] = 'root' unless config.key?(:username)
     # jdbc:mysql://[host][,failoverhost...][:port]/[database]
@@ -25,12 +28,12 @@ ArJdbc::ConnectionMethods.module_eval do
     # - if the port is not specified, it defaults to 3306
     # - alternate fail-over syntax: [host:port],[host:port]/[database]
     unless config[:url]
-      host = config[:host]; host = host.join(',') if host.respond_to?(:join)
+      host = config[:host]
+      host ||= 'localhost' if mariadb_driver
+      host = host.join(',') if host.respond_to?(:join)
       config[:url] = "jdbc:mysql://#{host}#{ config[:port] ? ":#{config[:port]}" : nil }/#{config[:database]}"
     end
 
-    mariadb_driver = ! mysql_driver && driver.start_with?('org.mariadb.')
-
     properties = ( config[:properties] ||= {} )
     if mysql_driver
       properties['zeroDateTimeBehavior'] ||= 'convertToNull'
@@ -63,8 +66,8 @@ ArJdbc::ConnectionMethods.module_eval do
     end
     if config[:sslkey] || sslcert = config[:sslcert] # || config[:use_ssl]
       properties['useSSL'] ||= true # supported by MariaDB as well
-      properties['requireSSL'] ||= true if mysql_driver
       if mysql_driver
+        properties['requireSSL'] ||= true
         properties['clientCertificateKeyStoreUrl'] ||= java.io.File.new(sslcert).to_url.to_s if sslcert
         if sslca = config[:sslca]
           properties['trustCertificateKeyStoreUrl'] ||= java.io.File.new(sslca).to_url.to_s

data/lib/arjdbc/postgresql/adapter.rb

@@ -52,8 +52,30 @@ module ArJdbc
       @postgresql_version ||=
         begin
           version = @connection.database_product
-          if version =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
-            ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+          if match = version.match(/([\d\.]*\d).*?/)
+            version = match[1].split('.').map(&:to_i)
+            # PostgreSQL version representation does not have more than 4 digits
+            # From version 10 onwards, PG has changed its versioning policy to
+            # limit it to only 2 digits. i.e. in 10.x, 10 being the major
+            # version and x representing the patch release
+            # Refer to:
+            #   https://www.postgresql.org/support/versioning/
+            #   https://www.postgresql.org/docs/10/static/libpq-status.html -> PQserverVersion()
+            # for more info
+
+            if version.size >= 3
+              (version[0] * 100 + version[1]) * 100 + version[2]
+            elsif version.size == 2
+              if version[0] >= 10
+                version[0] * 100 * 100 + version[1]
+              else
+                (version[0] * 100 + version[1]) * 100
+              end
+            elsif version.size == 1
+              version[0] * 100 * 100
+            else
+              0
+            end
           else
             0
           end
@@ -214,12 +236,16 @@ module ArJdbc
 
     def supports_ddl_transactions?; true end
 
+    def supports_advisory_locks?; true end
+
     def supports_explain?; true end
 
     def supports_expression_index?; true end
 
     def supports_foreign_keys?; true end
 
+    def supports_validate_constraints?; true end
+
     def supports_index_sort_order?; true end
 
     def supports_partial_index?; true end
@@ -230,6 +256,12 @@ module ArJdbc
 
     def supports_views?; true end
 
+    def supports_bulk_alter?; true end    
+
+    def supports_datetime_with_precision?; true end
+
+    def supports_comments?; true end
+
     # Does PostgreSQL support standard conforming strings?
     def supports_standard_conforming_strings?
       standard_conforming_strings?
@@ -244,6 +276,14 @@ module ArJdbc
       postgresql_version >= 90000
     end
 
+    def supports_materialized_views?
+      postgresql_version >= 90300
+    end
+
+    def supports_json?
+      postgresql_version >= 90200
+    end
+
     def supports_insert_with_returning?
       postgresql_version >= 80200
     end
@@ -377,6 +417,12 @@ module ArJdbc
       @connection.configure_connection
     end
 
+    def default_sequence_name(table_name, pk = "id") #:nodoc:
+      serial_sequence(table_name, pk)
+    rescue ActiveRecord::StatementInvalid
+      %Q("#{table_name}_#{pk}_seq")
+    end
+
     def last_insert_id_result(sequence_name)
       exec_query("SELECT currval('#{sequence_name}')", 'SQL')
     end
@@ -590,6 +636,8 @@ module ArJdbc
     end
 
     def translate_exception(exception, message)
+      return super unless exception.is_a?(ActiveRecord::JDBCError)
+
       # TODO: Can we base these on an error code of some kind?
       case exception.message
       when /duplicate key value violates unique constraint/
@@ -680,12 +728,12 @@ module ActiveRecord::ConnectionAdapters
     # AR expects OID to be available on the adapter
     OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-    def initialize(connection, logger = nil, config = {})
+    def initialize(connection, logger = nil, connection_parameters = nil, config = {})
       # @local_tz is initialized as nil to avoid warnings when connect tries to use it
       @local_tz = nil
       @max_identifier_length = nil
 
-      super # configure_connection happens in super
+      super(connection, logger, config) # configure_connection happens in super
 
       @type_map = Type::HashLookupTypeMap.new
       initialize_type_map
@@ -698,19 +746,14 @@ module ActiveRecord::ConnectionAdapters
       Arel::Visitors::PostgreSQL.new(self)
     end
 
-    def exec_query(sql, name = nil, binds = [], prepare: false)
-      super
-    rescue ActiveRecord::StatementInvalid => e
-      raise unless e.cause.message.include?('cached plan must not change result type'.freeze)
+    require 'active_record/connection_adapters/postgresql/schema_definitions'
 
-      if open_transactions > 0
-        # In a transaction, have to fail it - See AR code for details
-        raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
-      else
-        # Not in a transaction, clear the prepared statement and try again
-        delete_cached_statement(sql)
-        retry
-      end
+    ColumnMethods = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods
+    TableDefinition = ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition
+    Table = ActiveRecord::ConnectionAdapters::PostgreSQL::Table
+
+    def create_table_definition(*args) # :nodoc:
+      TableDefinition.new(*args)
     end
 
     public :sql_for_insert

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -51,8 +51,15 @@ ArJdbc::ConnectionMethods.module_eval do
     properties['tcpKeepAlive'] ||= config[:keepalives] if config.key?(:keepalives)
     properties['kerberosServerName'] ||= config[:krbsrvname] if config[:krbsrvname]
 
-    # If prepared statements are off, lets make sure they are really *off*
-    properties['prepareThreshold'] ||= 0 unless config[:prepared_statements]
+    prepared_statements = config.fetch(:prepared_statements) { true }
+    prepared_statements = false if prepared_statements == 'false'
+    if prepared_statements
+      # this makes the pgjdbc driver handle hot compatibility internally
+      properties['autosave'] ||= 'conservative'
+    else
+      # If prepared statements are off, lets make sure they are really *off*
+      properties['prepareThreshold'] = 0
+    end
 
     jdbc_connection(config)
   end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -81,7 +81,7 @@ module ArJdbc
         register_class_with_limit m, 'bit', OID::Bit
         register_class_with_limit m, 'varbit', OID::BitVarying
         m.alias_type 'timestamptz', 'timestamp'
-        m.register_type 'date', Type::Date.new
+        m.register_type 'date', OID::Date.new
 
         m.register_type 'money', OID::Money.new
         m.register_type 'bytea', OID::Bytea.new
@@ -168,6 +168,7 @@ module ArJdbc
       ActiveRecord::Type.register(:bit_varying, OID::BitVarying, adapter: :postgresql)
       ActiveRecord::Type.register(:binary, OID::Bytea, adapter: :postgresql)
       ActiveRecord::Type.register(:cidr, OID::Cidr, adapter: :postgresql)
+      ActiveRecord::Type.register(:date, OID::Date, adapter: :postgresql)
       ActiveRecord::Type.register(:datetime, OID::DateTime, adapter: :postgresql)
       ActiveRecord::Type.register(:decimal, OID::Decimal, adapter: :postgresql)
       ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -62,8 +62,7 @@ module ArJdbc
       end
     end
 
-    # DIFFERENCE: we remove connection_options because we are not using it.
-    def initialize(connection, logger, config)
+    def initialize(connection, logger, connection_options, config)
       super(connection, logger, config)
 
       @active     = true

data/lib/arjdbc/tasks/database_tasks.rb

@@ -1,52 +1,33 @@
 module ArJdbc
   module Tasks
 
-    if defined? ActiveRecord::Tasks::DatabaseTasks # AR-4.x
-
-      def self.register_tasks(pattern, task)
-        ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
-      end
-
-      # support adapter: mariadb (as if it were mysql)
-      register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
-
-    else
-
-      @@tasks = {}
-
-      def self.register_tasks(pattern, task)
-        @@tasks[pattern] = task
-      end
-
-      def self.tasks_instance(config)
-        adapter = config['adapter']
-        key = @@tasks.keys.detect { |pattern| adapter[pattern] }
-        ( @@tasks[key] || JdbcDatabaseTasks ).new(config)
-      end
-
+    def self.register_tasks(pattern, task)
+      ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
     end
 
+    # support adapter: mariadb (as if it were mysql)
+    register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
+
     require 'arjdbc/tasks/jdbc_database_tasks'
-    require 'arjdbc/tasks/db2_database_tasks'
-    require 'arjdbc/tasks/derby_database_tasks'
-    require 'arjdbc/tasks/h2_database_tasks'
-    require 'arjdbc/tasks/hsqldb_database_tasks'
-    require 'arjdbc/tasks/mssql_database_tasks'
+    require 'arjdbc/tasks/sqlite_database_tasks_patch'
+    #require 'arjdbc/tasks/db2_database_tasks'
+    #require 'arjdbc/tasks/derby_database_tasks'
+    #require 'arjdbc/tasks/h2_database_tasks'
+    #require 'arjdbc/tasks/hsqldb_database_tasks'
+    #require 'arjdbc/tasks/mssql_database_tasks'
 
     # re-invent built-in (but deprecated on 4.0) tasks :
-    register_tasks(/sqlserver/, MSSQLDatabaseTasks)
-    register_tasks(/mssql/, MSSQLDatabaseTasks) # (built-in) alias
+    #register_tasks(/sqlserver/, MSSQLDatabaseTasks)
+    #register_tasks(/mssql/, MSSQLDatabaseTasks) # (built-in) alias
     # tasks for custom (JDBC) adapters :
-    register_tasks(/db2/, DB2DatabaseTasks)
-    register_tasks(/derby/, DerbyDatabaseTasks)
-    register_tasks(/h2/, H2DatabaseTasks)
-    register_tasks(/hsqldb/, HSQLDBDatabaseTasks)
+    #register_tasks(/db2/, DB2DatabaseTasks)
+    #register_tasks(/derby/, DerbyDatabaseTasks)
+    #register_tasks(/h2/, H2DatabaseTasks)
+    #register_tasks(/hsqldb/, HSQLDBDatabaseTasks)
     # (default) generic JDBC task :
     register_tasks(/^jdbc$/, JdbcDatabaseTasks)
 
     # NOTE: no need to register "built-in" adapters such as MySQL
-    # - on 4.0 these are registered and will be instantiated
-    # - while on 2.3/3.x we keep the AR built-in task behavior
 
   end
 end

data/lib/arjdbc/tasks/databases.rake

@@ -1,91 +1,48 @@
-raise "ArJdbc needs rake 0.9.x or newer" unless Rake.const_defined?(:VERSION)
-
-Rake::DSL.module_eval do
-
-  def redefine_task(*args, &block)
-    if Hash === args.first
-      task_name = args.first.keys[0]
-      old_prereqs = false # leave as specified
-    else
-      task_name = args.first; old_prereqs = []
-      # args[0] = { task_name => old_prereqs }
-    end
-
-    full_name = Rake::Task.scope_name(Rake.application.current_scope, task_name)
-
-    if old_task = Rake.application.lookup(task_name)
-      old_comment = old_task.full_comment
-      old_prereqs = old_task.prerequisites.dup if old_prereqs
-      old_actions = old_task.actions.dup
-      old_actions.shift # remove the main 'action' block - we're redefining it
-      # old_task.clear_prerequisites if old_prereqs
-      # old_task.clear_actions
-      # remove the (old) task instance from the application :
-      Rake.application.send(:instance_variable_get, :@tasks)[full_name.to_s] = nil
-    else
-      # raise "could not find rake task with (full) name '#{full_name}'"
-    end
-
-    new_task = task(*args, &block)
-    new_task.comment = old_comment if old_comment
-    new_task.actions.concat(old_actions) if old_actions
-    new_task.prerequisites.concat(old_prereqs) if old_prereqs
-    new_task
-  end
-
-end
-
-namespace :db do
-
-  def rails_env
-    defined?(Rails.env) ? Rails.env : ( RAILS_ENV || 'development' )
-  end
+require 'arjdbc/tasks/database_tasks'
 
-  if defined? adapt_jdbc_config
-    ArJdbc.warn "double loading #{__FILE__} please delete lib/tasks/jdbc.rake if present!"
-  end
+module ActiveRecord::Tasks
 
-  def adapt_jdbc_config(config)
-    return config unless config['adapter']
-    config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
-  end
+  DatabaseTasks.module_eval do
 
-  if defined? ActiveRecord::Tasks::DatabaseTasks # 4.0
+    # @override patched to adapt jdbc configuration
+    def each_current_configuration(environment)
+      environments = [environment]
+      environments << 'test' if environment == 'development'
 
-    def current_config(options = {})
-      ActiveRecord::Tasks::DatabaseTasks.current_config(options)
+      configurations = ActiveRecord::Base.configurations.values_at(*environments)
+      configurations.compact.each do |config|
+        yield adapt_jdbc_config(config) unless config['database'].blank?
+      end
     end
 
-  else # 3.x / 2.3
+    # @override patched to adapt jdbc configuration
+    def each_local_configuration
+      ActiveRecord::Base.configurations.each_value do |config|
+        next unless config['database']
 
-    def current_config(options = {}) # not on 2.3
-      options = { :env => rails_env }.merge! options
-      if options[:config]
-        @current_config = options[:config]
-      else
-        @current_config ||= ENV['DATABASE_URL'] ?
-          database_url_config : ActiveRecord::Base.configurations[options[:env]]
+        if local_database?(config)
+          yield adapt_jdbc_config(config)
+        else
+          $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
+        end
       end
     end
 
-    def database_url_config(url = ENV['DATABASE_URL'])
-      # NOTE: ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver
-      # since AR 4.0 that is handled by DatabaseTasks - only care about 2.3/3.x :
-      unless defined? ActiveRecord::Base::ConnectionSpecification::Resolver
-        raise "DATABASE_URL not supported on ActiveRecord #{ActiveRecord::VERSION::STRING}"
-      end
-      resolver = ActiveRecord::Base::ConnectionSpecification::Resolver.new(url, {})
-      resolver.spec.config.stringify_keys
+    private
+
+    def adapt_jdbc_config(config)
+      return config unless config['adapter']
+      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
     end
 
   end
 
-end
+  MySQLDatabaseTasks.class_eval do
 
-require 'arjdbc/tasks/database_tasks'
+    def error_class
+      ActiveRecord::JDBCError
+    end
+
+  end if const_defined?(:MySQLDatabaseTasks)
 
-if defined? ActiveRecord::Tasks::DatabaseTasks # 4.0
-  load File.expand_path('databases4.rake', File.dirname(__FILE__))
-else # 3.x / 2.3
-  load File.expand_path('databases3.rake', File.dirname(__FILE__))
-end
+end

data/lib/arjdbc/tasks/sqlite_database_tasks_patch.rb

@@ -0,0 +1,17 @@
+# patch SQLiteDatabaseTasks for JRuby
+# The problem is that JRuby does not yet support the "out:" option for
+# Kernel.system(). Uses plain output redirection as a workaround.
+
+require 'active_record/tasks/sqlite_database_tasks'
+require 'shellwords'
+
+module ActiveRecord
+  module Tasks
+    class SQLiteDatabaseTasks
+      private
+        def run_cmd(cmd, args, out)
+          `#{cmd} #{Shellwords.join(args)} > "#{out}"`
+        end
+    end
+  end
+end

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '52.0'
+  VERSION = '52.1'
 end

data/rakelib/db.rake

@@ -4,25 +4,35 @@ namespace :db do
   task :mysql do
     require File.expand_path('../../test/shared_helper', __FILE__)
     fail "could not create test database: mysql executable not found" unless mysql = which('mysql')
+
     load 'test/db/mysql_config.rb' # rescue nil
     enc = MYSQL_CONFIG[:encoding] || 'utf8' # 'utf8mb4'
     puts MYSQL_CONFIG.inspect if $VERBOSE
-    # DROP USER arjdbc@localhost; __ERROR 1396 (HY000): Operation CREATE USER failed__
+
+    clean_script = sql_script <<-SQL, 'mysqlclean'
+DROP USER #{MYSQL_CONFIG[:username]}@localhost;
+    SQL
+
     script = sql_script <<-SQL, 'mysql'
 DROP DATABASE IF EXISTS `#{MYSQL_CONFIG[:database]}`;
 CREATE DATABASE `#{MYSQL_CONFIG[:database]}` DEFAULT CHARACTER SET `#{enc}` COLLATE `#{enc}_general_ci`;
+CREATE USER #{MYSQL_CONFIG[:username]}@localhost IDENTIFIED BY '#{MYSQL_CONFIG[:password]}';
 GRANT ALL PRIVILEGES ON `#{MYSQL_CONFIG[:database]}`.* TO #{MYSQL_CONFIG[:username]}@localhost;
 GRANT ALL PRIVILEGES ON `test\_%`.* TO #{MYSQL_CONFIG[:username]}@localhost;
-SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG[:password]}');
     SQL
+
     params = { '-u' => 'root' }
-    if ENV['DATABASE_YML']; require 'yaml'
-    params['-p'] = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
+    if ENV['DATABASE_YML']
+      require 'yaml'
+      params['-p'] = YAML.load(File.new(ENV['DATABASE_YML']))["production"]["password"]
     end
     params['-u'] = ENV['MY_USER'] if ENV['MY_USER']
     params['-p'] = ENV['MY_PASSWORD'] if ENV['MY_PASSWORD']
+
     puts "Creating MySQL (test) database: #{MYSQL_CONFIG[:database]}"
-    sh "cat #{script.path} | #{mysql} -f #{params.map {|k, v| "#{k}#{v}"}.join(' ')}", :verbose => $VERBOSE # so password is not echoed
+    mysql_cmd = "#{mysql} -f #{params.map {|k, v| "#{k}#{v}"}.join(' ')}"
+    sh "cat #{clean_script.path} | #{mysql_cmd}", verbose: false
+    sh "cat #{script.path} | #{mysql_cmd}", verbose: $VERBOSE # so password is not echoed
   end
 
   desc "Creates the test database for PostgreSQL"
@@ -30,8 +40,10 @@ SET PASSWORD FOR #{MYSQL_CONFIG[:username]}@localhost = PASSWORD('#{MYSQL_CONFIG
     require File.expand_path('../../test/shared_helper', __FILE__)
     fail 'could not create test database: psql executable not found' unless psql = which('psql')
     fail 'could not create test database: missing "postgres" role' unless PostgresHelper.postgres_role?
+
     load 'test/db/postgres_config.rb' # rescue nil
     puts POSTGRES_CONFIG.inspect if $VERBOSE
+
     script = sql_script <<-SQL, 'psql'
 DROP DATABASE IF EXISTS #{POSTGRES_CONFIG[:database]};
 DROP USER IF EXISTS #{POSTGRES_CONFIG[:username]};
@@ -40,12 +52,14 @@ CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]
        TEMPLATE template0
        ENCODING '#{POSTGRES_CONFIG[:encoding]}' LC_COLLATE '#{POSTGRES_CONFIG[:collate]}' LC_CTYPE '#{POSTGRES_CONFIG[:collate]}';
     SQL
+
     params = { '-U' => ENV['PSQL_USER'] || 'postgres' }
     params['-q'] = nil unless $VERBOSE
+
     puts "Creating PostgreSQL (test) database: #{POSTGRES_CONFIG[:database]}"
-    sh "cat #{script.path} | #{psql} #{params.to_a.join(' ')}", :verbose => $VERBOSE
+    sh "cat #{script.path} | #{psql} #{params.to_a.join(' ')}", verbose: $VERBOSE
   end
-  task :postgres => :postgresql
+  task postgres: :postgresql
 
   private
 

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -2898,7 +2898,7 @@ public class RubyJdbcConnection extends RubyObject {
         final RubySymbol type = (RubySymbol) attributeSQLType(context, attribute);
 
         // For some reason the driver doesn't like "character varying" as a type
-        if ( type.eql(context.runtime.newSymbol("string")) ) return "text";
+        if ( type.eql(context.runtime.newSymbol("string")) ) return "varchar";
 
         final RubyHash nativeTypes = (RubyHash) getAdapter().callMethod(context, "native_database_types");
         // e.g. `integer: { name: 'integer' }`
@@ -3445,12 +3445,14 @@ public class RubyJdbcConnection extends RubyObject {
                 if ( ! gotConnection ) { // SQLException from driver/data-source
                     reconnectOnRetry = connected;
                 }
+                else if (!autoCommit) {
+                    // never retry inside a transaction
+                    break;
+                }
                 else if ( isTransient(exception) ) {
                     reconnectOnRetry = false; // continue;
                 }
                 else {
-                    if ( ! autoCommit ) break; // do not retry if (inside) transactions
-
                     if ( isConnectionValid(context, getConnectionImpl()) ) {
                         break; // connection not broken yet failed (do not retry)
                     }

data/src/java/arjdbc/postgresql/PostgreSQLRubyJdbcConnection.java

@@ -55,6 +55,7 @@ import org.joda.time.DateTimeZone;
 import org.jruby.*;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
+import org.jruby.ext.bigdecimal.RubyBigDecimal;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
@@ -100,6 +101,7 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         POSTGRES_JDBC_TYPE_FOR.put("line", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("lseg", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("ltree", Types.OTHER);
+        POSTGRES_JDBC_TYPE_FOR.put("money", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("numrange", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("path", Types.OTHER);
         POSTGRES_JDBC_TYPE_FOR.put("point", Types.OTHER);
@@ -374,12 +376,26 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
         final int index, IRubyObject value,
         final IRubyObject attribute, final int type) throws SQLException {
 
+        if ( value instanceof RubyFloat ) {
+            final double doubleValue = ( (RubyFloat) value ).getValue();
+            if ( Double.isInfinite(doubleValue) ) {
+                setTimestampInfinity(statement, index, doubleValue);
+                return;
+            }
+        }
+
         if ( ! "Date".equals(value.getMetaClass().getName()) && value.respondsTo("to_date") ) {
             value = value.callMethod(context, "to_date");
         }
 
-        // NOTE: assuming Date#to_s does right ...
-        statement.setDate(index, Date.valueOf(value.toString()));
+        int year = RubyNumeric.num2int(value.callMethod(context, "year"));
+        int month = RubyNumeric.num2int(value.callMethod(context, "month"));
+        int day = RubyNumeric.num2int(value.callMethod(context, "day"));
+
+        @SuppressWarnings("deprecated")
+        Date date = new Date(year - 1900, month - 1, day);
+
+        statement.setDate(index, date);
     }
 
     @Override
@@ -441,6 +457,14 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
                 }
                 break;
 
+            case "money":
+                if (value instanceof RubyBigDecimal) {
+                    statement.setBigDecimal(index, ((RubyBigDecimal) value).getValue());
+                } else {
+                    setPGobjectParameter(statement, index, value, columnType);
+                }
+                break;
+
             case "lseg":
                 pointValues = parseDoubles(value);
                 statement.setObject(index, new PGlseg(pointValues[0], pointValues[1], pointValues[2], pointValues[3]));
@@ -690,8 +714,16 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
     protected IRubyObject dateToRuby(ThreadContext context, Ruby runtime, ResultSet resultSet, int index) throws SQLException {
         // NOTE: PostgreSQL adapter under MRI using pg gem returns UTC-d Date/Time values
         final String value = resultSet.getString(index);
+        if (value == null) return context.nil;
+
+        final int len = value.length();
+        if (len < 10 && value.charAt(len - 1) == 'y') { // infinity / -infinity
+            IRubyObject infinity = parseInfinity(context.runtime, value);
+
+            if (infinity != null) return infinity;
+        }
 
-        return value == null ? context.nil : DateTimeUtils.parseDate(context, value, getDefaultTimeZone(context));
+        return DateTimeUtils.parseDate(context, value, getDefaultTimeZone(context));
     }
 
 

data/src/java/arjdbc/util/DateTimeUtils.java

@@ -30,6 +30,7 @@ import java.util.TimeZone;
 
 import org.joda.time.DateTime;
 import org.joda.time.DateTimeZone;
+import org.joda.time.chrono.GJChronology;
 import org.joda.time.chrono.ISOChronology;
 import org.jruby.Ruby;
 import org.jruby.RubyFloat;
@@ -303,19 +304,24 @@ public abstract class DateTimeUtils {
         // month
         end = nonDigitIndex(str, start, len);
         month = extractIntValue(str, start, end);
-
-        //sep = str.charAt(end);
-        //if ( sep != '-' ) {
-        //    throw new NumberFormatException("expected date to be dash-separated, got '" + sep + "'");
-        //}
-
         start = end + 1; // Skip '-'
 
         // day of month
         end = nonDigitIndex(str, start, len);
         day = extractIntValue(str, start, end);
 
-        return newDate(context, year, month, day, ISOChronology.getInstance(defaultZone));
+        start = end + 1; // Skip possible space
+        boolean bcEra = false;
+        if ( start + 1 < len ) {
+            final char e1 = str.charAt(start);
+            if ( e1 == 'B' && str.charAt(start + 1) == 'C' ) bcEra = true;
+        }
+
+        if ( bcEra ) year = -1 * year; // no + 1 since we use GJChronology
+
+        DateTime dateTime = new DateTime(year, month, day, 0, 0, 0, GJChronology.getInstance(defaultZone));
+        final Ruby runtime = context.runtime;
+        return runtime.getClass("Date").newInstance(context, Java.getInstance(runtime, dateTime), Block.NULL_BLOCK);
     }
 
     public static IRubyObject parseTime(final ThreadContext context, final CharSequence str, final DateTimeZone defaultZone)

metadata

@@ -1,24 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: '52.0'
+  version: '52.1'
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2018-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.2.0
-  type: :runtime
+  name: activerecord
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -119,7 +119,6 @@ files:
 - lib/arjdbc/jdbc/error.rb
 - lib/arjdbc/jdbc/extension.rb
 - lib/arjdbc/jdbc/java.rb
-- lib/arjdbc/jdbc/jdbc.rake
 - lib/arjdbc/jdbc/railtie.rb
 - lib/arjdbc/jdbc/rake_tasks.rb
 - lib/arjdbc/jdbc/serialized_attributes_helper.rb
@@ -157,14 +156,13 @@ files:
 - lib/arjdbc/tasks.rb
 - lib/arjdbc/tasks/database_tasks.rb
 - lib/arjdbc/tasks/databases.rake
-- lib/arjdbc/tasks/databases3.rake
-- lib/arjdbc/tasks/databases4.rake
 - lib/arjdbc/tasks/db2_database_tasks.rb
 - lib/arjdbc/tasks/derby_database_tasks.rb
 - lib/arjdbc/tasks/h2_database_tasks.rb
 - lib/arjdbc/tasks/hsqldb_database_tasks.rb
 - lib/arjdbc/tasks/jdbc_database_tasks.rb
 - lib/arjdbc/tasks/mssql_database_tasks.rb
+- lib/arjdbc/tasks/sqlite_database_tasks_patch.rb
 - lib/arjdbc/util/quoted_cache.rb
 - lib/arjdbc/util/serialized_attributes.rb
 - lib/arjdbc/util/table_copier.rb
@@ -181,7 +179,6 @@ files:
 - rakelib/01-tomcat.rake
 - rakelib/02-test.rake
 - rakelib/bundler_ext.rb
-- rakelib/compile.rake
 - rakelib/db.rake
 - rakelib/rails.rake
 - src/java/arjdbc/ArJdbcModule.java
@@ -225,7 +222,7 @@ homepage: https://github.com/jruby/activerecord-jdbc-adapter
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -245,9 +242,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.6.14.1
+signing_key:
 specification_version: 4
 summary: JDBC adapter for ActiveRecord, for use within JRuby on Rails.
 test_files: []

data/lib/arjdbc/jdbc/jdbc.rake

@@ -1,4 +0,0 @@
-load 'arjdbc/tasks.rb'
-
-require 'arjdbc'
-ArJdbc.deprecate "load 'arjdbc/tasks.rb' (or 'arjdbc/tasks/database.rake') instead of 'arjdbc/jdbc/jdbc.rake'"

data/lib/arjdbc/tasks/databases3.rake

@@ -1,215 +0,0 @@
-module ArJdbc
-  module Tasks
-    class << self
-
-      # API similar to ActiveRecord::Tasks::DatabaseTasks on AR 4.0
-
-      def create(config)
-        tasks_instance(config).create
-      end
-
-      def drop(config)
-        tasks_instance(config).drop
-      end
-
-      def purge(config)
-        tasks_instance(config).purge
-      end
-
-      def charset(config)
-        tasks_instance(config).charset
-      end
-
-      def collation(config)
-        tasks_instance(config).collation
-      end
-
-      def structure_dump(config, filename)
-        tasks_instance(config).structure_dump(filename)
-      end
-
-      def structure_load(config, filename)
-        tasks_instance(config).structure_load(filename)
-      end
-
-    end
-  end
-end
-
-namespace :db do
-
-  class << self
-    alias_method :_rails_create_database, :create_database
-    alias_method :_rails_drop_database,   :drop_database
-  end
-
-  def create_database(config)
-    case config['adapter']
-    when /mysql2/
-      unless defined? Mysql2::Error
-        # NOTE: fake it for create_database(config)
-        Object.const_set :Mysql2, Module.new
-        Mysql2.const_set :Error, ActiveRecord::JDBCError
-        ActiveRecord::JDBCError.class_eval do
-          def error; self end # Mysql2::Error#error
-        end
-      end
-      _rails_create_database adapt_jdbc_config(config)
-    when /mysql/
-      unless defined? Mysql::Error
-        # NOTE: fake it for create_database(config)
-        Object.const_set :Mysql, Module.new
-        Mysql.const_set :Error, ActiveRecord::JDBCError
-        ActiveRecord::JDBCError.class_eval do
-          def error; self end # Mysql::Error#error
-        end
-      end
-      _rails_create_database adapt_jdbc_config(config)
-    when /postgresql|sqlite/
-      _rails_create_database adapt_jdbc_config(config)
-    else
-      ArJdbc::Tasks.create(config)
-    end
-  end
-
-  def drop_database(config)
-    case config['adapter']
-    when /mysql|postgresql|sqlite/
-      _rails_drop_database adapt_jdbc_config(config)
-    else
-      ArJdbc::Tasks.drop(config)
-    end
-  end
-
-  redefine_task :charset do # available on 2.3
-    ArJdbc::Tasks.charset ActiveRecord::Base.configurations[rails_env]
-  end
-
-  redefine_task :collation do # available on 2.3
-    ArJdbc::Tasks.collation ActiveRecord::Base.configurations[rails_env]
-  end
-
-  namespace :structure do
-
-    redefine_task :dump do
-      config = ActiveRecord::Base.configurations[rails_env] # current_config
-      filename = structure_sql
-
-      case config['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(config)
-        File.open(filename, 'w:utf-8') { |f| f << ActiveRecord::Base.connection.structure_dump }
-      when /postgresql/
-        ActiveRecord::Base.establish_connection(config)
-
-        ENV['PGHOST'] = config['host'] if config['host']
-        ENV['PGPORT'] = config['port'].to_s if config['port']
-        ENV['PGPASSWORD'] = config['password'].to_s if config['password']
-        ENV['PGUSER'] = config['username'].to_s if config['username']
-
-        require 'shellwords'
-        search_path = config['schema_search_path']
-        unless search_path.blank?
-          search_path = search_path.split(",").map{ |part| "--schema=#{Shellwords.escape(part.strip)}" }.join(" ")
-        end
-        sh "pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(config['database'])}"
-
-        File.open(filename, 'a') { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
-      when /sqlite/
-        dbfile = config['database']
-        sh "sqlite3 #{dbfile} .schema > #{filename}"
-      else
-        ActiveRecord::Base.establish_connection(config)
-        ArJdbc::Tasks.structure_dump(config, filename)
-      end
-
-      if ActiveRecord::Base.connection.supports_migrations?
-        File.open(filename, 'a') { |f| f << ActiveRecord::Base.connection.dump_schema_information }
-      end
-
-    end
-
-    redefine_task :load do
-      config = current_config
-      filename = structure_sql
-
-      case config['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(config)
-        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-        IO.read(filename).split("\n\n").each do |table|
-          ActiveRecord::Base.connection.execute(table)
-        end
-      when /postgresql/
-        ENV['PGHOST'] = config['host'] if config['host']
-        ENV['PGPORT'] = config['port'].to_s if config['port']
-        ENV['PGPASSWORD'] = config['password'].to_s if config['password']
-        ENV['PGUSER'] = config['username'].to_s if config['username']
-
-        `psql -f "#{filename}" #{config['database']}`
-      when /sqlite/
-        dbfile = config['database']
-        `sqlite3 #{dbfile} < "#{filename}"`
-      else
-        ArJdbc::Tasks.structure_load(config, filename)
-      end
-    end
-
-    def structure_sql
-      ENV['DB_STRUCTURE'] ||= begin
-        root = defined?(Rails.root) ? Rails.root : ( RAILS_ROOT rescue nil )
-        if ActiveRecord::VERSION::STRING > '3.2'
-          root ? File.join(root, "db", "structure.sql") : File.join("db", "structure.sql")
-        else
-          root ? File.join(root, "db/#{rails_env}_structure.sql") : "db/#{rails_env}_structure.sql"
-        end
-      end
-    end
-
-  end
-
-  namespace :test do
-
-    # desc "Recreate the test database from an existent structure.sql file"
-    redefine_task :load_structure => 'db:test:purge' do # not on 2.3
-      begin
-        current_config(:config => ActiveRecord::Base.configurations['test'])
-        Rake::Task["db:structure:load"].invoke
-      ensure
-        current_config(:config => nil)
-      end
-    end
-
-    # desc "Recreate the test database from a fresh structure.sql file"
-    redefine_task :clone_structure => [ "db:structure:dump", "db:test:load_structure" ]
-    # same as on 3.2 - but this task gets changed on 2.3 by depending on :load_structure
-
-    # desc "Empty the test database"
-    redefine_task :purge do
-      config = ActiveRecord::Base.configurations['test']
-      case config['adapter']
-      when /mysql/
-        ActiveRecord::Base.establish_connection(:test)
-        options = mysql_creation_options(config) rescue config
-        ActiveRecord::Base.connection.recreate_database(config['database'], options)
-      when /postgresql/
-        ActiveRecord::Base.clear_active_connections!
-        # drop_database(config) :
-        ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
-        ActiveRecord::Base.connection.drop_database config['database']
-        # create_database(config) :
-        encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
-        ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => encoding))
-      when /sqlite/
-        dbfile = config['database']
-        File.delete(dbfile) if File.exist?(dbfile)
-      else
-        ArJdbc::Tasks.purge(config)
-      end
-    end
-    # only does (:purge => :environment) on AR < 3.2
-    task :purge => :load_config if Rake::Task.task_defined?(:load_config)
-
-  end
-
-end

data/lib/arjdbc/tasks/databases4.rake

@@ -1,39 +0,0 @@
-module ActiveRecord::Tasks
-
-  DatabaseTasks.module_eval do
-    
-    # patched to adapt jdbc configuration
-    def each_current_configuration(environment)
-      environments = [environment]
-      environments << 'test' if environment == 'development'
-
-      configurations = ActiveRecord::Base.configurations.values_at(*environments)
-      configurations.compact.each do |config|
-        yield adapt_jdbc_config(config) unless config['database'].blank?
-      end
-    end
-
-    # patched to adapt jdbc configuration
-    def each_local_configuration
-      ActiveRecord::Base.configurations.each_value do |config|
-        next unless config['database']
-
-        if local_database?(config)
-          yield adapt_jdbc_config(config)
-        else
-          $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
-        end
-      end
-    end
-
-  end
-
-  MySQLDatabaseTasks.class_eval do
-
-    def error_class
-      ActiveRecord::JDBCError
-    end
-
-  end
-  
-end

data/rakelib/compile.rake

@@ -1,70 +0,0 @@
-jar_file = File.join(*%w(lib arjdbc jdbc adapter_java.jar))
-begin
-  require 'ant'
-  directory classes = "pkg/classes"
-  CLEAN << classes
-
-  driver_jars = []
-  # PostgreSQL driver :
-  driver_jars << Dir.glob("jdbc-postgres/lib/*.jar").sort.last
-  
-  file jar_file => FileList['src/java/**/*.java', 'pkg/classes'] do
-    rm_rf FileList["#{classes}/**/*"]
-    ant.javac :srcdir => "src/java", :destdir => "pkg/classes",
-      :source => "7", :target => "7", :debug => true, :deprecation => true,
-      :classpath => "${java.class.path}:${sun.boot.class.path}:#{driver_jars.join(':')}",
-      :includeantRuntime => false
-
-    ant.tstamp do |ts|
-      ts.format(:property => 'TODAY', :pattern => 'yyyy-MM-dd HH:mm:ss')
-    end
-
-    begin
-      require 'arjdbc/version'
-    rescue LoadError
-      path = File.expand_path('../lib', File.dirname(__FILE__))
-      unless $LOAD_PATH.include?(path)
-        $LOAD_PATH << path; retry
-      end
-    end
-
-    gem_version = Gem::Version.create(ArJdbc::VERSION)
-    if gem_version.segments.last == 'DEV'
-      version = gem_version.segments[0...-1] # 1.3.0.DEV -> 1.3.0
-    else
-      version = gem_version.segments.dup
-    end
-    version = version.join('.')
-    
-    ant.manifest :file => 'MANIFEST.MF' do |mf|
-      mf.attribute :name => 'Built-By', :value => '${user.name}'
-      mf.attribute :name => 'Built-Time', :value => '${TODAY}'
-      mf.attribute :name => 'Built-Jdk', :value => '${java.version}'
-      mf.attribute :name => 'Built-JRuby', :value => JRUBY_VERSION
-      
-      mf.attribute :name => 'Specification-Title', :value => 'ActiveRecord-JDBC'
-      mf.attribute :name => 'Specification-Version', :value => '1.3'
-      mf.attribute :name => 'Specification-Vendor', :value => 'JRuby'
-      mf.attribute :name => 'Implementation-Version', :value => version
-      mf.attribute :name => 'Implementation-Vendor', :value => 'The JRuby Team'
-    end
-    
-    ant.jar :basedir => "pkg/classes", :includes => "**/*.class", 
-            :destfile => jar_file, :manifest => 'MANIFEST.MF'
-  end
-
-  desc "Compile the native Java code."
-  task :jar => jar_file
-  
-  namespace :jar do
-    task :force do
-      rm jar_file if File.exist?(jar_file)
-      Rake::Task['jar'].invoke
-    end
-  end
-  
-rescue LoadError
-  task :jar do
-    puts "Run 'jar' with JRuby to re-compile the agent extension class"
-  end
-end