activerecord-jdbcsqlserver-adapter 51.1.0 → 52.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0fc70db649cdce388b0aa9682a6c67c425953238feed9db877e597edea9a887
-  data.tar.gz: ae1c960295840fecfb6a6134d012e557f2ac61c2da7f1651cd10e9ceb2f23025
+  metadata.gz: c764412410f757d3f4ee0312e3950ba5eb3cd1b3f7e21645e2d081ce4974f7b2
+  data.tar.gz: 463f9a3245a8d95ff78d76fd2284a8cacbc64b8510bfb95915d55c2e2b50021f
 SHA512:
-  metadata.gz: 4d17bb43ed779b8dbb7b27c12d64e00666368dd1aa7eec19a1b2ef19db4c7202dd2f4a81058ade3dcc4c4977630a4109e952f43cec683f728fcc05cc3939055c
-  data.tar.gz: bd361d607277b673f3e2f83428024730c9aa86a08b38cf5e01677dbd2b0ba7e817338c58efff22bf33ca9a915f0ae8030624f5d93bfb84a3053d04a81e05c7f1
+  metadata.gz: 703e10527b9d65e5e237dde6b5cdc381cb2f398f8fcd3cad780f64567694c193e9922ac58f5b4e591611157cb480ed405c75093d314e535c00210ad2ccbaeb99
+  data.tar.gz: f229972c054e17396b5aa1f6f554ae0a661a4e8d69ca9cb8e9ed52e4c7c3afef0f2d0eeb3e217f3e8b9c0323140329c16aa1e0986e2bc2b57da7817524a0232e

data/.travis.yml

@@ -5,7 +5,7 @@ services:
 env:
   global:
     - COMPOSE_FILE: docker-compose.ci.yml
-    - ARJDBC_BRANCH=51-stable
+    - ARJDBC_BRANCH: 52-stable
   matrix:
     - TARGET_VERSION=9.1
     - TARGET_VERSION=9.2

data/CHANGELOG.md

@@ -1,62 +1,45 @@
-## v51.1.0
 
-* Updated activerecord-jdbc-adapter dependecy to fix an issue with inserts on tables with composite primary keys
-* Changed how the jdbc driver is loaded so that other drivers can be used if needed
+## v52.0.0
 
-## v51.0.0
+- Forked to support JRuby
 
-* Forked original gem to provide JRuby support
-
-## v5.1.6
-
-#### Added
-
-* Use lock hint when joining table in query.
-
-
-## v5.1.5
+## v5.2.1
 
 #### Fixed
 
-* Memoize `@@version` queries. Fixes #632
-
+- [#691](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/691) Fix constraints bug
+- [#700](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/700) SET SINGLE_USER before dropping the database
+- [#733](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/733) Calculate should not remove ordering for MSSQL
+- [#735](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/735) Order by selected items when using distinct exists
+- [#737](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/737) Use default precision for 'time' column type
+- [#744](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/744) Adapter does not use prepared statement cache
+- [#743](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/743) Set default time precision when registering time type
+- [#745](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/745) Quoted table names containing square brackets need to be regex escaped
 
-## v5.1.4
+## v5.2.0
 
 #### Fixed
 
-* Add case insensitive comparison for better performance with CI collations. Fixes #624
+- [#686](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/686) sql_for_insert set table name in case when pk is not nil
 
-
-## v5.1.3
+## v5.2.0.rc2
 
 #### Fixed
 
-* Use bigint type in sqlserver_type when needed. Fixes #616
-
+- [#681](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/681) change_column_null should not clear other column attributes. Fixes #582.
+- [#684](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/684) Fix explain with array conditions. Fixes #673.
 
-## v5.1.2
+## v5.2.0.rc1
 
 #### Fixed
 
-* The `fast_string_to_time` method when zone local. Fixes #609 #614 #620
-* Patched `Relation#build_count_subquery`. Fixes #613.
-* Inserts to tables with triggers using default `OUTPUT INSERTED` style. Fixes #595.
-
-
-## v5.1.1
-
-#### Fixed
-
-* Use `ActiveSupport.on_load` to hook into ActiveRecord Fixes #588 #598
-
-
-## v5.1.0
+- [#638](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/638) Don't disable referential integrity for the same table twice.
+- [#646](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/646) Make String equality check work for Type::Data values. Fixes #645.
+- [#671](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/671) Fix tinyint columns schema migration. Fixes #670.
 
 #### Changed
 
-* The `drop_table` with force cascade option now mimics in via pure SQL for us.
+- [#642](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/642) Added with (nolock) hint to information_schema.views.
 
-#### Added
 
-* Support MismatchedForeignKey exception.
+Please check [5-1-stable-jdbc](https://github.com/jruby/activerecord-jdbcsqlserver-adapter/blob/5-1-stable-jdbc/CHANGELOG.md) for previous changes.

data/Gemfile

@@ -2,9 +2,7 @@ require 'openssl'
 source 'https://rubygems.org'
 gemspec
 
-gem 'rb-readline', platform: :mri
-gem 'sqlite3', platform: :mri
-gem 'minitest', '< 5.3.4'
+gem 'sqlite3', '~> 1.3.6', platform: :mri
 gem 'bcrypt'
 gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]
 

data/README.md

@@ -1,18 +1,16 @@
-# ActiveRecord SQL Server Adapter. For SQL Server 2012 And Higher.
+# ActiveRecord JDBC SQL Server Adapter. For SQL Server 2012 And Higher.
 
 [![Gem Version](http://img.shields.io/gem/v/activerecord-jdbcsqlserver-adapter.svg)](https://rubygems.org/gems/activerecord-jdbcsqlserver-adapter) - Gem Version
 
-The JDBC SQL Server adapter for ActiveRecord v5.1 using SQL Server 2012 or higher.
+## About The Adapter
+
+The JDBC SQL Server adapter for ActiveRecord v5.2 using SQL Server 2012 or higher.
 
 We currently support JRuby 9.2+. Older versions may work but they are not tested and there is a known date issue with JRuby 9.1.
 
 For older versions see [activerecord-jdbcmssql-adapter](https://rubygems.org/gems/activerecord-jdbcmssql-adapter)
 
 
-#### Native Data Type Support
-
-The Rails v5 adapter supports ActiveRecord's `datetime_with_precision` setting. This means that passing `:precision` to a datetime column is supported. Using a pecision with the `:datetime` type will signal the adapter to use the `datetime2` type under the hood.
-
 #### Schemas & Users
 
 Depending on your user and schema setup, it may be needed to use a table name prefix of `dbo.`. So something like this in your initializer file for ActiveRecord or the adapter.
@@ -48,7 +46,7 @@ gem 'activerecord-jdbcsqlserver-adapter'
 
 ## Contributing
 
-If you would like to contribute a feature or bugfix, thanks! To make sure your fix/feature has a high chance of being added, please read the following guidelines. First, ask on the Gitter, or post a ticket on github issues. Second, make sure there are tests! We will not accept any patch that is not tested. Please read the `RUNNING_UNIT_TESTS` file for the details of how to run the unit tests.
+If you would like to contribute a feature or bugfix, thanks! To make sure your fix/feature has a high chance of being added, please read the following guidelines. First, ask on the Gitter, or post a ticket on github issues. Second, make sure there are tests! We will not accept any patch that is not tested. Please read the [`RUNNING_UNIT_TESTS`](RUNNING_UNIT_TESTS.md) file for the details of how to run the unit tests.
 
 This is a fork of the activerecord-sqlserver-adapter. If you find a bug in the base code, please submit patches to: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter
 
@@ -89,4 +87,3 @@ JDBC version of the gem:
 ## License
 
 Copyright © 2008-2019. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.
-

data/VERSION

@@ -1 +1 @@
-51.1.0
+52.0.0

data/activerecord-jdbcsqlserver-adapter.gemspec

@@ -15,8 +15,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-
-  spec.add_dependency 'activerecord', '~> 5.1.0', '>= 5.1.7'
-  spec.add_dependency 'activerecord-jdbc-adapter' , '~> 51.8'
+  spec.add_dependency 'activerecord', '~> 5.2.0', '>= 5.2.3'
+  spec.add_dependency 'activerecord-jdbc-adapter' , '~> 52.7'
   spec.add_dependency 'jdbc-mssql', '>= 0.6.0'
 end

data/docker-compose.ci.yml

@@ -1,11 +1,13 @@
 version: "2.2"
 services:
-  database:
+  sqlserver:
     image: metaskills/mssql-server-linux-rails
   ci:
     environment:
-      - ACTIVERECORD_UNITTEST_HOST=database
-    build: .
-    command: test/bin/wait-for.sh database:1433 -- bundle exec rake test
+      - ACTIVERECORD_UNITTEST_HOST=sqlserver
+    build:
+      context: .
+      dockerfile: Dockerfile.ci
+    command: test/bin/wait-for.sh sqlserver:1433 -- bundle exec rake test
     depends_on:
-      - "database"
+      - "sqlserver"

data/lib/active_record/connection_adapters/sqlserver/core_ext/calculations.rb

@@ -7,37 +7,37 @@ module ActiveRecord
       module CoreExt
         module Calculations
 
-          # @Override
-          # If we are ordering a subquery for a count, we have to artificially add the offset bind parameter
-          def bound_attributes
-            attrs = super
-            if @_setting_offset_for_count
-              @_setting_offset_for_count = false
-              attrs << Attribute.with_cast_value('OFFSET'.freeze, 0, ::ActiveRecord::Type.default_value)
+          # Same as original except we don't perform PostgreSQL hack that removes ordering.
+          def calculate(operation, column_name)
+            if has_include?(column_name)
+              relation = apply_join_dependency
+
+              if operation.to_s.downcase == "count"
+                unless distinct_value || distinct_select?(column_name || select_for_count)
+                  relation.distinct!
+                  relation.select_values = [ klass.primary_key || table[Arel.star] ]
+                end
+              end
+
+              relation.calculate(operation, column_name)
+            else
+              perform_calculation(operation, column_name)
             end
-            attrs
           end
 
           private
 
-          # @Override
           def build_count_subquery(relation, column_name, distinct)
+            super(relation.unscope(:order), column_name, distinct)
+          end
 
-            # For whatever reason, mssql requires an offset if an ORDER BY is included in a subquery
-            if distinct && !has_limit_or_offset? && !relation.orders.empty?
-              relation = relation.offset(0)
-
-              # This is purely to appease activerecord/test/cases/calculations_test.rb @ line 258 CalculationsTest#test_distinct_count_all_with_custom_select_and_order
-              # hopefully nobody tries to do anything too crazy in a literal...
-              if relation.projections.length == 1 && relation.projections.first.is_a?(::Arel::Nodes::SqlLiteral)
-                relation.projections[0] = ::Arel::Nodes::SqlLiteral.new(relation.projections.first + ' as some_name_that_hopefully_never_exists123')
-              end
-
-              @_setting_offset_for_count = true
+          def type_cast_calculated_value(value, type, operation = nil)
+            case operation
+            when "count"   then value.to_i
+            when "sum"     then type.deserialize(value || 0)
+            when "average" then value&.respond_to?(:to_d) ? value.to_d : value
+            else type.deserialize(value)
             end
-
-            super
-
           end
         end
       end
@@ -46,10 +46,6 @@ module ActiveRecord
 end
 
 ActiveSupport.on_load(:active_record) do
-  if ActiveRecord::VERSION::MAJOR == 5 &&
-     ActiveRecord::VERSION::MINOR == 1 &&
-     ActiveRecord::VERSION::TINY >= 4
-    mod = ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::Calculations
-    ActiveRecord::Relation.prepend(mod)
-  end
+  mod = ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::Calculations
+  ActiveRecord::Relation.prepend(mod)
 end

data/lib/active_record/connection_adapters/sqlserver/core_ext/explain.rb

@@ -5,12 +5,11 @@ module ActiveRecord
         module Explain
 
           SQLSERVER_STATEMENT_PREFIX = 'EXEC sp_executesql '.freeze
-          SQLSERVER_PARAM_MATCHER = /@\d+ = (.*)/
-          SQLSERVER_NATIONAL_STRING_MATCHER = /N'(.*)'/m
+          SQLSERVER_STATEMENT_REGEXP = /N'(.+)', N'(.+)', (.+)/
 
           def exec_explain(queries)
             unprepared_queries = queries.map do |(sql, binds)|
-              [unprepare_sqlserver_statement(sql), binds]
+              [unprepare_sqlserver_statement(sql, binds), binds]
             end
             super(unprepared_queries)
           end
@@ -19,22 +18,19 @@ module ActiveRecord
 
           # This is somewhat hacky, but it should reliably reformat our prepared sql statment
           # which uses sp_executesql to just the first argument, then unquote it. Likewise our
-          # `sp_executesql` method should substitude the @n args withe the quoted values.
-          def unprepare_sqlserver_statement(sql)
-            if sql.starts_with?(SQLSERVER_STATEMENT_PREFIX)
-              executesql = sql.from(SQLSERVER_STATEMENT_PREFIX.length)
-              args = executesql.split(', ')
-              unprepared_sql = args.shift.strip.match(SQLSERVER_NATIONAL_STRING_MATCHER)[1]
-              unprepared_sql = Utils.unquote_string(unprepared_sql)
-              args = args.from(args.length / 2)
-              args.each_with_index do |arg, index|
-                value = arg.match(SQLSERVER_PARAM_MATCHER)[1]
-                unprepared_sql.sub! "@#{index}", value
-              end
-              unprepared_sql
-            else
-              sql
+          # `sp_executesql` method should substitude the @n args with the quoted values.
+          def unprepare_sqlserver_statement(sql, binds)
+            return sql unless sql.starts_with?(SQLSERVER_STATEMENT_PREFIX)
+
+            executesql = sql.from(SQLSERVER_STATEMENT_PREFIX.length)
+            executesql = executesql.match(SQLSERVER_STATEMENT_REGEXP).to_a[1]
+
+            binds.each_with_index do |bind, index|
+              value = connection.quote(bind)
+              executesql = executesql.sub("@#{index}", value)
             end
+
+            executesql
           end
 
         end

data/lib/active_record/connection_adapters/sqlserver/core_ext/finder_methods.rb

@@ -0,0 +1,43 @@
+require 'active_record/relation'
+require 'active_record/version'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module FinderMethods
+
+          private
+
+          # Same as original except we order by values in distinct select if present.
+          def construct_relation_for_exists(conditions)
+            if distinct_value && offset_value
+              relation = limit!(1)
+
+              if select_values.present?
+                relation = relation.order(*select_values)
+              else
+                relation = relation.except(:order)
+              end
+            else
+              relation = except(:select, :distinct, :order)._select!(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit!(1)
+            end
+
+            case conditions
+            when Array, Hash
+              relation.where!(conditions) unless conditions.empty?
+            else
+              relation.where!(primary_key => conditions) unless conditions == :none
+            end
+
+            relation
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Relation.include(ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::FinderMethods)
+end

data/lib/active_record/connection_adapters/sqlserver/core_ext/query_methods.rb

@@ -0,0 +1,26 @@
+require 'active_record/relation'
+require 'active_record/version'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module QueryMethods
+
+          private
+
+          # Copy of original from Rails master. This patch can be removed when adapter supports Rails 6.
+          def table_name_matches?(from)
+            table_name = Regexp.escape(table.name)
+            quoted_table_name = Regexp.escape(connection.quote_table_name(table.name))
+            /(?:\A|(?<!FROM)\s)(?:\b#{table_name}\b|#{quoted_table_name})(?!\.)/i.match?(from.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Relation.include(ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::QueryMethods)
+end

data/lib/active_record/connection_adapters/sqlserver/database_limits.rb

@@ -2,7 +2,6 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module DatabaseLimits
-
         def table_alias_length
           128
         end
@@ -32,7 +31,7 @@ module ActiveRecord
         end
 
         def in_clause_length
-          65_536
+          10_000
         end
 
         def sql_query_length
@@ -43,6 +42,18 @@ module ActiveRecord
           256
         end
 
+        private
+
+        # The max number of binds is 2100, but because sp_executesql takes
+        # the first 2 params as the query string and the list of types,
+        # we have only 2098 spaces left
+        def bind_params_length
+          2_098
+        end
+
+        def insert_rows_length
+          1_000
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -33,10 +33,6 @@ module ActiveRecord
           super(sql, name, binds).rows.first.first
         end
 
-        def supports_statement_cache?
-          true
-        end
-
         def begin_db_transaction
           do_execute 'BEGIN TRANSACTION'
         end
@@ -77,17 +73,55 @@ module ActiveRecord
 
         def case_sensitive_comparison(table, attribute, column, value)
           if column.collation && !column.case_sensitive?
-            table[attribute].eq(Arel::Nodes::Bin.new(Arel::Nodes::BindParam.new))
+            table[attribute].eq(Arel::Nodes::Bin.new(value))
           else
             super
           end
         end
 
+        # We should propose this change to Rails team
+        def insert_fixtures_set(fixture_set, tables_to_delete = [])
+          fixture_inserts = []
+
+          fixture_set.each do |table_name, fixtures|
+            fixtures.each_slice(insert_rows_length) do |batch|
+              fixture_inserts << build_fixture_sql(batch, table_name)
+            end
+          end
+
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
+          total_sql = Array.wrap(combine_multi_statements(table_deletes + fixture_inserts))
+
+          disable_referential_integrity do
+            transaction(requires_new: true) do
+              total_sql.each do |sql|
+                execute sql, "Fixtures Load"
+                yield if block_given?
+              end
+            end
+          end
+        end
+
         def can_perform_case_insensitive_comparison_for?(column)
           column.type == :string && (!column.collation || column.case_sensitive?)
         end
         private :can_perform_case_insensitive_comparison_for?
 
+        def combine_multi_statements(total_sql)
+          total_sql
+        end
+        private :combine_multi_statements
+
+        def default_insert_value(column)
+          if column.is_identity?
+            table_name = quote(quote_table_name(column.table_name))
+            Arel.sql("IDENT_CURRENT(#{table_name}) + IDENT_INCR(#{table_name})")
+          else
+            super
+          end
+        end
+        private :default_insert_value
+
         # === SQLServer Specific ======================================== #
 
         def execute_procedure(proc_name, *variables)
@@ -238,6 +272,8 @@ module ActiveRecord
         def sp_executesql_types_and_parameters(binds)
           types, params = [], []
           binds.each_with_index do |attr, index|
+            attr = attr.value if attr.is_a?(Arel::Nodes::BindParam)
+
             types << "@#{index} #{sp_executesql_sql_type(attr)}"
             params << sp_executesql_sql_param(attr)
           end
@@ -255,12 +291,12 @@ module ActiveRecord
         end
 
         def sp_executesql_sql_param(attr)
-          case attr.value_for_database
+          case value = attr.value_for_database
           when Type::Binary::Data,
                ActiveRecord::Type::SQLServer::Data
-            quote(attr.value_for_database)
+            quote(value)
           else
-            quote(type_cast(attr.value_for_database))
+            quote(type_cast(value))
           end
         end
 
@@ -282,7 +318,14 @@ module ActiveRecord
         def raw_connection_do(sql)
           case @connection_options[:mode]
           when :dblib
-            @connection.execute(sql).do
+            result = @connection.execute(sql)
+
+            # TinyTDS returns false instead of raising an exception if connection fails.
+            # Getting around this by raising an exception ourselves while this PR
+            # https://github.com/rails-sqlserver/tiny_tds/pull/469 is not released.
+            raise TinyTds::Error, "failed to execute statement" if result.is_a?(FalseClass)
+
+            result.do
           end
         ensure
           @update_sql = false
@@ -306,7 +349,7 @@ module ActiveRecord
         end
 
         def exec_insert_requires_identity?(sql, pk, binds)
-          query_requires_identity_insert?(sql) if pk && binds.map(&:name).include?(pk)
+          query_requires_identity_insert?(sql)
         end
 
         def query_requires_identity_insert?(sql)