activerecord-jdbc-adapter 51.4-java → 51.5-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63cf6264259b636000fa1b17e13d555ca97d91aa9e237026bb81bac717b3130f
-  data.tar.gz: ca5867009951cda63cccf434b87ec38fc0b541cd8a206899ed9ba23841ceb0c4
+  metadata.gz: 5ae6545b5caaa121f681eea19ce6111cd1fff119af8a378c88217f6ae2e31f36
+  data.tar.gz: 115b33124dfa6c2c0d502e0c2d3883e513e995d22849dd49a33822c2dc01d998
 SHA512:
-  metadata.gz: a762d4f3877d7c834da321fa67784cee8ca8999c22ac3ec9d9e3f5f65df0d52ed2261dde7a91287c4b9cd0d5641f6786e26e0ab470d1b4c4c6527624163bbaf5
-  data.tar.gz: 5fb6ee5eafa8a10a7389f7c4a471061553e5ca97e9347b2f78f69d94ec2fca28277f109eeeebe636de053324a346dcab25eab379351e46afd475855296bd3ae4
+  metadata.gz: f8539261190260793902f87665626c09775da9d2b8004b268ca72e0ebce0daacd5f37537d797f6d7e54690d67be43b9e0410717d2e6bcb052c6da82addbe8e7b
+  data.tar.gz: fb1150aa6c36615549a7627b938b9a583306b73b06edcd2e859b61cb5255c6d107ca33de967ae9dcda14a0a8b14f1f75c816ddcf48cd6f18ec27741ef73a7f2f

data/README.md

@@ -5,15 +5,16 @@
 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
@@ -32,6 +33,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:
 
@@ -166,4 +168,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
 
@@ -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/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.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/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/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/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '51.4'
+  VERSION = '51.5'
 end

data/rakelib/02-test.rake

@@ -58,7 +58,6 @@ end
 test_task_for :Derby, :desc => 'Run tests against (embedded) DerbyDB'
 test_task_for :H2, :desc => 'Run tests against H2 database engine'
 test_task_for :HSQLDB, :desc => 'Run tests against HyperSQL (Java) database'
-test_task_for :MSSQL, :driver => :jtds, :database_name => 'MS-SQL (SQLServer)'
 test_task_for :MySQL #, :prereqs => 'db:mysql'
 task :test_mysql2 => :test_mysql
 test_task_for :PostgreSQL, :driver => ENV['JDBC_POSTGRES_VERSION'] || 'postgres' #, :prereqs => 'db:postgresql'
@@ -76,8 +75,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)");
@@ -3917,6 +3922,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

@@ -28,17 +28,32 @@ package arjdbc.mssql;
 import arjdbc.jdbc.Callable;
 import arjdbc.jdbc.RubyJdbcConnection;
 
+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.Timestamp;
 import java.sql.Types;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
+import arjdbc.util.DateTimeUtils;
+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.RubyTime;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
@@ -52,6 +67,53 @@ 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("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);
     }
@@ -83,6 +145,136 @@ 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);
+    }
+
+    // We need higher precision than the default for Time objects (which is milliseconds) so we use a DateTimeOffset object
+    @Override
+    protected void setTimeParameter(final ThreadContext context,
+        final Connection connection, final PreparedStatement statement,
+        final int index, IRubyObject value,
+        final IRubyObject attribute, final int type) throws SQLException {
+
+        statement.setObject(index, convertToDateTimeOffset(context, value), Types.TIME);
+
+    }
+
+    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,
@@ -124,16 +316,79 @@ 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);
+    }
+
+    /**
+     * Converts a JDBC time to a Ruby time. We use timestamp because java.sql.Time doesn't support sub-millisecond values
+     * @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 RubyTime if there is a value
+     * @throws SQLException if it fails to retrieve the value from the result set
+     */
+    @Override
+    protected IRubyObject timeToRuby(final ThreadContext context,final Ruby runtime,
+            final ResultSet resultSet, final int column) throws SQLException {
+
+        return timestampToRuby(context, runtime, resultSet, column);
+    }
+
     @Override
     protected ColumnData[] extractColumns(final ThreadContext context,
         final Connection connection, final ResultSet resultSet,
@@ -163,19 +418,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
     }
 
 }