activerecord-jdbc-alt-adapter 71.0.0-java → 72.0.0.rc3-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 973f3cfa750c3424b5de9105f177584edea8ebe705d50b20e4b9f6d989a4919f
-  data.tar.gz: e7f86bfeb49f90f2767e3bdcc3e0101a58149e97421e8d7b96da8f59fc469959
+  metadata.gz: 7f13e7b4fa08bfb67f978fad2353bd633bd0420848babe30b611949d69667e77
+  data.tar.gz: 35ce8492f5985337a6f2ca02beac9eb38a0a3b9fc5957d816c39bf2da0790687
 SHA512:
-  metadata.gz: f276911281e38f162526b603959f5798fa5d09c73284a79078376126b5fade87add2e4a4345242029a4b4e39097b5a6964651483576f51ed8bee3ac7b6e586a3
-  data.tar.gz: 8e5d458add630631bfaa82605f20d28c80310e25787c9db2c94c1b8cc677ac8ff6e0730c97b6271a333cbfe919da8a35ad8deb7911aeedc89c3021629e0c5370
+  metadata.gz: 897405b85f5f90c962ca468c600ec44ca12d3cb0f058be273d9944dc998531e03daebf6f80a0cd8ad9cf7367fa90a7b811e7fc5282fc46a503dd987ef628f1f4
+  data.tar.gz: 6a85da335eaf8ecfd708bc6641ec58c7665bdba75784e57d4c3ee33540c5e7d42904ae87587d00ebb304cebc3e94a0d0bebf3f48e74dc7a41103ca1f22960a42

data/README.md

@@ -175,7 +175,7 @@ adapters are available:
 
 ```yml
 development:
-  adapter: mysql2 # or mysql
+  adapter: mysql2
   database: blog_development
   username: blog
   password: 1234
@@ -199,7 +199,7 @@ or preferably using the *properties:* syntax:
 
 ```yml
 production:
-  adapter: mysql
+  adapter: mysql2
   username: blog
   password: blog
   url: "jdbc:mysql://localhost:3306/blog?profileSQL=true"

data/activerecord-jdbc-adapter.gemspec

@@ -41,7 +41,7 @@ Gem::Specification.new do |gem|
   gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files = gem.files.grep(%r{^test/})
 
-  gem.add_dependency 'activerecord', '~> 7.1.3'
+  gem.add_dependency "activerecord", "~> 7.2.2"
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/activerecord-jdbc-alt-adapter.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |gem|
   gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files = gem.files.grep(%r{^test/})
 
-  gem.add_dependency 'activerecord', '~> 7.1.3'
+  gem.add_dependency "activerecord", "~> 7.2.2"
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/lib/arel/visitors/sqlserver.rb

@@ -83,15 +83,17 @@ module Arel
         @select_statement = nil
       end
 
-      def visit_Arel_Table o, collector
+      def visit_Arel_Table(o, collector)
         # Apparently, o.engine.connection can actually be a different adapter
         # than sqlserver. Can be removed if fixed in ActiveRecord. See:
         # github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/450
         table_name = begin
-          if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
-            remote_server_table_name(o)
-          else
-            quote_table_name(o.name)
+          o.class.engine.with_connection do |connection|
+            if connection.respond_to?(:sqlserver?) && connection.database_prefix_remote_server?
+              remote_server_table_name(o)
+            else
+              quote_table_name(o.name)
+            end
           end
         rescue Exception => e
           quote_table_name(o.name)
@@ -259,10 +261,12 @@ module Arel
         column_name ? t[column_name] : nil
       end
 
-      def remote_server_table_name o
-        ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
-          "#{o.class.engine.connection.database_prefix}#{o.name}"
-        ).quoted
+      def remote_server_table_name(o)
+        o.class.engine.with_connection do |connection|
+          ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
+            "#{connection.database_prefix}#{o.name}"
+          ).quoted
+        end
       end
 
       # Need to remove ordering from subqueries unless TOP/OFFSET also used. Otherwise, SQLServer

data/lib/arjdbc/abstract/core.rb

@@ -60,7 +60,16 @@ module ArJdbc
       # this version of log() automatically fills type_casted_binds from binds if necessary
       def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil, async: false)
         if binds.any? && (type_casted_binds.nil? || type_casted_binds.empty?)
-          type_casted_binds = ->{ binds.map(&:value_for_database) } # extract_raw_bind_values
+          type_casted_binds = lambda {
+            # extract_raw_bind_values
+            binds.map do |bind|
+              if bind.respond_to?(:value_for_database)
+                bind.value_for_database
+              else
+                bind
+              end
+            end
+          }
         end
         super
       end

data/lib/arjdbc/abstract/database_statements.rb

@@ -44,14 +44,17 @@ module ArJdbc
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
+        # puts "internal----->sql: #{sql}, binds: #{binds}"
+        type_casted_binds = type_casted_binds(binds)
+
         with_raw_connection do |conn|
           if without_prepared_statement?(binds)
             log(sql, name, async: async) { conn.execute_query(sql) }
           else
-            log(sql, name, binds, async: async) do
+            log(sql, name, type_casted_binds, async: async) do
               # this is different from normal AR that always caches
               cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
-              conn.execute_prepared_query(sql, binds, cached_statement)
+              conn.execute_prepared_query(sql, type_casted_binds, cached_statement)
             end
           end
         end
@@ -79,7 +82,7 @@ module ArJdbc
       alias :exec_delete :exec_update
 
       # overridden to support legacy binds
-      def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil, async: false)
+      def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil, async: false, allow_retry: false)
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
         super
       end

data/lib/arjdbc/abstract/transaction_support.rb

@@ -26,7 +26,9 @@ module ArJdbc
       def begin_db_transaction
         log('BEGIN', 'TRANSACTION') do
           with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
-            conn.begin
+            result = conn.begin
+            verified!
+            result
           end
         end
       end

data/lib/arjdbc/jdbc/adapter.rb

@@ -5,7 +5,6 @@ require 'active_record/connection_adapters/abstract_adapter'
 
 require 'arjdbc/version'
 require 'arjdbc/jdbc/java'
-require 'arjdbc/jdbc/base_ext'
 require 'arjdbc/jdbc/error'
 require 'arjdbc/jdbc/connection_methods'
 require 'arjdbc/jdbc/column'

data/lib/arjdbc/mssql/adapter.rb

@@ -30,6 +30,8 @@ require 'arjdbc/mssql/errors'
 require 'arjdbc/mssql/schema_creation'
 require 'arjdbc/mssql/database_limits'
 
+require "arjdbc/mssql/adapter_hash_config"
+
 require "arjdbc/abstract/relation_query_attribute_monkey_patch"
 
 module ActiveRecord
@@ -44,6 +46,7 @@ module ActiveRecord
       # include ArJdbc::Abstract::DatabaseStatements
       # include ArJdbc::Abstract::StatementCache
       include ArJdbc::Abstract::TransactionSupport
+      include ArJdbc::MSSQLConfig
 
       include MSSQL::Quoting
       include MSSQL::SchemaStatements
@@ -51,6 +54,7 @@ module ActiveRecord
       include MSSQL::ExplainSupport
       include MSSQL::DatabaseLimits
 
+      # Latin1-General, case-sensitive, accent-sensitive, kanatype-insensitive, width-sensitive
       @cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
 
       class << self
@@ -81,7 +85,8 @@ module ActiveRecord
         # configure_connection happens in super
         super
 
-        conn_params = @config.compact
+        # assign arjdbc extra connection params
+        conn_params = build_connection_config(@config.compact)
 
         @raw_connection = nil
 
@@ -261,29 +266,25 @@ module ActiveRecord
 
       alias_method :current_schema=, :default_schema=
 
-      # FIXME: This needs to be fixed when we implement the collation per
-      # column basis. At the moment we only use the global database collation
-      def default_uniqueness_comparison(attribute, value) # :nodoc:
+      # FIXME: This needs to be fixed when we implement the collation per column
+      def case_sensitive_comparison(attribute, value)
         column = column_for_attribute(attribute)
 
-        if [:string, :text].include?(column.type) && collation && !collation.match(/_CS/) && !value.nil?
-          # NOTE: there is a deprecation warning here in the mysql adapter
-          # no sure if it's required.
+        case_sensitive = collation && collation.match(/_CS/)
+
+        if %i[string text].include?(column.type) && !case_sensitive && !value.nil?
           attribute.eq(Arel::Nodes::Bin.new(value))
         else
           super
         end
       end
 
-      def case_sensitive_comparison(attribute, value)
-        column = column_for_attribute(attribute)
+      def can_perform_case_insensitive_comparison_for?(column)
+        case_sensitive = collation && collation.match(/_CS/)
 
-        if [:string, :text].include?(column.type) && collation && !collation.match(/_CS/) && !value.nil?
-          attribute.eq(Arel::Nodes::Bin.new(value))
-        else
-          super
-        end
+        %i[string text].include?(column.type) && !case_sensitive
       end
+      private :can_perform_case_insensitive_comparison_for?
 
       def configure_connection
         # Here goes initial settings per connection
@@ -340,7 +341,7 @@ module ActiveRecord
 
         schemas_and_tables.map do |schema_table|
           schema, table = schema_table
-          "#{quote_name_part(schema)}.#{quote_name_part(table)}"
+          "#{self.class.mssql_quote_name_part(schema)}.#{self.class.mssql_quote_name_part(table)}"
         end
       end
 
@@ -481,6 +482,8 @@ module ActiveRecord
           ConnectionNotEstablished.new(exception)
         when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
           RecordNotUnique.new(message, sql: sql, binds: binds)
+        when /Violation of PRIMARY KEY constraint .* Cannot insert duplicate key in object .* The duplicate key value is/i
+          RecordNotUnique.new(message, sql: sql, binds: binds)
         when /Lock request time out period exceeded/i
           LockTimeout.new(message, sql: sql, binds: binds)
         when /The .* statement conflicted with the FOREIGN KEY constraint/

data/lib/arjdbc/mssql/adapter_hash_config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module MSSQLConfig
+    def build_connection_config(config)
+      config = config.deep_dup
+
+      load_jdbc_driver
+
+      config[:driver] ||= database_driver_name
+
+      config[:host] ||= "localhost"
+      config[:connection_alive_sql] ||= "SELECT 1"
+      config[:lock_timeout] ||= 5000
+
+      config[:url] ||= build_connection_url(config)
+
+      config
+    end
+
+    private
+
+    def load_jdbc_driver
+      require "jdbc/mssql"
+
+      ::Jdbc::Mssql.load_driver if defined?(::Jdbc::Mssql.load_driver)
+    rescue LoadError
+      # assuming driver.jar is on the class-path
+    end
+
+    def database_driver_name
+      "com.microsoft.sqlserver.jdbc.SQLServerDriver"
+    end
+
+    def build_connection_url(config)
+      url = "".dup
+      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 << "sendTimeAsDatetime=#{config[:send_time_as_datetime] || false};"
+      url << "loginTimeout=#{config[:login_timeout].to_i};" if config[:login_timeout]
+      url << "lockTimeout=#{config[:lock_timeout].to_i};"
+      url << "encrypt=#{config[:encrypt]};" if config.key?(:encrypt)
+      url << "trustServerCertificate=#{config[:trust_server_certificate]};" if config.key?(:trust_server_certificate)
+      app = config[:application_name] || config[:appname] || config[:application]
+      url << "applicationName=#{app};" if app
+      isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll
+      url << "integratedSecurity=#{isc};" unless isc.nil?
+      url
+    end
+  end
+end

data/lib/arjdbc/mssql/column.rb

@@ -9,17 +9,26 @@ module ActiveRecord
       def initialize(name, raw_default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
         @table_name = table_name
 
-        default = extract_default(raw_default)
+        default_val, default_fun = extract_default(raw_default)
 
-        super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
+        super(name, default_val, sql_type_metadata, null, default_fun, collation: collation, comment: comment)
       end
 
       def extract_default(value)
-        # return nil if default does not match the patterns to avoid
-        # any unexpected errors.
-        return unless value =~ /^\(N?'(.*)'\)$/m || value =~ /^\(\(?(.*?)\)?\)$/
-
-        unquote_string(Regexp.last_match[1])
+        return [nil, nil] unless value
+
+        case value
+        when /\A\(N?'(.*)'\)\Z/m
+          [unquote_string(Regexp.last_match[1]), nil]
+        when /\A\(\((.*)\)\)\Z/
+          [unquote_string(Regexp.last_match[1]), nil]
+        when /\A\((\w+\(\))\)\Z/
+          [nil, unquote_string(Regexp.last_match[1])]
+        else
+          # return nil if default does not match the patterns to avoid
+          # any unexpected errors.
+          [nil, nil]
+        end
       end
 
       def unquote_string(string)

data/lib/arjdbc/mssql/database_statements.rb

@@ -31,6 +31,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         # Internal method to test different isolation levels supported by this
@@ -90,7 +92,7 @@ module ActiveRecord
           end
         end
 
-        def internal_exec_query(sql, name = 'SQL', binds = [], prepare: false, async: false)
+        def internal_exec_query(sql, name = 'SQL', binds = [], prepare: false, async: false, allow_retry: false)
           sql = transform_query(sql)
 
           check_if_write_query(sql)
@@ -100,6 +102,8 @@ module ActiveRecord
           # binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
           # puts "internal----->sql: #{sql}, binds: #{binds}"
+          type_casted_binds = type_casted_binds(binds)
+
           if without_prepared_statement?(binds)
             log(sql, name) do
               with_raw_connection do |conn|
@@ -111,13 +115,13 @@ module ActiveRecord
               end
             end
           else
-            log(sql, name, binds) do
+            log(sql, name, type_casted_binds) do
               with_raw_connection do |conn|
                 # this is different from normal AR that always caches
                 cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
 
                 result = conditional_indentity_insert(sql) do
-                  conn.execute_prepared_query(sql, binds, cached_statement)
+                  conn.execute_prepared_query(sql, type_casted_binds, cached_statement)
                 end
                 verified!
                 result
@@ -176,6 +180,9 @@ module ActiveRecord
             log(sql, name, binds) do
               with_raw_connection do |conn|
                 result = conditional_indentity_insert(sql) do
+                  # DEPRECATION WARNING: to_time will always preserve the timezone offset of the receiver in Rails 8.0.
+                  # To opt in to the new behavior, set `ActiveSupport.to_time_preserves_timezone = true`.
+                  # (called from block in execute_insert_pk
                   conn.execute_insert_pk(sql, binds, pk)
                 end
                 verified!
@@ -244,7 +251,7 @@ module ActiveRecord
         end
 
         def raw_jdbc_connection
-          @raw_connection
+          any_raw_connection
         end
 
         # It seems the truncate_tables is mostly used for testing

data/lib/arjdbc/mssql/quoting.rb

@@ -4,6 +4,62 @@ module ActiveRecord
   module ConnectionAdapters
     module MSSQL
       module Quoting
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # \[table_name\].\[column_name\] | function(one or no argument)
+                  ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+                )
+                (?:\s+AS\s+(?:\w+|\[\w+\]))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # \[table_name\].\[column_name\] | function(one or no argument)
+                  ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+                )
+                (?:\s+ASC|\s+DESC)?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= mssql_quote_column_name(name)
+          end
+
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= mssql_quote_column_name(name)
+          end
+
+          def mssql_quote_column_name(name)
+            name = name.to_s.split(".")
+            name.map! { |n| mssql_quote_name_part(n) } # "[#{name}]"
+            name.join(".")
+          end
+
+          # Implements the quoting style for SQL Server
+          def mssql_quote_name_part(part)
+            part =~ /^\[.*\]$/ ? part : "[#{part.gsub(']', ']]')}]"
+          end
+        end
+
         QUOTED_TRUE  = '1'
         QUOTED_FALSE = '0'
 
@@ -88,42 +144,6 @@ module ActiveRecord
         # @see #quote in old adapter
         BLOB_VALUE_MARKER = "''"
 
-        def column_name_matcher
-          COLUMN_NAME
-        end
-
-        def column_name_with_order_matcher
-          COLUMN_NAME_WITH_ORDER
-        end
-
-        COLUMN_NAME = /
-          \A
-          (
-            (?:
-              # \[table_name\].\[column_name\] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
-            )
-            (?:\s+AS\s+(?:\w+|\[\w+\]))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        COLUMN_NAME_WITH_ORDER = /
-          \A
-          (
-            (?:
-              # \[table_name\].\[column_name\] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
-            )
-            (?:\s+ASC|\s+DESC)?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
         private
 
         def time_with_db_timezone(value)

data/lib/arjdbc/mssql/schema_creation.rb

@@ -38,6 +38,22 @@ module ActiveRecord
           end
         end
 
+        def visit_CreateIndexDefinition(o)
+          index = o.index
+
+          sql = []
+          sql << "IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = '#{o.index.name}')" if o.if_not_exists
+          sql << "CREATE"
+          sql << "UNIQUE" if index.unique
+          sql << index.type.upcase if index.type
+          sql << "INDEX"
+          sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
+          sql << "(#{quoted_columns(index)})"
+          sql << "WHERE #{index.where}" if index.where
+
+          sql.join(" ")
+        end
+
         def add_column_options!(sql, options)
           sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
 

data/lib/arjdbc/mssql/schema_statements.rb

@@ -80,8 +80,50 @@ module ActiveRecord
           valid_raw_connection.primary_keys(table_name)
         end
 
+        def build_change_column_definition(table_name, column_name, type, **options) # :nodoc:
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column_name, type, **options)
+          ChangeColumnDefinition.new(cd, column_name)
+        end
+
+        def build_change_column_default_definition(table_name, column_name, default_or_changes) # :nodoc:
+          column = column_for(table_name, column_name)
+          return unless column
+
+          default = extract_new_default_value(default_or_changes)
+          ChangeColumnDefaultDefinition.new(column, default)
+        end
+
         def foreign_keys(table_name)
-          valid_raw_connection.foreign_keys(table_name)
+          # valid_raw_connection.foreign_keys(table_name)
+          fk_info = execute_procedure(:sp_fkeys, nil, nil, nil, table_name, nil)
+
+          grouped_fk = fk_info.group_by { |row| row["FK_NAME"] }.values.each { |group| group.sort_by! { |row| row["KEY_SEQ"] } }
+          grouped_fk.map do |group|
+            row = group.first
+            options = {
+              name: row["FK_NAME"],
+              on_update: extract_foreign_key_action("update", row["FK_NAME"]),
+              on_delete: extract_foreign_key_action("delete", row["FK_NAME"])
+            }
+
+            if group.one?
+              options[:column] = row["FKCOLUMN_NAME"]
+              options[:primary_key] = row["PKCOLUMN_NAME"]
+            else
+              options[:column] = group.map { |row| row["FKCOLUMN_NAME"] }
+              options[:primary_key] = group.map { |row| row["PKCOLUMN_NAME"] }
+            end
+
+            ForeignKeyDefinition.new(table_name, row["PKTABLE_NAME"], options)
+          end
+        end
+
+        def extract_foreign_key_action(action, fk_name)
+          case select_value("SELECT #{action}_referential_action_desc FROM sys.foreign_keys WHERE name = '#{fk_name}'")
+          when "CASCADE" then :cascade
+          when "SET_NULL" then :nullify
+          end
         end
 
         def charset
@@ -182,20 +224,8 @@ module ActiveRecord
           rename_table_indexes(table_name, new_name)
         end
 
-        # This is the same as the abstract method
-        def quote_table_name(name)
-          quote_column_name(name)
-        end
-
-        # This overrides the abstract method to be specific to SQL Server.
-        def quote_column_name(name)
-          name = name.to_s.split('.')
-          name.map! { |n| quote_name_part(n) } # "[#{name}]"
-          name.join('.')
-        end
-
         def quote_database_name(name)
-          quote_name_part(name.to_s)
+          self.class.mssql_quote_name_part(name.to_s)
         end
 
         # @private these cannot specify a limit
@@ -439,11 +469,6 @@ module ActiveRecord
           result
         end
 
-        # Implements the quoting style for SQL Server
-        def quote_name_part(part)
-          part =~ /^\[.*\]$/ ? part : "[#{part.gsub(']', ']]')}]"
-        end
-
         def remove_check_constraints(table_name, column_name)
           constraints = select_values "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'", 'SCHEMA'
           constraints.each do |constraint|

data/lib/arjdbc/mssql.rb

@@ -6,4 +6,4 @@ module ArJdbc
   MsSQL = MSSQL # compatibility with 1.2
 end
 
-ArJdbc.warn_unsupported_adapter 'mssql', [7, 1] # warns on AR >= 4.2
+ArJdbc.warn_unsupported_adapter "mssql", [7, 2] # warns on AR >= 4.2