activerecord-jdbc-alt-adapter 51.3.2-java → 51.7.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6c42966e47ce277f02009b46245502666af2a44e8e49c9e153f1fa41fceb6fc
-  data.tar.gz: 1ecdd492d26a05f456801f7cfb2f9b8804b5170e9636b3cda06396d4312ee88a
+  metadata.gz: 9bac3f491bd6e25ce779db381c70f8de2bcfc566f7d7add71c73453d4b9d96da
+  data.tar.gz: 5e3cdf41dde39ac86a39d6d21057ede60c0fa321aa9e1164cc5c13c1b6584800
 SHA512:
-  metadata.gz: d7c0c078d3d2a3809fb80f79aeefe5ac68419e758ed3cd27097925d03aea9756801f3d339e2896caa19ea9af2f67ce10427456377714b59ced3d8078c87df629
-  data.tar.gz: 5f074ac80032b34bf31999fd57bad1c8b5618cb7094e2aaa5ac14fbc05e3d7571592c14924ef8f40118a6c3ef7dd24ccbfaed1abaf8ef73f2fc9e891855b74f4
+  metadata.gz: 28c69d682d31b0c159bf4fbc309699c0c362696e7edff789e1a51304284407dd09f4f63bf0d97bd460616378b3456cad4535c7fef4c19d607a92ccb962c8d80d
+  data.tar.gz: d83167a275cc51a6715f9a019d8df7519c6bb35d531466fe2e0c61191150238f20c70f9ae233a85e5ad31f89ae61b2f28d9c1fb2b7a17e2591c2ca2ccf529b1b

data/.gitignore

@@ -2,6 +2,7 @@
 *.tgz
 *~
 *.log
+/log/
 patches*
 *#
 TAGS
@@ -33,3 +34,5 @@ activerecord-jdbc.iml
 lib/arjdbc/jdbc/adapter_java.jar
 .jrubyrc
 tags
+.ruby-version
+pik.sh

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

@@ -11,7 +11,7 @@ Gem::Specification.new do |gem|
   gem.license = 'BSD-2-Clause'
   gem.summary = 'ActiveRecord JDBC adapter, for use within JRuby on Rails and SQL Server'
   gem.description = "" <<
-    "Fork of the ActiveRecord JDBC adapter with support for SQL Server/Azure SQL, " <<
+    "Fork of the ActiveRecord JDBC adapter with support for SQL Server and Azure SQL, " <<
     "for more information and help look at the README file in the github repository. " <<
     "AR-JDBC is a database adapter for Rails' ActiveRecord component designed " <<
     "to be used with JRuby built upon Java's JDBC API for database access. " <<
@@ -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/activerecord-jdbc-alt-adapter.rb

@@ -0,0 +1 @@
+require 'arjdbc'

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,11 +10,13 @@ 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) }
+          log(sql, name) { @connection.execute_insert_pk(sql, pk) }
         else
           log(sql, name, binds) do
-            @connection.execute_insert(sql, binds)
+            @connection.execute_insert_pk(sql, binds, pk)
           end
         end
       end
@@ -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/mssql/adapter.rb

@@ -85,6 +85,12 @@ module ActiveRecord
         ::ActiveRecord::ConnectionAdapters::MSSQLColumn
       end
 
+      # Does this adapter support DDL rollbacks in transactions? That is, would
+      # CREATE TABLE or ALTER TABLE get rolled back by a transaction?
+      def supports_ddl_transactions?
+        true
+      end
+
       # Does this adapter support creating foreign key constraints?
       def supports_foreign_keys?
         true
@@ -100,6 +106,16 @@ module ActiveRecord
         true
       end
 
+      # Does this adapter support index sort order?
+      def supports_index_sort_order?
+        true
+      end
+
+      # Also known as filtered index
+      def supports_partial_index?
+        true
+      end
+
       # Does this adapter support views?
       def supports_views?
         true
@@ -116,6 +132,13 @@ module ActiveRecord
         super
       end
 
+      def reset!
+        # execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
+        # NOTE: it seems the above line interferes with the jdbc driver
+        # and ending up in connection closed, issue seen in rails 5.2 and 6.0
+        reconnect!
+      end
+
       def disable_referential_integrity
         tables = tables_with_referential_integrity
 
@@ -202,21 +225,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

@@ -52,6 +52,8 @@ ArJdbc::ConnectionMethods.module_eval do
 
   # @note Assumes SQLServer SQL-JDBC driver on the class-path.
   def sqlserver_connection(config)
+    config = config.deep_dup
+
     config[:adapter_spec] ||= ::ArJdbc::MSSQL
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::MSSQLAdapter unless config.key?(:adapter_class)
 
@@ -60,12 +62,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/mssql/database_statements.rb

@@ -87,7 +87,7 @@ module ActiveRecord
         end
 
         def identity_column_name(table_name)
-          for column in columns(table_name)
+          for column in schema_cache.columns(table_name)
             return column.name if column.identity?
           end
           nil

data/lib/arjdbc/mssql/schema_statements.rb

@@ -46,7 +46,7 @@ module ActiveRecord
         # NOTE: This is ready, all implemented in the java part of adapter,
         # it uses MSSQLColumn, SqlTypeMetadata, etc.
         def columns(table_name)
-          @connection.columns(table_name)
+          log('JDBC: GETCOLUMNS', 'SCHEMA') { @connection.columns(table_name) }
         rescue => e
           raise translate_exception_class(e, nil)
         end

data/lib/arjdbc/mysql/connection_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def mysql_connection(config)
+    config = config.deep_dup
     # NOTE: this isn't "really" necessary but Rails (in tests) assumes being able to :
     #   ActiveRecord::Base.mysql2_connection ActiveRecord::Base.configurations['arunit'].merge(database: ...)
     config = symbolize_keys_if_necessary(config)
@@ -10,11 +11,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 +21,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 +40,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 +113,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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def postgresql_connection(config)
+    config = config.deep_dup
     # NOTE: this isn't "really" necessary but Rails (in tests) assumes being able to :
     #   ActiveRecord::Base.postgresql_connection ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false)
     # ... while using symbols by default but than configurations returning string keys ;(
@@ -16,7 +17,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/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)
 

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '51.3.2'
+  VERSION = '51.7.0'
 end

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/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/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/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)");
@@ -722,7 +727,10 @@ public class RubyJdbcConnection extends RubyObject {
 
     private void connectImpl(final boolean forceConnection) throws SQLException {
         setConnection( forceConnection ? newConnection() : null );
-        if ( forceConnection ) configureConnection();
+        if (forceConnection) {
+            if (getConnectionImpl() == null) throw new SQLException("Didn't get a connection. Wrong URL?");
+            configureConnection();
+        }
     }
 
     @JRubyMethod(name = "read_only?")
@@ -880,15 +888,31 @@ public class RubyJdbcConnection extends RubyObject {
         return mapQueryResult(context, connection, resultSet);
     }
 
+    private static String[] createStatementPk(IRubyObject pk) {
+        String[] statementPk;
+        if (pk instanceof RubyArray) {
+            RubyArray ary = (RubyArray) pk;
+            int size = ary.size();
+            statementPk = new String[size];
+            for (int i = 0; i < size; i++) {
+                statementPk[i] = sqlString(ary.eltInternal(i));
+            }
+        } else {
+            statementPk = new String[] { sqlString(pk) };
+        }
+        return statementPk;
+    }
+
     /**
      * Executes an INSERT SQL statement
      * @param context
      * @param sql
+     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert", required = 1)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
+    @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;
@@ -896,7 +920,13 @@ public class RubyJdbcConnection extends RubyObject {
                 try {
 
                     statement = createStatement(context, connection);
-                    statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
+
+                    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) {
@@ -909,23 +939,35 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @Deprecated
+    @JRubyMethod(name = "execute_insert", required = 1)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
+        return execute_insert_pk(context, sql, context.nil);
+    }
+
     /**
      * Executes an INSERT SQL statement using a prepared statement
      * @param context
      * @param sql
      * @param binds RubyArray of values to be bound to the query
+     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert", required = 2)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql, final IRubyObject binds) {
+    @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));
+                    }
 
-                    statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
                     setStatementParameters(context, connection, statement, (RubyArray) binds);
                     statement.executeUpdate();
                     return mapGeneratedKeys(context, connection, statement);
@@ -940,6 +982,12 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
+    @Deprecated
+    @JRubyMethod(name = "execute_insert", required = 2)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject binds, final IRubyObject sql) {
+        return execute_insert_pk(context, sql, binds, context.nil);
+    }
+
     /**
      * Executes an UPDATE (DELETE) SQL statement
      * @param context
@@ -3928,6 +3976,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,176 @@ 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);
+                }
+            }
+        });
+    }
+
+    /**
+     * Executes an INSERT SQL statement
+     * @param context
+     * @param sql
+     * @param pk Rails PK
+     * @return ActiveRecord::Result
+     * @throws SQLException
+     */
+    @Override
+    @JRubyMethod(name = "execute_insert_pk", required = 2)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
+
+        // MSSQL does not like composite primary keys here so chop it if there is more than one column
+        IRubyObject modifiedPk = pk;
+
+        if (pk instanceof RubyArray) {
+            RubyArray ary = (RubyArray) pk;
+            if (ary.size() > 0) {
+                modifiedPk = ary.eltInternal(0);
+            }
+        }
+
+        return super.execute_insert_pk(context, sql, modifiedPk);
+    }
+
+    /**
+     * Executes an INSERT SQL statement using a prepared statement
+     * @param context
+     * @param sql
+     * @param binds RubyArray of values to be bound to the query
+     * @param pk Rails PK
+     * @return ActiveRecord::Result
+     * @throws SQLException
+     */
+    @Override
+    @JRubyMethod(name = "execute_insert_pk", required = 3)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject binds,
+                                         final IRubyObject pk) {
+        // MSSQL does not like composite primary keys here so chop it if there is more than one column
+        IRubyObject modifiedPk = pk;
+
+        if (pk instanceof RubyArray) {
+            RubyArray ary = (RubyArray) pk;
+            if (ary.size() > 0) {
+                modifiedPk = ary.eltInternal(0);
+            }
+        }
+
+        return super.execute_insert_pk(context, sql, binds, modifiedPk);
+    }
+
+    @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 +534,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 +659,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 +746,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/postgresql/PostgreSQLRubyJdbcConnection.java

@@ -367,8 +367,9 @@ public class PostgreSQLRubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection
             value = value.callMethod(context, "to_date");
         }
 
-        // NOTE: assuming Date#to_s does right ...
-        statement.setDate(index, Date.valueOf(value.toString()));
+        // NOTE: Here we rely in ActiveRecord (ActiveSupport) to get
+        // the date as a string in the database format.
+        statement.setDate(index, Date.valueOf(value.callMethod(context, "to_s", context.runtime.newSymbol("db")).toString()));
     }
 
     @Override

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.2
+  version: 51.7.0
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-29 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -20,8 +20,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 5.1.7
   name: activerecord
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -30,8 +30,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.1.7
-description: 'Fork of the ActiveRecord JDBC adapter with support for SQL Server/Azure
-  SQL, for more information and help look at the README file in the github repository.
+description: 'Fork of the ActiveRecord JDBC adapter with support for SQL Server and
+  Azure SQL, for more information and help look at the README file in the github repository.
   AR-JDBC is a database adapter for Rails'' ActiveRecord component designed to be
   used with JRuby built upon Java''s JDBC API for database access. Provides (ActiveRecord)
   built-in adapters: MySQL, PostgreSQL and SQLite3 as well as adapters for popular
@@ -76,6 +76,7 @@ files:
 - lib/active_record/connection_adapters/sqlite3_adapter.rb
 - lib/active_record/connection_adapters/sqlserver_adapter.rb
 - lib/activerecord-jdbc-adapter.rb
+- lib/activerecord-jdbc-alt-adapter.rb
 - lib/arel/visitors/compat.rb
 - lib/arel/visitors/db2.rb
 - lib/arel/visitors/derby.rb
@@ -269,8 +270,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.7.6
+rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
 summary: ActiveRecord JDBC adapter, for use within JRuby on Rails and SQL Server