activerecord-sqlserver-adapter 5.2.0 → 6.0.1

data/VERSION

@@ -1 +1 @@
-5.2.0
+6.0.1

data/activerecord-sqlserver-adapter.gemspec

@@ -1,21 +1,32 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "active_record/connection_adapters/sqlserver/version"
+# frozen_string_literal: true
+
+version = File.read(File.expand_path("VERSION", __dir__)).strip
 
 Gem::Specification.new do |spec|
-  spec.name          = 'activerecord-sqlserver-adapter'
-  spec.version       = ActiveRecord::ConnectionAdapters::SQLServer::Version::VERSION
+  spec.name          = "activerecord-sqlserver-adapter"
   spec.platform      = Gem::Platform::RUBY
-  spec.license       = 'MIT'
-  spec.authors       = ['Ken Collins', 'Anna Carey', 'Will Bond', 'Murray Steele', 'Shawn Balestracci', 'Joe Rafaniello', 'Tom Ward']
-  spec.email         = ['ken@metaskills.net', 'will@wbond.net']
-  spec.homepage      = 'http://github.com/rails-sqlserver/activerecord-sqlserver-adapter'
-  spec.summary       = 'ActiveRecord SQL Server Adapter.'
-  spec.description   = 'ActiveRecord SQL Server Adapter. SQL Server 2012 and upward.'
+  spec.version       = version
+
+  spec.required_ruby_version = ">= 2.5.0"
+
+  spec.license       = "MIT"
+  spec.authors       = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward"]
+  spec.email         = ["ken@metaskills.net", "will@wbond.net"]
+  spec.homepage      = "http://github.com/rails-sqlserver/activerecord-sqlserver-adapter"
+  spec.summary       = "ActiveRecord SQL Server Adapter."
+  spec.description   = "ActiveRecord SQL Server Adapter. SQL Server 2012 and upward."
+
+  spec.metadata      = {
+    "bug_tracker_uri" => "https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues",
+    "changelog_uri" => "https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v#{version}/CHANGELOG.md",
+    "source_code_uri" => "https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v#{version}",
+  }
+
   spec.files         = `git ls-files -z`.split("\x0")
   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.2.0'
-  spec.add_dependency 'tiny_tds'
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 6.0.0"
+  spec.add_dependency "tiny_tds"
 end

data/appveyor.yml

@@ -1,12 +1,23 @@
+image: Visual Studio 2017
+skip_tags: true
+clone_depth: 5
+build: off
+matrix:
+  fast_finish: true
+  allow_failures:
+    - ruby_version: "25"
+    - ruby_version: "26"
+    - ruby_version: "27"
+    - ruby_version: "27-x64"
+services:
+  - mssql2014
+
 init:
   - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
   - SET PATH=C:\MinGW\msys\1.0\bin;%PATH%
   - SET RAKEOPT=-rdevkit
-  - SET TINYTDS_VERSION=2.1.0
-clone_depth: 5
-skip_tags: true
-matrix:
-  fast_finish: true
+  - SET TINYTDS_VERSION=2.1.3.pre
+
 install:
   - ps: Update-AppveyorBuild -Version "$(Get-Content $env:appveyor_build_folder\VERSION).$env:appveyor_build_number"
   - ruby --version
@@ -14,26 +25,22 @@ install:
   - bundle install
   - gem uninstall bcrypt
   - gem install bcrypt --platform=ruby
-build: off
+
 test_script:
   - powershell -File "%APPVEYOR_BUILD_FOLDER%\test\appveyor\dbsetup.ps1"
   - timeout /t 4 /nobreak > NUL
-  - ps: Start-Service 'MSSQL$SQL2014'
-  - timeout /t 4 /nobreak > NUL
   - sqlcmd -S ".\SQL2014" -U sa -P Password12! -i %APPVEYOR_BUILD_FOLDER%\test\appveyor\dbsetup.sql
   - bundle exec rake test ACTIVERECORD_UNITTEST_DATASERVER="localhost\SQL2014"
-  - ps: Stop-Service 'MSSQL$SQL2014'
-  - ps: Start-Service 'MSSQL$SQL2012SP1'
-  - timeout /t 4 /nobreak > NUL
-  - sqlcmd -S ".\SQL2012SP1" -U sa -P Password12! -i %APPVEYOR_BUILD_FOLDER%\test\appveyor\dbsetup.sql
-  - bundle exec rake test ACTIVERECORD_UNITTEST_DATASERVER="localhost\SQL2012SP1"
+
 environment:
   CI_AZURE_HOST:
     secure: VChrioaIWkf9iuuaSs4cryiA4honrADgZqNC0++begg=
   CI_AZURE_PASS:
     secure: cSQp8sk4urJYvq0utpsK+r7J+snJ2wpcdp8RdXJfB+w=
   matrix:
-    - ruby_version: "23-x64"
-    - ruby_version: "23"
-    - ruby_version: "22-x64"
-    - ruby_version: "22"
+    - ruby_version: "25-x64"
+    - ruby_version: "25"
+    - ruby_version: "26-x64"
+    - ruby_version: "26"
+    - ruby_version: "27-x64"
+    - ruby_version: "27"

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: wait-for database:1433 -- bundle exec rake test
+      - ACTIVERECORD_UNITTEST_HOST=sqlserver
+    build:
+      context: .
+      dockerfile: Dockerfile.ci
+    command: wait-for sqlserver:1433 -- bundle exec rake test
     depends_on:
-      - "database"
+      - "sqlserver"

data/guides/RELEASING.md

@@ -0,0 +1,11 @@
+# Releasing
+
+## Building locally
+
+If you want to build the gem to test it locally run `bundle exec rake build`.
+
+This command will build the gem in `pkg/activerecord-sqlserver-adapter-A.B.C.gem`, where `A.B.C` is the version in `VERSION` file.
+
+## Releasing to RubyGems
+
+Run `bundle exec rake release` to build the gem locally and push the `gem` file to RubyGems.

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

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module CoreExt
         module ActiveRecord
-
           extend ActiveSupport::Concern
 
           module ClassMethods
-
             def execute_procedure(proc_name, *variables)
               if connection.respond_to?(:execute_procedure)
                 connection.execute_procedure(proc_name, *variables)
@@ -15,9 +15,7 @@ module ActiveRecord
                 []
               end
             end
-
           end
-
         end
       end
     end

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

@@ -1,12 +1,12 @@
-require 'active_record/attribute_methods'
+# frozen_string_literal: true
+
+require "active_record/attribute_methods"
 
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module CoreExt
         module AttributeMethods
-
-
           private
 
           def attributes_for_update(attribute_names)
@@ -15,7 +15,6 @@ module ActiveRecord
               column && column.respond_to?(:is_identity?) && column.is_identity?
             end
           end
-
         end
       end
     end

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

@@ -1,11 +1,31 @@
-require 'active_record/relation'
-require 'active_record/version'
+# frozen_string_literal: true
+
+require "active_record/relation"
+require "active_record/version"
 
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module CoreExt
         module Calculations
+          # 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
+          end
+
           private
 
           def build_count_subquery(relation, column_name, distinct)

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

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module CoreExt
         module Explain
-
-          SQLSERVER_STATEMENT_PREFIX = 'EXEC sp_executesql '.freeze
+          SQLSERVER_STATEMENT_PREFIX = "EXEC sp_executesql "
           SQLSERVER_STATEMENT_REGEXP = /N'(.+)', N'(.+)', (.+)/
 
           def exec_explain(queries)
@@ -32,7 +33,6 @@ module ActiveRecord
 
             executesql
           end
-
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ActiveSupport.on_load(:active_record) do
   silence_warnings do
     # Already defined in Rails

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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)
+            conditions = sanitize_forbidden_attributes(conditions)
+
+            if distinct_value && offset_value
+              if select_values.present?
+                relation = order(*select_values).limit!(1)
+              else
+                relation = except(:order).limit!(1)
+              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/preloader.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_record/associations/preloader"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module Preloader
+          private
+
+          def records_for(ids)
+            ids.each_slice(in_clause_length).flat_map do |slice|
+              scope.where(association_key_name => slice).load do |record|
+                # Processing only the first owner
+                # because the record is modified but not an owner
+                owner = owners_by_key[convert_key(record[association_key_name])].first
+                association = owner.association(reflection.name)
+                association.set_inverse_instance(record)
+              end.records
+            end
+          end
+
+          def in_clause_length
+            10_000
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  mod = ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::Preloader
+  ActiveRecord::Associations::Preloader::Association.prepend(mod)
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+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 version greater than 6.0.2.2
+          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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
@@ -9,10 +11,12 @@ module ActiveRecord
         def column_name_length
           128
         end
+        deprecate :column_name_length
 
         def table_name_length
           128
         end
+        deprecate :table_name_length
 
         def index_name_length
           128
@@ -21,14 +25,17 @@ module ActiveRecord
         def columns_per_table
           1024
         end
+        deprecate :columns_per_table
 
         def indexes_per_table
           999
         end
+        deprecate :indexes_per_table
 
         def columns_per_multicolumn_index
           16
         end
+        deprecate :columns_per_multicolumn_index
 
         def in_clause_length
           10_000
@@ -37,10 +44,12 @@ module ActiveRecord
         def sql_query_length
           65_536 * 4_096
         end
+        deprecate :sql_query_length
 
         def joins_per_query
           256
         end
+        deprecate :joins_per_query
 
         private
 

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

@@ -1,9 +1,23 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module DatabaseStatements
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :dbcc, :explain, :save, :select, :set, :rollback) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        end
 
         def execute(sql, name = nil)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          materialize_transactions
+
           if id_insert_table_name = query_requires_identity_insert?(sql)
             with_identity_insert_enabled(id_insert_table_name) { do_execute(sql, name) }
           else
@@ -11,7 +25,13 @@ module ActiveRecord
           end
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+        def exec_query(sql, name = "SQL", binds = [], prepare: false)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
+          materialize_transactions
+
           sp_executesql(sql, name, binds, prepare: prepare)
         end
 
@@ -24,17 +44,17 @@ module ActiveRecord
         end
 
         def exec_delete(sql, name, binds)
-          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
           super(sql, name, binds).rows.first.first
         end
 
         def exec_update(sql, name, binds)
-          sql = sql.dup << '; SELECT @@ROWCOUNT AS AffectedRows'
+          sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
           super(sql, name, binds).rows.first.first
         end
 
         def begin_db_transaction
-          do_execute 'BEGIN TRANSACTION'
+          do_execute "BEGIN TRANSACTION"
         end
 
         def transaction_isolation_levels
@@ -51,11 +71,11 @@ module ActiveRecord
         end
 
         def commit_db_transaction
-          do_execute 'COMMIT TRANSACTION'
+          do_execute "COMMIT TRANSACTION"
         end
 
         def exec_rollback_db_transaction
-          do_execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
+          do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
         end
 
         include Savepoints
@@ -71,9 +91,11 @@ module ActiveRecord
         def release_savepoint(name = current_savepoint_name)
         end
 
-        def case_sensitive_comparison(table, attribute, column, value)
+        def case_sensitive_comparison(attribute, value)
+          column = column_for_attribute(attribute)
+
           if column.collation && !column.case_sensitive?
-            table[attribute].eq(Arel::Nodes::Bin.new(value))
+            attribute.eq(Arel::Nodes::Bin.new(value))
           else
             super
           end
@@ -89,12 +111,12 @@ module ActiveRecord
             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))
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}" }
+          total_sqls = Array.wrap(table_deletes + fixture_inserts)
 
           disable_referential_integrity do
             transaction(requires_new: true) do
-              total_sql.each do |sql|
+              total_sqls.each do |sql|
                 execute sql, "Fixtures Load"
                 yield if block_given?
               end
@@ -107,11 +129,6 @@ module ActiveRecord
         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))
@@ -122,16 +139,29 @@ module ActiveRecord
         end
         private :default_insert_value
 
+        def build_insert_sql(insert) # :nodoc:
+          sql = +"INSERT #{insert.into}"
+
+          if returning = insert.send(:insert_all).returning
+            sql << " OUTPUT " << returning.map { |column| "INSERTED.#{quote_column_name(column)}" }.join(", ")
+          end
+
+          sql << " #{insert.values_list}"
+          sql
+        end
+
         # === SQLServer Specific ======================================== #
 
         def execute_procedure(proc_name, *variables)
+          materialize_transactions
+
           vars = if variables.any? && variables.first.is_a?(Hash)
                    variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
                  else
                    variables.map { |v| quote(v) }
-                 end.join(', ')
+                 end.join(", ")
           sql = "EXEC #{proc_name} #{vars}".strip
-          name = 'Execute Procedure'
+          name = "Execute Procedure"
           log(sql, name) do
             case @connection_options[:mode]
             when :dblib
@@ -156,20 +186,22 @@ module ActiveRecord
 
         def use_database(database = nil)
           return if sqlserver_azure?
+
           name = SQLServer::Utils.extract_identifiers(database || @connection_options[:database]).quoted
           do_execute "USE #{name}" unless name.blank?
         end
 
         def user_options
           return {} if sqlserver_azure?
-          rows = select_rows('DBCC USEROPTIONS WITH NO_INFOMSGS', 'SCHEMA')
+
+          rows = select_rows("DBCC USEROPTIONS WITH NO_INFOMSGS", "SCHEMA")
           rows = rows.first if rows.size == 2 && rows.last.empty?
           rows.reduce(HashWithIndifferentAccess.new) do |values, row|
             if row.instance_of? Hash
-              set_option = row.values[0].gsub(/\s+/, '_')
+              set_option = row.values[0].gsub(/\s+/, "_")
               user_value = row.values[1]
-            elsif  row.instance_of? Array
-              set_option = row[0].gsub(/\s+/, '_')
+            elsif row.instance_of? Array
+              set_option = row[0].gsub(/\s+/, "_")
               user_value = row[1]
             end
             values[set_option] = user_value
@@ -179,9 +211,9 @@ module ActiveRecord
 
         def user_options_dateformat
           if sqlserver_azure?
-            select_value 'SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID', 'SCHEMA'
+            select_value "SELECT [dateformat] FROM [sys].[syslanguages] WHERE [langid] = @@LANGID", "SCHEMA"
           else
-            user_options['dateformat']
+            user_options["dateformat"]
           end
         end
 
@@ -196,43 +228,44 @@ module ActiveRecord
                     WHEN 5 THEN 'SNAPSHOT' END AS [isolation_level]
                     FROM [sys].[dm_exec_sessions]
                     WHERE [session_id] = @@SPID).squish
-            select_value sql, 'SCHEMA'
+            select_value sql, "SCHEMA"
           else
-            user_options['isolation_level']
+            user_options["isolation_level"]
           end
         end
 
         def user_options_language
           if sqlserver_azure?
-            select_value 'SELECT @@LANGUAGE AS [language]', 'SCHEMA'
+            select_value "SELECT @@LANGUAGE AS [language]", "SCHEMA"
           else
-            user_options['language']
+            user_options["language"]
           end
         end
 
         def newid_function
-          select_value 'SELECT NEWID()'
+          select_value "SELECT NEWID()"
         end
 
         def newsequentialid_function
-          select_value 'SELECT NEWSEQUENTIALID()'
+          select_value "SELECT NEWSEQUENTIALID()"
         end
 
-
         protected
 
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        def sql_for_insert(sql, pk, binds)
           if pk.nil?
             table_name = query_requires_identity_insert?(sql)
             pk = primary_key(table_name)
           end
+
           sql = if pk && use_output_inserted? && !database_prefix_remote_server?
                   quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
                   table_name ||= get_table_name(sql)
                   exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+
                   if exclude_output_inserted
-                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? 'bigint' : exclude_output_inserted
-                    <<-SQL.strip_heredoc
+                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? "bigint" : exclude_output_inserted
+                    <<~SQL.squish
                       DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
                       #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
                       SELECT CAST(#{quoted_pk} AS #{id_sql_type}) FROM @ssaIdInsertTable
@@ -256,7 +289,9 @@ module ActiveRecord
 
         # === SQLServer Specific (Executing) ============================ #
 
-        def do_execute(sql, name = 'SQL')
+        def do_execute(sql, name = "SQL")
+          materialize_transactions
+
           log(sql, name) { raw_connection_do(sql) }
         end
 
@@ -282,11 +317,12 @@ module ActiveRecord
 
         def sp_executesql_sql_type(attr)
           return attr.type.sqlserver_type if attr.type.respond_to?(:sqlserver_type)
+
           case value = attr.value_for_database
           when Numeric
-            value > 2_147_483_647 ? 'bigint'.freeze : 'int'.freeze
+            value > 2_147_483_647 ? "bigint".freeze : "int".freeze
           else
-            'nvarchar(max)'.freeze
+            "nvarchar(max)".freeze
           end
         end
 
@@ -301,16 +337,16 @@ module ActiveRecord
         end
 
         def sp_executesql_sql(sql, types, params, name)
-          if name == 'EXPLAIN'
+          if name == "EXPLAIN"
             params.each.with_index do |param, index|
               substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
               sql = sql.sub substitute_at_finder, param.to_s
             end
           else
-            types = quote(types.join(', '))
-            params = params.map.with_index{ |p, i| "@#{i} = #{p}" }.join(', ') # Only p is needed, but with @i helps explain regexp.
+            types = quote(types.join(", "))
+            params = params.map.with_index { |p, i| "@#{i} = #{p}" }.join(", ") # Only p is needed, but with @i helps explain regexp.
             sql = "EXEC sp_executesql #{quote(sql)}"
-            sql << ", #{types}, #{params}" unless params.empty?
+            sql += ", #{types}, #{params}" unless params.empty?
           end
           sql
         end
@@ -318,7 +354,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
@@ -336,8 +379,10 @@ module ActiveRecord
 
         def exclude_output_inserted_table_name?(table_name, sql)
           return false unless exclude_output_inserted_table_names?
+
           table_name ||= get_table_name(sql)
           return false unless table_name
+
           self.class.exclude_output_inserted_table_names[table_name]
         end
 
@@ -366,7 +411,7 @@ module ActiveRecord
 
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name = 'SQL', binds = [], options = {})
+        def raw_select(sql, name = "SQL", binds = [], options = {})
           log(sql, name, binds) { _raw_select(sql, options) }
         end
 
@@ -414,7 +459,6 @@ module ActiveRecord
           end
           handle
         end
-
       end
     end
   end