activerecord-jdbc-alt-adapter 52.4.0-java → 61.0.0-java

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def sqlite3_connection(config)
+    config = config.deep_dup
     config[:adapter_spec] ||= ::ArJdbc::SQLite3
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
 
@@ -22,17 +23,37 @@ ArJdbc::ConnectionMethods.module_eval do
         raise
       end
     end
-    
+
+    config[:properties] ||= {}
+
     database = config[:database] # NOTE: "jdbc:sqlite::memory:" syntax is supported
     config[:url] ||= "jdbc:sqlite:#{database == ':memory:' ? '' : database}"
     config[:connection_alive_sql] ||= 'SELECT 1'
 
+    if config[:readonly]
+      # See
+      # * http://sqlite.org/c3ref/open.html
+      # * http://sqlite.org/c3ref/c_open_autoproxy.html
+      # => 0x01 = readonly, 0x40 = uri (default in JDBC)
+      config[:properties][:open_mode] = ::SQLite3::Constants::Open::READONLY | ::SQLite3::Constants::Open::URI
+    end
+
+    if config[:flags]
+      config[:properties][:open_mode] ||= 0
+      config[:properties][:open_mode] |= config[:flags]
+
+      # JDBC driver has an extra flag for it
+      if config[:flags] & ::SQLite3::Constants::Open::SHAREDCACHE != 0
+        config[:properties][:shared_cache] = true
+      end
+    end
+
     timeout = config[:timeout]
     if timeout && timeout.to_s !~ /\A\d+\Z/
       raise TypeError.new "Timeout must be nil or a number (got: #{timeout})."
     end
 
-    options = ( config[:properties] ||= {} )
+    options = config[:properties]
     options['busy_timeout'] ||= timeout unless timeout.nil?
 
     jdbc_connection(config)
@@ -50,8 +71,9 @@ ArJdbc::ConnectionMethods.module_eval do
   def parse_sqlite3_config!(config)
     database = ( config[:database] ||= config[:dbfile] )
     if ':memory:' != database
-      config[:database] = File.expand_path(database, Rails.root) if defined?(Rails.root)
-      dirname = File.dirname(database)
+      # make sure to have an absolute path. Ruby and Java don't agree on working directory
+      config[:database] = File.expand_path(database, defined?(Rails.root) ? Rails.root : nil)
+      dirname = File.dirname(config[:database])
       Dir.mkdir(dirname) unless File.directory?(dirname)
     end
   end

data/lib/arjdbc/tasks/databases.rake

@@ -5,34 +5,42 @@ module ActiveRecord::Tasks
   DatabaseTasks.module_eval do
 
     # @override patched to adapt jdbc configuration
-    def each_current_configuration(environment)
+    def each_current_configuration(environment, name = nil)
       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?
+      environments.each do |env|
+        ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
+          next if name && name != db_config.name
+
+          if db_config.database
+            yield adapt_jdbc_config(db_config), db_config.name, env
+          end
+        end
       end
     end
 
     # @override patched to adapt jdbc configuration
     def each_local_configuration
-      ActiveRecord::Base.configurations.each_value do |config|
-        next unless config['database']
+      ActiveRecord::Base.configurations.configs_for.each do |db_config|
+        next unless db_config.database
 
-        if local_database?(config)
-          yield adapt_jdbc_config(config)
+        if local_database?(db_config)
+          yield adapt_jdbc_config(db_config)
         else
-          $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
+          $stderr.puts "This task only modifies local databases. #{db_config.database} is on a remote host."
         end
       end
     end
 
     private
 
-    def adapt_jdbc_config(config)
-      return config unless config['adapter']
-      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
+    def adapt_jdbc_config(db_config)
+      if db_config.adapter.start_with? 'jdbc'
+        config = db_config.configuration_hash.merge(adapter: db_config.adapter.sub(/^jdbc/, ''))
+        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(db_config.env_name, db_config.name, config)
+      end
+      db_config
     end
 
   end
@@ -45,4 +53,4 @@ module ActiveRecord::Tasks
 
   end if const_defined?(:MySQLDatabaseTasks)
 
-end
+end

data/lib/arjdbc/tasks/mssql_database_tasks.rb

@@ -1,46 +1,147 @@
-require 'arjdbc/tasks/jdbc_database_tasks'
+# frozen_string_literal: true
+
+require 'active_record/tasks/database_tasks'
 
 module ArJdbc
-  module Tasks
-    class MSSQLDatabaseTasks < JdbcDatabaseTasks
+  module Tasks # :nodoc:
+    class MSSQLDatabaseTasks # :nodoc:
+      delegate :connection, to: ActiveRecord::Base
+      delegate :establish_connection, to: ActiveRecord::Base
+      delegate :clear_active_connections!, to: ActiveRecord::Base
+
+      def self.using_database_configurations?
+        true
+      end
+
+      def initialize(db_config)
+        @db_config = db_config
+        @configuration_hash = db_config.configuration_hash
+      end
+
+      def create
+        establish_master_connection
+        connection.create_database(db_config.database, creation_options)
+        establish_connection(db_config)
+      rescue ActiveRecord::StatementInvalid => e
+        case e.message
+        when /database .* already exists/i
+          raise ActiveRecord::Tasks::DatabaseAlreadyExists
+        else
+          raise
+        end
+      end
+
+      def drop
+        establish_master_connection
+        connection.drop_database(db_config.database)
+      end
+
+      def charset
+        connection.charset
+      end
+
+      def collation
+        connection.collation
+      end
 
       def purge
-        test = deep_dup(configuration)
-        test_database = resolve_database(test)
-        test['database'] = 'master'
-        establish_connection(test)
-        connection.recreate_database(test_database)
+        clear_active_connections!
+        drop
+        create
       end
 
-      def structure_dump(filename)
-        config = config_from_url_if_needed
-        `smoscript -s #{config['host']} -d #{config['database']} -u #{config['username']} -p #{config['password']} -f #{filename} -A -U`
+      def structure_dump(filename, _extra_flags)
+        args = prepare_command_options
+
+        args.concat(["-f #{filename}"])
+
+        run_cmd('mssql-scripter', args, 'dumping')
       end
 
-      def structure_load(filename)
-        config = config_from_url_if_needed
-        `sqlcmd -S #{config['host']} -d #{config['database']} -U #{config['username']} -P #{config['password']} -i #{filename}`
+      def structure_load(filename, _extra_flags)
+        args = prepare_command_options
+
+        args.concat(["-i #{filename}"])
+
+        run_cmd('mssql-cli', args, 'loading')
       end
 
       private
 
-      def config_from_url_if_needed
-        config = self.config
-        if config['url'] && ! config.key?('database')
-          config = config_from_url(config['url'])
+      attr_reader :db_config, :configuration_hash
+
+      def creation_options
+        {}.tap do |options|
+          options[:collation] = configuration_hash[:collation] if configuration_hash.include?(:collation)
+
+          # azure creation options
+          options[:azure_maxsize] = configuration_hash[:azure_maxsize] if configuration_hash.include?(:azure_maxsize)
+          options[:azure_edition] = configuration_hash[:azure_edition] if configuration_hash.include?(:azure_edition)
+
+          if configuration_hash.include?(:azure_service_objective)
+            options[:azure_service_objective] = configuration_hash[:azure_service_objective]
+          end
         end
-        config
       end
 
-      def deep_dup(hash)
-        dup = hash.dup
-        dup.each_pair do |k,v|
-          tv = dup[k]
-          dup[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? deep_dup(tv) : v
+      def establish_master_connection
+        establish_connection(configuration_hash.merge(database: 'master'))
+      end
+
+      def prepare_command_options
+        {
+          server: '-S',
+          database: '-d',
+          username: '-U',
+          password: '-P'
+        }.map { |option, arg| "#{arg} #{config_for_cli[option]}" }
+      end
+
+      def config_for_cli
+        {}.tap do |options|
+          if configuration_hash[:host].present? && configuration_hash[:port].present?
+            options[:server] = "#{configuration_hash[:host]},#{configuration_hash[:port]}"
+          elsif configuration_hash[:host].present?
+            options[:server] = configuration_hash[:host]
+          end
+
+          options[:database] = configuration_hash[:database] if configuration_hash[:database].present?
+          options[:username] = configuration_hash[:username] if configuration_hash[:username].present?
+          options[:password] = configuration_hash[:password] if configuration_hash[:password].present?
         end
-        dup
       end
 
+      def run_cmd(cmd, args, action)
+        fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+      end
+
+      def run_cmd_error(cmd, args, action)
+        msg = +"failed to execute:\n"
+        msg << "#{cmd} #{args.join(' ')}\n\n"
+        msg << "Failed #{action} structure, please check the output above for any errors"
+        msg << " and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+        msg
+      end
     end
+
+    module DatabaseTasksMSSQL
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+      def check_protected_environments!
+        super
+      rescue ActiveRecord::JDBCError => e
+        case e.message
+        when /cannot open database .* requested by the login/i
+        else
+          raise
+        end
+      end
+
+      end
+    end
+
+    ActiveRecord::Tasks::DatabaseTasks.send(:include, DatabaseTasksMSSQL)
   end
 end

data/lib/arjdbc/util/quoted_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
   module Util
     # Caches table and column name (quoted) outcomes.
@@ -57,4 +59,4 @@ module ArJdbc
 
     end
   end
-end
+end

data/lib/arjdbc/util/serialized_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
   module Util
     # Gets included into `ActiveRecord::Base` to support sending LOB values
@@ -95,4 +97,4 @@ module ArJdbc
   end
   # @private only due backwards compatibility
   SerializedAttributesHelper = Util::SerializedAttributes
-end
+end

data/lib/arjdbc/util/table_copier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
   module Util
     module TableCopier
@@ -107,4 +109,4 @@ module ArJdbc
   end
   # @private @deprecated backwards compatibility
   MissingFunctionalityHelper = Util::TableCopier
-end
+end

data/lib/arjdbc/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
-  VERSION = '52.4.0'
+  VERSION = '61.0.0'
 end

data/pom.xml

@@ -12,7 +12,7 @@
   <url>http://github.com/jruby/activerecord-jdbc-adapter/wiki</url>
 
   <properties>
-    <jruby.version>9.1.6.0</jruby.version>
+    <jruby.version>9.2.6.0</jruby.version>
   </properties>
 
   <issueManagement>
@@ -75,7 +75,7 @@
     <dependency>
       <groupId>org.postgresql</groupId>
       <artifactId>postgresql</artifactId>
-      <version>42.1.4.jre7</version>
+      <version>42.1.4</version>
     </dependency>
   </dependencies>
 
@@ -103,8 +103,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>2.5.1</version>
         <configuration>
-          <source>1.7</source>
-          <target>1.7</target>
+          <source>1.8</source>
+          <target>1.8</target>
         </configuration>
       </plugin>
     </plugins>

data/rakelib/01-tomcat.rake

@@ -1,6 +1,6 @@
 namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
 
-  TOMCAT_MAVEN_REPO = 'http://repo2.maven.org/maven2/org/apache/tomcat'
+  TOMCAT_MAVEN_REPO = 'https://repo1.maven.org/maven2/org/apache/tomcat'
   TOMCAT_VERSION = '7.0.54'
 
   DOWNLOAD_DIR = File.expand_path('../test/jars', File.dirname(__FILE__))
@@ -48,4 +48,4 @@ namespace :'tomcat-jndi' do # contains a FS JNDI impl (for tests)
     rm jar_path if File.exist?(jar_path)
   end
 
-end
+end

data/rakelib/rails.rake

@@ -57,7 +57,7 @@ namespace :rails do
       ruby_opts_string += " -C \"#{ar_path}\""
       ruby_opts_string += " -rbundler/setup"
       ruby_opts_string += " -rminitest -rminitest/excludes" unless ENV['NO_EXCLUDES'].eql?('true')
-      file_list = ENV["TEST"] ? FileList[ ENV["TEST"] ] : test_files_finder.call
+      file_list = ENV["TEST"] ? FileList[ ENV["TEST"].split(',') ] : test_files_finder.call
       file_list_string = file_list.map { |fn| "\"#{fn}\"" }.join(' ')
       # test_loader_code = "-e \"ARGV.each{|f| require f}\"" # :direct
       option_list = ( ENV["TESTOPTS"] || ENV["TESTOPT"] || ENV["TEST_OPTS"] || '' )

data/src/java/arjdbc/ArJdbcModule.java

@@ -151,7 +151,7 @@ public class ArJdbcModule {
             throw newNativeException(runtime, e);
         }
 
-        return runtime.getTrue();
+        return context.tru;
     }
 
     /**
@@ -191,7 +191,7 @@ public class ArJdbcModule {
     }
 
     // NOTE: probably useless - only to be useful for the pooled runtime mode when jar at WEB-INF/lib
-    static final Map<Ruby, Map<String, Boolean>> loadedDrivers = new WeakHashMap<Ruby, Map<String, Boolean>>(8);
+    static final Map<Ruby, Map<String, Boolean>> loadedDrivers = new WeakHashMap<>(8);
 
     private static IRubyObject loadDriver(final ThreadContext context, final IRubyObject self,
         final String constName) {
@@ -202,7 +202,7 @@ public class ArJdbcModule {
             synchronized (ArJdbcModule.class) {
                 loadedMap = loadedDrivers.get(runtime);
                 if ( loadedMap == null ) {
-                    loadedMap = new HashMap<String, Boolean>(4);
+                    loadedMap = new HashMap<>(4);
                     loadedDrivers.put(runtime, loadedMap);
                 }
             }
@@ -210,8 +210,8 @@ public class ArJdbcModule {
 
         final Boolean driverLoaded = loadedMap.get(constName);
         if ( driverLoaded != null ) {
-            if ( driverLoaded.booleanValue() ) return runtime.getFalse();
-            return runtime.getNil();
+            if (driverLoaded) return context.fals;
+            return context.nil;
         }
 
         try { // require 'jdbc/mysql'

data/src/java/arjdbc/jdbc/DriverWrapper.java

@@ -60,15 +60,7 @@ public class DriverWrapper {
 
     private Driver allocateDriver(final Class<? extends Driver> driverClass)
         throws InstantiationException, IllegalAccessException {
-        try {
-            return driverClass.newInstance();
-        }
-        catch (InstantiationException e) {
-            throw e;
-        }
-        catch (IllegalAccessException e) {
-            throw e;
-        }
+        return driverClass.newInstance();
     }
 
     protected static Class<? extends Driver> loadDriver(final Ruby runtime, final String name)