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

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -35,7 +35,17 @@ ArJdbc::ConnectionMethods.module_eval do
       # * 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] = 0x01 | 0x40
+      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]

data/lib/arjdbc/tasks/databases.rake

@@ -5,15 +5,17 @@ module ActiveRecord::Tasks
   DatabaseTasks.module_eval do
 
     # @override patched to adapt jdbc configuration
-    def each_current_configuration(environment, spec_name = nil)
+    def each_current_configuration(environment, name = nil)
       environments = [environment]
       environments << 'test' if environment == 'development'
 
       environments.each do |env|
         ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
-          next if spec_name && spec_name != db_config.spec_name
+          next if name && name != db_config.name
 
-          yield adapt_jdbc_config(db_config.config), db_config.spec_name, env unless db_config.config['database'].blank?
+          if db_config.database
+            yield adapt_jdbc_config(db_config), db_config.name, env
+          end
         end
       end
     end
@@ -21,21 +23,24 @@ module ActiveRecord::Tasks
     # @override patched to adapt jdbc configuration
     def each_local_configuration
       ActiveRecord::Base.configurations.configs_for.each do |db_config|
-        next unless db_config.config['database']
+        next unless db_config.database
 
-        if local_database?(db_config.config)
-          yield adapt_jdbc_config(db_config.config)
+        if local_database?(db_config)
+          yield adapt_jdbc_config(db_config)
         else
-          $stderr.puts "This task only modifies local databases. #{db_config.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

data/lib/arjdbc/tasks/mssql_database_tasks.rb

@@ -1,18 +1,29 @@
-require 'active_record/tasks/database_tasks'
+# frozen_string_literal: true
 
-require 'arjdbc/tasks/jdbc_database_tasks'
+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(configuration['database'])
-        establish_connection configuration
-      rescue ActiveRecord::StatementInvalid => error
-        case error.message
+        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
@@ -22,7 +33,15 @@ module ArJdbc
 
       def drop
         establish_master_connection
-        connection.drop_database configuration['database']
+        connection.drop_database(db_config.database)
+      end
+
+      def charset
+        connection.charset
+      end
+
+      def collation
+        connection.collation
       end
 
       def purge
@@ -31,40 +50,78 @@ module ArJdbc
         create
       end
 
+      def structure_dump(filename, _extra_flags)
+        args = prepare_command_options
+
+        args.concat(["-f #{filename}"])
 
-      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`
+        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
 
+      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
+      end
+
       def establish_master_connection
-        establish_connection configuration.merge('database' => 'master')
+        establish_connection(configuration_hash.merge(database: 'master'))
       end
 
-      def config_from_url_if_needed
-        config = self.config
-        if config['url'] && ! config.key?('database')
-          config = config_from_url(config['url'])
-        end
-        config
+      def prepare_command_options
+        {
+          server: '-S',
+          database: '-d',
+          username: '-U',
+          password: '-P'
+        }.map { |option, arg| "#{arg} #{config_for_cli[option]}" }
       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 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
@@ -74,8 +131,8 @@ module ArJdbc
 
       def check_protected_environments!
         super
-      rescue ActiveRecord::JDBCError => error
-        case error.message
+      rescue ActiveRecord::JDBCError => e
+        case e.message
         when /cannot open database .* requested by the login/i
         else
           raise
@@ -85,6 +142,6 @@ module ArJdbc
       end
     end
 
-    ActiveRecord::Tasks::DatabaseTasks.send :include, DatabaseTasksMSSQL
+    ActiveRecord::Tasks::DatabaseTasks.send(:include, DatabaseTasksMSSQL)
   end
 end

data/lib/arjdbc/version.rb

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

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

@@ -86,6 +86,7 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.ext.bigdecimal.RubyBigDecimal;
 import org.jruby.ext.date.RubyDate;
+import org.jruby.ext.date.RubyDateTime;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.Block;
@@ -124,6 +125,7 @@ public class RubyJdbcConnection extends RubyObject {
     private IRubyObject config;
     private IRubyObject adapter; // the AbstractAdapter instance we belong to
     private volatile boolean connected = true;
+    private RubyClass attributeClass;
 
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
@@ -132,6 +134,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
+        attributeClass = runtime.getModule("ActiveModel").getClass("Attribute");
     }
 
     private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
@@ -359,7 +362,7 @@ public class RubyJdbcConnection extends RubyObject {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.commit();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.runtime.newBoolean(true);
                 }
                 finally {
@@ -380,7 +383,7 @@ public class RubyJdbcConnection extends RubyObject {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.rollback();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.tru;
                 } finally {
                     connection.setAutoCommit(true);
@@ -516,7 +519,7 @@ public class RubyJdbcConnection extends RubyObject {
         return null;
     }
 
-    protected boolean resetSavepoints(final ThreadContext context) {
+    protected boolean resetSavepoints(final ThreadContext context, final Connection connection) throws SQLException {
         if ( hasInternalVariable("savepoints") ) {
             removeInternalVariable("savepoints");
             return true;
@@ -610,11 +613,7 @@ public class RubyJdbcConnection extends RubyObject {
                 return convertJavaToRuby( connection.unwrap(Connection.class) );
             }
         }
-        catch (AbstractMethodError e) {
-            debugStackTrace(context, e);
-            warn(context, "driver/pool connection does not support unwrapping: " + e);
-        }
-        catch (SQLException e) {
+        catch (AbstractMethodError | SQLException e) {
             debugStackTrace(context, e);
             warn(context, "driver/pool connection does not support unwrapping: " + e);
         }
@@ -860,27 +859,25 @@ public class RubyJdbcConnection extends RubyObject {
      */
     @JRubyMethod(name = "execute_insert_pk", required = 2)
     public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                final String query = sqlString(sql);
-                try {
-
-                    statement = createStatement(context, connection);
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
 
-                    if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
-                        statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
-                    } else {
-                        statement.executeUpdate(query, createStatementPk(pk));
-                    }
+                statement = createStatement(context, connection);
 
-                    return mapGeneratedKeys(context, connection, statement);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
+                    statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
+                } else {
+                    statement.executeUpdate(query, createStatementPk(pk));
                 }
+
+                return mapGeneratedKeys(context, connection, statement);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -903,26 +900,24 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(name = "execute_insert_pk", required = 3)
     public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject binds,
                                          final IRubyObject pk) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                PreparedStatement statement = null;
-                final String query = sqlString(sql);
-                try {
-                    if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
-                        statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
-                    } else {
-                        statement = connection.prepareStatement(query, createStatementPk(pk));
-                    }
-
-                    setStatementParameters(context, connection, statement, (RubyArray) binds);
-                    statement.executeUpdate();
-                    return mapGeneratedKeys(context, connection, statement);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+        return withConnection(context, connection -> {
+            PreparedStatement statement = null;
+            final String query = sqlString(sql);
+            try {
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
+                    statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
+                } else {
+                    statement = connection.prepareStatement(query, createStatementPk(pk));
                 }
+
+                setStatementParameters(context, connection, statement, (RubyArray) binds);
+                statement.executeUpdate();
+                return mapGeneratedKeys(context, connection, statement);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -1012,12 +1007,12 @@ public class RubyJdbcConnection extends RubyObject {
                     binds = null;
                 } else {                              // (sql, binds)
                     maxRows = 0;
-                    binds = (RubyArray) TypeConverter.checkArrayType(args[1]);
+                    binds = (RubyArray) TypeConverter.checkArrayType(context, args[1]);
                 }
                 break;
             case 3:                                   // (sql, max_rows, binds)
                 maxRows = RubyNumeric.fix2int(args[1]);
-                binds = (RubyArray) TypeConverter.checkArrayType(args[2]);
+                binds = (RubyArray) TypeConverter.checkArrayType(context, args[2]);
                 break;
             default:                                  // (sql) 1-arg
                 maxRows = 0;
@@ -1106,6 +1101,28 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @JRubyMethod(required = 1)
+    public IRubyObject get_first_value(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
+                statement = createStatement(context, connection);
+                statement.execute(query);
+                ResultSet rs = statement.getResultSet();
+                if (rs == null || !rs.next()) return context.nil;
+
+                return jdbcToRuby(context, context.getRuntime(), 1, rs.getMetaData().getColumnType(1), rs);
+
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
+            }
+        });
+    }
+
     /**
      * Prepares a query, returns a wrapped PreparedStatement. This takes care of exception wrapping
      * @param context which context this method is executing on.
@@ -2402,9 +2419,16 @@ public class RubyJdbcConnection extends RubyObject {
             final Connection connection, final PreparedStatement statement,
             final int index, IRubyObject attribute) throws SQLException {
 
-        //debugMessage(context, attribute);
-        final int type = jdbcTypeForAttribute(context, attribute);
-        IRubyObject value = valueForDatabase(context, attribute);
+        final IRubyObject value;
+        final int type;
+
+        if (attributeClass.isInstance(attribute)) {
+            type = jdbcTypeForAttribute(context, attribute);
+            value = valueForDatabase(context, attribute);
+        } else {
+            type = jdbcTypeForPrimitiveAttribute(context, attribute);
+            value = attribute;
+        }
 
         // All the set methods were calling this first so save a method call in the nil case
         if ( value == context.nil ) {
@@ -2520,6 +2544,34 @@ public class RubyJdbcConnection extends RubyObject {
         return Types.OTHER; // -1 as well as 0 are used in Types
     }
 
+    protected String internedTypeForPrimitive(final ThreadContext context, final IRubyObject value) throws SQLException {
+        if (value instanceof RubyString) {
+            return "string";
+        }
+        if (value instanceof RubyInteger) {
+            return "integer";
+        }
+        if (value instanceof RubyNumeric) {
+            return "float";
+        }
+        if (value instanceof RubyTime || value instanceof RubyDateTime) {
+            return "timestamp";
+        }
+        if (value instanceof RubyDate) {
+            return "date";
+        }
+        if (value instanceof RubyBoolean) {
+            return "boolean";
+        }
+        return "string";
+    }
+
+    protected Integer jdbcTypeForPrimitiveAttribute(final ThreadContext context,
+                                                    final IRubyObject attribute) throws SQLException {
+        final String internedType = internedTypeForPrimitive(context, attribute);
+        return jdbcTypeFor(internedType);
+    }
+
     protected Integer jdbcTypeFor(final String type) {
         return JDBC_TYPE_FOR.get(type);
     }
@@ -2531,7 +2583,9 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected static IRubyObject attributeSQLType(final ThreadContext context, final IRubyObject attribute) {
-        return attributeType(context, attribute).callMethod(context, "type");
+        final IRubyObject type = attributeType(context, attribute);
+        if (type != null) return type.callMethod(context, "type");
+        return context.nil;
     }
 
     private final CachingCallSite value_site = new FunctionalCachingCallSite("value"); // AR::Attribute#value
@@ -2546,23 +2600,7 @@ public class RubyJdbcConnection extends RubyObject {
 
         final IRubyObject value = value_site.call(context, attribute, attribute);
 
-        if (value instanceof RubyInteger) {
-            return "integer";
-        }
-
-        if (value instanceof RubyNumeric) {
-            return "float";
-        }
-
-        if (value instanceof RubyTime) {
-            return "timestamp";
-        }
-
-        if (value instanceof RubyBoolean) {
-            return "boolean";
-        }
-
-        return "string";
+        return internedTypeForPrimitive(context, value);
     }
 
     // to be overriden in child class for database specific types