activerecord-jdbc-alt-adapter 51.3.4-java → 51.5.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a3c0428b4f948977af84376216125a83a330607ae740a9a4d85518e47a124bc
-  data.tar.gz: e3d3d39df6e9081ec13518feb7da1d6dc35a4bf357a8a383fa55e9ffe938319e
+  metadata.gz: 72f71b731808f36e43c33470fa32823359c66dfa433feb5fa996c076edb3e6a5
+  data.tar.gz: ea64550ca388dfc1e2cc05a60d21eec0184e603a4ffb84dbbce5378b0357857b
 SHA512:
-  metadata.gz: 19dcc8bfc27295e6f4330cf07691be49d3a1e6abdd11ed822c2da92de9ce6a9191e04319cd3b5e4cf05e0a76ba07a4b65603d423c514ebbe327998f73f9f6905
-  data.tar.gz: 528335a89635de9ea73accb6b46eb5160ee464e01203e4fb4eebe3e481a2143f14c2f31bd0ed0ce5d630c90928d814605d00d9b1429bfa2b500c2394e46e8a58
+  metadata.gz: 87c1acff7cf0394988fcccfdb1382828921876c3800f01dd4eb32c76a6d915c4a4e221b634474b7c80171c34b9716fa9bd6b0f802dd45302658e0d964da7913c
+  data.tar.gz: 9e69077c86dedc2a91888ea9fbf8d915f97067f6974b724ebcc1c86e13f46c02d443616316a82842cf800407e7cd9a81d5b6cf554719e7357c7480f7233ae1de

data/.travis.yml

@@ -1,18 +1,27 @@
-language: ruby
 sudo: false
-branches:
-  only:
-  - master
-  - /.*-stable$/
-  - /^test-.*/
-  - /maintenance|support/
-  - /.*dev$/
-bundler_args: --without development
-script: bundle exec rake ${TEST_PREFIX}test_$DB
+dist: xenial
+
+services:
+  - mysql
+addons:
+  postgresql: 9.4
+
 before_install:
   - unset _JAVA_OPTIONS
   - rvm @default,@global do gem uninstall bundler -a -x -I || true
   - gem install bundler -v "~>1.17.3"
+install:
+- bundle install --retry 3 --without development
+# to fix this issue: https://travis-ci.community/t/mariadb-10-1-fails-to-install-on-xenial/3151/3
+- mysql -u root -e 'CREATE USER IF NOT EXISTS travis@localhost; GRANT ALL ON *.* TO travis@localhost;' || true
+
+language: ruby
+rvm:
+  - jruby-9.1.16.0
+jdk:
+  - openjdk8
+
+script: bundle exec rake ${TEST_PREFIX}test_$DB
 before_script:
   - echo "JAVA_OPTS=$JAVA_OPTS"
   - export JRUBY_OPTS="-J-Xms64M -J-Xmx1024M"
@@ -38,12 +47,7 @@ before_script:
     psql  -c "create database activerecord_unittest;" -U postgres && \
     psql  -c "create database activerecord_unittest2;" -U postgres \
     || true
-rvm:
-  - jruby-9.1.16.0
-jdk:
-  - openjdk8
-addons:
-  postgresql: "9.4"
+
 env:
   - DB=mysql2 PREPARED_STATEMENTS=false
   - DB=mysql2 PREPARED_STATEMENTS=true
@@ -86,10 +90,10 @@ matrix:
       env: DB=sqlite3
     # testing against MariaDB
     - addons:
-        mariadb: '10.0'
+        mariadb: 10.2
       env: DB=mariadb PREPARED_STATEMENTS=false
     - addons:
-        mariadb: '10.1'
+        mariadb: 10.3
       env: DB=mariadb PREPARED_STATEMENTS=true
     # Rails test-suite :
     - env: DB=mysql2     TEST_PREFIX="rails:" AR_VERSION="v5.1.7" # PS off by default

data/Gemfile

@@ -48,7 +48,7 @@ group :test do
   gem 'mocha', '~> 1.2', require: false # Rails has '~> 0.14'
 
   gem 'bcrypt', '~> 3.1.11', require: false
-  gem 'jdbc-mssql', '~> 0.6.0', require: nil
+  gem 'jdbc-mssql', '~> 0.7.0', require: nil
   # gem 'pry-debugger-jruby', platform: :jruby
 end
 

data/README.md

@@ -114,15 +114,16 @@ this adapter should just work.
 ActiveRecord-JDBC-Adapter (AR-JDBC) is the main database adapter for Rails'
 *ActiveRecord* component that can be used with [JRuby][0].
 ActiveRecord-JDBC-Adapter provides full or nearly full support for:
-**MySQL**, **PostgreSQL**, **SQLite3**.  In the near future there are plans to
-add support **MSSQL**. Unless we get more contributions we will not be going
-beyond these four adapters.  Note that the amount of work needed to get
-another adapter is not huge but the amount of testing required to make sure
-that adapter continues to work is not something we can do with the resources
-we currently have.
+**MySQL**, **PostgreSQL**, **SQLite3** and **MSSQL*** (SQLServer).
 
-For Oracle database users you are encouraged to use
-https://github.com/rsim/oracle-enhanced.
+Unless we get more contributions we will not be supporting more adapters.
+Note that the amount of work needed to get another adapter is not huge but
+the amount of testing required to make sure that adapter continues to work
+is not something we can do with the resources we currently have.
+
+- for **Oracle** database users you are encouraged to use
+  https://github.com/rsim/oracle-enhanced
+- **MSSQL** adapter's gem parts reside in a [separate repository][8]
 
 Version **50.x** supports Rails version 5.0.x and it lives on branch 50-stable.
 Version **51.x** supports Rails version 5.1.x and is currently on master until
@@ -141,6 +142,7 @@ adapters are available:
   - MySQL (`activerecord-jdbcmysql-adapter`)
   - PostgreSQL (`activerecord-jdbcpostgresql-adapter`)
   - SQLite3 (`activerecord-jdbcsqlite3-adapter`)
+  - MSSQL (`activerecord-jdbcsqlserver-adapter`)
 
 2. If you're generating a new Rails application, use the following command:
 
@@ -275,4 +277,4 @@ license the database's drivers are licensed. See each driver gem's LICENSE.txt.
 [5]: https://github.com/jruby/activerecord-jdbc-adapter/wiki
 [6]: https://webchat.freenode.net/?channels=#jruby
 [7]: http://badge.fury.io/rb/activerecord-jdbc-adapter
-[8]: https://github.com/jruby/activerecord-jdbc-adapter/wiki/Migrating-from-1.2.x-to-1.3.0
+[8]: https://github.com/jruby/activerecord-jdbcsqlserver-adapter

data/Rakefile

@@ -1,3 +1,29 @@
+# Common usage
+#
+#   rake build:adapters - to build all specific adapter gems and the base gem
+#   rake release:do - build:adapters + git tag + push gems
+#
+# Environment variables used by this Rakefile:
+#
+# INCLUDE_JAR_IN_GEM [default task - false, other taks - true]:
+#   Note: This is something you should not normally have to set.
+#   For local development we always will end up including the jar file
+#   in any task which generates our main gem.  The wrinkle to this
+#   is when we do a custom github link in bundler:
+#
+#      gem 'ar-jdbc', github: '...'
+#
+#   Because we stopped committing a .jar file for every change and so when
+#   we  include a gem like this it clones the repository and does a default
+#   build in rake.  This in turn will end up forcing a compile to generate
+#   that jar (similar to how c-extensions compile at the time of install).
+#   For shipped gems we do include the jar so that people do not require
+#   this compile step.
+#
+# NOOP [release:do - false]
+#
+#   No commands or gem pushing during a release.
+
 require 'rake/clean'
 
 CLEAN.include 'derby*', 'test.db.*', '*test.sqlite3', 'test/reports'
@@ -38,7 +64,8 @@ rake = lambda { |task| ruby "-S", "rake", task }
 
 desc "Build #{gem_name} gem into the pkg directory."
 task :build => :jar do
-  sh("RELEASE=#{ENV['RELEASE']} gem build -V '#{gemspec_path}'") do
+  include_jar = ENV['INCLUDE_JAR_IN_GEM'] || 'true'
+  sh("INCLUDE_JAR_IN_GEM=#{include_jar} gem build -V '#{gemspec_path}'") do
     gem_path = built_gem_path.call
     file_name = File.basename(gem_path)
     FileUtils.mkdir_p(File.join(base_dir, 'pkg'))
@@ -58,7 +85,6 @@ end
 
 desc "Releasing AR-JDBC gems (use NOOP=true to disable gem pushing)"
 task 'release:do' do
-  ENV['RELEASE'] = 'true' # so that .gemspec is built with adapter_java.jar
   Rake::Task['build'].invoke
   # Rake::Task['build:adapters'].invoke
 
@@ -257,7 +283,7 @@ if defined? JRUBY_VERSION
       begin
         require 'arjdbc/version'
       rescue LoadError
-        path = File.expand_path('../lib', File.dirname(__FILE__))
+        path = File.expand_path('lib', File.dirname(__FILE__))
         unless $LOAD_PATH.include?(path)
           $LOAD_PATH << path; retry
         end
@@ -297,7 +323,7 @@ if defined? JRUBY_VERSION
       # class_files.gsub!('$', '\$') unless windows?
       # args = class_files.map { |path| [ "-C #{classes_dir}", path ] }.flatten
 
-      if ENV['RELEASE'] == 'true'; require 'tempfile'
+      if ENV['INCLUDE_JAR_IN_GEM'] == '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"

data/activerecord-jdbc-adapter.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |gem|
     reject { |f| f =~ /^(gemfiles)/ } # no tests - no Gemfile_s appraised ...
   gem.files += ['lib/arjdbc/jdbc/adapter_java.jar'] #if ENV['RELEASE'].eql?('true')
 
-  if ENV['RELEASE'] != 'true' # @see Rakefile
+  if ENV['INCLUDE_JAR_IN_GEM'] != 'true' # @see Rakefile
     gem.extensions << 'Rakefile' # to support auto-building .jar with :git paths
 
     #gem.add_runtime_dependency 'jar-dependencies', '~> 0.1' # development not enough!

data/activerecord-jdbc-alt-adapter.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |gem|
     reject { |f| f =~ /^(gemfiles)/ } # no tests - no Gemfile_s appraised ...
   gem.files += ['lib/arjdbc/jdbc/adapter_java.jar'] #if ENV['RELEASE'].eql?('true')
 
-  if ENV['RELEASE'] != 'true' # @see Rakefile
+  if ENV['INCLUDE_JAR_IN_GEM'] != 'true' # @see Rakefile
     gem.extensions << 'Rakefile' # to support auto-building .jar with :git paths
 
     #gem.add_runtime_dependency 'jar-dependencies', '~> 0.1' # development not enough!

data/lib/arjdbc/abstract/core.rb

@@ -22,7 +22,7 @@ module ArJdbc
 
         connection.configure_connection # will call us (maybe)
       end
-      
+
       # Retrieve the raw `java.sql.Connection` object.
       # The unwrap parameter is useful if an attempt to unwrap a pooled (JNDI)
       # connection should be made - to really return the 'native' JDBC object.
@@ -56,7 +56,7 @@ module ArJdbc
         case e
           when SystemExit, SignalException, NoMemoryError then e
           when ActiveModel::RangeError, TypeError, RuntimeError then e
-          else ActiveRecord::StatementInvalid.new(message)
+          else super
         end
       end
 

data/lib/arjdbc/abstract/database_statements.rb

@@ -10,6 +10,8 @@ module ArJdbc
       NO_BINDS = [].freeze
 
       def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil)
+        binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+
         if without_prepared_statement?(binds)
           log(sql, name) { @connection.execute_insert(sql) }
         else
@@ -22,6 +24,8 @@ module ArJdbc
       # It appears that at this point (AR 5.0) "prepare" should only ever be true
       # if prepared statements are enabled
       def exec_query(sql, name = nil, binds = NO_BINDS, prepare: false)
+        binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+
         if without_prepared_statement?(binds)
           log(sql, name) { @connection.execute_query(sql) }
         else
@@ -34,6 +38,8 @@ module ArJdbc
       end
 
       def exec_update(sql, name = nil, binds = NO_BINDS)
+        binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+
         if without_prepared_statement?(binds)
           log(sql, name) { @connection.execute_update(sql) }
         else

data/lib/arjdbc/jdbc/column.rb

@@ -26,23 +26,17 @@ module ActiveRecord
           end
         end
 
-        if ArJdbc::AR50
-          default = args[0].cast(default)
+        default = args[0].cast(default)
 
-          sql_type = args.delete_at(1)
-          type = args.delete_at(0)
+        sql_type = args.delete_at(1)
+        type = args.delete_at(0)
 
-          args.unshift(SqlTypeMetadata.new(:sql_type => sql_type, :type => type))
-        elsif ArJdbc::AR42
-          default = args[0].type_cast_from_database(default)
-        else
-          default = default_value(default)
-        end
+        args.unshift(SqlTypeMetadata.new(:sql_type => sql_type, :type => type))
 
         # super <= 4.1: (name, default, sql_type = nil, null = true)
         # super >= 4.2: (name, default, cast_type, sql_type = nil, null = true)
         # super >= 5.0: (name, default, sql_type_metadata = nil, null = true)
-        
+
         super(name, default, *args)
         init_column(name, default, *args)
       end

data/lib/arjdbc/jdbc.rb

@@ -2,12 +2,8 @@ require 'active_support/deprecation'
 
 module ArJdbc
 
-  # @private
-  AR40 = ::ActiveRecord::VERSION::MAJOR > 3
   # @private
   AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
-  # @private
-  AR50 = ::ActiveRecord::VERSION::MAJOR > 4
 
   class << self
 

data/lib/arjdbc/mssql/adapter.rb

@@ -218,21 +218,11 @@ module ActiveRecord
       end
 
       def configure_connection
-        execute("SET LOCK_TIMEOUT #{lock_timeout}")
+        # Here goes initial settings per connection
 
         set_session_transaction_isolation
       end
 
-      def lock_timeout
-        timeout = config[:lock_timeout].to_i
-
-        if timeout.positive?
-          timeout
-        else
-          5_000
-        end
-      end
-
       def set_session_transaction_isolation
         isolation_level = config[:transaction_isolation]
 

data/lib/arjdbc/mssql/connection_methods.rb

@@ -60,12 +60,15 @@ ArJdbc::ConnectionMethods.module_eval do
     config[:host] ||= 'localhost'
     config[:driver] ||= 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
     config[:connection_alive_sql] ||= 'SELECT 1'
+    config[:lock_timeout] ||= 5000
 
     config[:url] ||= begin
       url = "jdbc:sqlserver://#{config[:host]}"
       url << ( config[:port] ? ":#{config[:port]};" : ';' )
       url << "databaseName=#{config[:database]};" if config[:database]
       url << "instanceName=#{config[:instance]};" if config[:instance]
+      url << "loginTimeout=#{config[:login_timeout].to_i};" if config[:login_timeout]
+      url << "lockTimeout=#{config[:lock_timeout].to_i};"
       app = config[:appname] || config[:application]
       url << "applicationName=#{app};" if app
       isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll

data/lib/arjdbc/mysql/connection_methods.rb

@@ -10,11 +10,9 @@ ArJdbc::ConnectionMethods.module_eval do
 
     return jndi_connection(config) if jndi_config?(config)
 
-    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.')
+    driver = config[:driver]
+    mysql_driver = driver.nil? || driver.to_s.start_with?('com.mysql.')
+    mariadb_driver = ! mysql_driver && driver.to_s.start_with?('org.mariadb.')
 
     begin
       require 'jdbc/mysql'
@@ -22,6 +20,11 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end if mysql_driver
 
+    if driver.nil?
+      config[:driver] ||=
+        defined?(::Jdbc::MySQL.driver_name) ? ::Jdbc::MySQL.driver_name : 'com.mysql.jdbc.Driver'
+    end
+
     config[:username] = 'root' unless config.key?(:username)
     # jdbc:mysql://[host][,failoverhost...][:port]/[database]
     # - if the host name is not specified, it defaults to 127.0.0.1
@@ -36,7 +39,8 @@ ArJdbc::ConnectionMethods.module_eval do
 
     properties = ( config[:properties] ||= {} )
     if mysql_driver
-      properties['zeroDateTimeBehavior'] ||= 'convertToNull'
+      properties['zeroDateTimeBehavior'] ||=
+        config[:driver].to_s.start_with?('com.mysql.cj.') ? 'CONVERT_TO_NULL' : 'convertToNull'
       properties['jdbcCompliantTruncation'] ||= false
       # NOTE: this is "better" than passing what users are used to set on MRI
       # e.g. 'utf8mb4' will fail cause the driver will check for a Java charset
@@ -108,7 +112,8 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end
 
-    config[:driver] ||= 'org.mariadb.jdbc.Driver'
+    config[:driver] ||=
+      defined?(::Jdbc::MariaDB.driver_name) ? ::Jdbc::MariaDB.driver_name : 'org.mariadb.jdbc.Driver'
 
     mysql_connection(config)
   end

data/lib/arjdbc/postgresql/column.rb

@@ -15,7 +15,7 @@ module ArJdbc
       end
 
       # Extracts the value from a PostgreSQL column default definition.
-      def extract_value_from_default(default) # :nodoc:
+      def extract_value_from_default(default)
         case default
           # Quoted types
           when /\A[\(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
@@ -41,10 +41,13 @@ module ArJdbc
         end
       end
 
-      def extract_default_function(default_value, default) # :nodoc:
-        default if ! default_value && ( %r{\w+\(.*\)|\(.*\)::\w+} === default )
+      def extract_default_function(default_value, default)
+        default if has_default_function?(default_value, default)
       end
 
+      def has_default_function?(default_value, default)
+        !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP} === default
+      end
     end
 
   end

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -16,7 +16,8 @@ ArJdbc::ConnectionMethods.module_eval do
       ::Jdbc::Postgres.load_driver(:require) if defined?(::Jdbc::Postgres.load_driver)
     rescue LoadError # assuming driver.jar is on the class-path
     end
-    driver = config[:driver] ||= 'org.postgresql.Driver'
+    driver = (config[:driver] ||=
+      defined?(::Jdbc::Postgres.driver_name) ? ::Jdbc::Postgres.driver_name : 'org.postgresql.Driver')
 
     host = config[:host] ||= ( config[:hostaddr] || ENV['PGHOST'] || 'localhost' )
     port = config[:port] ||= ( ENV['PGPORT'] || 5432 )

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '51.3.4'
+  VERSION = '51.5.0'
 end

data/rakelib/02-test.rake

@@ -76,8 +76,6 @@ end
   test_task_for adapter, :desc => "Run tests against #{adapter} (ensure driver is on class-path)"
 end
 
-#test_task_for :MSSQL, :name => 'test_sqlserver', :driver => nil, :database_name => 'MS-SQL using SQLJDBC'
-
 test_task_for :AS400, :desc => "Run tests against AS400 (DB2) (ensure driver is on class-path)",
               :files => FileList["test/db2*_test.rb"] + FileList["test/db/db2/*_test.rb"]
 

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

@@ -487,7 +487,7 @@ public class RubyJdbcConnection extends RubyObject {
                 savepoint = ((IRubyObject) savepoint).toJava(Savepoint.class);
             }
 
-            connection.releaseSavepoint((Savepoint) savepoint);
+            releaseSavepoint(connection, (Savepoint) savepoint);
             return context.nil;
         }
         catch (SQLException e) {
@@ -495,6 +495,11 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
+    // MSSQL doesn't support releasing savepoints so we make it possible to override the actual release action
+    protected void releaseSavepoint(final Connection connection, final Savepoint savepoint) throws SQLException {
+        connection.releaseSavepoint(savepoint);
+    }
+
     protected static RuntimeException newSavepointNotSetError(final ThreadContext context, final IRubyObject name, final String op) {
         RubyClass StatementInvalid = ActiveRecord(context).getClass("StatementInvalid");
         return context.runtime.newRaiseException(StatementInvalid, "could not " + op + " savepoint: '" + name + "' (not set)");
@@ -3928,6 +3933,12 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
+    public static void debugMessage(final ThreadContext context, final IRubyObject obj) {
+        if ( isDebug(context.runtime) ) {
+            debugMessage(context.runtime, obj.callMethod(context, "inspect"));
+        }
+    }
+
     public static void debugMessage(final Ruby runtime, final String msg, final Object e) {
         if ( isDebug(runtime) ) {
             final PrintStream out = runtime != null ? runtime.getOut() : System.out;

data/src/java/arjdbc/mssql/MSSQLRubyJdbcConnection.java

@@ -29,22 +29,33 @@ import arjdbc.jdbc.Callable;
 import arjdbc.jdbc.RubyJdbcConnection;
 import arjdbc.util.DateTimeUtils;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
+import java.sql.Date;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.Savepoint;
+import java.sql.Statement;
 import java.sql.SQLException;
-import java.sql.Types;
 import java.sql.Timestamp;
+import java.sql.Types;
 import java.util.Locale;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyBoolean;
 import org.jruby.RubyClass;
 import org.jruby.RubyString;
 import org.jruby.RubySymbol;
+import org.jruby.RubyTime;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
@@ -58,6 +69,54 @@ import org.jruby.util.ByteList;
 public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
     private static final long serialVersionUID = -745716565005219263L;
 
+    private static final int DATETIMEOFFSET_TYPE;
+    private static final Method DateTimeOffsetGetMinutesOffsetMethod;
+    private static final Method DateTimeOffsetGetTimestampMethod;
+    private static final Method DateTimeOffsetValueOfMethod;
+    private static final Method PreparedStatementSetDateTimeOffsetMethod;
+
+    private static final Map<String, Integer> MSSQL_JDBC_TYPE_FOR = new HashMap<String, Integer>(32, 1);
+    static {
+
+        Class<?> DateTimeOffset;
+        Class<?> MssqlPreparedStatement;
+        Class<?> MssqlTypes;
+        try {
+            DateTimeOffset = Class.forName("microsoft.sql.DateTimeOffset");
+            MssqlPreparedStatement = Class.forName("com.microsoft.sqlserver.jdbc.SQLServerPreparedStatement");
+            MssqlTypes = Class.forName("microsoft.sql.Types");
+        } catch (ClassNotFoundException e) {
+            System.err.println("You must require the Microsoft JDBC driver to use this gem"); // The exception doesn't bubble when ruby is initializing
+            throw new RuntimeException("You must require the Microsoft JDBC driver to use this gem");
+        }
+
+        try {
+            DATETIMEOFFSET_TYPE = MssqlTypes.getField("DATETIMEOFFSET").getInt(null);
+            DateTimeOffsetGetMinutesOffsetMethod = DateTimeOffset.getDeclaredMethod("getMinutesOffset");
+            DateTimeOffsetGetTimestampMethod = DateTimeOffset.getDeclaredMethod("getTimestamp");
+
+            Class<?>[] valueOfArgTypes = { Timestamp.class, int.class };
+            DateTimeOffsetValueOfMethod = DateTimeOffset.getDeclaredMethod("valueOf", valueOfArgTypes);
+
+            Class<?>[] setOffsetArgTypes = { int.class, DateTimeOffset };
+            PreparedStatementSetDateTimeOffsetMethod = MssqlPreparedStatement.getDeclaredMethod("setDateTimeOffset", setOffsetArgTypes);
+        } catch (Exception e) {
+            System.err.println("You must require the Microsoft JDBC driver to use this gem"); // The exception doesn't bubble when ruby is initializing
+            throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
+        }
+
+        MSSQL_JDBC_TYPE_FOR.put("binary_basic", Types.BINARY);
+        MSSQL_JDBC_TYPE_FOR.put("image", Types.BINARY);
+        MSSQL_JDBC_TYPE_FOR.put("datetimeoffset", DATETIMEOFFSET_TYPE);
+        MSSQL_JDBC_TYPE_FOR.put("money", Types.DECIMAL);
+        MSSQL_JDBC_TYPE_FOR.put("smalldatetime", Types.TIMESTAMP);
+        MSSQL_JDBC_TYPE_FOR.put("smallmoney", Types.DECIMAL);
+        MSSQL_JDBC_TYPE_FOR.put("ss_timestamp", Types.BINARY);
+        MSSQL_JDBC_TYPE_FOR.put("text_basic", Types.LONGVARCHAR);
+        MSSQL_JDBC_TYPE_FOR.put("uuid", Types.CHAR);
+        MSSQL_JDBC_TYPE_FOR.put("varchar_max", Types.VARCHAR);
+    }
+
     public MSSQLRubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
     }
@@ -89,6 +148,125 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
         return context.runtime.newBoolean( startsWithIgnoreCase(sqlBytes, EXEC) );
     }
 
+    // Support multiple result sets for mssql
+    @Override
+    @JRubyMethod(name = "execute", required = 1)
+    public IRubyObject execute(final ThreadContext context, final IRubyObject sql) {
+        final String query = sqlString(sql);
+        return withConnection(context, new Callable<IRubyObject>() {
+            public IRubyObject call(final Connection connection) throws SQLException {
+                Statement statement = null;
+                try {
+                    statement = createStatement(context, connection);
+
+                    // For DBs that do support multiple statements, lets return the last result set
+                    // to be consistent with AR
+                    boolean hasResultSet = doExecute(statement, query);
+                    int updateCount = statement.getUpdateCount();
+
+                    final List<IRubyObject> results = new ArrayList<IRubyObject>();
+                    ResultSet resultSet;
+
+                    while (hasResultSet || updateCount != -1) {
+
+                        if (hasResultSet) {
+                            resultSet = statement.getResultSet();
+
+                            // Unfortunately the result set gets closed when getMoreResults()
+                            // is called, so we have to process the result sets as we get them
+                            // this shouldn't be an issue in most cases since we're only getting 1 result set anyways
+                            results.add(mapExecuteResult(context, connection, resultSet));
+                        } else {
+                            results.add(context.runtime.newFixnum(updateCount));
+                        }
+
+                        // Check to see if there is another result set
+                        hasResultSet = statement.getMoreResults();
+                        updateCount = statement.getUpdateCount();
+                    }
+
+                    if (results.size() == 0) {
+                        return context.nil; // If no results, return nil
+                    } else if (results.size() == 1) {
+                        return results.get(0);
+                    } else {
+                        return context.runtime.newArray(results);
+                    }
+
+                } catch (final SQLException e) {
+                    debugErrorSQL(context, query);
+                    throw e;
+                } finally {
+                    close(statement);
+                }
+            }
+        });
+    }
+
+    @Override
+    protected Integer jdbcTypeFor(final String type) {
+
+        Integer typeValue = MSSQL_JDBC_TYPE_FOR.get(type);
+
+        if ( typeValue != null ) {
+            return typeValue;
+        }
+
+        return super.jdbcTypeFor(type);
+    }
+
+    // Datetimeoffset values also make it into here
+    @Override
+    protected void setStringParameter(final ThreadContext context, final Connection connection,
+            final PreparedStatement statement, final int index, final IRubyObject value,
+            final IRubyObject attribute, final int type) throws SQLException {
+
+        // datetimeoffset values also make it in here
+        if (type == DATETIMEOFFSET_TYPE) {
+
+            Object dto = convertToDateTimeOffset(context, value);
+
+            try {
+
+                Object[] setStatementArgs = { index, dto };
+                PreparedStatementSetDateTimeOffsetMethod.invoke(statement, setStatementArgs);
+
+            } catch (IllegalAccessException e) {
+                debugMessage(context.runtime, e.getMessage());
+                throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
+            } catch (InvocationTargetException e) {
+                debugMessage(context.runtime, e.getMessage());
+                throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
+            }
+
+            return;
+        }
+        super.setStringParameter(context, connection, statement, index, value, attribute, type);
+    }
+
+    private Object convertToDateTimeOffset(final ThreadContext context, final IRubyObject value) {
+
+        RubyTime time = (RubyTime) value;
+        DateTime dt = time.getDateTime();
+        Timestamp timestamp = new Timestamp(dt.getMillis());
+        timestamp.setNanos(timestamp.getNanos() + (int) time.getNSec());
+        int offsetMinutes = dt.getZone().getOffset(dt.getMillis()) / 60000;
+
+        try {
+
+            Object[] dtoArgs = { timestamp, offsetMinutes };
+            return DateTimeOffsetValueOfMethod.invoke(null, dtoArgs);
+
+        } catch (IllegalAccessException e) {
+            debugMessage(context.runtime, e.getMessage());
+            throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
+        } catch (InvocationTargetException e) {
+            debugMessage(context.runtime, e.getMessage());
+            throw new RuntimeException("Please make sure you are using the latest version of the Microsoft JDBC driver");
+        }
+    }
+
+
     @Override
     protected RubyArray mapTables(final ThreadContext context, final Connection connection,
             final String catalog, final String schemaPattern, final String tablePattern,
@@ -305,29 +483,6 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
         statement.setObject(index, timeStr, Types.NVARCHAR);
     }
 
-    // Overrides the method in parent, we only remove the savepoint
-    // from the getSavepoints Map
-    @JRubyMethod(name = "release_savepoint", required = 1)
-    public IRubyObject release_savepoint(final ThreadContext context, final IRubyObject name) {
-      if (name == context.nil) throw context.runtime.newArgumentError("nil savepoint name given");
-
-      final Connection connection = getConnection(true);
-
-      Object savepoint = getSavepoints(context).remove(name);
-
-      if (savepoint == null) throw newSavepointNotSetError(context, name, "release");
-
-      // NOTE: RubyHash.remove does not convert to Java as get does :
-      if (!(savepoint instanceof Savepoint)) {
-        savepoint = ((IRubyObject) savepoint).toJava(Savepoint.class);
-      }
-
-      // The 'releaseSavepoint' method is not currently supported
-      // by the Microsoft SQL Server JDBC Driver
-      // connection.releaseSavepoint((Savepoint) savepoint);
-      return context.nil;
-    }
-
     //----------------------------------------------------------------
     // read_uncommitted: "READ UNCOMMITTED",
     // read_committed:   "READ COMMITTED",
@@ -453,16 +608,64 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
 
     /**
      * Treat LONGVARCHAR as CLOB on MSSQL for purposes of converting a JDBC value to Ruby.
+     * Also handle datetimeoffset values here
      */
     @Override
     protected IRubyObject jdbcToRuby(
         final ThreadContext context, final Ruby runtime,
         final int column, int type, final ResultSet resultSet)
         throws SQLException {
-        if ( type == Types.LONGVARCHAR || type == Types.LONGNVARCHAR ) type = Types.CLOB;
+
+        if (type == DATETIMEOFFSET_TYPE) {
+
+            Object dto = resultSet.getObject(column); // Returns a microsoft.sql.DateTimeOffset
+
+            if (dto == null) return context.nil;
+
+            try {
+
+                int minutes = (int) DateTimeOffsetGetMinutesOffsetMethod.invoke(dto);
+                DateTimeZone zone = DateTimeZone.forOffsetHoursMinutes(minutes / 60, minutes % 60);
+                Timestamp ts = (Timestamp) DateTimeOffsetGetTimestampMethod.invoke(dto);
+
+                int nanos = ts.getNanos(); // max 999-999-999
+                nanos = nanos % 1000000;
+
+                // We have to do this differently than the newTime helper because the Timestamp loses its zone information when passed around
+                DateTime dateTime = new DateTime(ts.getTime(), zone);
+                return RubyTime.newTime(context.runtime, dateTime, nanos);
+
+            } catch (IllegalAccessException e) {
+                debugMessage(runtime, e.getMessage());
+                return context.nil;
+            } catch (InvocationTargetException e) {
+                debugMessage(runtime, e.getMessage());
+                return context.nil;
+            }
+        }
+
+        if (type == Types.LONGVARCHAR || type == Types.LONGNVARCHAR) type = Types.CLOB;
         return super.jdbcToRuby(context, runtime, column, type, resultSet);
     }
 
+    /**
+     * Converts a JDBC date object to a Ruby date by referencing Date#civil
+     * @param context current thread context
+     * @param resultSet the jdbc result set to pull the value from
+     * @param index the index of the column to convert
+     * @return RubyNil if NULL or RubyDate if there is a value
+     * @throws SQLException if it fails to retrieve the value from the result set
+     */
+    @Override
+    protected IRubyObject dateToRuby(ThreadContext context, Ruby runtime, ResultSet resultSet, int index) throws SQLException {
+
+        final Date value = resultSet.getDate(index);
+
+        if (value == null) return context.nil;
+
+        return DateTimeUtils.newDate(context, value);
+    }
+
     @Override
     protected ColumnData[] extractColumns(final ThreadContext context,
         final Connection connection, final ResultSet resultSet,
@@ -492,19 +695,9 @@ public class MSSQLRubyJdbcConnection extends RubyJdbcConnection {
         return columns;
     }
 
-    // internal helper not meant as a "public" API - used in one place thus every
-    @JRubyMethod(name = "jtds_driver?")
-    public RubyBoolean jtds_driver_p(final ThreadContext context) throws SQLException {
-        // "jTDS Type 4 JDBC Driver for MS SQL Server and Sybase"
-        // SQLJDBC: "Microsoft JDBC Driver 4.0 for SQL Server"
-        return withConnection(context, new Callable<RubyBoolean>() {
-            // NOTE: only used in one place for now (on release_savepoint) ...
-            // might get optimized to only happen once since driver won't change
-            public RubyBoolean call(final Connection connection) throws SQLException {
-                final String driver = connection.getMetaData().getDriverName();
-                return context.getRuntime().newBoolean( driver.indexOf("jTDS") >= 0 );
-            }
-        });
+    @Override
+    protected void releaseSavepoint(final Connection connection, final Savepoint savepoint) throws SQLException {
+        // MSSQL doesn't support releasing savepoints
     }
 
 }

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

@@ -31,6 +31,7 @@ import java.util.TimeZone;
 import org.joda.time.Chronology;
 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;
@@ -50,6 +51,9 @@ import static arjdbc.util.StringHelper.decByte;
  * @author kares
  */
 public abstract class DateTimeUtils {
+
+    private static final GJChronology CHRONO_ITALY_UTC = GJChronology.getInstance(DateTimeZone.UTC);
+
     public static RubyTime toTime(final ThreadContext context, final IRubyObject value) {
         if (!(value instanceof RubyTime)) { // unlikely
             return (RubyTime) TypeConverter.convertToTypeWithCheck(value, context.runtime.getTime(), "to_time");
@@ -217,9 +221,11 @@ public abstract class DateTimeUtils {
         final int hours = time.getHours();
         final int minutes = time.getMinutes();
         final int seconds = time.getSeconds();
-        final int nanos = time.getNanos(); // max 999-999-999
+        int nanos = time.getNanos(); // max 999-999-999
+        final int millis = nanos / 1000000;
+        nanos = nanos % 1000000;
 
-        DateTime dateTime = new DateTime(2000, 1, 1, hours, minutes, seconds, defaultZone);
+        DateTime dateTime = new DateTime(2000, 1, 1, hours, minutes, seconds, millis, defaultZone);
         return RubyTime.newTime(context.runtime, dateTime, nanos);
     }
 
@@ -232,9 +238,11 @@ public abstract class DateTimeUtils {
         final int hours = timestamp.getHours();
         final int minutes = timestamp.getMinutes();
         final int seconds = timestamp.getSeconds();
-        final int nanos = timestamp.getNanos(); // max 999-999-999
+        int nanos = timestamp.getNanos(); // max 999-999-999
+        final int millis = nanos / 1000000;
+        nanos = nanos % 1000000;
 
-        DateTime dateTime = new DateTime(year, month, day, hours, minutes, seconds, 0, defaultZone);
+        DateTime dateTime = new DateTime(year, month, day, hours, minutes, seconds, millis, defaultZone);
         return RubyTime.newTime(context.runtime, dateTime, nanos);
     }
 
@@ -259,6 +267,15 @@ public abstract class DateTimeUtils {
         return newDate(context, year, month, day, ISOChronology.getInstance(zone));
     }
 
+    @SuppressWarnings("deprecation")
+    public static IRubyObject newDate(final ThreadContext context, final Date date) {
+        final int year = date.getYear() + 1900;
+        final int month = date.getMonth() + 1;
+        final int day = date.getDate();
+
+        return newDate(context, year, month, day, CHRONO_ITALY_UTC);
+    }
+
     // @Deprecated
     public static Timestamp convertToTimestamp(final RubyFloat value) {
         final Timestamp timestamp = new Timestamp(value.getLongValue() * 1000); // millis
@@ -553,7 +570,7 @@ public abstract class DateTimeUtils {
     }
 
     private static IRubyObject newDate(final ThreadContext context, final int year, final int month, final int day,
-                                       final ISOChronology chronology) {
+                                       final Chronology chronology) {
         // NOTE: JRuby really needs a native date.rb until than its a bit costly going from ...
         // java.sql.Date -> allocating a DateTime proxy, help a bit by shooting at the internals
         //

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-alt-adapter
 version: !ruby/object:Gem::Version
-  version: 51.3.4
+  version: 51.5.0
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-30 00:00:00.000000000 Z
+date: 2019-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -271,7 +271,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.7.9
+rubygems_version: 2.7.10
 signing_key:
 specification_version: 4
 summary: ActiveRecord JDBC adapter, for use within JRuby on Rails and SQL Server