activerecord-sqlserver-adapter 6.0.3 → 6.1.0.0.rc1

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

@@ -92,7 +92,7 @@ module ActiveRecord
               @schema = @parts.first
             end
             rest = scanner.rest
-            rest = rest.starts_with?(".") ? rest[1..-1] : rest[0..-1]
+            rest = rest.start_with?(".") ? rest[1..-1] : rest[0..-1]
             @object = unquote(rest)
             @parts << @object
           end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -59,13 +59,73 @@ module ActiveRecord
       self.use_output_inserted = true
       self.exclude_output_inserted_table_names = Concurrent::Map.new { false }
 
-      def initialize(connection, logger = nil, config = {})
+      class << self
+        def new_client(config)
+          case config[:mode]
+          when :dblib
+            require "tiny_tds"
+            dblib_connect(config)
+          else
+            raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+          end
+        end
+
+        def dblib_connect(config)
+          TinyTds::Client.new(
+            dataserver:    config[:dataserver],
+            host:          config[:host],
+            port:          config[:port],
+            username:      config[:username],
+            password:      config[:password],
+            database:      config[:database],
+            tds_version:   config[:tds_version] || "7.3",
+            appname:       config_appname(config),
+            login_timeout: config_login_timeout(config),
+            timeout:       config_timeout(config),
+            encoding:      config_encoding(config),
+            azure:         config[:azure],
+            contained:     config[:contained]
+          ).tap do |client|
+            if config[:azure]
+              client.execute("SET ANSI_NULLS ON").do
+              client.execute("SET ANSI_NULL_DFLT_ON ON").do
+              client.execute("SET ANSI_PADDING ON").do
+              client.execute("SET ANSI_WARNINGS ON").do
+            else
+              client.execute("SET ANSI_DEFAULTS ON").do
+            end
+            client.execute("SET QUOTED_IDENTIFIER ON").do
+            client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+            client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
+            client.execute("SET TEXTSIZE 2147483647").do
+            client.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
+          end
+        rescue TinyTds::Error => e
+          raise ActiveRecord::NoDatabaseError if e.message.match(/database .* does not exist/i)
+          raise e
+        end
+
+        def config_appname(config)
+          config[:appname] || configure_application_name || Rails.application.class.name.split("::").first rescue nil
+        end
+
+        def config_login_timeout(config)
+          config[:login_timeout].present? ? config[:login_timeout].to_i : nil
+        end
+
+        def config_timeout(config)
+          config[:timeout].present? ? config[:timeout].to_i / 1000 : nil
+        end
+
+        def config_encoding(config)
+          config[:encoding].present? ? config[:encoding] : nil
+        end
+      end
+
+      def initialize(connection, logger, _connection_options, config)
         super(connection, logger, config)
-        # Our Responsibility
         @connection_options = config
-        connect
-        initialize_dateformatter
-        use_database
+        configure_connection
       end
 
       # === Abstract Adapter ========================================== #
@@ -226,6 +286,14 @@ module ActiveRecord
         do_execute "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
       end
 
+      def configure_connection
+        @spid = _raw_select("SELECT @@SPID", fetch: :rows).first.first
+        @version_year = version_year
+
+        initialize_dateformatter
+        use_database
+      end
+
       # === Abstract Adapter (Misc Support) =========================== #
 
       def tables_with_referential_integrity
@@ -375,6 +443,8 @@ module ActiveRecord
 
       def translate_exception(e, message:, sql:, binds:)
         case message
+        when /(SQL Server client is not connected)|(failed to execute statement)/i
+          ConnectionNotEstablished.new(message)
         when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
           RecordNotUnique.new(message, sql: sql, binds: binds)
         when /(conflicted with the foreign key constraint) | (The DELETE statement conflicted with the REFERENCE constraint)/i
@@ -408,78 +478,18 @@ module ActiveRecord
 
       # === SQLServer Specific (Connection Management) ================ #
 
-      def connect
-        config = @connection_options
-        @connection = case config[:mode]
-                      when :dblib
-                        dblib_connect(config)
-                      end
-        @spid = _raw_select("SELECT @@SPID", fetch: :rows).first.first
-        @version_year = version_year
-        configure_connection
-      end
-
       def connection_errors
         @connection_errors ||= [].tap do |errors|
           errors << TinyTds::Error if defined?(TinyTds::Error)
         end
       end
 
-      def dblib_connect(config)
-        TinyTds::Client.new(
-          dataserver: config[:dataserver],
-          host: config[:host],
-          port: config[:port],
-          username: config[:username],
-          password: config[:password],
-          database: config[:database],
-          tds_version: config[:tds_version] || "7.3",
-          appname: config_appname(config),
-          login_timeout: config_login_timeout(config),
-          timeout: config_timeout(config),
-          encoding: config_encoding(config),
-          azure: config[:azure],
-          contained: config[:contained]
-        ).tap do |client|
-          if config[:azure]
-            client.execute("SET ANSI_NULLS ON").do
-            client.execute("SET ANSI_NULL_DFLT_ON ON").do
-            client.execute("SET ANSI_PADDING ON").do
-            client.execute("SET ANSI_WARNINGS ON").do
-          else
-            client.execute("SET ANSI_DEFAULTS ON").do
-          end
-          client.execute("SET QUOTED_IDENTIFIER ON").do
-          client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
-          client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
-          client.execute("SET TEXTSIZE 2147483647").do
-          client.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
-        end
-      end
-
-      def config_appname(config)
-        config[:appname] || configure_application_name || Rails.application.class.name.split("::").first rescue nil
-      end
-
-      def config_login_timeout(config)
-        config[:login_timeout].present? ? config[:login_timeout].to_i : nil
-      end
-
-      def config_timeout(config)
-        config[:timeout].present? ? config[:timeout].to_i / 1000 : nil
-      end
-
-      def config_encoding(config)
-        config[:encoding].present? ? config[:encoding] : nil
-      end
-
-      def configure_connection; end
-
       def configure_application_name; end
 
       def initialize_dateformatter
         @database_dateformat = user_options_dateformat
         a, b, c = @database_dateformat.each_char.to_a
+
         [a, b, c].each { |f| f.upcase! if f == "y" }
         dateformat = "%#{a}-%#{b}-%#{c}"
         ::Date::DATE_FORMATS[:_sqlserver_dateformat]     = dateformat
@@ -502,6 +512,13 @@ module ActiveRecord
       def sqlserver_version
         @sqlserver_version ||= _raw_select("SELECT @@version", fetch: :rows).first.first.to_s
       end
+
+      private
+
+      def connect
+        @connection = self.class.new_client(@connection_options)
+        configure_connection
+      end
     end
   end
 end

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -27,6 +27,23 @@ module ActiveRecord
       def case_sensitive?
         collation && collation.match(/_CS/)
       end
+
+      private
+
+      # In the Rails version of this method there is an assumption that the `default` value will always be a
+      # `String` class, which must be true for the MySQL/PostgreSQL/SQLite adapters. However, in the SQL Server
+      # adapter the `default` value can also be Boolean/Date/Time/etc. Changed the implementation of this method
+      # to handle non-String `default` objects.
+      def deduplicated
+        @name = -name
+        @sql_type_metadata = sql_type_metadata.deduplicate if sql_type_metadata
+        @default = (default.is_a?(String) ? -default : default.dup.freeze) if default
+        @default_function = -default_function if default_function
+        @collation = -collation if collation
+        @comment = -comment if comment
+
+        freeze
+      end
     end
   end
 end

data/lib/active_record/sqlserver_base.rb

@@ -4,21 +4,15 @@ module ActiveRecord
   module ConnectionHandling
     def sqlserver_connection(config) #:nodoc:
       config = config.symbolize_keys
-      config.reverse_merge! mode: :dblib
-      mode = config[:mode].to_s.downcase.underscore.to_sym
-      case mode
-      when :dblib
-        require "tiny_tds"
-      else
-        raise ArgumentError, "Unknown connection mode in #{config.inspect}."
-      end
-      ConnectionAdapters::SQLServerAdapter.new(nil, nil, config.merge(mode: mode))
-    rescue TinyTds::Error => e
-      if e.message.match(/database .* does not exist/i)
-        raise ActiveRecord::NoDatabaseError
-      else
-        raise
-      end
+      config.reverse_merge!(mode: :dblib)
+      config[:mode] = config[:mode].to_s.downcase.underscore.to_sym
+
+      ConnectionAdapters::SQLServerAdapter.new(
+        ConnectionAdapters::SQLServerAdapter.new_client(config),
+        logger,
+        nil,
+        config
+        )
     end
   end
 end

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -13,13 +13,18 @@ module ActiveRecord
       delegate :connection, :establish_connection, :clear_active_connections!,
                to: ActiveRecord::Base
 
+      def self.using_database_configurations?
+        true
+      end
+
       def initialize(configuration)
         @configuration = configuration
+        @configuration_hash = @configuration.configuration_hash
       end
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration["database"], configuration.merge("collation" => default_collation)
+        connection.create_database configuration.database, configuration_hash.merge(collation: default_collation)
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => e
         if /database .* already exists/i === e.message
@@ -31,7 +36,7 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration["database"]
+        connection.drop_database configuration.database
       end
 
       def charset
@@ -49,14 +54,14 @@ module ActiveRecord
       end
 
       def structure_dump(filename, extra_flags)
-        server_arg = "-S #{Shellwords.escape(configuration['host'])}"
-        server_arg += ":#{Shellwords.escape(configuration['port'])}" if configuration["port"]
+        server_arg = "-S #{Shellwords.escape(configuration_hash[:host])}"
+        server_arg += ":#{Shellwords.escape(configuration_hash[:port])}" if configuration_hash[:port]
         command = [
           "defncopy-ttds",
           server_arg,
-          "-D #{Shellwords.escape(configuration['database'])}",
-          "-U #{Shellwords.escape(configuration['username'])}",
-          "-P #{Shellwords.escape(configuration['password'])}",
+          "-D #{Shellwords.escape(configuration_hash[:database])}",
+          "-U #{Shellwords.escape(configuration_hash[:username])}",
+          "-P #{Shellwords.escape(configuration_hash[:password])}",
           "-o #{Shellwords.escape(filename)}",
         ]
         table_args = connection.tables.map { |t| Shellwords.escape(t) }
@@ -80,16 +85,14 @@ module ActiveRecord
 
       private
 
-      def configuration
-        @configuration
-      end
+      attr_reader :configuration, :configuration_hash
 
       def default_collation
-        configuration["collation"] || DEFAULT_COLLATION
+        configuration_hash[:collation] || DEFAULT_COLLATION
       end
 
       def establish_master_connection
-        establish_connection configuration.merge("database" => "master")
+        establish_connection configuration_hash.merge(database: "master")
       end
     end
 
@@ -110,9 +113,9 @@ module ActiveRecord
         end
 
         def configuration_host_ip(configuration)
-          return nil unless configuration["host"]
+          return nil unless configuration.host
 
-          Socket::getaddrinfo(configuration["host"], "echo", Socket::AF_INET)[0][3]
+          Socket::getaddrinfo(configuration.host, "echo", Socket::AF_INET)[0][3]
         end
 
         def local_ipaddr?(host_ip)

data/lib/arel/visitors/sqlserver.rb

@@ -11,13 +11,14 @@ module Arel
 
       private
 
-      # SQLServer ToSql/Visitor (Overides)
+      # SQLServer ToSql/Visitor (Overrides)
 
-      def visit_Arel_Nodes_BindParam o, collector
-        collector.add_bind(o.value) { |i| "@#{i - 1}" }
-      end
+      BIND_BLOCK = proc { |i| "@#{i - 1}" }
+      private_constant :BIND_BLOCK
+
+      def bind_block; BIND_BLOCK; end
 
-      def visit_Arel_Nodes_Bin o, collector
+      def visit_Arel_Nodes_Bin(o, collector)
         visit o.expr, collector
         collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
       end
@@ -28,26 +29,26 @@ module Arel
         visit o.right, collector
       end
 
-      def visit_Arel_Nodes_UpdateStatement(o, a)
+      def visit_Arel_Nodes_UpdateStatement(o, collector)
         if o.orders.any? && o.limit.nil?
           o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
         end
         super
       end
 
-      def visit_Arel_Nodes_Lock o, collector
+      def visit_Arel_Nodes_Lock(o, collector)
         o.expr = Arel.sql("WITH(UPDLOCK)") if o.expr.to_s =~ /FOR UPDATE/
         collector << " "
         visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Offset o, collector
+      def visit_Arel_Nodes_Offset(o, collector)
         collector << OFFSET
         visit o.expr, collector
         collector << ROWS
       end
 
-      def visit_Arel_Nodes_Limit o, collector
+      def visit_Arel_Nodes_Limit(o, collector)
         if node_value(o) == 0
           collector << FETCH0
           collector << ROWS_ONLY
@@ -63,7 +64,38 @@ module Arel
         super
       end
 
-      def visit_Arel_Nodes_SelectStatement o, collector
+      def visit_Arel_Nodes_HomogeneousIn(o, collector)
+        collector.preparable = false
+
+        collector << quote_table_name(o.table_name) << "." << quote_column_name(o.column_name)
+
+        if o.type == :in
+          collector << " IN ("
+        else
+          collector << " NOT IN ("
+        end
+
+        values = o.casted_values
+
+        if values.empty?
+          collector << @connection.quote(nil)
+        elsif @connection.prepared_statements
+          # Monkey-patch start. Add query attribute bindings rather than just values.
+          column_name = o.column_name
+          column_type = o.attribute.relation.type_for_attribute(o.column_name)
+          attrs = values.map { |value| ActiveRecord::Relation::QueryAttribute.new(column_name, value, column_type) }
+
+          collector.add_binds(attrs, &bind_block)
+          # Monkey-patch end.
+        else
+          collector.add_binds(values, &bind_block)
+        end
+
+        collector << ")"
+        collector
+      end
+
+      def visit_Arel_Nodes_SelectStatement(o, collector)
         @select_statement = o
         distinct_One_As_One_Is_So_Not_Fetch o
         if o.with
@@ -90,7 +122,7 @@ module Arel
         collector << "OPTION (#{hints})"
       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
@@ -112,7 +144,7 @@ module Arel
         end
       end
 
-      def visit_Arel_Nodes_JoinSource o, collector
+      def visit_Arel_Nodes_JoinSource(o, collector)
         if o.left
           collector = visit o.left, collector
           collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
@@ -124,7 +156,7 @@ module Arel
         collector
       end
 
-      def visit_Arel_Nodes_InnerJoin o, collector
+      def visit_Arel_Nodes_InnerJoin(o, collector)
         if o.left.is_a?(Arel::Nodes::As) && o.left.left.is_a?(Arel::Nodes::Lateral)
           collector << "CROSS "
           visit o.left, collector
@@ -141,7 +173,7 @@ module Arel
         end
       end
 
-      def visit_Arel_Nodes_OuterJoin o, collector
+      def visit_Arel_Nodes_OuterJoin(o, collector)
         if o.left.is_a?(Arel::Nodes::As) && o.left.left.is_a?(Arel::Nodes::Lateral)
           collector << "OUTER "
           visit o.left, collector
@@ -154,11 +186,11 @@ module Arel
         end
       end
 
-      def collect_in_clause(left, right, collector)
-        if Array === right
-          right.each { |node| remove_invalid_ordering_from_select_statement(node) }
+      def visit_Arel_Nodes_In(o, collector)
+        if Array === o.right
+          o.right.each { |node| remove_invalid_ordering_from_select_statement(node) }
         else
-          remove_invalid_ordering_from_select_statement(right)
+          remove_invalid_ordering_from_select_statement(o.right)
         end
 
         super
@@ -170,7 +202,7 @@ module Arel
 
       # SQLServer ToSql/Visitor (Additions)
 
-      def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
+      def visit_Arel_Nodes_SelectStatement_SQLServer_Lock(collector, options = {})
         if select_statement_lock?
           collector = visit @select_statement.lock, collector
           collector << " " if options[:space]
@@ -178,7 +210,7 @@ module Arel
         collector
       end
 
-      def visit_Orders_And_Let_Fetch_Happen o, collector
+      def visit_Orders_And_Let_Fetch_Happen(o, collector)
         make_Fetch_Possible_And_Deterministic o
         unless o.orders.empty?
           collector << " ORDER BY "
@@ -191,14 +223,14 @@ module Arel
         collector
       end
 
-      def visit_Make_Fetch_Happen o, collector
+      def visit_Make_Fetch_Happen(o, collector)
         o.offset = Nodes::Offset.new(0) if o.limit && !o.offset
         collector = visit o.offset, collector if o.offset
         collector = visit o.limit, collector if o.limit
         collector
       end
 
-      def visit_Arel_Nodes_Lateral o, collector
+      def visit_Arel_Nodes_Lateral(o, collector)
         collector << "APPLY"
         collector << " "
         if o.expr.is_a?(Arel::Nodes::SelectStatement)
@@ -226,7 +258,7 @@ module Arel
         @select_statement && @select_statement.lock
       end
 
-      def make_Fetch_Possible_And_Deterministic o
+      def make_Fetch_Possible_And_Deterministic(o)
         return if o.limit.nil? && o.offset.nil?
 
         t = table_From_Statement o
@@ -239,7 +271,7 @@ module Arel
         end
       end
 
-      def distinct_One_As_One_Is_So_Not_Fetch o
+      def distinct_One_As_One_Is_So_Not_Fetch(o)
         core = o.cores.first
         distinct = Nodes::Distinct === core.set_quantifier
         oneasone = core.projections.all? { |x| x == ActiveRecord::FinderMethods::ONE_AS_ONE }
@@ -250,7 +282,7 @@ module Arel
         end
       end
 
-      def table_From_Statement o
+      def table_From_Statement(o)
         core = o.cores.first
         if Arel::Table === core.from
           core.from
@@ -261,15 +293,15 @@ module Arel
         end
       end
 
-      def primary_Key_From_Table t
+      def primary_Key_From_Table(t)
         return unless t
 
         column_name = @connection.schema_cache.primary_keys(t.name) ||
-                      @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
         column_name ? t[column_name] : nil
       end
 
-      def remote_server_table_name o
+      def remote_server_table_name(o)
         ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
           "#{o.class.engine.connection.database_prefix}#{o.name}"
         ).quoted

data/test/cases/adapter_test_sqlserver.rb

@@ -53,7 +53,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert Topic.table_exists?, "Topics table name of 'dbo.topics' should return true for exists."
 
       # Test when database and owner included in table name.
-      Topic.table_name = "#{ActiveRecord::Base.configurations["arunit"]['database']}.dbo.topics"
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      Topic.table_name = "#{db_config.database}.dbo.topics"
       assert Topic.table_exists?, "Topics table name of '[DATABASE].dbo.topics' should return true for exists."
     ensure
       Topic.table_name = "topics"
@@ -64,8 +65,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     arunit_connection = Topic.connection
     arunit2_connection = College.connection
 
-    arunit_database = arunit_connection.pool.spec.config[:database]
-    arunit2_database = arunit2_connection.pool.spec.config[:database]
+    arunit_database = arunit_connection.pool.db_config.database
+    arunit2_database = arunit2_connection.pool.db_config.database
 
     # Assert that connections use different default databases schemas.
     assert_not_equal arunit_database, arunit2_database
@@ -100,21 +101,23 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
   it "test bad connection" do
     assert_raise ActiveRecord::NoDatabaseError do
-      config = ActiveRecord::Base.configurations["arunit"].merge(database: "inexistent_activerecord_unittest")
-      ActiveRecord::Base.sqlserver_connection config
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      configuration = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
+      ActiveRecord::Base.sqlserver_connection configuration
     end
   end
 
   it "test database exists returns false if database does not exist" do
-    config = ActiveRecord::Base.configurations["arunit"].merge(database: "inexistent_activerecord_unittest")
-    assert_not ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(config),
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    configuration = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
+    assert_not ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(configuration),
                "expected database to not exist"
   end
 
   it "test database exists returns true when the database exists" do
-    config = ActiveRecord::Base.configurations["arunit"]
-    assert ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(config),
-           "expected database #{config[:database]} to exist"
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    assert ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(db_config.configuration_hash),
+           "expected database #{db_config.database} to exist"
   end
 
   describe "with different language" do
@@ -466,12 +469,11 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   describe "block writes to a database" do
     def setup
       @conn = ActiveRecord::Base.connection
-      @connection_handler = ActiveRecord::Base.connection_handler
     end
 
     def test_errors_when_an_insert_query_is_called_while_preventing_writes
       assert_raises(ActiveRecord::ReadOnlyError) do
-        @connection_handler.while_preventing_writes do
+        ActiveRecord::Base.while_preventing_writes do
           @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
         end
       end
@@ -481,7 +483,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
 
       assert_raises(ActiveRecord::ReadOnlyError) do
-        @connection_handler.while_preventing_writes do
+        ActiveRecord::Base.while_preventing_writes do
           @conn.update("UPDATE [subscribers] SET [subscribers].[name] = 'Aidan' WHERE [subscribers].[nick] = 'aido'")
         end
       end
@@ -491,7 +493,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
 
       assert_raises(ActiveRecord::ReadOnlyError) do
-        @connection_handler.while_preventing_writes do
+        ActiveRecord::Base.while_preventing_writes do
           @conn.execute("DELETE FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
         end
       end
@@ -500,7 +502,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
       @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
 
-      @connection_handler.while_preventing_writes do
+      ActiveRecord::Base.while_preventing_writes do
         assert_equal 1, @conn.execute("SELECT * FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
       end
     end